repo
stringlengths 26
115
| file
stringlengths 54
212
| language
stringclasses 2
values | license
stringclasses 16
values | content
stringlengths 19
1.07M
|
|---|---|---|---|---|
https://github.com/stats-tgeorge/SJ_stats_course_JSM24 | https://raw.githubusercontent.com/stats-tgeorge/SJ_stats_course_JSM24/master/README.md | markdown | ## Materials JSM 2024 Speed 6 Talk and Poster
### \"Course: Statistics for Social Justice\"
August 6th, 2024
#### Speed Talk Materials Website:
<https://stats-tgeorge.github.io/SJ_stats_course_JSM24/>
#### Overview Presentation Slides at:
<https://stats-tgeorge.github.io/SJ_stats_course_JSM24/Slides_SJ_stats_course_JSM24>
#### Poster at:
<https://stats-tgeorge.github.io/SJ_stats_course_JSM24/Poster_SJ_stats_JSM24.pdf>
#### Course Website:
<https://stats-tgeorge.quarto.pub/sta-200-stats4sj/>
This poster was made using a template written by <NAME>. <https://github.com/quarto-ext/typst-templates/tree/main/poster>
|
|
https://github.com/jeffa5/typstfmt | https://raw.githubusercontent.com/jeffa5/typstfmt/main/.github/ISSUE_TEMPLATE/reformat-bug-report.md | markdown | MIT License | ---
name: Reformat bug report
about: Reformatting the output would not pass check
title: "[Reformat]"
labels: bug, reformat
assignees: ''
---
**To Reproduce**
Code snippet:
```typst
<your problematic snippet here, or upload the file>
```
**Version**
`X.X.X`
**Additional context**
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/cetz/0.0.1/styles.typ | typst | Apache License 2.0 | #let resolve(current, new, root: none) = {
let global
if root != none and type(current) == "dictionary" {
(global, current) = (current, current.at(root))
}
if new == auto {
return current
} else if type(current) != "dictionary" {
return new
}
assert.ne(current, none, message: repr((global, current, new, root)))
for (k, v) in new {
current.insert(
k,
if k in current and type(current.at(k)) == "dictionary" and type(v) == "dictionary" {
resolve(current.at(k), v)
} else {
v
}
)
}
if root != none {
for (k, v) in current {
if k in global {
if v == auto {
current.insert(
k,
global.at(k)
)
} else if type(v) == "dictionary" {
// panic(global, v, k)
current.insert(k, resolve(global, v, root: k))
}
}
}
}
return current
}
#let default = (
fill: none,
stroke: black + 1pt,
radius: 1,
mark: (
size: .15,
start: none,
end: none,
fill: auto,
stroke: auto
),
line: (
fill: auto,
stroke: auto,
mark: auto,
),
rect: (
fill: auto,
stroke: auto,
),
arc: (
fill: auto,
stroke: auto,
radius: auto,
mode: "OPEN",
),
circle: (
fill: auto,
stroke: auto,
radius: auto
),
content: (
padding: 0em
),
bezier: (
fill: auto,
stroke: auto,
),
shadow: (
color: gray,
offset-x: .1,
offset-y: -.1,
)
) |
https://github.com/TideDra/seu-thesis-typst | https://raw.githubusercontent.com/TideDra/seu-thesis-typst/main/translation_thesis.typ | typst | #import "template.typ": translation_conf
#import "utils.typ": set_doc_footnote
// 由于Typst目前的缺陷，footnote必须在开头设置。未来可能会改进
#show: doc => set_doc_footnote(doc)
#let info = (
raw_paper_name: "Name of Raw Paper",
translated_paper_name: "论文中文标题",
student_id: "123456",
name: "张三",
college: "霍格沃兹学院",
major: "母猪产后护理",
supervisor: "指导老师",
abstract: [此处编写中文摘要],
key_words: ("关键词1", "关键词2"),
)
// 对以下文本应用模板
#show: doc => translation_conf(doc, ..info)
= 绪论
此处编写正文
|
|
https://github.com/yingziyu-llt/blog | https://raw.githubusercontent.com/yingziyu-llt/blog/main/typst_document/ml/content/chapter2.typ | typst | #import "../template.typ":*
= 线性模型
== 基本形式
实际上就是找到一种对于各个属性的线性组合，使得其最接近真实的lable。
整体的形式是$f(x) = w^T x + b$. w,b 两者学习到之后，模型就被确定。通过 w，我们可以看出每个元素的重要性，从而有一定的可解释性。
== 线性回归
对于各种属性，怎么将其转换为数字呢？
+ 数字元素 直接使用就可以
+ 有序的属性 如高、中、低，可以分别用1,0.5,0来表示
+ 无序的属性 如红、黄、蓝，进行one-hot编码
如何确定两个参数呢？这取决于如何定义最接近。最常见的做法是用最小二乘法，即使得预测结果和目标的欧式距离最短。即$(w^*,b^*) = arg limits(min)_{a,b} (w^T x + b - y)^2$
对于更加一般的数据集D,我们要试图学到$f(x_i)=w^T x_i+b$，使得均方误差最小。为了便于处理，我们让$hat(w) = (w;b)$,将数据集表示为一个$(m+1)times b$的矩阵$X$.
对于每一个数据$x_i$,我们让$X$的第i行为$(x_i^T 1)$,于是有$hat(w) = arg limits(min)_{w} (y-X w)^T(y-X w)$,对$w$求偏导，得$partial(E)/partial(w) = 2X^T(X w - y)$
如果$2X^T X$是正定的/满秩的，那么便有一个 close form 的解。
实际上大概率是非满秩的。所以我们常引入一个正则项(regularization)。
如果要拟合的函数不是一个线性的怎么办呢？假设是$f$性质的函数，那么令$f^-1(y)=w^t x+b$，先处理y，然后拟合就可以了。
== 对数几率回归
对于一个分类问题，我们更需要知道是概率如何，应当是一个$[0,1]$的数。为了将线性回归出来的数映射到$[0,1]$上，我们有很多种方法。
最为显然的一个方法是，建立分段函数$ f(x) = cases(1 x > 0,0.5 x=0,0 x<0) $显然可以描述。
但显然这个玩意不可逆，于是改变方法，用 Sigmoid 函数($1/(1+e^-x)$)来映射。
这玩意loss推导那块很无聊，反正最后得出来$ l(beta) = sum_(i=1)^m (-y_i beta^T x_i + log(1+e^(beta^T x_i)) $
是个凸函数，可以用凸优化的常规方法求出最小值。
== 线性判别分析
整体的思路就是将一堆点映射到某个直线上，让类内点距离最近的同时类间点距离最远。
|
|
https://github.com/monaqa/typscrap.nvim | https://raw.githubusercontent.com/monaqa/typscrap.nvim/master/class/states.typ | typst | #let slug = state("slug")
|
|
https://github.com/dangh3014/postercise | https://raw.githubusercontent.com/dangh3014/postercise/main/themes/better.typ | typst | MIT License | /*
betterposter originally developed by <NAME>
https://osf.io/ef53g/
*/
#import "../utils/scripts.typ": *
// Different behavior than for basic.typ
#let theme(
primary-color: rgb(28,55,103), // Dark blue
background-color: white,
accent-color: rgb(243,163,30), // Yellow
titletext-color: black,
titletext-size: 2em,
body,
) = {
set page(
margin: 0pt,
)
color-primary.update(primary-color)
color-background.update(background-color)
color-accent.update(accent-color)
color-titletext.update(color-titletext => titletext-color)
size-titletext.update(size-titletext => titletext-size)
body
}
#let focus-box(
footer-kwargs: none,
body
) = {
focus-content.update(focus-body => body)
}
#let normal-box(
color: none,
body
) = {
locate(loc =>
{
let primary-color = color-primary.get()
let accent-color = color-accent.get()
if color != none [
#let accent-color = color
#box(
stroke: none, //primary-color+0.2em,
width: 100%,
fill: accent-color,
inset: 0%,
[
#box(
inset: (top: 4%, left: 4%, right: 4%, bottom: 4%),
body
)
]
)
] else [
// #let accent-color = color
#box(
stroke: none, //primary-color+0.0625em,
width: 100%,
fill: accent-color,
inset: 0%,
[
#box(
inset: (top: 4%, left: 4%, right: 4%, bottom: 4%),
body
)
]
)
]
})
}
#let poster-content(
col: 1,
title: none,
subtitle: none,
authors: none,
affiliation: none,
left-logo: none,
right-logo: none,
textcolor: black,
body
)={
locate(loc =>
{
let edge-color = color-background.get()
let center-color = color-primary.get()
let titletext-color = color-titletext.get()
let titletext-size = size-titletext.get()
let current-title = context title-content.get()
let current-subtitle = context subtitle-content.get()
let current-author = context author-content.get()
let current-affiliation = context affiliation-content.get()
let current-focus = context focus-content.get()
let current-footer = context footer-content.get()
// Table captions go above
// TO DO: Numbering is not working properly
show figure.where(kind:table) : set figure.caption(position:top)
show figure.caption: it => [
// #context it.counter.display(it.numbering)
#it.body
]
// First, need body (hidden) to update header and footer
block(height: 0pt, hide[#body])
v(0pt, weak: true)
grid(
columns: (12.5/52*100%, 28.5/52*100%, 11/52*100%),
rows: (100%),
// Left = title and main text
[
#grid(
columns: (100%),
rows: (auto, 1fr),
[
#box(
stroke: none,
fill: edge-color,
// height: 100%,
width: 100%,
inset: 6%,
[
#align(top+left)[
\
#set text(size: titletext-size/(7/5),
fill: titletext-color,
)
*#current-title*
#current-subtitle \
// i.e. (6/7 = 0.857), which converts 1.4 -> 1.2, or (5/7 = 714) 1.4 -> 1.0
#set text(size: 0.714em)
\
#current-author \
#current-affiliation
]
]
)
#v(0pt, weak: true)
],
[
#align(top+left)[
#box(
inset: 6%,
fill: edge-color,
columns(col)[
#body
]
)
]
]
)
],
// Center = focus box
[
#box(
height: 100%,
width: 100%,
inset: 10%,
fill: center-color,
align(left+horizon)[
#set text(size: 2em,
fill: white)
#current-focus
]
)
],
// Right = declarations and affiliation
[
#box(
stroke: none,
fill: edge-color,
height: 100%,
width: 100%,
inset: 6%,
align(bottom+left)[#current-footer]
)
]
)
})
}
|
https://github.com/Kasci/LiturgicalBooks | https://raw.githubusercontent.com/Kasci/LiturgicalBooks/master/_general/casoslov/vecierne.typ | typst | #show <X>: it => {
if it.location().position().y > 480pt [$ $ #colbreak() #it]
else [#it]
}
#set text(font: "Monomakh Unicode", lang: "sk", fill: black)
#include "/SK/casoslov/vecierne/vecierenBezKnaza.typ"
#pagebreak()
#set text(font: "Monomakh Unicode", lang: "sk", fill: black)
#include "/SK/casoslov/vecierne/velkaVecierenBezKnaza.typ"
#pagebreak()
#set text(font: "Monomakh Unicode", lang: "sk", fill: black)
#include "/SK/casoslov/vecierne/postnaVecierenBezKnaza.typ"
#pagebreak()
// #set text(font: "Monomakh Unicode", lang: "cs", fill: black)
// #include "/CSL/casoslov/vecierenBezKnaza.typ"
// #pagebreak()
// #set text(font: "Monomakh Unicode", lang: "cs", fill: black)
// #include "/CSL/casoslov/velkaVecierenBezKnaza.typ"
// #pagebreak()
// #set text(font: "Monomakh Unicode", lang: "ru", fill: black)
// #include "/CU/casoslov/vecierenBezKnaza.typ"
// #pagebreak()
// #set text(font: "Monomakh Unicode", lang: "ru", fill: black)
// #include "/CU/casoslov/velkaVecierenBezKnaza.typ" |
|
https://github.com/donabe8898/typst-slide | https://raw.githubusercontent.com/donabe8898/typst-slide/main/opc/並行prog/03/Go1.typ | typst | MIT License | #show link: set text(blue)
#set text(font: "Noto Sans CJK JP",size:13pt)
#show heading: set text(font: "Noto Sans CJK JP")
#show raw: set text(font: "0xProto Nerd Font")
#show raw.where(block: true): block.with(
fill: luma(245),
inset: 10pt,
radius: 10pt
)
#align(center)[
```go
// 今回はコメント書かなくてOKです
package main
import "fmt"
func main() {
var arr1 = [3]string{} // 配列宣言
arr1[0] = "りんご"
arr1[1] = "バナナ"
arr1[2] = "CL7 Honda ACCORD Euro R"
arr2 := [3]int{3, 1, 8} // :=での宣言も可能
// 出力
for i := 0; i < 3; i++ {
fmt.Printf("%s = %d\n", arr1[i], arr2[i])
}
// 宣言時に個数が決まっているのであれば[...]でもOk
arr3 := [...]int64{1000, 1500, 1600, 1050, 1150, 1550, 1650, 1100}
fmt.Printf("%v\n", arr3)
}
```
]
|
https://github.com/bennyhandball/PA1_LoB_Finance | https://raw.githubusercontent.com/bennyhandball/PA1_LoB_Finance/main/PA/codelst/2.0.1/README.md | markdown | # codelst (v2.0.1)
**codelst** is a [Typst](https://github.com/typst/typst) package for rendering sourcecode with line numbers and some other additions.
## Usage
Import the package from the typst preview repository:
```js
#import "@preview/codelst:2.0.1": sourcecode
```
After importing the package, simply wrap any fenced code block in a call to `#sourcecode()`:
````js
#import "@preview/codelst:2.0.1": sourcecode
#sourcecode[```typ
#show "ArtosFlow": name => box[
#box(image(
"logo.svg",
height: 0.7em,
))
#name
]
This report is embedded in the
ArtosFlow project. ArtosFlow is a
project of the Artos Institute.
```]
````
## Further documentation
See `manual.pdf` for a comprehensive manual of the package.
See `example.typ` for some quick usage examples.
## Development
The documentation is created using [Mantys](https://github.com/jneug/typst-mantys), a Typst template for creating package documentation.
To compile the manual, Mantys needs to be available as a local package. Refer to Mantys' manual for instructions on how to do so.
## Changelog
### v2.0.1
This version makes `codelst` compatible to Typst 0.11.0. Version 2.0.1 now requires Typst 0.11.0, since there are some breaking changes to the way counters work.
Thanks to @kilpkonn for theses changes.
### v2.0.0
Version 2 requires Typst 0.9.0 or newer. Rendering is now done using the new
`raw.line` elements get consistent line numbers and syntax highlighting (even
if `showrange` is used). Rendering is now done in a `#table`.
- Added `theme` and `syntaxes` options to overwrite passed in `#raw` values.
- Breaking: Renamed `tab-indend` to `tab-size`, to conform with the Typst option.
- Breaking: Removed `continue-numbering` option for now. (The feature failed in combination with label parsing and line highlights.)
- Breaking: Removed styling of line numbers via a `show`-rule.
### v1.0.0
- Complete rewrite of code rendering.
- New options for `#sourcecode()`:
- `lang`: Overwrite code language setting.
- `numbers-first`: First line number to show.
- `numbers-step`: Only show every n-th number.
- `frame`: Set a frame (replaces `<codelst>` label.)
- Merged `line-numbers` and `numbering` options.
- Removed `#numbers-style()` function.
- `numbers-style` option now gets passed `counter.display()`.
- Removed `<codelst>` label.
- `codelst-style` only sets `breakable` for figures.
- New `codelst` function to setup a catchall show rules for `raw` text.
- `label-regex: none` disables labels parsing.
- Code improvements and refactorings.
### v0.0.5
- Fixed insets for line highlights.
- Added `numbers-width` option to manually set width of line numbers column.
- This allows line numbers on margins by setting `numbers-width` to `0pt` or a negative number like `-1em`.
### v0.0.4
- Fixed issue with context unaware syntax highlighting.
### v0.0.3
- Removed call to `#read()` from `#sourcefile()`.
- Added `continue-numbering` argument to `#sourcecode()`.
- Fixed problem with `showrange` having out of range line numbers.
### v0.0.2
- Added a comprehensive manual.
- Fixed crash for missing `lang` attribute in `raw` element.
### v0.0.1
- Initial version submitted to typst/packages.
|
|
https://github.com/gianzamboni/cancionero | https://raw.githubusercontent.com/gianzamboni/cancionero/main/wip/the-lobster-quadrille.typ | typst | #import "../theme/project.typ": *;
#cancion("The Lobster Quadrille","<NAME>", withCords: true)[
Will you #chord[walk][Em][0] a little faster?
Said a whiting to a snail
"There's a #chord[porpoise][A][0] close behind us
Treading on my tail.
#new-stanza
See how #chord[eagerly][Em][0] the lobsters
And the turtles all advance
They are #chord[waiting][A][0] on the shingle
Will you come and join the dance?
#new-stanza
#chord[Will][Em][0] you, won't you, won't you,
will you, won't you join the dance?
Will you, won't you, will you,
Won't you, won't you join the dance?
#new-stanza
You can #chord[really][Em][0] have no notion
How delightful it will be
When they #chord[take][A][0] us up and throw us
With the lobsters, out to sea!"
#new-stanza
But the #chord[snail][Em][0] replied "Too far, too far!"
And gave a look askance
Said he #chord[thanked][A][0] the whiting kindly
But he would not join the dance.
#new-stanza
#chord[Would][E][0] not, could not, would not,
Could not, would not join the dance.
Would not, could not, would not,
Could not, could not join the dance.
#new-stanza
What #chord[matters][Em][0] it how far we go?
His scaly friend replied
There is another shore, you know
Upon the other side
#new-stanza
The #chord[further][Em][0] off from England
The nearer is to France
Then #chord[turn][A][0] not pale, beloved snail
but come and join the dance.
#new-stanza
_\[Instrumental\]_
#new-stanza
#chord[Will][Em][0] you, won't you, will you,
Won't you, will you join the dance?
Will you, won't you, will you,
Won't you, won't you join the dance?"
] |
|
https://github.com/Goldan32/brilliant-cv | https://raw.githubusercontent.com/Goldan32/brilliant-cv/main/modules_hu/projects.typ | typst | Apache License 2.0 | #import "../brilliant-CV/template.typ": *
#cvSection("Projektek")
#cvEntry(
title: [Rust Használata Többmagos STM32H7 Mikrokontrolleren],
date: [2023],
society: [],
location: [],
description: list(
[Egy szoftver keretrendszer, ami lehetővé teszi a fejlesztést egy STM32H745 mikrokontroller mindkét magjára],
[Példák a két mag közötti kommunikációra és együttműködésre],
[Tartalmaz egy példaprogramot is, ami felhasználja mindkét magot, az ethernet csatlakozót, és analóg perifériákat]
)
)
#cvEntry(
title: [Neurális Hálózat Kiértékelése Xilinx SoC-n],
date: [2022],
society: [],
location: [],
description: list(
[Run pre-trained neural networks to perform facial recognition on a Xilinx evaluation board using Petalinux],
[Előre tanított arcfelismerő neurális hálózat kiértékelése egy Xilinx SoC kártyán Petalinux felhasználásával],
[Gstreamer felhasználása a képek előkészítésére és videófolyam kezelésére]
)
)
#cvEntry(
title: [Firmware Frissítő Szoftver Aurix TriCore Mikrokontrollerhez],
date: [2021],
society: [],
location: [],
description: list(
[Másodlagos bootloader egy Infineon Aurix mikrokontrolleren],
[TFTP felhasználása az új bináris memóriába töltésére],
[Az új image aktiválása a mikrokontroller biztonsági funkcióinak kezelésével]
)
)
|
https://github.com/mariunaise/HDA-Thesis | https://raw.githubusercontent.com/mariunaise/HDA-Thesis/master/graphics/plots/temperature/25_5_re.typ | typst | #import "@preview/cetz:0.2.2": canvas, plot
#let data5 = csv("../../../data/errorrates/2bit_temp/reconstruction/errorrates_left_25_5.csv")
#let ndata5 = data5.map(value => value.map(v => calc.log(float(v))))// fucking hell is that cursed
#let data25 = csv("../../../data/errorrates/2bit_temp/reconstruction/errorrates_left_25_25.csv")
#let ndata25 = data25.map(value => value.map(v => calc.log(float(v))))
#let data35 = csv("../../../data/errorrates/2bit_temp/reconstruction/errorrates_left_25_35.csv")
#let ndata35 = data35.map(value => value.map(v => calc.log(float(v))))
#let data55 = csv("../../../data/errorrates/2bit_temp/reconstruction/errorrates_left_25_55.csv")
#let ndata55 = data55.map(value => value.map(v => calc.log(float(v))))
#let data15 = csv("../../../data/errorrates/2bit_temp/reconstruction/errorrates_left_25_15.csv")
#let ndata15 = data15.map(value => value.map(v => calc.log(float(v))))
#let data45 = csv("../../../data/errorrates/2bit_temp/reconstruction/errorrates_left_25_45.csv")
#let ndata45 = data45.map(value => value.map(v => calc.log(float(v))))
#let formatter(v) = [$10^#v$]
#let dashed = (stroke: (dash: "dashed"))
#canvas({
plot.plot(size: (10,5),
x-tick-step: none,
x-ticks: ((0.04, [2]),(2, [100])),
y-label: $op("BER")(S, 2^2)$,
x-label: $S$,
y-tick-step: 1,
x-max: 2,
//y-ticks : (
// (-1.5, calc.exp(-1.5)),
//),
y-max: -1,
y-format: formatter,
axis-style: "left",
{
plot.add((ndata5), line: "spline", label: $5°C$)
plot.add((ndata25), line: "spline", label: $25°C$)
plot.add((ndata15), line: "spline", label: $15°C$)
plot.add((ndata35), line: "spline", label: $35°C$)
plot.add((ndata45), line: "spline", label: $45°C$)
plot.add((ndata55), line: "spline", label: $55°C$, style: (stroke: (paint: teal)))
})
})
|
|
https://github.com/Functional-Bus-Description-Language/Specification | https://raw.githubusercontent.com/Functional-Bus-Description-Language/Specification/master/src/functionalities/block.typ | typst | == Block
The block functionality is used to logically group or encapsulate functionalities.
The block is usually used to separate functionalities related to particular peripherals such as UART, I2C transceivers, timers, ADCs, DACs etc.
The block might also be used to limit the access for particular provider to only a subset of functionalities.
The block functionality has following properties:
*`masters`*` integer (1) {definitive}`
#pad(left: 1em)[
The `masters` property defines the number of block master ports.
This property defines how many master ports shall be generated.
However, it is up to the user how many master ports are connected in the design.
]
*`reset`*` string (None) {definitive}`
#pad(left: 1em)[
The reset property defines the block reset type.
By default the block has no reset.
Valid values of the reset property are _`"Sync"`_ for synchronous reset and _`"Async"`_ for asynchronous reset.
]
The following example presents how to limit the scope of access for particular requester.
#block(breakable: false)[
#pad(left: 1em)[
```fbd
Main bus
C config
Blk block
masters = 2
S status
```
]
]
The logical connection of the system components may look as follows:
#set align(center)
#image("../images/requester-access-limit.svg", width: 70%)
#set align(left)
The requester number 1 can acces both config C and status S.
However, the requester number 2 can access only the status S.
|
|
https://github.com/Shuenhoy/modern-zju-thesis | https://raw.githubusercontent.com/Shuenhoy/modern-zju-thesis/master/utils/fakebold.typ | typst | MIT License | // Orignal source: https://github.com/csimide/cuti
#let fakebold(base-weight: none, s, ..params) = {
set text(weight: base-weight) if base-weight != none
set text(..params) if params != ()
context {
set text(stroke: 0.02857 * 4 / 3 * text.size + text.fill)
s
}
}
#let regex-fakebold(reg-exp: ".", base-weight: none, s, ..params) = {
show regex(reg-exp): it => {
fakebold(base-weight: base-weight, it, ..params)
}
s
}
#let show-fakebold(reg-exp: ".", base-weight: none, s, ..params) = {
show text.where(weight: "bold").or(strong): it => {
regex-fakebold(reg-exp: reg-exp, base-weight: base-weight, it, ..params)
}
s
}
#let cn-fakebold(s, ..params) = {
regex-fakebold(reg-exp: "[\p{script=Han}！-･〇-〰—]+", base-weight: "regular", s, ..params)
}
#let show-cn-fakebold(s, ..params) = {
show-fakebold(reg-exp: "[\p{script=Han}！-･〇-〰—]+", base-weight: "regular", s, ..params)
}
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/cetz-plot/0.1.0/src/plot/boxwhisker.typ | typst | Apache License 2.0 | #import "/src/cetz.typ": draw, util
/// Add one or more box or whisker plots
///
/// #example(```
/// plot.plot(size: (2,2), x-tick-step: none, y-tick-step: none, {
/// plot.add-boxwhisker((x: 1, // Location on x-axis
/// outliers: (7, 65, 69), // Optional outlier values
/// min: 15, max: 60, // Minimum and maximum
/// q1: 25, // Quartiles: Lower
/// q2: 35, // Median
/// q3: 50)) // Upper
/// })
/// ```)
///
/// - data (array, dictionary): dictionary or array of dictionaries containing the
/// needed entries to plot box and whisker plot.
///
/// The following fields are supported:
/// - `x` (number) X-axis value
/// - `min` (number) Minimum value
/// - `max` (number) Maximum value
/// - `q1`, `q2`, `q3` (number) Quartiles from lower to to upper
/// - `outliers` (array of number) Optional outliers
///
/// - axes (array): Name of the axes to use ("x", "y"), note that not all
/// plot styles are able to display a custom axis!
/// - style (style): Style to use, can be used with a palette function
/// - box-width (float): Width from edge-to-edge of the box of the box and whisker in plot units. Defaults to 0.75
/// - whisker-width (float): Width from edge-to-edge of the whisker of the box and whisker in plot units. Defaults to 0.5
/// - mark (string): Mark to use for plotting outliers. Set `none` to disable. Defaults to "x"
/// - mark-size (float): Size of marks for plotting outliers. Defaults to 0.15
/// - label (none,content): Legend label to show for this plot.
#let add-boxwhisker(data,
label: none,
axes: ("x", "y"),
style: (:),
box-width: 0.75,
whisker-width: 0.5,
mark: "*",
mark-size: 0.15) = {
// Add multiple boxes as multiple calls to
// add-boxwhisker
if type(data) == array {
for it in data {
add-boxwhisker(
it,
axes:axes,
style: style,
box-width: box-width,
whisker-width: whisker-width,
mark: mark,
mark-size: mark-size)
}
return
}
assert("x" in data, message: "Specify 'x', the x value at which to display the box and whisker")
assert("q1" in data, message: "Specify 'q1', the lower quartile")
assert("q2" in data, message: "Specify 'q2', the median")
assert("q3" in data, message: "Specify 'q3', the upper quartile")
assert("min" in data, message: "Specify 'min', the minimum excluding outliers")
assert("max" in data, message: "Specify 'max', the maximum excluding outliers")
assert(data.q1 <= data.q2 and data.q2 <= data.q3,
message: "The quartiles q1, q2 and q3 must follow q1 < q2 < q3")
assert(data.min <= data.q1 and data.max >= data.q2,
message: "The minimum and maximum must be <= q1 and >= q3")
// Y domain
let max-value = util.max(data.max, ..data.at("outliers", default: ()))
let min-value = util.min(data.min, ..data.at("outliers", default: ()))
let prepare(self, ctx) = {
return self
}
let stroke(self, ctx) = {
let data = self.bw-data
// Box
draw.rect((data.x - box-width / 2, data.q1),
(data.x + box-width / 2, data.q3),
..self.style)
// Mean
draw.line((data.x - box-width / 2, data.q2),
(data.x + box-width / 2, data.q2),
..self.style)
// whiskers
let whisker(x, start, end) = {
draw.line((x, start),(x, end),..self.style)
draw.line((x - whisker-width / 2, end),(x + whisker-width / 2, end), ..self.style)
}
whisker(data.x, data.q3, data.max)
whisker(data.x, data.q1, data.min)
}
((
type: "boxwhisker",
label: label,
axes: axes,
bw-data: data,
style: style,
plot-prepare: prepare,
plot-stroke: stroke,
x-domain: (data.x - calc.max(whisker-width, box-width),
data.x + calc.max(whisker-width, box-width)),
y-domain: (min-value, max-value),
) + (if "outliers" in data { (
type: "boxwhisker-outliers",
data: data.outliers.map(it => (data.x, it)),
axes: axes,
mark: mark,
mark-size: mark-size,
mark-style: (:)
) }),)
}
|
https://github.com/sabitov-kirill/comp-arch-conspect | https://raw.githubusercontent.com/sabitov-kirill/comp-arch-conspect/master/conf.typ | typst | #let conf(doc, color: black, title: "", pageHeader: "", credits: "") = {
set text(11pt, font: "Linux Libertine", lang: "RU", region: "RU")
set par(justify: true)
show heading: i => {
set text(fill: color)
i
}
align(center, title)
credits
outline(title: [Содержание], depth: 2, indent: true)
set page(
header: align(right + horizon)[
Билеты к экзамену по ЭВМ.
],
footer: align(
center + horizon,
[#counter(page).display()],
),
margin: (x: 1cm, y: 1cm),
)
set heading(numbering: "1.1. ")
doc
} |
|
https://github.com/Error-418-SWE/Documenti | https://raw.githubusercontent.com/Error-418-SWE/Documenti/src/1%20-%20Candidatura/Verbali/Interni/18-10-23/18-10-23.typ | typst | ERROR\_418 \
Verbale 18/10/23
#figure(
align(center)[#table(
columns: 2,
align: (col, row) => (left,left,).at(col),
inset: 6pt,
[Mail:],
[<EMAIL>],
[Redattori:],
[<NAME>, <NAME>],
[Verificatori:],
[<NAME>, <NAME>, <NAME>],
[Amministratori:],
[<NAME>, <NAME>],
[Destinatari:],
[<NAME>, <NAME>],
)]
)
#figure(
align(center)[#table(
columns: 2,
align: (col, row) => (center,center,).at(col),
inset: 6pt,
[Inizio Meeting: 15:00 Fine Meeting: 16:00 Durata:1:00h],
[],
[Presenze:],
[],
)]
)
#block[
#figure(
align(center)[#table(
columns: 5,
align: (col, row) => (center,center,center,center,center,).at(col),
inset: 6pt,
[Nome], [Durata Presenza], [], [Nome], [Durata Presenza],
[Antonio],
[1:00h],
[],
[Alessio],
[1:00h],
[Riccardo],
[1:00h],
[],
[Giovanni],
[1:00h],
[Rosario],
[1:00h],
[],
[Silvio],
[1:00h],
[Mattia],
[1:00h],
[],
[],
[],
)]
)
]
Ordine del giorno:
- Discussione capitolati;
- Discussione proposte per nomi e loghi.
= Capitolati
<capitolati>
Si sono scelti, in ordine di preferenza: C9, C5, C3. La tabella di
coordinamento è stato aggiornata di conseguenza.
== C3
<c3>
Valutazione iniziale: capitolato molto lungo e ricco di richieste.
Domande al proponente:
- Ancora da formulare.
== C3
<c3-1>
Valutazione iniziale: il capitolato richiede l’implementazione di un
numero limitato di feature. La difficoltà principale individuata è la
gestione del 3D. \
Domande al proponente:
- Chiarimenti in merito alla figura dell’amministratore;
- Controllo del movimento di veicoli all’interno del magazzino
\(controllo della congestione);
- Chiarimenti in merito all’obiettivo minimo 3: \
Possibilità di selezionare un prodotto \(oggetto all’interno della
scaffalatura) e richiederne lo spostamento in un’altra area \(altra
scaffalatura o la stessa);
- Domanda in merito alla necessità di Hardware necessario alla
modellazione 3D ed eventuale fornitura da parte dell’azienda.
== C9
<c9>
Valutazione iniziale: il capitolato richiede una forte comprensione del
\"prompt engineering\" al fine di generare mediante un modello un prompt
ad-hoc per chat-GPT \(o altri modelli), con obiettivo finale
l’interrogazione di una base di dati. \
Domande al proponente:
- Fornitura di Hardware necessario al training e alla creazione del
modello;
- Come creare i prompt intermedi.
= Coordinamento
<coordinamento>
== E-mail
<e-mail>
Mail/Riflettore per il gruppo creata e impostato l’inoltro automatico
delle mail da quelle del gruppo alle mail individuali.
== Repository
<repository>
Creata l’organizzazione GitHub e aggiunti tutti i membri.
== Risoluzioni
<risoluzioni>
Confermare l’inoltro automatico nella propria casella di posta
\@<EMAIL>. \
Giovanni contatta i proponenti C5 e C9 per esporre le domande proposte.
\
Antonio si occupa di impostare le pipeline per la creazione dei
documenti. \
Fissare meeting il prima possibile non appena ricevuta risposta dai
proponenti. \
Darsi delle regole per il WoW su commit, gestione PR, CI e strumenti
adottati.
|
|
https://github.com/AU-Master-Thesis/thesis | https://raw.githubusercontent.com/AU-Master-Thesis/thesis/main/sections/0-predoc/abstract.typ | typst | MIT License | #import "../../lib/mod.typ": *
= Abstract <abstract>
Automation advancements ultimately lead to sophisticated autonomous systems in fields like agriculture and transportation, requiring efficient path planning to optimize movement and prevent collisions. As such, this thesis explores enhancing multi-agent path planning in complex environments using #acr("GBP") and global pathfinding strategies such as #acr("RRT*"). It addresses inefficiencies and limitations in current systems, particularly in collision avoidance and navigation through intricate and constrained spaces. The key contributions are; the development of a flexible simulation framework called #acr("MAGICS"), in-depth studies of possible enhancements to #acr("GBP") algorithms, integrating a global planning layer and introducing a new tracking factor to the #acr("GBP") structure.
The core problem is the inefficiency and limitations of current systems in complex environments, exacerbated by a lack of robust simulation frameworks. The integration of global planning capabilities with #acr("GBP") is relatively unexplored. This thesis proposes solutions to enhance the usability, functionality, and scalability of such systems.
Three hypotheses guide this research: 1) Reimplementing the #gbpplanner@gbpplanner in a modern, flexible framework will enhance scientific communication and extendibility; 2) Enhancements, such as different #acr("GBP") iteration schedules and a more distributed approach, will improve flexibility and performance without altering core functionality; and 3) Adding a global planning layer will improve navigation in complex environments without compromising local collision avoidance or performance. The new tracking factor will be able reduce path deviation.
The methodology involves reimplementing the original #gbpplanner in the new simulation tool #acr("MAGICS"), introducing and testing various #acr("GBP") iteration schedules and amounts, and extending the reimplementation with a global planning layer, and a tracking factor.
// #acr("MAGICS") enhances usability while reproducing original results on some metrics, and on others it lacks behind. Studying iteration schedules and amount deepens current knowledge, and concretises factualities before left up to assumptions. The global planning layer significantly improves navigation in complex environments, without degrading performance.
The thesis concludes that reimplementing the #gbpplanner in a modern simulation framework, along with targeted enhancements and extending the existing systems with a global planning layer and a tracking factor, evidently improves the extendibility of multi-agent path planning systems. #acr("MAGICS") enhances usability while reproducing original results on some metrics, and on others it lacks behind. Studying iteration schedules and amount deepens current knowledge, and concretizes factualities that were otherwise left up to assumptions. The global planning layer significantly improves navigation in complex environments, without degrading performance. Even though the tracking factor did reduce path deviation by a substantial amount, it also increased collision count.
// Future work includes refining the simulation framework, exploring further algorithmic enhancements, and testing the global planning layer across diverse complex environments. The study opens avenues for integrating advanced AI techniques and improving real-time performance in multi-agent systems. By addressing current limitations and proposing innovative solutions, this thesis contributes significantly to the advancement of multi-agent path planning, enabling more efficient and effective autonomous systems in complex environments.
|
https://github.com/shealligh/typst-template | https://raw.githubusercontent.com/shealligh/typst-template/main/readme.md | markdown | # Assignment template based on Typst
## Basic usage
Create another file, e.g. hw1.typ, import this template and config basic information.
```typ
#import "conf.typ": *
#show: doc => conf(
course: [course name],
homework: [Homework 1/2/3/4/],
due_time: [Sep 16/17/18, 2024],
instructor: [someone],
student: [you],
id: [id],
doc,
)
```
Then write problems in homework like this:
```typ
#problem(name: [name])[ // or #problem(name: "name")
#lorem(20)
something
]
```
or number the problems automatically:
```typ
#problem[
#lorem(50)
something
]
```
## Other useful functions
```typ
#proof[ // #proof(color: blue)[...]
#lorem(50)
something
]
```
```typ
#ans[ // #ans(color: red)[...]
#lorem(50)
something
]
```
|
|
https://github.com/drupol/master-thesis | https://raw.githubusercontent.com/drupol/master-thesis/main/src/thesis/abstract.typ | typst | Other | #import "theme/abstract.typ": *
#abstract[
The concept of reproducibility has long been a cornerstone in scientific
research, ensuring that results are robust, repeatable, and can be
independently verified. This concept has been extended to computer science,
focusing on the ability to recreate identical software artefacts. However, the
importance of reproducibility in software engineering is often overlooked,
leading to challenges in the validation, security, and reliability of software
products.
This master's thesis aims to investigate the current state of reproducibility
in software engineering, exploring both the barriers and potential solutions
to making software more reproducible and raising awareness. It identifies key
factors that impede reproducibility such as inconsistent environments, lack of
standardisation, and incomplete documentation. To tackle these issues, I
propose an empirical comparison of tools facilitating software
reproducibility.
To provide a comprehensive assessment of reproducibility in software
engineering, this study adopts a methodology that involves a hands-on
evaluation of four different methods and tools. Through a systematic
evaluation of these tools, this research seeks to determine their
effectiveness in establishing and maintaining identical software environments
and builds.
This study contributes to academic knowledge and offers practical insights
that could influence future software development protocols and standards.
]
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compute/data-02.typ | typst | Other | // Error: 18-28 file is not valid utf-8
#let data = read("test/assets/files/bad.txt")
|
https://github.com/goshakowska/Typstdiff | https://raw.githubusercontent.com/goshakowska/Typstdiff/main/tests/test_working_types/code/code.typ | typst | `print("first line")`
`print("second line")` |
|
https://github.com/fenjalien/metro | https://raw.githubusercontent.com/fenjalien/metro/main/tests/complex/num/test.typ | typst | Apache License 2.0 | #import "/src/lib.typ": *
#set page(width: auto, height: auto, margin: 1cm)
#complex(1, 1)
#complex(1, 45deg)
#complex(1, 1, complex-mode: "cartesian")
#complex(1, 45deg, complex-mode: "cartesian", round-mode: "places")
#complex(1, 1, complex-mode: "polar", round-mode: "places", round-pad: false)
#complex(1, 45deg, complex-mode: "polar")
|
https://github.com/pths-prog-paradigms/Home | https://raw.githubusercontent.com/pths-prog-paradigms/Home/main/maven-guide.typ | typst |
#set par(justify: true)
= Запуск программ без среды разработки
Собирать проекты из больше чем одного файла вручную --- занятие довольно
болезненное. Поэтому воспользуемся средой разработки Maven
== Установка
Предполагается, что вы уже установили java необходимой версии (17+), а также
Git. Проверьте, что у вас переменная окружения JAVA_HOME существует и указывает
на папку установки Java (Например, у меня это `C:\Program Files\Java\jdk-17`).
Если нет --- добавьте её. https://remontka.pro/environment-variables-windows/ --- Вот довольно подробный гайд, если вы не знаете, что такое переменные
окружения и с чем их едят.
Скачайте Maven (вас интересует binary zip archive): https://maven.apache.org/download.cgi --- ссылка.
Распакуйте, куда считаете нужным. Установите переменную MAVEN_HOME --- место,
куда вы его распаковали (например, у меня это `C:\Program
Files\Maven\apache-maven-3.9.5`). Добавьте вхождение `%MAVEN_HOME%\bin` в
переменную Path. Перезагрузите компьютер, чтобы изменения вступили в действие.
== Взаимодействие с репозиторием из консоли
Git Bash --- эмулятор терминала для Windows. Изначально он откроется в "домашнем"
каталоге --- `C\Users\Ваш-пользователь`. Для перемещения между каталогами
используйте команду `cd`. Можно посмотреть справку по ней, набрав `cd --help`.
Используйте `cd ..`, чтобы перейти в родительский каталог, `cd имя`, чтобы
перейти в каталог `имя` (Если в имени присутствуют пробелы или кириллица, нужно
выделить имя в кавычки: `cd "Имя каталога"`). При нажатии Tab терминал дополнит
название, если сможет (если у вас единственный файл/каталог с набранным
префиксом)
Чтобы склонировать репозиторий, используйте команду ```bash
git clone <ссылка-на-репозиторий>
``` Будьте внимательны, Ctrl+C и Ctrl+V в консоли работают не ожидаемым образом.
Вместо них для копирования и вставки используйте Ctrl+Insert и Shift+Insert.
Репозиторий склонируется в каталог, в котором вы находитесь, создав подкаталог с
именем репозитория.
Чтобы отправить на сервер своё решение, из каталога репозитория (после
предыдущего шага, например, нужно было бы сделать `cd kotlin-basics-LDemetrios`)
выполните команды
```bash
git add .
git commit 'Ваше сообщение'
git push```
При клонировании и при пуше у вас могут потребовать ввести passphrase, которую
вы указывали при создании ssh-ключа.
== Редакторы
Писать можно хоть в блокноте, но более приятно, всё же, с подсветкой и хоть
каким-то автоформатированием. Из очень легковесных и бесплатных редакторов могу
посоветовать Sublime Text.
== Собственно, сборка проекта.
Каждый репозиторий с заданием уже объявлен как Maven-проект (для этого в корне
должен лежать файл pom.xml с описанием структуры проекта).
В задании по KotlinBasics не учтено, что может возникнуть необходимость работать
без IDE, поэтому чтобы запускаться из консоли, поменяйте pom.xml в проекте на
тот, что лежит https://github.com/pths-prog-paradigms/Home/blob/main/kotlin-basics/pom.xml --- здесь.
Из консоли (не из Git Bash, а именно из Windows'овой консоли), из каталога
проекта (пользоваться можно той же командой сd для перемещения), выполните
```bash
mvn package
```
При первом запуске выполнение команды займёт довольно много времени --- ей нужно
скачать все зависимости, используемые в проекте (в нашем случае это
kotlin-stdlib).
После этого можно запустить вашу программу:
```bash
java -jar target\KotlinBasics-1.0-SNAPSHOT-jar-with-dependencies.jar
```
(имя архива перед этим вам выведет команда mvn package:
#text(
size: 10pt,
)[
#show "INFO" : (it) => text(fill: rgb("#7700ff"), it)
#show "BUILD SUCCESS" : (it) => text(fill: rgb("#008800"), it)
#show "assembly:3.6.0:single" : (it) => text(fill: rgb("#008800"), it)
#show "jar:3.3.0:jar" : (it) => text(fill: rgb("#008800"), it)
#show regex(" KotlinBasics ") : (it) => text(fill: rgb("#5555ff"), it)
`
[INFO] --- jar:3.3.0:jar (default-jar) @ KotlinBasics ---
[INFO] Building jar: C:\Users\Admin\oop-LDemetrios\target\KotlinBasics-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- assembly:3.6.0:single (make-assembly) @ KotlinBasics ---
[INFO] Building jar: C:\Users\Admin\oop-LDemetrios\target\` #text(weight: 700)[`KotlinBasics-1.0-SNAPSHOT-jar-with-dependencies.jar`] `
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.122 s
[INFO] Finished at: 2023-10-08T17:03:35+03:00
[INFO] ------------------------------------------------------------------------`
]
--- жирным выделено искомое имя
)
Что происходит? mvn package в соответствии с описанием в pom.xml собирает
программу в "цели" --- в случае Java и JVM-языков это jar-файл. По сути, jar
(Java ARchive) --- это zip, внутри которого скомпилированные файлы и отдельный
файл, указывающий, что является в программе главным (в нашем случае он только
указывает на местоположение метода main). `java -jar <...>` --- вы этот архив
запускаете как java-программу. Дело в том, что Kotlin компилируется в
JVM-bytecode, в то же, во что и Java. Поэтому исполнитель у них один и тот же.
Забавный факт: при создании задания по OOP я забыл поменять название проекта,
поэтому там тоже архива будет называться KotlinBasics :). |
|
https://github.com/han0126/MCM-test | https://raw.githubusercontent.com/han0126/MCM-test/main/2024校赛typst/chapter/chapter4.typ | typst | #import "../template/template.typ": *
= 符号说明
#figure(
table(
columns: (1fr,1fr),
align: horizon + center,
stroke: none,
table.hline(stroke: 1.5pt),
table.header(
[符号],[说明]
),
table.hline(stroke: 0.8pt),
[$a_0$],[线性回归方程常数项],
[$a_1$],[线性回归方程一次项],
[$a_2$],[线性回归方程二次项],
[$b_1$],[非线性回归方程分子一次项],
[$b_2$],[非线性回归方程分子常数项],
[$b_3$],[非线性回归方程分母常数项],
table.hline(stroke: 1.5pt),
)
) |
|
https://github.com/howardlau1999/sysu-thesis-typst | https://raw.githubusercontent.com/howardlau1999/sysu-thesis-typst/master/chapters/acknowledgement.typ | typst | MIT License | 感谢 Typst 开发者的辛勤付出。们断的？ 明民人是男，难是体士育然机影小中都等拿大环集为理十的各是却没热名这说不有用展一农答的; 的引然于技望一没痛港样！ 着西结爸轮。 接买了紧身分物的前类这时求一。 人家去的有...... 学事的共于传的代字近眼活不计台己美可半天及一保易内湾过到经人在，法中当书那间...... 学容尽人花每的清小跟法我本其。 福称当近我有，出条的会山们新医、些美理不，管也仍任我山间日和现论底管诗大大至销且人子不心我每...... 委面任力不成另科务奇象皮，以是族相车政什资理的电因当，年才球调称。
是虽成有动是。 好标而，爱我停智怎在要结感身但是话美。
获谢改微传正大上实他益政告动是！ 共是异。 合会以价领善在就善断然是个长上清小大题有下！ 台治文教...... 半呢济病书。 人代带还设：在是想一着。 入三英别电，的现先存河心设时马他呢，将以生吗然意衣处因一母真里...... 连那最，观例各？ 突打脑考世近商物有适类力可了标象亲何下说位院世班医做的难开而取参刻不力形算、宝持增前不要的有球：是西评趣样修生特统生病图农看以实线精说顾个营如结公样朋读着大大业而亚人们什和创点实车能安他好中己...... 化一亲水人怀、不此他越，出功作处一父果好度的微有供个道长评。
施落见的必眼一好生利后花分所。 皮希快观事、一前节给分如...... 方引论了党里过汽对有如，在之求言这有斯工走过后管安觉天作管无不政？ 春国发安谈衣高险公孩可，来发她实外不有水香比本合果以云？
|
https://github.com/howardlau1999/sysu-thesis-typst | https://raw.githubusercontent.com/howardlau1999/sysu-thesis-typst/master/thesis.typ | typst | MIT License | #import "template.typ": *
#show: doc => conf(
outlinedepth: 3,
blind: false,
listofimage: true,
listoftable: true,
listofcode: true,
alwaysstartodd: true,
doc,
)
#include "chapters/ch01.typ"
#include "chapters/ch02.typ"
#include "chapters/ch03.typ"
#appendix()
#include "chapters/appendix01.typ"
#include "chapters/appendix02.typ"
#pagebreak()
#bibliography(("bibs/ex01.bib", "bibs/ex02.bib"),
style: "ieee"
)
|
https://github.com/mdm/igotist | https://raw.githubusercontent.com/mdm/igotist/main/scale.typ | typst | #let fit(label, width, height) = {
let stretch = if label.len() > 1 { 50% } else { 100% }
set text(font: "Inter", size: height, stretch: stretch)
style(styles => {
let size = measure(label, styles)
let x = 70% * (width / size.width)
scale(x: x, label)
})
}
#circle(radius: 25pt)[
#set align(center + horizon)
#fit(str(100), 50pt, 50pt)
]
|
|
https://github.com/daskol/typstd | https://raw.githubusercontent.com/daskol/typstd/main/doc/subsection.typ | typst | Apache License 2.0 | #import "template.typ": *
== Subsection
@hu2021lora
|
https://github.com/barrel111/readings | https://raw.githubusercontent.com/barrel111/readings/main/notes/aluffi.typ | typst | #import "@local/preamble:0.1.0": *
#import "@preview/commute:0.2.0": node, arr, commutative-diagram
#show: project.with(
course: "Algebra",
sem: "Summer",
title: "Algebra",
subtitle: "Aluffi",
authors: ("<NAME>",),
)
#set enum(indent: 15pt, numbering: "a.")
#let Obj = $"Obj"$
#let Hom = (c, a, b) => $"Hom"_(sans(#c))(#a, #b)$
= Preliminaries
== Naive Set Theory
#definition[The _ordered pair_ $(s, t)$ can be defined as the set ${s, {s, t}}$. This
retains both the elements of the tuple but also conveys an ordering.]
#definition[The _disjoint union_ of two sets $S, T$ is the set $S union.sq T$ obtained by
first producing 'copies' $S'$ and $T'$ and then taking the union.]
#definition[The _product_ of two sets $S,T$ is the set $S times T$ defined as $ S times T = {(s, t) "such that" s in S,, t in T}. $]
#definition[A _relation_ on a set $S$ is a subset $R$ of the product $S times S$. If $(a, b) in R$,
we write $a R b$.]
#definition[An _equivalence relation_ on a set $S$ is any relation $tilde$ satisfying the
following properties
+ _reflexivity_: $forall a in S. #h(5pt) a tilde a$
+ _symmetry_: $forall a in S. forall b in S. #h(5pt) a tilde b arrow.double.l.r.long b tilde a$
+ _transitivity_: $forall a in S. forall b in S. forall c in S. #h(5pt) a tilde b, b tilde c arrow.long.double a tilde c$.]
#definition[A _partition_ of $S$ is a family of _disjoint_ nonempty subsets of $S$ whose
union is $S$.]
#definition[Let $tilde$ be an equivalence relation on $S$. Then for every $a in S$, the _equivalence class_ of $a$ is
the subset $S$ defined by $ [a]_tilde = {b in S bar b tilde a}. $ Further, the
equivalence classes form a partition $cal(P)_tilde$ of $S$.]
#lemma[Every partition of $S$ corresponds to an equivalence relation.]
#definition[The _quotient_ of the set $S$ with respect to the equivalence relation $tilde$ is
the set $ S tilde = cal(P)_tilde $ of equivalence classes of elements of $S$ with
respect to $tilde$.]
== Functions Between Sets
#definition[The graph of $f$ is the set $ Gamma_f = {(a, b) in A times B bar b = f(a)} subset.eq A times B. $ Officially,
a function _is_ its graph together with information of the source $A$ and the
target $B$ of $f$.]
#definition[A function is a relation $Gamma subset.eq A times B$ such that $forall a in A, exists! b in B$ with $(a, b) in Gamma$.
To denote $f$ is a function from $A$ to $B$ we write $f: A arrow.long B$.]
#definition[The collection of all functions from a set $A$ to a set $B$ is denoted $B^A$.]
#example[Every set $A$ comes equipped with the _identity function_, $"id"_A: A to A$,
whose graph is the diagonal in $A times A$. It is defined by $forall a in A. #h(5pt) "id"_A (a) = a.$]
#definition[If $S subset.eq A$, for $f: A to B$, we define $f(S) subset.eq B$ as $ f(S) = {b in B bar exists a in S. b = f(a)} $]
#definition[The _restriction_ of $f: A to B$ to $S subset.eq A$, denoted $f bar_S$ is the
function $S to B$ defined by $ forall s in S. #h(8pt) f bar_S (s) = f(s). $]
#remark[The restriction can be equivalently described as $f compose i$ where $i: S to A$ is
the inclusion. Further, $f(S) = "im"(f bar_S)$.]
#example(
"Multisets",
)[A _multiset_ is like a set but allows for multiple instances of each element. A
multiset may be defined by giving a function $m: A to NN^star$, where $N^star$ is
the set of positive integers. The corresponding multiset consists of the
elements $a in A$, each taken $m(a)$ times.]
#example(
"Indexed Sets",
)[One may think of an _indexed set_ ${a_i}_(i in I)$ as set whose elements are
denoted by $a_i$ for $i$ ranging over some 'set of indices' $I$. Instead, it is
more proper to think of an indexed set as a function $a: I to A$, with the
understanding that $a_i$ is a shorthand for $a(i)$. One benefit is that this
allows us to consider $a_0, a_1$ as distinct elements of ${a_i}_(i in NN)$ even
if $a_0 = a_1$ as elements of $A$.]
#definition[If $f: A to B$ and $g: B to C$ are functions then so is the operation $g compose f$ defined
by $ forall a in A. #h(8pt) (g compose f)(a) = g(f(a)). $ Pictorially, the
following diagram _commutes_
#align(center)[
#commutative-diagram(
node-padding: (60pt, 50pt),
node((0, 0), $A$),
node((0, 1), $B$),
node((1, 1), $C$),
arr($A$, $B$, $f$),
arr($B$, $C$, $g$),
arr($A$, $C$, $g compose f$, label-pos: right),
)
]]
#remark[A diagram _commutes_ when the result of following a path of arrows from any
point of the diagram to any other point only depends on the starting and ending
points and not on the particular path chosen.]
#lemma[Composition of functions is associative. That is to say, if $f: A to B$, $g: B to C$ and $h: C to D$ then $ h compose (g compose f) = (h compose g) compose f. $ Graphically,
the following diagram commutes
#v(10pt)
#align(center)[
#commutative-diagram(
node-padding: (54pt, 50pt),
node((0, 0), $A$),
node((0, 1), $B$),
node((0, 2), $C$),
node((0, 3), $D$),
arr($A$, $B$, $f$),
arr($B$, $C$, $g$),
arr($C$, $D$, $h$),
arr($A$, $C$, $g compose f$, curve: -25deg, label-pos: right),
arr($B$, $D$, $h compose g$, curve: 25deg, label-pos: left),
)
]
#v(10pt)
]
#example[If $f: A to B$ then $id_B compose f = f$ and $f compose id_A = f$. Graphically,
the following diagrams commute
#v(15pt)
#align(center)[
#commutative-diagram(
node-padding: (60pt, 50pt),
node((0, 0), $A$),
node((0, 1), $B$, "B1"),
node((0, 2), $B$, "B2"),
arr($A$, "B1", $f$),
arr("B1", "B2", $id_B$),
arr($A$, "B2", $id_B compose f$, curve: 25deg),
)
#commutative-diagram(
node-padding: (60pt, 50pt),
node((0, 0), $A$, "A1"),
node((0, 1), $A$, "A2"),
node((0, 2), $B$),
arr("A1", "A2", $id_A$),
arr("A2", $B$, $f$),
arr("A1", $B$, $id_B compose f$, curve: 25deg),
)
]]
#definition[A function $f: A to B$ is _injective_ if $forall a', a'' in A$, $a' != a'' implies f(a') != f(a'')$.]
#definition[A function $f: A to B$ is _surjective_ if $forall b in B$, $exists a in A$ such
that $b = f(a)$. That is to say $f$ _covers_ $B$ and equivalently, $im(f) = B$.]
#definition[If $f: A to B$ is both injective and surjective then it is a _bijection_. Then
we often write $f: A to^tilde B$. We also say that $A$ and $B$ are _isomorphic_ and
denote this by $A tilde.equiv B$.]
#definition[A function $g: B to A$ is a _left inverse_ of $f: A to B$ if $g compose f = id_A$.
Graphically, the following diagram commutes
#v(15pt)
#align(center)[
#commutative-diagram(
node-padding: (60pt, 50pt),
node((0, 0), $A$, "A1"),
node((0, 1), $B$),
node((0, 2), $A$, "A2"),
arr("A1", $B$, $f$),
arr($B$, "A2", $g$),
arr("A1", "A2", $id_A$, curve: 25deg),
)
]]
#definition[A function $f: A to B$ is a _right inverse_ of $g: B to A$ if $f compose g = id_A$.
Graphically, the following diagram commutes
#v(15pt)
#align(center)[
#commutative-diagram(
node-padding: (60pt, 50pt),
node((0, 0), $B$, "B1"),
node((0, 1), $A$),
node((0, 2), $B$, "B2"),
arr("B1", $A$, $g$),
arr($A$, "B2", $f$),
arr("B1", "B2", $id_B$, curve: 25deg),
)
]]
#definition[We call $g: B to A$ an inverse of $f: A to B$ if $g$ is both a left and right
inverse of $f$. Then $g$ may also be denoted $f^(-1)$.]
#prop[Assume $A != emptyset$ and let $f: A to B$ be a function. Then
+ $f$ has a left inverse iff it is injective.
+ $f$ has a right inverse iff it is surjective.]
#corollary[A function $f: A to B$ is a bijection if and only if it has a (two-sided)
inverse.]
#remark[An injective but not surjective function has no right inverse. If the source has
more than two elements, there will be more than one left inverse.]
#remark[A surjective function but not injective function will have multiple inverses.
These are called _sections_.]
#definition[Let $f: A to B$ be any function and $S subset.eq B$ be a subset. Then $f^(-1)(S)$ is
defined by $ f^(-1)(S) = {a in A bar f(a) in S}. $ If $S = {q}$ is a singleton
then $f^(-1)(T) = f^(-1)(q)$ is denoted the _fiber_ of $f$ over $q$.]
#remark[In this language: $f$ is a bijection iff it has nonempty fiber over all elements
of $B$ and every fiber is a singleton.]
#definition[A function $f: A to B$ is a _monomorphism_ (or _monic_) if for all sets $Z$ and
all functions $alpha', alpha'': Z to A$ $ f compose alpha' = f compose alpha'' implies alpha' = alpha''. $]
#prop[A function is injective iff it is a monomorphism.]
#example(
"Projection",
)[Let $A, B$ be sets. Then there are _natural projections_ $pi_A, pi_B$
#align(center)[
#commutative-diagram(
node-padding: (50pt, 30pt),
node((0, 0), $A times B$),
node((1, -1), $A$),
node((1, 1), $B$),
arr($A times B$, $A$, $pi_A$, label-pos: right, "surj"),
arr($A times B$, $B$, $pi_B$, "surj"),
)
]
defined by $ forall (a, b) in A times B. #h(10pt) pi_A ((a, b)) = a, #h(15pt) pi_B ((a, b)) = b. $ These
maps are clearly surjective.]
#example(
"Direct Sum Injection",
)[
There are natural injections from $A, B$ to their disjoint union $A union.sq B$
#align(center)[
#commutative-diagram(
node-padding: (50pt, 30pt),
node((0, 0), $A$),
node((0, 2), $B$),
node((1, 1), $A union.sq B$),
arr($A$, $A union.sq B$, "", "inj"),
arr($B$, $A union.sq B$, "", "inj"),
)
]
obtained by sending $a in A$ (resp. $b in B$) to the corresponding element in
the isomorphic copy $A'$ of $A$ (resp. $B'$ of $B$) in $A union.sq B$.
]
#example(
"Equivalence Relation Projection",
)[
Let $tilde$ be an equivalence relation on $A$. Then there is a surjective _canonical projection_
#align(center)[
#commutative-diagram(
node-padding: (45pt, 50pt),
node((0, 0), $A$),
node((0, 1), $A \/ tilde$),
arr($A$, $A \/ tilde$, "", "surj"),
)
]
obtained by sending every $a in A$ to its equivalence class $[a]_tilde in A \/ tilde$.
]
#lemma[Every function $f: A to B$ defines an equivalence relation $tilde$ on $A$ as
follows: for every $a', a'' in A$, $ a' tilde a'' iff f(a') = f(a''). $]
#prop(
"Canonical Decomposition",
)[Let $f: A to B$ be any function and define $tilde$ as above. Then $f$ decomposes
as follows:
#v(20pt)
#align(center)[
#commutative-diagram(
node-padding: (45pt, 50pt),
node((0, 0), $A$),
node((0, 1), $(A \/ tilde)$),
node((0, 2), $im(f)$),
node((0, 3), $B$),
arr($A$, $(A \/ tilde)$, "", "surj"),
arr($(A \/ tilde)$, $im(f)$, $tilde(f)$, label-pos: right),
arr($(A \/ tilde)$, $im(f)$, $tilde$),
arr($im(f)$, $B$, "", "inj"),
arr($A$, $B$, $f$, curve: 30deg),
)
]
The first function is the canonical projection $A to A\/tilde$. The third
function is the inclusion $im f subset.eq B$. The bijection $tilde(f)$ in the
middle is defined by $ tilde(f)([a]_tilde) = f(a) $ for all $a in A$.]
== Categories
#set list(indent: 15pt)
#definition[A _category_ $sans(C)$ consists of
- a class $"Obj"(sans(C))$ of _objects_ the category.
- for every two objects $A, B$ of $sans(C)$, a set $"Hom"_(sans(C)) (A, B)$ of _morphisms_ with
the following properties
- for every object $A$ of $sans(C)$, there exists (at least) one morphism $1_A in "Hom"_sans(C) (A, A)$,
the 'identity' on $A$.
- two morphisms $f in "Hom"_sans(C) (A, B)$ and $g in "Hom"_(sans(C)) (B, C)$ determine
a morphism $f g in "Hom"_(sans(C)) (A, C)$. That is for every triple of objects $A, B, C$ of $sans(C)$ there
is a function (of sets) $ "Hom"_sans(C) (A, B) times "Hom"_sans(C) (B, C) to "Hom"_sans(C) (A, C) $ and
the image of the pair $(f, g)$ is denoted $f g$.
- this composition law is associative: if $f in "Hom"_(sans(C)) (A, B)$, $g in "Hom"_(sans(C)) (B, C)$ and $h in "Hom"(sans(C)) (C, D)$ then $(h g) f = h (g f).$
- the identity morphisms are identities with respect to composition: that is for
all $f in "Hom"_(sans(C)) (A, B)$ we have $ f dot.c 1_A = f, #h(10pt) 1_B dot.c f = f. $
- the sets $"Hom"_(sans(C)) (A, B)$ and $"Hom"_(sans(C)) (C, D)$ are disjoint
unless $A = C$ and $B = D$.]
#definition[A morphism of an object $A$ of a category $C$ to itself is called an _endomorphism_.
Furthermore, $"Hom"_(sans(C))(A, A)$ is also denoted $"End"_C(A)$.]
#definition[A _diagram commutes_ if all ways to traverse it lead to the same results of
composing morphisms along the way.]
#example(
$sans("Set")$,
)[By $sans("Set")$ we denote the category of sets, where
- _objects_: $"Obj"(sans("Set")) = $ the class of all sets;
- _morphisms_: For $A, B$ in $"Obj"(sans("Set"))$, $"Hom"_(sans("Set"))(A, B) = B^A$;
- _composition_: Composition of morphisms is defined to be the same as the
composition of functions;
- _identity_: For any object $A$ of $sans("Set")$, the identity is defined to be
the identity function on $A$.]
#example(
"Relations",
)[Suppose $tilde$ is a reflexive and transitive relation on some set $S$. Then, we
can encode this data into a category, $sans("C")$.
- _objects_: The elements of $S$;
- _morphisms_: If $a, b$ are objects, then let $Hom("", a, b)$ be the set
consisting of the element $(a, b) in S times S$ if $a tilde b$ and let $Hom("", a, b) = emptyset$ otherwise;
- _composition_: For composition, let $a, b, c$ be objects and $f in Hom("", a, b)$ and $g in Hom("", b, c)$
Then, $g f in Hom("", a, c)$ is defined to be $ g f = (a, c). $
- _identity_: By reflexivity, we are guaranteed that $(a, a) in Hom("C", A, A)$.
Then, for any object $A$ of $sans("C")$, we define the identity to be $1_A = (a, a)$.
#remark[This is a _small category_;]
]
#let Shat = $accent(sans(S), hat)$
#example(
"Partial Ordering of Sets",
)[Let $S$ be a set. Define another (_small_) category $Shat$ by
- _objects_: $Obj(Shat) = cal(P)(S)$;
- _morphisms_: For $A, B$ objects of $Shat$, let $Hom(Shat, A, B)$ be the pair $(A, B)$ if $A subset.eq B$ and
let $Hom(Shat, A, B) = emptyset$ otherwise.
- _composition_: Let $A, B, C$ be objects and $f in Hom(Shat, A, B)$ and $g in Hom(Shat, B, C)$.
Then, $g f in Hom(Shat, A, C)$ is definted to be $ g f = (A, C). $
- _identity_: For any set $A$, $A subset.eq A$ and so, $(A, A) in Hom(Shat, A, A)$.
The, for every object $A$ of $sans("C")$, we define the identity to be $1_A = (A, A)$.
]
#example(
$sans("C")_A$,
)[Let $sans(C)$ be a category and let $A$ be an object of $sans(C)$. We will
define a category $sans(C)_A$ whose objects are certain _morphisms_ in $sans(C)$ and
whose morphisms are certain _diagrams_ of $sans(C)$.
- _objects_: $Obj(sans(C)_A) = $ all morphisms from any object of $sans(C)$ to $A$;
that is, an object of $sans(C)$ is an element $f in Hom(sans(C), Z, A)$ for some
object $Z$ of $sans(C)$. Pictorally, an object of $sans(C)_A$ is an arrow $Z ->^f A$ _in_ $sans(C)$;
#align(center)[
#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $Z$),
node((1, 0), $A$),
arr($Z$, $A$, $f$, label-pos: right),
)
]
- _morphisms_: For objects $f_1, f_2$ of $sans(C)_A$, that is two arrows #align(center)[
#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $Z_1$),
node((1, 0), $A$, "A1"),
node((0, 1), $Z_2$),
node((1, 1), $A$, "A2"),
arr($Z_1$, "A1", $f_1$, label-pos: right),
arr($Z_2$, "A2", $f_2$),
)
] in $sans(C)$, morphisms $f_1 -> f_2$ are defined to be _commutative diagrams_ #align(center)[
#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $Z_1$),
node((1, 1), $A$, "A1"),
node((0, 2), $Z_2$),
arr($Z_1$, "A1", $f_1$, label-pos: right),
arr($Z_2$, "A1", $f_2$),
arr($Z_1$, $Z_2$, $sigma$),
)
] in the _ambient_ category $sans(C)$. Alternatively, morphisms $f_1 -> f_2$ corresponds
to those morphisms $sigma: Z_1 -> Z_2$ in $sans(C)$ such that $f_1 = f_2 sigma$.
- _composition_: Two morphisms $f_1 -> f_2 -> f_3$ in $sans("C")_A$ correspond to putting two diagrams side-by-side, #align(center)[
#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $Z_1$),
node((0, 2), $Z_2$),
node((0, 4), $Z_3$),
node((1, 2), $A$),
arr($Z_1$, $Z_2$, $sigma$),
arr($Z_2$, $Z_3$, $tau$),
arr($Z_1$, $A$, $f_1$, label-pos: right),
arr($Z_2$, $A$, $f_2$),
arr($Z_3$, $A$, $f_3$)
)
] That is, the composition $f_1 -> f_2 -> f_3$ is the commutative diagram #align(center)[#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $Z_1$),
node((0, 2), $Z_3$),
node((1, 1), $A$),
arr($Z_1$, $A$, $f_1$, label-pos: right),
arr($Z_3$, $A$, $f_3$),
arr($Z_1$, $Z_3$, $tau sigma$)
)]
- _identity_: The identity morphism corresponds to the following commutative diagram #align(center)[#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $Z$, "Z1"),
node((0, 2), $Z$, "Z2"),
node((1, 1), $A$),
arr("Z1", $A$, $f$, label-pos: right),
arr("Z2", $A$, $g$),
arr("Z1", "Z2", $"id"_Z$),
)]
Categories constructed in these manners are known as _slice categories_, which
are particular cases of _comma categories_.]
#example(
$sans("C")_A "II"$,
)[Suppose $sans(C)$ is the category with $S = ZZ$ and using the relation $<=$.
Choose an object $A = 3$ of $sans(C)$. Then the objects of $sans(C)_A$ are
morphisms in $sans(C)$ with target $3$, that is, pairs $(n, 3) in ZZ times ZZ$ with $n <= 3$.
There is a morphism #align(center)[
#commutative-diagram(
node-padding: (30pt, 40pt),
node((0, 0), $(m, 3)$),
node((0, 1), $(n, 3)$),
arr($(m, 3)$, $(n, 3)$, $$),
)
] if and only if $m <= n$. In this example, $sans(C)_A$ may be harmlessly
identified with the _subcategory_ of integers $<= 3$ with the _same_ morphisms
as in $sans(C)$.]
#example(
$sans("C")^A$,
)[We can consider a construction similar to slice categories but one where we take
objects to be morphisms in a category $sans(C)$ _from_ a fixed object $A$ to all
objects in $sans(C)$. Morphisms are again defined to be suitable commutative
diagrams. This construction is known as _the coslice category_.]
#example(
$sans("C")^A "II"$,
)[Let $sans(C) = sans("Set")$ and $A = "fixed singleton" = {star}$. Call the
constructed co-slice category $sans("Set")^star$.
An object in $sans("Set")^star$ is then a morphism $f: {star} -> S$ in $sans("Set")$ where $S$ is
any set. The information of an object in $sans("Set")^star$ consists of a
nonempty set $S$ and an element $s in S$ -- that is, the element $f(star)$. This
element determines and is determined by, $f$. So, we can denote objects of $sans("Set")^star$ as
pairs $(S, s)$ where $S$ is any set and $s in S$ is any element of $S$.
A morphism between two such objects, $(S, s) -> (T, t)$ corresponds to a set
function $sigma: S -> T$ _such that_ $sigma(s) = t$.
Objects of $sans("Set")^star$ are called _pointed sets_.]
#example(
$sans(C)_(A, B)$,
)[Start from a category $sans(C)$ and two objects $A, B$ of $sans(C)$. We then
define a new category $sans(C)_(A, B)$ by a similar procedure with which we
defined $sans(C)_A$.
- _objects_: $Obj(sans(C)_(A, B)) =$ diagrams\ #box(width: 100%)[#align(center)[
#commutative-diagram(
node-padding: (50pt, 20pt),
node((0, 0), $Z$),
node((-1, 1), $A$),
node((1, 1), $B$),
arr($Z$, $A$, $f$),
arr($Z$, $B$, $g$, label-pos: right),
)
]] in $sans(C)$;
- _morphisms_:\ #box(width: 100%)[#align(center)[
#commutative-diagram(
node-padding: (40pt, 25pt),
node((0, 0), $Z_1$),
node((-1, 1), $A$),
node((1, 1), $B$),
node((0, 2), $Z_2$, "Z2"),
node((-1, 3), $A$, "A1"),
node((1, 3), $B$, "B1"),
node((0, 1), $$, "S"),
arr($Z_1$, $A$, $f_1$),
arr("Z2", "A1", $f_2$),
arr($Z_1$, $B$, $g_1$, label-pos: right),
arr("Z2", "B1", $g_1$, label-pos: right),
arr("S", "Z2", $$),
)
]] are _commutative diagrams_ #align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
node((-1, 2), $A$),
node((1, 2), $B$),
arr($Z_1$, $Z_2$, $sigma$),
arr($Z_2$, $A$, $f_2$),
arr($Z_2$, $B$, $g_2$, label-pos: right),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
)
] Alternatively, morphisms in $sans(C)_(A, B)$ corresponds to those morphisms $sigma: Z_1 -> Z_2$ in $sans(C)$ such
that $f_1 = f_2 sigma$ and $g_1 = g_2 sigma$.
- _composition_: Consider the two morphisms #align(center)[#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
node((-1, 2), $A$),
node((1, 2), $B$),
arr($Z_1$, $Z_2$, $sigma$),
arr($Z_2$, $A$, $f_2$),
arr($Z_2$, $B$, $g_2$, label-pos: right),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
)
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_2$),
node((0, 1), $Z_3$),
node((-1, 2), $A$),
node((1, 2), $B$),
arr($Z_2$, $Z_3$, $sigma'$),
arr($Z_3$, $A$, $f_3$),
arr($Z_3$, $B$, $g_3$, label-pos: right),
arr($Z_2$, $A$, $f_2$, curve: 25deg),
arr($Z_2$, $B$, $g_2$, curve: -25deg, label-pos: right),
)
] Then, their composition corresponds to the commutative diagram #align(center)[#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
arr($Z_1$, $Z_2$, $sigma$),
arr($Z_2$, $A$, $f_2$, curve: 15deg),
arr($Z_2$, $B$, $g_2$, label-pos: right, curve: -15deg),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
node((0, 3), $Z_3$),
node((-1, 5), $A$),
node((1, 5), $B$),
arr($Z_3$, $A$, $f_3$, label-pos: left),
arr($Z_3$, $B$, $g_3$, label-pos: right),
arr($Z_2$, $Z_3$, $sigma'$))] That is, the composition of the two morphism corresponds to the following morphism #align(center)[#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_3$),
arr($Z_1$, $Z_3$, $sigma' sigma$),
node((-1, 2), $A$),
node((1, 2), $B$),
arr($Z_1$, $A$, $f_1$, curve: 20deg),
arr($Z_1$, $B$, $g_1$, curve: -20deg, label-pos: right),
arr($Z_3$, $A$, $f_3$),
arr($Z_3$, $B$, $g_3$, label-pos: right)
)]
- _identity_: The identity morphism corresponds to the following commutative diagram #align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z$, "Z_1"),
node((0, 1), $Z$, "Z_2"),
node((-1, 2), $A$),
node((1, 2), $B$),
arr("Z_1", "Z_2", $"id"_Z$),
arr("Z_2", $A$, $f$),
arr("Z_2", $B$, $g$, label-pos: right),
arr("Z_1", $A$, $f$, curve: 25deg),
arr("Z_1", $B$, $g$, curve: -25deg, label-pos: right),
)
]]
#example(
$italic("Fibered") sans(C)_(A, B)$,
)[Start with a given category $sans("C")$ and choose two fixed morphisms $alpha: A -> C, beta: B -> C$ in $sans("C")$ with
the same target $C$. We can then consider a category $C_(alpha, beta)$ as
follows
- _objects_: $Obj(sans(C)_(alpha, beta))$ = commutative diagrams\ #box(width: 100%)[#align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z$),
node((-1, 1), $A$),
node((1, 1), $B$),
node((0, 2), $C$),
arr($Z$, $A$, $f$),
arr($Z$, $B$, $g$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
)
]] in $sans(C)$;
- _morphisms_: morphisms correspond to commutative diagrams\ #box(width: 100%)[#align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
node((-1, 2), $A$),
node((1, 2), $B$),
node((0, 3), $C$),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
arr($Z_2$, $A$, $f_2$),
arr($Z_2$, $B$, $g_2$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr($Z_1$, $Z_2$, $sigma$),
)
]]
- _composition_: Consider the two morphisms #align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
node((-1, 2), $A$),
node((1, 2), $B$),
node((0, 3), $C$),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
arr($Z_2$, $A$, $f_2$),
arr($Z_2$, $B$, $g_2$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr($Z_1$, $Z_2$, $sigma$),
)
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_2$),
node((0, 1), $Z_3$),
node((-1, 2), $A$),
node((1, 2), $B$),
node((0, 3), $C$),
arr($Z_2$, $A$, $f_2$, curve: 25deg),
arr($Z_2$, $B$, $g_2$, curve: -25deg, label-pos: right),
arr($Z_3$, $A$, $f_3$),
arr($Z_3$, $B$, $g_3$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr($Z_2$, $Z_3$, $sigma'$),
)
] Then their composition corresponds to the commutative diagram #align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
arr($Z_2$, $A$, $f_2$, curve: 15deg),
arr($Z_2$, $B$, $g_2$, curve: -15deg, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr($Z_1$, $Z_2$, $sigma$),
node((0, 3), $Z_3$),
node((-1, 4), $A$),
node((1, 4), $B$),
node((0, 5), $C$),
arr($Z_3$, $A$, $f_3$),
arr($Z_3$, $B$, $g_3$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr($Z_2$, $Z_3$, $#h(10pt) sigma'$)
)
] That is, the composition of the two morphism corresponds to the following morphism #align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z_1$),
node((0, 1), $Z_2$),
node((-1, 2), $A$),
node((1, 2), $B$),
node((0, 3), $C$),
arr($Z_1$, $A$, $f_1$, curve: 25deg),
arr($Z_1$, $B$, $g_1$, curve: -25deg, label-pos: right),
arr($Z_2$, $A$, $f_3$),
arr($Z_2$, $B$, $g_3$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr($Z_1$, $Z_2$, $sigma' sigma$),
)
]
- _identity_: The identity morphism corresponds to the following commutative diagram #align(center)[
#commutative-diagram(
node-padding: (40pt, 30pt),
node((0, 0), $Z$, "Z_1"),
node((0, 1), $Z$, "Z_2"),
node((-1, 2), $A$),
node((1, 2), $B$),
node((0, 3), $C$),
arr("Z_1", $A$, $f$, curve: 25deg),
arr("Z_1", $B$, $g$, curve: -25deg, label-pos: right),
arr("Z_2", $A$, $f$),
arr("Z_2", $B$, $g$, label-pos: right),
arr($A$, $C$, $alpha$),
arr($B$, $C$, $beta$, label-pos: right),
arr("Z_1", "Z_2", $"id"_Z$),
)
]]
== Morphisms
Throughout this section let $sans(C)$ be a category.
#definition(
"Isomorphism",
)[A morphism $f in Hom(C, A, B)$ is an _isomorphism_ if it has a (two-sided)
inverse: that is $exists g in Hom(C, B, A)$ such that $ g f = 1_A #h(25pt) f g = 1_B. $]
#prop[The inverse of an isomorphism is unique.]
#remark[Due to uniqueness, we may unambiguously refer to the inverse of an isomorphism $f$ as $f^(-1)$.]
#prop[+ Each identity $1_A$ is an isomorphism and is its own inverse,
+ If $f$ is an isomorphism. the $f^(-1)$ is an isomorphism and further $(f^(-1))^(-1) = f$,
+ If $f in Hom(C, A, B)$ and $g in Hom(C, B, C)$ are isomorphisms, then the
composition $g f$ is an isomorphism and $(g f)^(-1) = f^(-1) g^(-1)$.]
#definition[Two objects $A, B$ of a category $sans(C)$ are _isomorphic_ if there is an
isomorphism $f:A -> B$.]
#corollary[ Isomorphism is an equivalence relation on the objects of a category. ]
#example[Isomorphisms in $sans("Set")$ are precisely bijective functions.]
#example[In the category $sans(C)$ obtained from the relation $<=$ on $ZZ$ there is a
morphism $a -> b$ and $b -> a$ only if $a <= b$ and $b <= a$-- that is, if $ a = b$.
So an isomorphism must act from an object to itself and in $sans(C)$ there is
only one such object $1_a$.]
#example[There are categories in which every morphism is an isomorphism. These are known
as _groupoids_.]
#definition[An _automorphism_ of an object $A$ of a category $sans("C")$ is an isomorphism
from $A$ to itself. The set of automorphisms is denoted $"Aut"_(sans("C"))(A)$ and
is a subset of $"End"_("C")(A)$.]
#remark[Equipped with composition, $"Aut"_(sans("C"))(A)$ is a group!]
#definition[Let $sans("C")$ be a category. A morphism $f in Hom("C", A, B)$ is a _monomorphism_ if
for all objects $Z$ of $sans("C")$ and all morphisms $alpha', alpha'' in Hom(C, Z, A)$, $ f compose alpha' = f compose alpha'' implies alpha' = alpha''. $]
#definition[Let $sans("C")$ be a category. A morphism $f in Hom("C", A, B)$ is an _epimorphism_ if
the following holds if for all objects $Z$ of $sans("C")$ and all morphisms $beta', beta'' in Hom("C", B, Z)$, $ beta' compose f = beta'' compose f implies beta' = beta''. $]
#example[In $sans("C")$, injective functions are _monomorphisms_ whereas surjective
functions are _epimorphisms_.]
#example[In the category $sans("C")$ obtained from the relation $<=$ on $ZZ$, every
morphism is both a monomorphism and an epimorphism. However, there is at most
one isomorphism between any two pair of objects in $sans("C")$.]
#remark[The previous example shows how the property of $sans("Set")$, wherin a function
is an isomorphism iff it is a monomorphism and epimorphism, doesn't generalize
to all categories. It can be shown that this is true in _abelian categories_ (but $sans("Set")$ isn't
an example of one!)]
#remark[The property of $sans("Set")$ that a function is an epimorphism iff it has a
right inverse doesn't generalize to all categories either.]
== Universal Properties
#definition[We say that an object $I$ of category $sans("C")$ is _initial_ in $sans("C")$ if
for every object $A$ of $sans("C")$ there exists exactly one isomorphism $I -> A$ in $sans("C")$--- that
is, for every object $A$ of $sans("C")$, $Hom("C", I, A)$ is a singleton.]
#definition[We say that an object $F$ of category $sans("C")$ is _final_ in $sans("C")$ if
for every object $A$ of $sans("C")$ there exists exactly one isomorphism $A -> F$ in $sans("C")$--- that
is, for every object $A$ of $sans("C")$, $Hom("C", A, F)$ is a singleton.]
#definition[An object $F$ of category $sans("C")$ is _terminal_ in $sans("C")$ if it is
either initial or final.]
|
|
https://github.com/Skimmeroni/Appunti | https://raw.githubusercontent.com/Skimmeroni/Appunti/main/Statistica4AI/Introduction/Statistics.typ | typst | Creative Commons Zero v1.0 Universal | #import "../Stats4AI_definitions.typ": *
The discipline of statistics instructs how to make intelligent judgments
and informed decisions in the presence of uncertainty and variation.
Collections of facts are called *data*: statistics provides methods
for organizing, summarizing and drawing conclusions based on information
contained in the data.
A statistical enquiry will typically focus on a well-defined collection of
objects constituting a *population*. When desired information is available
for all objects in the population, a *census* is available.
In general, such a situation is hardly possible, either because it would be
too expensive or too time consuming to do so or simply because the population
has an infinite amount of members. A more reasonable approach is to extract
a subset of the population, called *sample* that is both sufficiently small
to be able to work with and sufficiently large to capture all the nuances of
the population as a whole.
// Provide an example
Each object of the population possesses many features, some of which may
or may not be of interest. Any feature whose value might change from object
to object in the population and that has relevance with respect to a
statistical enquiry is called a *variable*.
Variables are generally distinct in *numerical* variables and *categorical*
variables. Numerical variables are distinct in *discrete* and *continuous*.
Numerical variables are discrete if the set of its possible values is either
finite or countably infinite. Numerical variables are continuous if the
set of its possible values is uncountably infinite. Categorical variables
are distinct in *ordinal* and *nominal*. Categorical variables are ordinal
if the set of its possible values obeys an objective hierarchy or ordering
of some sort, otherwhise are called *nominal*.
#exercise[
Provide an example for each of the four types of variables.
]
#solution[
- A numerical discrete variable could be the number of items sold in a
store, since such number is necessarely an integer (it's not possible
to sell, say, half an item, or three quarters of an item). Another
example is the number of attempts necessary to win the lottery: it
could be infinite, but it's still countable;
- A numerical continuous variable could be the temperature measured in
a certain meteorological station, since such value is a real number
(it could be approximated to an integer, but it would entail losing
much informaton);
- A categorical ordinal variable could be the ranks in an army, such
as general, private, captain, etcetera. Such ranks can be arranged
in a (very) strict hierarchy, for example corporal is lower than
general while corporal is higher than private;
- A categorical nominal variable could be the colors of a dress.
It would make little sense to say that, for example, red scores
higher than green or that pink scores lower than blue, at least
in an objective way.
]
When referring to "statistics", it often entails two distinct concepts.
The first one is *descriptive statistics*, that consists in summarizing
and describing the data, in general through graphical representations
(called *plots*) or through *summary measures*, numbers that on their
own represent an aspect of the data as a whole.
The second one is *inferential statistics*, that consists in drawing
conclusions about the population as a whole from the sample extracted
from such population. In this case, a sampling is a means to an end,
not an end in itself.
Given a discrete numerical variable $x$, let $x_(1), x_(2), dots, x_(n)$
be the observations collected from the sample of such variable, with $n$
being the cardinality of the sample. The *sample mean* $overline(x)$ is
a summary measure that describes its average value, and is calculated as:
$ overline(x) = frac(x_(1) + x_(2) + dots + x_(n), n) =
frac(sum_(i = 1)^(n) x_(i), n) $
Given a discrete numerical variable $x$, let $x_(1), x_(2), dots, x_(n)$,
be the observations collected from the sample of such variable, arranged
from lowest to highest (including duplicates). The *sample median* $tilde(x)$
is a summary measure that describes the central value, and is calculated as
either the middle value of such sequence if $n$ is odd or the average of the
two middle values if $n$ is even:
$ tilde(x) = cases(
"The" (frac(n + 1, 2))^("th") "value if" n "is odd",
"The average of the" (frac(n, 2))^("th") "and the"
(frac(n, 2) + 1)^("th") "value if" n "is even") $
The *sample variance* $s^(2)$ is a summary measure that describes how "spread
out" are the values of the sample, or equivalently how close its values are to
the sample mean, and is defined as:
$ s^(2) = frac(sum_(i = 1)^(n) (x_(i) - overline(x))^(2), n - 1) =
frac(n sum_(i = 1)^(n) x_(i)^(2) - (sum_(i = 1)^(n) x_(i))^(2), n(n - 1)) $
The *sample standard deviation* is defined as the square root of the sample
variance:
$ s = sqrt(s^(2)) $
#theorem[
Given a discrete numerical variable $x$, let $x_(1), x_(2), dots, x_(n)$,
be the observations collected from the sample of such variable, and let
$c$ be a numerical constant. Then:
+ If, for each $1 lt.eq i lt.eq n$, the $y$ variable is constructed as
$y_(i) = x_(i) + c$, it is true that $s^(2)_(y) = s^(2)_(x)$;
+ If, for each $1 lt.eq i lt.eq n$, the $y$ variable is constructed as
$y_(i) = c x_(i)$, it is true that $s^(2)_(y) = c^(2) s^(2)_(x)$;
Where $s^(2)_(x)$ is the sample variance of the "original" variable $x$
and $s^(2)_(y)$ is the sample variance of the "transformed" variable $y$.
]
// #proof[
// To be added
// ]
|
https://github.com/GuilloteauQ/qcv | https://raw.githubusercontent.com/GuilloteauQ/qcv/main/README.md | markdown | MIT License | # QCV
Typst template for CV
## Example
```typst
#import "qcv.typ": *
#show: qcv.with()
#header("<NAME>",
email: "<EMAIL>",
webpage: "https://john.doe.org",
orcid: "1111-1111-1111-1111")
#let max_year = 2024
#let min_year = 2017
#let entry(..args) = {
raw_entry(min_year, max_year, ..args)
}
= Education
#entry(2020, 2023, title:"Phd Student", details: lorem(30))
```
See the PDF output [here](https://github.com/GuilloteauQ/qcv/blob/main/main.pdf)
|
https://github.com/T1mVo/shadowed | https://raw.githubusercontent.com/T1mVo/shadowed/main/src/lib.typ | typst | MIT License | #import "shadowed.typ": shadowed
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compiler/array-19.typ | typst | Other | // Test the `position` method.
#test(("Hi", "❤️", "Love").position(s => s == "❤️"), 1)
#test(("Bye", "💘", "Apart").position(s => s == "❤️"), none)
#test(("A", "B", "CDEF", "G").position(v => v.len() > 2), 2)
|
https://github.com/piepert/philodidaktik-hro-phf-ifp | https://raw.githubusercontent.com/piepert/philodidaktik-hro-phf-ifp/main/src/parts/ephid/rahmenplaene/themen.typ | typst | Other | #import "/src/template.typ": *
/*
== #ix("Themen")
To do#todo[]
*/ |
https://github.com/pluttan/typst-g7.32-2017 | https://raw.githubusercontent.com/pluttan/typst-g7.32-2017/main/gost7.32-2017/utils/image.typ | typst | MIT License | #import "../g7.32-2017.config.typ":config
// Выводит изображение
#let img(data, lable, f:(i)=>{i.display()}) = {
align(center)[
#data
#config.image.counter.step()
]
align(center)[
Рисунок #f(config.image.counter) #sym.bar.h _ #lable _
]
}
#let рис(данные, описание, ф:(i)=>{i.display()}) = {img(данные, описание, f:ф)}
// Инкрементирует номер рисунка
#let imgc() = {
align(center)[
#config.image.counter.step()
#config.image.counter.display()
]
}
#let рисп() = {imgc()} |
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/layout/list-marker-01.typ | typst | Other | // Test that last item is repeated.
#set list(marker: ([--], [•]))
- A
- B
- C
|
https://github.com/grnin/Zusammenfassungen | https://raw.githubusercontent.com/grnin/Zusammenfassungen/main/ParProg/ParProg_Spick_FS24_NG_JT.typ | typst | // Compiled with Typst 0.11.1
#import "../template_zusammenf.typ": *
#import "@preview/wrap-it:0.1.0": wrap-content
#show: project.with(
authors: ("<NAME>", "<NAME>"),
fach: "ParProg",
fach-long: "Parallel Programming",
semester: "FS24",
language: "en",
column-count: 5,
font-size: 4pt,
landscape: true,
)
= Multi-Threading
_Parallelism_ #hinweis[(Subprograms run simultaneously for faster programs)] vs.
_Concurrency_ #hinweis[(interleaved execution of programs for simpler programs)]
#wrap-content(
image("img/parprog_1.png"),
align: top + right,
columns: (65%, 35%),
)[
*Process:*
_Program under Execution_, own address space #hinweis[(heavyweight. Pros: Process isolation
and responsiveness, Cons: Interprocess communication overhead, expensive in creation, slow
context switching and process termination)].\
*Thread:*
_Parallel sequence_ within a process. Sharing the same address space, but separate stack and
registers #hinweis[(lightweight because most of the overhead already happened in the process
creation)].\
*Multi-threads:*
Changes made by one thread to shared resources will be _seen_ by other threads.\
*Context switch:*
Required when changing threads. _Synchronous_ #hinweis[(Thread waiting for condition)] or
_Asynchronous_ #hinweis[(Thread gets released after defined time)]\
*Multitasking:*
_Cooperative_ #hinweis[(Threads must explicitly initiate context switches, scheduler can't interrupt)] or
_preemptive_ #hinweis[(scheduler can asynchronously interrupt thread via timer interrupt)]\
*JVM Thread Model:*
JVM is a _process in the OS_. It runs as long as threads are running #hinweis[(Exception:
threads marked as daemon with ```java setDaemon(true)``` will not be waited upon)].
Threads are realized by the _thread class_ and the _interface Runnable_.
Code to be run in a Thread is within a overridden `run()`
]
== Starting a thread
*As a anonymous function (Lambda):*
```java var myThread = new Thread(() -> { /* thread behaviour */ }); myThread.start();```\
*As a named function:*
```java var myThread = new Thread(() -> AssyFunct()); myThread.start();```\
*With explicit runnable implementation:*
```java
class MyThread implements Runnable {
@Override
public void run() { /* thread behavior */ }}
var myThread = new Thread(new MyThread());
myThread.start();}
```
*In C\#:*
```cs var myThread = new Thread(() => { ... }); myThread.Start(); ... myThread.Join();```
==== Multi-Thread Example (no synchronization)
```java
public class MultiThreadTest {
public static void main(String[] args) {
var a = new Thread(() -> multiPrint("A"));
var b = new Thread(() -> multiPrint("B"));
a.start(); b.start(); System.out.println("main finished");
}
static void multiPrint(String label) {
for (int i = 0; i < 10; i++) { System.out.println(label + ": " + i);
}}}
```
#hinweis[The printout of this function varies. It can be all possible combinations of A's and
B's due to the non-deterministic scheduler]\
*Thread Join:*
Waiting for a thread to finish
#hinweis[(```java t2.join()``` blocks as long as `t2` is running).]
```java
var a = new Thread(() -> multiPrint("A")); var b = new Thread(() -> multiPrint("B"));
System.out.println("Threads start"); a.start(); b.start(); // ...
a.join(); b.join(); System.out.println("Threads joined");
```
*Thread States:*
_`Blocked`_ #hinweis[(Thread is blocked and waiting for a monitor lock)],
_`New`_ #hinweis[(Thread has not yet started)],
_`Runnable`_ #hinweis[(Thread is runnable (Ready to run or running))],
_`Terminated`_ #hinweis[(Thread is terminated)],
_`Timed_Waiting`_ #hinweis[(Thread is waiting with a specified waiting time
```java Thread.sleep(ms)```/```java Thread.join(ms)```)],
_`Waiting`_ #hinweis[(Thread is waiting)]\
*Yield:*
Thread is done processing for the moment and hints to the scheduler to release the processor.
The scheduler can ignore this. Thread enters into ready-state.
#hinweis[(```java Thread.yield()```)]\
*Interrupts:*
Threads can also be interrupted from the outside #hinweis[(```java myThread.interrupt()```,
Thread can decide what to do upon receiving an interrupt)]. If the thread is in the `sleep()`,
`wait()` or `join()` methods, a ```java InterruptException``` is thrown.
Otherwise a flag is set that can be checked with `interrupted()`/`isInterrupted()`\
*Exceptions:*
Exceptions thrown in `run()` can't be propagated to the Main thread.
The exception needs to be handled within the code executed on the thread.\
*Thread Methods:*
_`currentThread()`:_ #hinweis[(Reference to current thread)],
_`setDaemon(true)`:_ #hinweis[(Mark as daemon)],
_`getId()`/`getName()`:_ #hinweis[(Get thread ID/Name)],
_`isAlive()`:_ #hinweis[(Tests if thread is alive)],
_`getState()`:_ #hinweis[(Get thread state)]
= Monitor Synchronization
#let monitor-sync-code = ```java
class BankAccount {
private int balance = 0;
public void deposit(int amount){
// enter critical section
synchronized(this) {
this.balance += amount;
} // exit critical section
}
}
```
#wrap-content(
monitor-sync-code,
align: top + right,
columns: (58%, 42%),
)[
Threads run arbitrarily. _Restriction of concurrency_ for deterministic behavior.\
*Communication between threads:*
Sharing access to fields and the objects they refer to. Efficient, but poses problems:
_Thread interference_ and _memory consistency errors_.\
*Critical Section:*
Part of the code which must be executed by only 1 thread at a time for the values to stay
consistent. Implementation with _mutual exclusion_.\
*```java synchronized```:*
Body of method with the ```java synchronized``` keyword is a critical section.
Guarantees _memory consistency_ and a _happens-before relationship_.
Impossible for two invocations of a synchronized method on the same object to interleave.
Other threads are _blocked_ until the current thread is done with the object.
Every object has a _Lock_ #hinweis[(Monitor-Lock)]. Maximum 1 thread can acquire the lock.
Entry of a `synchronized` method acquires the lock of the object, the exit releases it.
```java public synchronized void deposit(int amount) { this.balance += amount; }```\
Can also be used within a method, the _object that should be locked_ must be specified.
```java synchronized(this) { this.balance += amount; }```\
*Exit synchronized block:*
End of the block, `return`, unhandled exceptions
]
=== Monitor Lock
A monitor is used for _internal mutual exclusion_. Only one thread operates at a time in
Monitor. All non-private methods are synchronized. Threads can _wait in Monitor_ for condition
to be fulfilled. Can be _inefficient_ with different waiting conditions, has
_fairness-problems_ and _no shared locks_.\
*Recursive Lock:*
A thread can acquire the same lock through recursive calls.
Lock will be free by the last release.\
*Busy Wait:*
Running `yield` or `sleep` in a loop doesn't release the lock and is inefficient. Use `wait`.\
*`wait()`:*
Waits on a condition. Temporarily releases Monitor-Lock so that other threads can run.
Needs to be _wrapped into a `while` loop_ to check if the wake up condition has been met.\
*Wakeup signal:*
Signalling a condition/thread in Monitor. _`notify()`_ signals any waiting thread
#hinweis[(sufficient if all threads wait for the same thing, so it does not matter which one
comes next - uniform waiters or if only one single thread can continue like in a turnstile)],
_`notifyAll()`_ wakes up all threads #hinweis[(i.e. one deposit can satisfy multiple withdraws,
does not guarantee fairness)].
If a thread is woken up, it goes from the _inner waiting room_ #hinweis[(waiting on a condition)]
into the _outer waiting room_ #hinweis[(Thread has not started yet)] where it waits
for entry to the Monitor. There is no shortcut.\
```java IllegalMonitorStateException``` is thrown if `notify`, `notifyAll` or `wait` is used
outside synchronized.
#colbreak()
#grid(
columns: (auto, auto),
gutter: 1em,
[
```java
// Java
class BankAccount {
private int balance = 0;
// Entry in the monitor
public synchronized void withdraw
(int amount)
throws InterruptedException {
while (amount > balance) { // not if
wait(); // wait on a condition
}
balance -= amount;
} // release / leave monitor
public synchronized void deposit
(int amount) {
balance += amount;
notifyAll(); // Wakes up all waiting threads in monitor inner waiting area
}}
```
],
[
```cs
// C# .NET
class BankAccount {
private decimal balance;
private object syncObject = new();
public void Withdraw(decimal amount) {
lock (syncObject) {
while (amount > balance) {
Monitor.Wait(syncObject);
}
balance -= amount;
}}
public void Deposit(decimal amount) {
lock(syncObject) {
balance += amount;
Monitor.PulseAll(syncObject);
}}}
```
],
)
= Specific synchronization primitives
== Semaphore
Allocation of a limited number of free resources. Is in essence a _counter_.
If a resource is _acquired_, `count--`, if a resource is _released_, `count++`.
Can wait until resource becomes available.
Can also acquire/release multiple permits at once atomically.
```java
public class Semaphore {
private int value; public Semaphore(int initial) { value = initial; }
public synchronized void acquire() throws InterruptedException {
while (value <= 0) { wait(); } value--; }
public synchronized void release() { value++; notify(); } }
```
*General Semaphore:*
```java new Semaphore(N)``` #hinweis[(Counts from 0 to $N$ for limited permits to access a resource)] \
*Binary Semaphore:*
```java new Semaphore(1)``` #hinweis[(Counter 0 or 1 for mutual exclusion, open/locked)]\
*Fair Semaphore:*
```java new Semaphore(N, true)``` #hinweis[(Uses FIFO Queue aging for fairness.
Slower than non-fair variant.)] \
Semaphores are _powerful_, any synchronization can be implemented. But relatively _low-level_.
```java
class BoundedBuffer<T> {
private Queue<T> queue = new LinkedList<>();
private Semaphore upperLimit = new Semaphore(Capacity, true); //how many free?
private Semaphore lowerLimit = new Semaphore(0, true); // how many full?
public void put(T item) throws InterruptedException {
upperLimit.acquire(); // No. of free places - 1
synchronized (queue) { queue.add(item);}
lowerLimit.release(); } // No. of full places + 1
public T get() throws InterruptedException {
T item;
lowerLimit.acquire(); // No. of full places - 1
synchronized (queue) { item = queue.remove(); }
upperLimit.release(); // No. of free places + 1
return item; }}
```
== Lock & Condition
Monitor with _multiple waiting lists_ and conditions. Independent from Monitor locks.\
*Lock-Object:*
Lock for entry in the monitor #hinweis[(outer waiting room)]\
*Condition-Object:*
Wait & Signal for a specific condition #hinweis[(inner waiting room)].\
*ReentrantLock:*
Class in Java, _alternative to `synchronized`_. Allows multiple locking operations by the same
thread and supports nested locking #hinweis[(Thread is able to re-enter the same lock)].\
*Condition:*
Factors out the Object monitor methods #hinweis[(`wait`, `notify` and `notifyAll`)] into
distinct objects to give the effect of having multiple wait-sets per object, by combining them
with the use of arbitrary Lock implementations. A _Condition replaces the use of the Object
monitor methods_. \
*`condition.await()`:*
Throws an InterruptedException if the current thread has its interrupted status set on entry to
this method or is interrupted while waiting #hinweis[(`finally` frees the lock in case of interrupt)].
==== Buffer with Lock & Condition
```java
class BoundedBuffer<T> {
private Queue<T> queue = new LinkedList<>();
private Lock monitor = new ReentrantLock(true); // fair queue
private Condition nonFull = monitor.newCondition();
private Condition nonEmpty = monitor.newCondition();
...
public void put(T item) throws InterruptedException {
monitor.lock(); // Lock queue
try { while (queue.size() == Capacity) { nonFull.await(); }
queue.add(item); nonEmpty.signal(); } finally { monitor.unlock(); }
} // signalAll() if uniform waiters
public T get() throws InterruptedException {
monitor.lock(); // wait for queue to be filled & signal to other queue
try { while (queue.size() == 0) { nonEmpty.await(); }
T item = queue.remove(); nonFull.signal(); return item;
} finally { monitor.unlock(); } // always release lock, even after Execption
}}
```
#let rw-lock-table = {
table(
columns: (1fr, 1fr, 1fr),
[Parallel], [Read], [Write],
[_Read_], [Yes], [No],
[_Write_], [No], [No],
)
}
#wrap-content(
rw-lock-table,
align: top + right,
columns: (65%, 35%),
)[
== Read-Write Lock
Mutual exclusion is _unnecessary for read-only_ threads.
So one should allow parallel reading access, but implement mutual exclusion for write access.
]
```java
ReadWriteLock rwLock = new ReentrantReadWriteLock(true); // true for fairness
rwLock.readLock().lock(); // shared Lock
// read-only accesses
rwLock.readLock().unlock();
rwLock.writeLock().lock(); // exclusive Lock
// write (and read) accesses
rwLock.writeLock().unlock();
```
== Count Down Latch
Synchronization with a counter that can only _count down_. Threads can wait
until counter $<= 0$, or they can count down. The Latches can only be used once.
```java
var ready = new CountDownLatch(N); var start = new CountDownLatch(1);
```
#grid(
columns: (auto, auto),
gutter: 1em,
[
```java
ready.countDown(); // wait for N cars
start.await(); // await race start
```
],
[
```java
ready.await(); // wait for all cars ready
start.countDown(); // start the race
```
],
)
== Cyclic Barrier
Meeting point for fixed number of threads. Threads wait _until everyone arrives_.
Is _reusable_, threads can synchronize in multiple rounds at the same barrier
#hinweis[(Simplifies example above)].
```java
var start = new CyclicBarrier(N); start.await(); // all cars race as they're here
```
== Exchanger
*Rendez-Vous:*
Barrier with _information exchange_ for 2 parties.
Without exchange: ```java new CyclicBarrier(2)```,
with exchange: ```java Exchanger.exchange(something)```.
The Exchanger blocks until another thread also calls `exchange()`,
returns argument `x` of the other thread.
```java
var exchanger = new Exchanger<Integer>();
for (int count = 0; count < 2; count++) { // odd n.of exch.: last one blocks
new Thread(() -> {
for (int in = 0; in < 5; in++) {
try {
int out = exchanger.exchange(in);
System.out.println(Thread.currentThread().getName() + " got " + out);
} catch (InterruptedException e) { }
} }).start(); }
```
#colbreak()
= Concurrency hazards
/*#let racetable = {
set par(justify: false)
set text(size: 0.8em)
table(
columns: (0.5fr, 1.1fr, 1fr),
table.header([], [Race Condition], [no RC]),
[_Data Race_], [Erroneous behavior], [Program works correctly, but formally incorrect],
[_No DR_], [Erroneous behavior], [Correct behavior],
)
}
#wrap-content(
racetable,
align: top + right,
columns: (65%, 35%),
)[*/
== Race Conditions
_Insufficiently synchronized access to shared resources._ The _order of events_ affects the
_correctness_ of the program. Leads to _non-deterministic behavior_.
Can occur without data race, but data race is often the cause.\
*Race Condition without data race:*
The critical section is not protected. Data Race is eliminated using synchronization, but there
is no synchronization over larger blocks, so race conditions are still possible
#hinweis[(i.e. non-atomic incrementing)].
== Data Race
Two threads in a single process _access the same variable_ concurrently without synchronization,
at least one of them is a _write access_.\
*Synchronize Everything?* May not help and is expensive. So no.
//]
== Thread Safety
*Dispensable cases in synchronization:*
_Immutable Classes_ #hinweis[(Declaring all fields private and final and don't provide setters)],
_Read-only Objects_ #hinweis[(Read-only accesses are thread-safe)]\
*Confinement:*
Object belongs to only one thread at a time.
_Thread Confinement_ #hinweis[(Object belongs to only one thread)],
_Object Confinement_ #hinweis[(Object is encapsulated in other synchronized objects)]\
*Thread safe:*
A data type or method that behaves correctly when used from multiple threads as if it was
running in a single thread without any additional coordination
#hinweis[(Java concurrent collections)].\
*Thread Safety:*
Avoidance of Data Races. When no sharing is intended, give each thread a private copy of the
data. When sharing is important, provide explicit synchronization.
== Deadlocks
Happens when threads lock each other out, prohibiting both from running.
Programs with potential deadlock are not considered correct.
Threads can suddenly block each other.
#columns(2)[
```java
// Thread 1
synchronized(listA) {
synchronized(listB) {
listB.addAll(listA);
}}
```
#colbreak()
```java
// Thread 2
synchronized(listB) {
synchronized(listA) {
listA.addALl(listB);
}}
```
]
Both threads in this scenario have _locked each other out_, the program cannot continue.\
*Livelock:*
Threads have blocked each other permanently, but still execute wait instructions and therefore
consume CPU during deadlock.
#columns(2)[
```java
// Thread 1
b = false; while(!a) { } ... b = true;
```
#colbreak();
```java
// Thread 2
a = false; while(!b) { } ... a = true;
```
]
#wrap-content(
image("img/parprog_2.png"),
align: top + right,
columns: (50%, 50%),
)[
=== Resource Graph
#grid(
columns: (1fr, 1fr),
gutter: 3pt,
[Thread T _waits for Lock_ of Resource R\
#image("img/parprog_3.png", width: 60%)],
[Thread T _acquires Lock_ of Resource R\
#image("img/parprog_4.png", width: 60%)],
)
Deadlocks can be identified by _cycles in the resource graph_.\
*Deadlock Avoidance:*
Introduce _linear blocking order_, lock nested only in ascending order.
Or use _coarse granular locks_ #hinweis[(When ordering does not make sense,
e.g. block the whole Bank to block all accounts)]
]
== Starvation
A thread never gets chance to access a resource.
_Avoidance:_ Use fair synchronization constructs. #hinweis[(Aging, Enable fairness in previous
synchronization constructs. Monitor and Thread priorities have a fairness problem.)]
== Parallelism Correctness Criteria
_Safety:_ No race conditions and no deadlocks, _Liveness:_ No starvation
== .NET Synchronization Primitives
Monitor with sync object: ```cs private object sync = new(); lock(sync){ ... }```.
Uses `Monitor.Wait(sync)`, `Monitor.PulseAll(sync)`. Uses fair FIFO-Queue.
_Lacks:_ No fairness flag, no Lock & Condition.
_Additional:_ `ReadWriteLockSlim` for Upgradeable Read/Write, Semaphores can also be used at
OS level, Mutex. Collections are _not_ Thread-safe.
= Thread Pools
Threads do have a _cost_. Many threads _slow down_ the system. There is also a _Memory Cost_,
because there is a stack for each thread. _Recycle_ threads for multiple tasks to avoid this.\
*Tasks:*
Define _potentially parallel_ work packages. Passive objects describing the functionality.\
*Thread Pool:*
Task are queued. A much smaller number of _working threads_ grab tasks from the queue and
execute them. A task must run to completion before a thread can grab a new one.\
*Scalable Performance:*
Programs with tasks run _faster on parallel machines_. This allows the exploitation of
parallelism _without thread costs_. The number of threads can be _adapted_ to the system.
#hinweis[(Rule of thumb: \# of Worker Threads = \# processors + 1 (Pending I/O Calls))]\
Any task must _complete execution_ before its worker thread is free to grab another task.
Exception: nested tasks. \
*Advantages:*
_Limited number of threads_ #hinweis[(Too many threads slow down the system or exceed available memory)],
_Thread recycling_ #hinweis[(save thread creation and release)],
_Higher level of abstraction_ #hinweis[(Disconnect task description from execution)],
_Number of threads configurable_ on a per-system basis.\
*Limitations:*
Task must not wait for each other #hinweis[(except sub-tasks)], results in deadlocks
#hinweis[(if one task $T_1$ is waiting for something the task $T_2$ behind him in the Queue
should provide, but $T_2$ waits for $T_1$ to finish, a deadlock occurs)]
== Java Thread Pool
```java
// Task Launch
var threadPool = new ForkJoinPool();
Future<Integer> future = threadPool.submit(() -> { // submit task into pool
int value = ...; /* long calculation */ return value;
});
```
=== `Future<T>`
Represents a _future result_ that is to be computed #hinweis[(asynchronous)].
Acts as proxy for the result that may be not available yet because the task has not finished.
Usage via _`.submit()`_ #hinweis[(submits task into pool and launches task)],
_`.get()`_ #hinweis[(waits if necessary for computation to complete and then retrieves its result)] and
_`.cancel()`_ #hinweis[(Attempts to cancel execution of this task, removes it from queue)].
Task ends when a unhandled exception occurs. It is included in the `ExecutionException` thrown
by `get()`.
=== Fire and Forget
Task are started _without retrieving results_ later #hinweis[(`submit()` without `get()`)].
Task is run, but Exceptions do not get catched.
=== Count Prime Numbers
```java
// Sequential
int counter = 0; for (int n = 2; n < N; n++) { if (isPrime(n)) { counter++}};
// Parallel and Recursive
class CountTask extends RecursiveTask<Integer> { //RecursiveAction: no return value
private final int lower, upper;
public CountTask(int lower, int upper) { this.lower = lower; this.upper = upper;}
protected Integer compute() {
if (lower == upper) { return 0; }
if (lower + 1 == upper) { return isPrime(lower) ? 1 : 0;}
int middle = (lower + upper) / 2;
var left = new CountTask(lower, middle);
var right = new CountTask(middle, upper);
left.fork(); right.fork();
return right.join() + left.join();
}}
int result = new CountTaks(2,N).invoke(); // invokeAll() to start multiple tasks
```
#colbreak()
=== Pairwise sum (recursive)
```java
class PairwiseSum extends RecursiveAction {
private final int[] array;
private final int lower, upper;
private static final int THRESHOLD = 1; // configurable
public PairwiseSum(int[] array, int lower, int upper) {
this.array = array; this.lower = lower; this.upper = upper;
}
protected void compute() {
if (upper - lower > THRESHOLD) {
int middle = (lower + upper) / 2;
invokeAll(
new PairwiseSum(array, lower, middle),
new PairwiseSum(array, middle, upper));
} else {
for (int i = lower; i < upper; i++) {
array[2*i] += array[2*i+1]; array[2*i+1] = 0;
}}}}
```
=== Work Stealing Thread Pool
Jobs get submitted into the _global queue_, which distributes the jobs to the _local queues_ of
each worker thread. If one thread has no work left, it can _"steal" work from another threads_
local queue instead of the global queue. This _distributes_ the scheduling work over idle processors.
== Java Fork Join Pool
*Special Features:* Fire-and-forget tasks may not finish, worker threads run as daemon threads.
Automatic degree of parallelism #hinweis[(Default: As much worker threads as Processors)].
== .NET Task Parallel Library (TPL)
Preferred way to write multi-threaded and parallel code.
Provides public types and APIs in `System.Threading` and `System.Threading.Tasks` namespaces.
_Efficient default thread pool_ #hinweis[(tasks are queued to the ThreadPool, supports
algorithms to provide load balancing, tasks are lightweight)], has _multiple abstraction
layers_ #hinweis[(Task Parallelization: use tasks explicitly, Data Parallelization: use
parallel statements and queries using tasks implicitly)], Asynchronous Programming and PLINQ.
```cs
// Task with return value in C#
Task<int> task = Task.Run(() => {
int total = ... // some calculation
return total;
});
Console.Write(task.Result); //Blocks until task is done and returns the result
```
```cs
// Nested Tasks
var task = Task.Run(() => {
var left = Task.Run(() => Count(leftPart));
var right = Task.Run(() => Count(rightPart));
return left.Result + right.Result;
});
static Task<int> Count(...part) {...}
```
=== Parallel Statements in C\#
#columns(2)[
Execute _independent_ statements _potentially in parallel_
#hinweis[(Start all tasks, implicit barrier at the end)].
```cs
Parallel.Invoke(
() => MergeSort(l,m),
() => MergeSort(m,r)
);
```
#colbreak()
Execute _loop-bodies potentially in parallel_\
#hinweis[(Queue a task for each item, implicit barrier at the end)].
```cs
Parallel.ForEach(list,
file => Convert(file));
Parallel.For(0, array.Length,
i => DoComputation(array[i]));
```
]
*Parallel Loop Partitioning:*
Loop with lots of quickly executing bodies. It would be _inefficient_ to execute each iteration
in parallel. Instead, TPL _automatically groups multiple bodies_ into a single task.
There are _4 kinds of partitioning schemes:_
Range #hinweis[(equally sized)],
Chunk #hinweis[(partitions start small and grow bigger)],
Stripe #hinweis[($n$-sized partitions, where $n$ "small number, sometimes 1")] and
Hash partitioning #hinweis[(default: if input is indexable then range partitioning, else chunk partitioning)].\
=== PLINQ
*LINQ:*
Set of technologies based on the integration of SQL-like query capabilities directly into C\#.\
*PLINQ:*
Is a parallel implementation of LINQ. Benefits from _simplicity_ and _readability_ of LINQ with
the power of parallel programming by creating segments from its data. Analog to Java Stream API.
_`from`_ `book` _`in`_ `bookCollection.AsParallel()` _`where`_ `book.Title.Contains("Concurrency")` _`select`_ ```cs book.ISBN // Random Order```
_`from`_ `number` _`in`_ `inputList.AsParallel().AsOrdered()` _`select`_ `IsPrime(number)`\
```cs // Maintains order but is slower```
=== Thread Injection
TPL adds new worker threads _at runtime_ every time a work item completes or every 500ms.\
*Hill Climbing Algorithm:*
_Maximize throughput_ while using as _few threads_ as possible. Measures throughput & _varies_
number of worker threads. _Avoids deadlock_ with task-dependencies #hinweis[(but inefficiently
since not designed for this. Deadlocks with `ThreadPool.SetMaxThreads()` are still possible).]
We should keep _parallel tasks short_ to better profit from this automatic performance improvement.
= Asynchronous programming
*Unnecessary Synchrony:*
Blocking method calls are often used without need #hinweis[(Long running calculations, I/O
calls, database or file accesses)]. With an _asynchronous call_, other work can continue while
waiting on the result of the long operation.\
```cs var task = Task.Run(LongOperation); /* other work */ int result = task.Result;```\
*Kinds of Asynchronisms:*
_Caller-centric_ #hinweis[("pull", caller waits for the task end and gets the result, blocking call)],
_Callee-Centric_ #hinweis[("push", Task hands over the result directly to successor / follower task)]\
*Task Continuations:*
Define task whose start is linked to the end of the predecessor task.
#grid(
columns: (auto, auto),
[
```cs
// C# .NET
Task
.Run(task1)
.ContinueWith(task2)
.ContinueWith(task3);
```
],
[
```java
// Java (there can be multiple Apply/AcceptAsync calls)
CompletableFuture
.supplyAsync(() -> longOP) // runAsync for return void
.thenApplyAsync(v -> 2*v) // returns value
.thenAcceptAsync(v -> ... .println(v)); // returns void
```
],
)
*Multi-Continuation:*
Continue when _all_ tasks are finished:\
```cs Task.WhenAll(task1, task2).ContinueWith(continuation);```\
Continue when _any_ of the tasks are finished
#hinweis[(other threads get lost after first thread is done)]:\
```cs Task.WhenAny(task1, task2).ContinueWith(continuation);```\
#hinweis[(Exceptions in fire & forget task get ignored,
i.e. ```cs Task.Run(() => { ...; throw e; })```)]\
*Exception Handling:*
Synchronously _`Wait()`_ for the _whole task-chain_ at the end.
_Register for unobserved exceptions_ with _`TaskScheduler.UnobservedTaskException`_
#hinweis[(Receives unhandled exceptions from fire & forget tasks)].
This should be executed as soon as the task object is dead #hinweis[(Garbage Collector)].
*Java `CompletableFuture`:*
_Modern asynchronous_ programming in Java. Also has _Multi-Continuation_ with
```java CompletableFuture.allOf(future1, future2)``` and ```java CompletableFuture.any(...)```
== Non-Blocking GUI's
*Use case:*
If a UI is doing a long task, it should not freeze.\
*GUI Thread Model:*
Only _single-threading_ #hinweis[(Only a special UI-thread is allowed to access
UI-components)]. The _UI thread_ loops to process the _event queue_.
#image("img/parprog_5.png", width: 87%)
*GUI Premise:*
_No long operations_ in UI events, or else blocks UI.
_No access to UI-elements by other threads_, or else incorrect
#hinweis[(Exception in .NET & Android, Race Condition in Javas Swing)].
=== Non-Blocking UI Implementation
#grid(
columns: (auto, auto),
[
```cs
// C# .NET
void buttonClick(...) {
var url = textBox.Text;
Task.Run(() => {
var text = Download(url);
Dispatcher.InvokeAsync(() => {
label.Content = text;
});
});
}
```
],
[
```java
// Java
button.addActionListener(event ->
var url = textField.getText();
CompletableFuture.runAsync(() -> {
var text = download(url); // to worker thread
SwingUtilities.invokeLater(() -> {
textArea.setText(text); // to UI thread
});
});
)
```
],
)
*Java `invokeLater`:*
To be executed _asynchronously_ on the event dispatching thread.
Should be used when an _application thread_ needs to _update the GUI_.\
== C\# Async/Await
More _readable_ than the "spaghetti code" in the chapter before.
This is the same code as before.
#grid(
columns: (3fr, 4fr),
[
```cs
...
var url = textBox.Text;
var text = await DownloadAsync(url);
label.Context = text;
...
```
],
[
```cs
async Task<string> DownloadAsync(string url) {
var web = new HttpClient();
string result = await web.GetStringAsync(url);
return result;
}
```
],
)
_`async` for methods_: Caller may not be blocked during the entire execution of the async method.
_`await` for tasks_: "Non-blocking wait" on task-end / result.\
*Execution Model:*
Async methods run partly _synchronous_ #hinweis[(as long as there is no blocking await)],
partly _asynchronous_ #hinweis[(until the awaited task is complete)].\
*Mechanism:*
Compiler dissects method into _segments_ which are then executed completely synchronously or asynchronously.\
*Different Execution Scenarios:*
_Case 1:_ Caller is a "normal" thread #hinweis[(Usual case, Continuation is executed by a TPL-Worker-Thread)],
_Case 2:_ Caller is a UI-thread #hinweis[(Continuation is dispatched to the UI thread and processed by the UI-Thread as event)]\
*Async Return Value Types:*
_`void`_ #hinweis[("fire-and-forget")],
_`Task`_ #hinweis[(No return value, allows waiting for end)],
_`Task<T>`_ #hinweis[(For methods having return value of type T)]. \
*Async without await:*
Execute long running operation explicitly in task with `await Task.Run()`.
```cs
public async Task<bool> IsPrimeAsync(long number) {
return await Task.Run(() => {
for (long i = 2; i*i <= number; i++) {
if (number % i == 0) { return false; }
} return true;
}); }
```
= Memory Models
*Lock-Free Programming:*
_Correct_ concurrent interactions _without using locks_. Use guarantees of memory models.
Goal is _efficient synchronization_.\
*Problems:*
Memory accesses are seen in _different order_ by different threads, except when _synchronized_
and at _memory barriers_ #hinweis[(weak consistency)]. Optimizations by compiler, runtime
system and CPU. Instructions are reordered or eliminated by optimization.\
*Memory model:*
Part of language semantics, there exist different models: _sequential consistency (SC)_
#hinweis[(Order of execution cannot be changed. Too strong a consistency model)]
and the _Java Memory Model_ #hinweis[(a "weak" memory model)].
== Java Memory Model (JMM)
Interleaving-based semantics. Minimum warranties: _Atomicity, Visibility and Ordering_.
=== Atomicity
An _atomic_ action is one that happens _all at once_ #hinweis[(So no thread interference)].
Java guarantees that read/writes to primitive data types up to 32 Bit, Object-References
#hinweis[(strings etc.)] and long and double #hinweis[(with `volatile` keyword)] are atomic.
_A single read/write is atomic._ Atomicity does _not imply visibility_.
=== Visibility
Guaranteed visibility between threads.
_Lock Release & Acquire_ #hinweis[(Memory writes before release are visible after acquire)],
_`volatile` Variable_ #hinweis[(Memory writes up to and including the write to volatile
variables are visible when reading the variable)],
_Thread/Task-Start and Join_ #hinweis[(Start: input to thread; Join: thread result)],
_Initialization of `final` variables_ #hinweis[(Visible after completion of the constructor)],
_`final` fields_.\
=== Ordering
*Java Happens Before:*
“Happens before” defines the _ordering and visibility guarantees_ between actions in a program.
It ensures that changes made by one thread become visible to others.
An _unlock_ of a monitor _happens-before_ every subsequent lock of that same monitor.\
*Java Ordering Guarantees:*
Writes before Unlock #sym.arrow reads after lock, `volatile` write #sym.arrow `volatile` read,
Partial Order. Synchronization operations are never reordered.
#hinweis[(Lock/Unlock, volatile-accesses, Thread-Start/Join.)]
== Synchronization
*Rendez-Vous:*
Primitive attempt to synchronize threads.
#grid(
columns: (auto, auto),
gutter: 10pt,
[
```java
// Java
volatile boolean a = false, b = false;
// Thread 1
a = true; while( !b ) { ... }
// Thread 2
b = true; while( !a ) { ... }
```
No reordering because `a` and `b` are `volatile`.\
],
[
```cs
// C# .NET
volatile bool a = false, b = false;
// Thread 1
a = true; Thread.MemoryBarrier();
while (!b) { ... }
// Thread 2
b = true; Thread.MemoryBarrier();
while (!a) { ... }
```
],
)
*Spin-Lock with atomic Operation:*
```java
public class SpinLock {
private final AtomicBoolean locked = new AtomicBoolean(false);
public void acquire() { while( locked.getAndSet(true) ) {...} }
public void release() { locked.set(false); }
}
```
*Java Atomic Classes:*
Classes for boolean, Integer, Long, References and Array-Elements.
Different kinds of atomic operations, _`addAndGet()`_, _`getAndAdd()`_ etc.\
*Operations on atomic data classes:*
```java boolean getAndSet(boolean newValue)```\
Atomically sets to the given value and returns the previous value.\
```java boolean compareAndSet(boolean expect, boolean update)```\
Sets `update` only when read value is equal to `expect`. Returns true when successful.\
*Optimistic Synchronization:*
```java
do { oldV = v.get(); newV = result; } while(!v.compareAndSet(oldV, newV));
```
*Lambda-Variants:*
```java AtomicInteger s = new AtomicInteger(2); s.updateAndGet(x -> x * x);```
#wrap-content(
image("img/parprog_6.png"),
align: top + right,
columns: (75%, 25%),
)[
== .NET Memory Model
Main differences to JMM:
_Atomicity_ #hinweis[(long/double also not atomic with volatile)],
_Ordering and Visibility_ #hinweis[(only half and full fences)].
_Atomic Instructions_ with the `Interlocked` class
=== Half Fence (Volatile)
Reordering in one direction still possible.
_Volatile Write:_ Release semantics #hinweis[(Preceding memory accesses are not moved below
it, but later operations can be executed before the write)].
_Volatile Read:_ Acquire semantics #hinweis[(Subsequent memory accesses are not moved above
it, but previous operations can be executed after the read)]
]
=== Full Fence (Memory Barrier)
Disallows reordering in both directions. ```cs Thread.MemoryBarrier();```
= GPU (Graphics Processing Unit)
*End of Moores Law:*
We can no longer gain performance by "growing" sequential processors. Instead, we _improve
performance_ by running code in _parallel_ on _multi-core (CPUs)_ #hinweis[(Low Latency)] and
many-core or _massively parallel co-processors (GPUs)_ #hinweis[(high throughput)].\
*GPU's*
are specialized electronic circuits designed to accelerate the computation of _computer graphics_.
They are faster than CPUs for suitable algorithms on large datasets. _Useful_ for
calculations which consist of _multiple independent sub-calculations_, not very useful for
calculations where the results rely on the previous results #hinweis[(like Fibonacci)].\
*High Parallelization:*
A _CPU_ offers few cores #hinweis[(4, 8, 16, 64)] and is very fast. Programming is easier.
A _GPU_ offers a very large number of cores #hinweis[(512, 1024, 3584, 5760)] and has very
specific slower processors. It is optimized for throughput. Programming is more difficult.\
*GPU Structure:*
A GPU consists of multiple _Streaming Multiprocessors (SM)_ which in turn consist of multiple
_Streaming Processors (SP)_ #hinweis[(e.g. 1-30 SM, 8-192 SPs per SM)].\
*SIMD:*
Single Instruction Multiple Data. The _same instruction_ is executed simultaneously on
_multiple cores_ working on _different data elements_ #hinweis[(Vector parallelism)].
Saves fetch & decode instructions.\
*SISD:*
Single Instruction Single Data. Purely _sequential_ calculations.\
*SIMT:*
Single Instruction Multiple Threads. The same instruction is executed in different threads over different data.
#image("img/parprog_7.png")
== Latency vs. Throughput
*Latency:*
_Elapsed time_ of an event
#hinweis[(Walking from point A to B takes one minute, the latency is one minute)].\
*Throughput:*
_The number of events_ that can be executed per unit of time #hinweis[(Bandwidth)]\
There is a _tradeoff_ between latency and throughput. Increasing throughput by pipelined
processing, latency most often also increases. All pipeline stages must operate in _lockstep_.
The _rate of processing_ is determined by the _slowest step_.\
*Pipelining:*
Run processes in an overlapping manner.\
*Example:*
A program consists of two operations:
Transfer data from CPU memory to GPU memory ($T_1$ units = #tcolor("grün", "20ms")),
Execute computation on the device ($T_2$ units = #tcolor("orange", "60ms")). \
What is the _latency_ (non-pipelined)? $fxcolor("grün", 20) + fxcolor("orange", 60) = underline(80"ms")$.\
What is the _throughput_ (pipelined)? Every #tcolor("orange", "60ms") an operation is finished.\
Throughput = $1/60$ operations/ms.
== CPU vs GPU
#table(
columns: (39%, auto),
table.header[CPUs][GPUs],
[
- _Low latency_
- Few but _optimized cores_
- _General purpose_
- Architecture and Compiler help to run any code fast
],
[
- Can execute _highly parallel data_ operations
- Simple but a _lot of cores_ with cache per core
- very useful for problems which consist of a _lot of independent data elements_
- Efficiency must be achieved by _optimizing_ the program
],
[
*Aim:* low latency per thread
],
[
*Aim:* high throughput
],
)
== NUMA Model
NUMA stands for _Non-Uniform Memory Access_. CPUs on host and GPU devices each have local
memories. There is _no common main memory_ between the two, so _explicit transfer_ between CPU
and GPU is needed. There is also _no garbage collector_ on the GPU.
== CUDA
Computer Unified Device Architecture. Is a _parallel computing platform and an API_ for Nvidia
GPU that allows the host program to use GPUs for general purpose processing.
==== CUDA Execution
#grid(
columns: (auto, 1fr),
gutter: 3pt,
[
+ _`cudaMalloc`:_ GPU memory allocate
+ _`cudaMemcpy`:_ Data transfer to GPU #hinweis[(HostToDevice)]
+ _`Kernel<<<1, N>>>`:_ Kernel execution
],
[
4. _`cudaMemcpy`:_ Transfer results from GPU to CPU #hinweis[(DeviceToHost)]
+ _`cudaFree`:_ Deallocate GPU memory
],
)
==== Example: Array addition
```cpp
for (int i = 0; i < N; i++) { C[i] = A[i] + B[i]; } // sequential
(i = 0 .. N-1): C[i] = A[i] + B[i]; // parallel using n threads
```
==== CUDA Kernel
A kernel is a function that is executed $n$ times in parallel by $m$ different CUDA threads.
```cpp
// kernel definition on GPU
__global__
void VectorAddKernel(float *A, float *B, float *C) {
int i = threadIdx.x; C[i] = A[i] + B[i];
}
// kernel invocation on CPU
VectorAddKernel<<<1, N>>>(A, B, C); // N is amount of threads
```
Only the GPU knows when the task is finished.
==== Boilerplate Orchestration Code
```cpp
void CudaVectorAdd(float* h_A, float* h_B, float* h_C, int N) {
size_t size = N * sizeof(float);
float *d_A, *d_B, *d_C; // data on GPU
cudaMalloc(&d_A, size); cudaMalloc(&d_B, size); cudaMalloc(&d_C, size);
cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);
VectorAddKernel<<<1, N>>>(d_A, d_B, d_C, N);
cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);
cudaFree(d_A); cudaFree(d_B); cudaFree(d_C);
}
```
#wrap-content(
image("img/parprog_8.png"),
align: top + right,
columns: (68%, 32%),
)[
== Performance Metrics
The performance is either limited by _memory bandwidth_ or _computation_.
*Compute Bound:*
Throughput is limited by calculation #hinweis[(Cores are at the limit, but the memory bus
could transfer more data)]. _This is better and reached if AI Kernel > AI GPU_.\
*Memory Bound:*
Throughput is limited by data transfer #hinweis[(Memory bus bandwidth is at its limit, but
cores could process more data)].\
*Arithmetic intensity:*
Defined as FLOPS #hinweis[(Floating Point Operations per Second)] per Byte.
The higher, the better.\
#box($ "Number of operations" / "Number of transferred bytes" = "FLOPS" / "Bytes" $)
*Example*
```cpp for(i=0; i<N, i++) { z[i] = x[i] + y[i] * x[i]; }```\
Read `x` and `y` from memory, write `z` to memory. That's 2 reads and 1 write
#hinweis[(`x` is used twice but read only once)]. In case `x`, `y` and `z` are ints,
we have #fxcolor("grün", "12") #hinweis($(3 dot 4)$) bytes transferred and
$#fxcolor("orange", "2")$ arithmetic ops ($+$, $*$).
The arithmetic intensity is therefore $#fxcolor("orange", "2") / #fxcolor("grün", "12") =
#fxcolor("orange", "1") / #fxcolor("grün", "6")$.
]
=== Roofline model
Provides performance estimates of a kernel running on differently sized architectures.
Has three parameters: Peak performance, peak bandwidth vs. arithmetic intensity.\
_Peak performance_ is derived from benchmarking FLOPS or GFLOPS #hinweis[(Giga-FLOPS , $10^9$
FLOPS)]. The _peak bandwidth_ from manuals of the memory subsystem. The _ridge point_ is where
the horizontal and diagonal lines meet = minimum AI required to achieve the peak performance.
#image("img/parprog_9.png", width: 94%)
= GPU Architecture
Because there are so _many cores_ on GPUs, it is possible to run many threads in parallel
_without context switches_. This allows better parallelism without a performance penalty.
== Compilation
*Just-in-time Compilation:*
The _NVCC compiler_ compiles the non-CUDA code with the host C compiler and translates code
written in CUDA into _PTX instructions_ #hinweis[(assembly language represented as ASCII
text)]. The graphics driver compiles the PTX into _executable binary code_.
The assembly of PTX code is _postponed until application runtime_, at which time the target
GPU is known. The _disadvantage_ of this is the _increased application startup delay_.
However, thanks to cache this only happens once #hinweis[(warmup)].\
*Programming Interface:*
_Runtime_ #hinweis[(The cudart library provides functions that execute on the host to
(de-)allocate device memory, transfer data etc.)] or _driver API_ #hinweis[(The CUDA driver API
is implemented in the `cuda.dll` or `cuda.so` which is copied on the system during installation
of the driver. This provides an additional level of control by exposing lower-level concepts
such as CUDA contexts. Often overkill)]. \
*Asynchronous Execution:*
The command pipeline in CUDA works asynchronous, commands and data can be transferred from/to
the GPU at the same time.
== CUDA SIMT Execution Model
Single instruction, multiple Threads. The kernel is executed $N$ times in parallel by $N$
different CUDA threads.\
*Blocks:*
Threads are _grouped_ in blocks. The host can define how many threads each block has
#hinweis[(up to 1024)]. Threads in one block can _interact_ with each other but not with
threads in other blocks. \
*Execution Model:*
_One thread_ runs on _one virtual scalar processor_ #hinweis[(one GPU core)].
_One block_ runs on _one virtual multi-processor_ #hinweis[(one GPU Streaming Multiprocessor)].
Blocks must be _independent_.\
*Thread Pool Abstraction:*
The compiled CUDA program has e.g. 8 CUDA blocks. The _runtime_ can _choose how to allocate_
these blocks to multiprocessors. For a larger GPU with 8 SMs, each SM gets one CUDA block.
This enables performance scalability without code changes.\
*Guarantees:*
CUDA guarantees that _all threads in a block_ run on the _same SM_ at the _same time_ and that
the blocks in a kernel _finish before_ any block from a new, _dependent kernel_ is _started_.\
*Mapping:*
One SM can run several _concurrent_ blocks depending on the resources needed. Each _kernel_ is
executed _on one device_. CUDA supports running _multiple kernels on a device_ at one time.
== CUDA Kernel specification
*Specifying Kernel:*
```cpp VectorAddKernel<<<GRID_dimension, BLOCK_dimension>>>(A,B,C)```\
Dimensions can be 1D, 2D or 3D and specified via `dim3` which is a structure designed for
storing block and grid dimensions: ```cpp struct dim3{x; y; z}```.\
```cpp dim3 dimGrid(2) == dim3 dimGrid(2,1,1)``` #hinweis[(Unassigned components are set to 1)]\
```cpp VectorAddKernel<<<dimGrid, dimBlock>>>(A,B,C);```\
_Number of blocks in a grid:_ ```cpp dimGrid.x * dimGrid.y * dimGrid.z ```\
_Number of threads in a block:_ ```cpp dimBlock.x * dimBlock.y * dimBlock.z```\
*1D Grid:*
We can simply use integers. ```cpp VectorAddKernel<<<1, N>>>``` creates 1 Block with N Threads.\
*2D Grid:*
```cpp dim3 gridS(3,3); dim3 blockS(3,3); VectorAddKernel<<<gridS, blockS>>>```\
*3D Grid:*
```cpp dim3 gridS(3,2,1); dim3 blockS(4,3,1); VectorAddKernel<<<gridS, blockS>>>```\
*Device Limits:*
_Max threads per block:_ 1024,
_Max thread dimensions per block:_ (1024, 1024, 64)
_Max grid size:_ (2'147'483'647, 65'535, 65'535)
#wrap-content(
image("img/matrices.svg"),
align: top + right,
columns: (60%, 40%),
)[
==== Calculation Examples
```cpp VectorAddKernel<<<dim3(8,4,2), dim3(16,16)>>>(d_A, d_B, d_C);```\
_Amount of Blocks:_ $8 dot 4 dot 2 = 64$ \
_Amount of threads per block:_ $16 dot 16 = 256$ \
_Threads in total:_ $64 dot 256 = 16'384$
If we have $1024$ threads in a block, how many blocks are needed to launch $N$ threads?\
_`int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;`_ \
#hinweis[Need to round up because for 1025 threads we need 2 blocks]
]
== Data Partitioning within threads
*Data Access:*
Each kernel decides which data to work on. The programmers decide data partitioning scheme.
`threadId.x/y/z` #hinweis[(Thread no. in block)],
`blockId.x` #hinweis[(Block no.)],
`blockDim.x` #hinweis[(Block size)]\
*Partitioning in Blocks:*
```cpp
__global__
void VectorAddKernel(float *A, float *B, float *C) {
int i = blockIdx.x * blockDim.x + threadIdx.x; //index based on (blockID, threadID)
if (i < N) {
C[i] = A[i] + B[i]; // without this if, some threads will be idle
}
}
// kernel invocation
N = 4097; int blockSize = 1024; int gridSize = (N + blockSize - 1) / blockSize;
VectorAddKernel<<<gridSize, blockSize>>>(A, B, C);
```
*Boundary Check:*
More threads than necessary work on the data. If N = 4097, 5 Blocks with 1024 Threads are
needed which results in _1023 unused threads_. Threads with $i >= N$ must _not be allowed_
to write to array $C$ because they might _corrupt the working memory_ of some other thread.
== Error Handling
Some functions have return type `cudaError`. Need to check for `cudaSuccess`. It's best to
write your own helper function and wrap _every fucking line_ in it. E.g. `handleCudaError()`
which prints the error and exits the program.
== Unified Memory
Unified memory allows automatic transfer from CPU to GPU and vice versa.
No explicit Memory Copy needed, but other new rules.
```cpp
cudaMallocManaged(&A, size); // ... same for &B and &C ...
A[0] = 8; ... // initialize A and B assuming they reside on the host
// A and B are automatically transferred to the device
VectorAddKernel<<<..,..>>>(A,B,C,N);
cudaDeviceSynchronize(); // wait for the GPU to finish
// C is transferred automatically to the host and can be read directly
std::cout << C[0]; ...
cudaFree(A); cudaFree(B); cudaFree(C);
```
= GPU Performance Optimizations
*Hardware:*
A scalable array of multithreaded _Streaming Multiprocessors_ (SMs),
the _threads_ of a thread block execute _concurrently_ on one multiprocessor,
multiple _thread blocks_ can execute _concurrently_ on one multiprocessor.
When thread blocks _terminate_, new blocks are launched on the free multiprocessors.
== Matrix Addition
```cpp
__global__
void MatrixAddKernel(float *A, floa *B, float *C) {
int column = blockIdx.x * blockDim.x + threadIdx.x;
int row = blockIdx.y * blockDim.y + threadIdx.y;
if (row < A_ROWS && col < A_COLS) { // boundary checking
C[row * A_COLS + col] = A[row * A_COLS + col] + B[row * A_COLS + col];
}
}
const int A_COLS, B_COLS, C_COLS = 6;
const int A_ROWS, B_ROWS, C_ROWS = 4;
dim 3 block = (2,2); dim3 grid = (3,2);
MatrixAddKernel<<<grid,block>>>(A,B,C);
```
== Matrix Multiplication
*Parallelization:*
Every Thread computes one element of the result matrix $C$.
Can be parallelized because results do not depend on each other.
```cpp
__global__
void multiply(float *A, floa *B, float *C) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
int j = blockIdx.y * blockDim.y + threadIdx.y;
if (i < N && j < M) { // boundary checking
float sum = 0;
for (int k = 0; k < K; k++) {
sum += A[i * K + k] * B[k * M + j];
}
C[i * M + j] = sum;
}
}
```
== Mapping Threads / Blocks to GPU Warps
*Warps:*
Blocks are split into _warps_ #hinweis[(1 Warp = 32 Threads)] and all threads within execute
the same code. If there aren't enough threads to fill a warp, "empty" threads are launched.
A number of warps constitutes a _thread block_. A number of _thread blocks_ are assigned to a
_Streaming Multiprocessor_. The whole GPU consists of several SM.\
Thread blocks are scheduled in _parallel_ or _sequentially_. Once a thread block is _launched_
on a SM, _all of its warps are resident_ until their execution finishes. Therefore, a _new
block on a SM_ is _not launched until_ there is a _sufficient number_ of free registers and
shared memory for _all warps_ of the new block.\
*Warp Execution:*
All threads in a warp execute the same instruction #hinweis[(SIMD)]. A SM can accommodate all
warps of a block, but only _a subset_ is _running in parallel_ at the same time
#hinweis[(1 to 24)].\
*Divergence:*
_Not_ all threads of a warp may _branch the same way_.
The branches do _not run simultaneously_, so the other threads need to _wait_ until one branch
is finished. So branches within one warp should be _avoided_ because of _performance problems_
#hinweis[(Branches are born at `if` / `switch` / ...)] \
#grid(
columns: (1.75fr, 2fr),
gutter: 1em,
[
```cpp
// bad case, divergence in same wrap
if (threadIdx.x > 1) { } else { }
```
],
[
```cpp
// good case, all t in warp in same branch
if (threadIdx.x / 32 > 1) { } else { }
```
],
)
*DRAM (Dynamic Random Access Memory):*
_Global memory of a CUDA device_ is implemented with DRAMs. If a GPU kernel accesses data from
_consecutive locations_, the DRAMs can supply the data at a much _higher rate_ than if a random
sequence of locations were accessed. \
*Memory Coalescing:*
Thread _access patterns_ are critical for performance. If the threads in a warp
_simultaneously_ access _consecutive memory locations_, their reads can be combined into a
single access _(burst)_. Else there are _expensive individual accesses_.\
*Coalesced Accesses:*
Read/Write the burst in one transaction per warp burst section, swapped read/write within the
same burst, only individual elements in the burst accessed.\
*Not Coalesced Accesses:*
Read/Write in different warp bursts, one action that spans multiple bursts.\
*Coalescing in Use:*
_`data[(Expression without threadId.x) + threadId.x]`_\
*Coalescing with Matrices:*
Matrices get linearized to a 1D array. The row of the matrix should be the longer side so that
there are as many coalescing accesses as possible.
== Memory Model
All threads have the access to the same _global memory_. Each thread block has _shared memory_
visible to all threads of the block and with the same lifetime as the block
#hinweis[(Has higher bandwidth and lower latency than local or global memory but longer latency
and lower bandwidth than registers which are private to a thread)].
Each thread has _private local memory_ #hinweis[(in device memory, high latency and low
bandwidth, same as global)]. Constant, texture and surface memory also reside in device memory.\
*Memory Hierarchy:*
_Shared Memory_ #hinweis[(per SM, fast, shared between threads in 1 block, a few KB, `__shared__ float x`)],
_Global Memory_ #hinweis[("Main Memory" in GPU Device, slow, accessible to all threads, in GB, `cudaMalloc()`)]
_Registers_ #hinweis[(private to a thread, fastest but very limited storage)]\
*Constant memory:*
Constant variables are stored in the _global memory_ but are _cached_.\
*Shared Memory Declaration:*
With keyword `__shared__`. A _static array size_ is necessary. Limited memory, around 48KB.
Multidimensionality is allowed.\
*Fast Matrix Multiplication:*
By _reducing global memory traffic_. Partition data into subsets called tiles which fit into
shared memory #hinweis[(the row & column that should be multiplied and the result cell)].
The kernel computation on these tiles must be able to run _independently_ of each other.
Because the shared memory is _limited_, load the tiles in _several steps_ and calculate the
_intermediate result_ from this.
```cpp
__global__ void MatrixMulKernel(float* d_M, float* d_N, float* d_P, int Width) {
__shared__ float Mds[TILE_WIDTH][TILE_WIDTH];
__shared__ float Nds[TILE_WIDTH][TILE_WIDTH];
int bx = blockIdx.x; int by = blockIdx.y;
int tx = threadIdx.x; int ty = threadIdx.y;
// identify row and column of the d_P element to work on
int Row = by * TILE_WIDTH + ty;
int Col = bx * TILE_WIDTH + tx;
float Pvalue = 0;
// loop over d_M and d_N tiles required to compute d_P element
for (int m = 0; m < Width/TILE_WIDTH; ++m) {
// collaborative loading of d_M and d_N tiles into shared memory
Mds[ty][tx] = d_M[Row*Width + m*TILE_WIDTH + tx];
Nds[ty][tx] = d_N][(m*TILE_WIDTH + ty)*Width + Col];
__syncthreads(); // CUDA equivalent to wait()
for (int k = 0; k < TILE_WIDTH; ++k) {
Pvalue += Mds[ty][k] * Nds[k][tx];
}
__syncthreads();
}
d_P[Row*Width + Col] = Pvalue;
}
```
#hinweis[```cpp __syncThreads()``` is only allowed in `if`/`else` if all threads of a block
choose the same branch, otherwise undefined behavior.]
= High Performance Computing (HPC) Cluster Parallelization
Cluster programming is the _highest possible parallel acceleration_ #hinweis[(Factor 100 and
more)]. Used for _general purpose programming_, lots of CPU cores. Combination of CPUs and GPUs possible. \
*Computer Cluster:*
Network of _powerful_ computing nodes, firmly connected at one location. Very _fast
interconnect_ #hinweis[(like 100GBit/s)], used for big simulations #hinweis[(Fluids, Weather, Traffic, etc.)]\
*SPMD:*
This is the most commonly used programming model, "high level".
_Single Program_ #hinweis[(All tasks execute their copy of the same program simultaneously)],
_Multiple Data_ #hinweis[(all tasks may use different data)].
The MPI program is started in several processes. All processes start and terminate
synchronously. Synchronization is done with barriers.\
*MPMD:*
Also a "high level" programming model.
_Multiple Program_ #hinweis[(Tasks may execute different programs simultaneously)],
_Multiple Data_ #hinweis[(all tasks may use different data)].\
*Hybrid Memory Model:*
All processors in a machine can _share_ the memory. They also can _request_ data from other
computers. #hinweis[(non-uniform memory access: not all accesses take the same time)]\
*Message Passing Interface (MPI)*:
Distributed programming model. Is a common choice for Parallelization on a cluster,
Industry-Standard libraries for multiple programming languages.\
*MPI Model:*
Notion of processes #hinweis[(Process is the running program plus its data)], parallelism is
achieved by running _multiple processes_, co-operating on the _same_ task. Each process has
_direct access_ only to its _own data_ #hinweis[(variables are private)].
Inter-Process-Communication by sending and receiving messages.\
*SPMD in MPI:*
All processes run their _own local copy_ of the program & data. Each process has a _unique
identifier_, processes can take _different paths_ through the program depending on their IDs.
Usually, _one process per core_ is used #hinweis[(to maximize the benefit of parallelization)].\
*Formalizing Message:*
A message transfers a number of data items from the memory of one process to the memory of
another process #hinweis[(Typically contains ID of sender and receiver, data type to be sent,
number of data items, data itself, message type identifier)].\
*Communication modes:*
_Point to Point_ #hinweis[(very simple, one sender and one receiver. Relies on matching send and receive calls)] and
_Collective communications_ #hinweis[(between groups of processes.
_Broadcast_: one to all,
_Scatter_: Split data and send each chunk to different node,
_Gather_: Collect the chunks back at the originating node)].\
== MPI Boilerplate Code
```c
int main(int argc, char * argv[]) {
MPI_Init(&argc, &argv); // MPI Initialization
int rank; int len;
MPI_Comm_rank(MPI_COMM_WORLD, &rank); // Process Identification
char name[MPI_MAX_PROCESSOR_NAME];
MPI_Get_processor_name(name, &len);
printf("MPI process %i on %s\n", rank, name);
MPI_Finalize(); // MPI Finalization
return 0; }
```
*`MPI_Init`:*
Must be the _first_ MPI call. Allows the `mpi_init` to broadcast to all the processes.
Does _not_ create processes, they are only created at launch time.
All MPI _global and internal variables are constructed_.
A _communicator_ is formed around all the processes that were spawned and _unique ranks_
#hinweis[(IDs)] are assigned to each process.
_`MPI_COMM_WORLD`_ encloses all processes in the job.\
*Communicator:*
Group of MPI processes, allows inter-process-communication.\
*`MPI_Comm_rank`:*
_Returns the rank_ of a process in a communicator. Used for sender/receiver IDs.\
*`MPI_Comm_size`:*
_Returns the total number_ of processes in a communicator.\
*`MPI_Finalize`:*
Is used to _clean up_ the environment. No more MPI calls after that.\
*`MPI_Barrier`:*
Blocks until all processes in the communicator have reached the barrier.
*Compilation & Execution:* ```sh mpicc HelloCluster.c && mpiexec -c 24 a.out && sbatch -hi.sub```\
*Process Identification:*
_Rank_ = number within a group, incremental numbering from 0.
Unique Identification = (Rank, Communicator)\
```c MPI_Send(void * data, int count, MPI_Datatype datatype, int destination, int tag, MPI_Comm communicator) // tag: freely selectable number for msg type (>= 0)```
```c MPI_Recv(void * data, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm communicator, MPI_Status* status) // status: error information```\
Each _send_ should have a matching _receive_.\
*Example direct communication:*\
```c MPI_Send(&value, 1, MPI_INT, receiverRank, tag, MPI_COMM_WORLD);```\
```c MPI_Recv(&value, 1, MPI_INT, senderRank, tag, MPI_COMM_WORLD, MPI_STATUS_IGNORE);```\
*Array send:* ```c int array[LENGTH];``` \
```c MPI_Send(array, LENGTH, MPI_INT, receiverRank, tag, MPI_COMM_WORLD);``` \
```c MPI_Recv(array, LENGTH, MPI_INT, senderRank, tag, MPI_COMM_WORLD, MPI_STATUS_IGN);``` \
*`MPI_Bcast`:*
Is _efficient_, because the root node does _not send the signal individually_ to each node,
the _other nodes help_ spread the message to others. #hinweis[(signal spreads like corona)]:
```c MPI_Bcast(void * data, int count, MPI_Datatype datatype, int root, MPI_Comm_World communicator)```\
*`MPI_Reduce`:*
Reduction is a classic concept: reducing a set of numbers into a smaller set of numbers via a
function #hinweis[(e.g. `[1,2,3,4,5] => sum => 15`)]. Each process contains one integer,
`MPI_Reduce` is called with a root process of 0 and using `MPI_SUM` as the reduction operation.
The four numbers are added and stored on the root process.
Job is done in a _distributed manner_.\
```c MPI_Reduce(void* send_data, void* recv_data, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)```
#hinweis[(_`send_data`_: array of elements of type `datatype` to reduce from each process,
_`recv_data`_: relevant on the root process. contains the reduced result and has a size of `sizeof(datatype) * count`.
_`op`_ the operation you wish to apply to your data: `MPI_MAX`, `MPI_MIN`, `MPI_SUM`,
`MPI_PROD`: multiplies all, `MPI_BAND`/`MPI_LAND`: Bitwise/Logical AND, `MPI_LOR`: Logical OR,
`MPI_MAXLOC`: Same as max plus rank of process that owns it)] \
*`MPI_AllReduce`:*
Many parallel applications require accessing the reduced results _across all processes_.
This function reduces the values and distributes the result to all processes.
Does not need a root node. This is an _implicit broadcast_ to all processes.\
```c MPI_Allreduce(void* send_data, void* recv_data, int count, MPI_Datatype datatype, MPI_Op op, MPI_COMM comm)```\
*`MPI_Gather`:*
Gather together multiple values from different processors.\
```c MPI_Gather(&input_value, 1, MPI_INT, &output_array, 1, MPI_INT, 0, MPI_COMM_WORLD)```
== Approximation of $bold(pi)$ via Monte Carlo Simulation <pi-approx>
Draw a circle inside of a square and randomly place dots in the square. The ratio of dots
inside the circle to the total number of dots will approximately equal $pi / 4$.
```c
// Sequential
long count_hits(long trials) { long hits = 0, i; for (i = 0; i < trials; i++) {
double x = (double)rand()/RAND_MAX; double y = (double)rand()/RAND_MAX;
if (x * x + y * y <= 1) { hits++;} // distance to center is bigger than radius=1
} return hits; }
//Parallel, the trials are split across different nodes
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size);
srand(rank * 4711); // each process receives a different seed
long hits = count_hits(TRIALS / size); // Each process computes a subtask
long total;
MPI_Reduce(&hits, &total, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
if (rank == 0) { double pi = 4 * ((double)total / TRIALS); }
```
= OpenMP
*Node:*
A standalone _"computer in a box"_. Usually comprised of multiple CPU/processors/cores, memory,
network interfaces etc. Nodes are _networked together_ to comprise a _supercomputer_.
Each node consists of 20 cores. The processes do _not share memory_, they must use messages.\
*Threads:*
Default are 24 on a single Node in OST cluster. Can be set with `omp_set_num_threads()` or with
the `OMP_NUM_THREADS` environment variable. Threads range from 0 #hinweis[(master thread)] to N-1.\
*HPC Hybrid memory model:*
Run a program on multiple nodes. No Shared Memory #hinweis[(NUMA)] between Nodes.
Shared Memory #hinweis[(SMP)] for Cores inside a Node.\
*OpenMP:*
Is a programming model for different languages.
_Allows to run multiple threads_, distribute work using synchronization and reduction constructs.
_Shared Memory_ #hinweis[(shared memory process consists of multiple threads)],
_Explicit Parallelism_ #hinweis[(Programmer has full control over parallelization)] and
_Compiler Directives_ #hinweis[(Most OpenMP parallelism is specified through the use of compiler
directives (`pragmas`) in the source code)].\
==== Fork and Join
```c
#include <stdio.h>
#include <omp.h>
int main(int argc, char* argv[]) {
const int np = omp_get_max_threads(); // executed by initial thread
printf("OpenMP with threads %d\n", np); // executed by initial thread
#pragma omp parallel // pragma spawns multiple threads (fork)
{
const int np = omp_get_num_threads(); // executed in parallel
printf("Hello from thread %d\n", omp_get_thread_num()); // executed in parallel
} // order not fixed. after execution, threads synchronize and terminate.
return 0; }
```
==== For loops
```c
#pragma omp parallel for
for (i=0; i<n; i++) { ... }
```
Each thread processes _one loop-iteration_ at a time. Execution returns to the initial threads.
_Oversubscription_ #hinweis[(too many threads for a problem)] is handled by OpenMP.
The iteration variable #hinweis[(i.e. `i`)] is implicitly made private for the duration of the loop.
==== Memory Model
```c
int A, B, C //automatically global because outside of pragma
#pragma omp parallel for private (A) shared (B) firstprivate (C)
for(...)
```
Each thread has a _private copy of `A`_ and use the _same memory location for `B`_.
`C` is also private, but gets its initial value from the global variable. After the loop is
over, threads die and both `A` and `B` will be cleared/removed from memory.
```c
#pragma omp parallel
int A = 0 // automatically private because inside of pragma
#pragma omp for ...
```
==== Avoiding Race conditions: Mutex
```c
int sum = 0;
#pragma omp parallel for
for (int i = 0; i < n; i++)
#pragma omp critical { sum += i; } // only one thread at a time
```
This is _extremely slow_ due to serialization, slower than single threading. Critical section
is _overkill_ for this code, with a heavy weight mutex the performance overhead is large.
==== Lightweight mutex: Atomic
```c
int sum = 0; int i;
#pragma omp parallel for
for (i = 0; i < n; i++)
#pragma omp atomic { sum += i }
```
==== Reduction across threads
When using `reduction(operator: variable)`, a _copy_ of the reduction variable per thread is created,
initialized to the identity of the reduction operator #hinweis[($+ = 0$, $* = 1$)].
Each thread will then _reduce_ into its local variable. At the end of the `parallel` region, the local
results are _combined into the global variable_. Only associative operators allowed
#hinweis[($+, *$ not $-, \/ $)].
```c
// Code using the reduction clause
int sum = 0;
#pragma omp parallel for reduction(+: sum)
for (int i = 0; i < n; i++) { sum += i; }
// The same code without the reduction clause
int sum = 0;
#pragma omp parallel {
int intermediate_sum = 0; // private
#pragma omp for
for (int i = 0; i < n; i++) { intermediate_sum += i; } // thread partial sum
#pragma omp atomic // reduction is protected with atomic
final_sum += intermediate_sum; }
```
==== Hybrid: OpenMP + MPI
```c
int numprocs, rank; int iam = 0, np = 1;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#pragma omp parallel default(shared) private(iam, np) {
np = omp_get_num_threads();
iam = omp_get_thread_num();
printf("I am T %d out of %d from P %d out of %d\n", iam, np, rank, numprocs);
} MPI_Finalize();
```
==== Sequential `count_hits` from @pi-approx in OpenMP
```c
long count_hits(long trials) {
long hits = 0; long i; double x,y;
#pragma omp parallel {
#pragma omp for reduction(+:hits) private(x,y)
for (i = 0; i < trials; i++) {
double x = random_double(); double y = random_double();
if (x * x + y * y <= 1) { hits +; }
}}
return hits; }
```
= Performance Scaling
*Difficulties with parallel programs*:
Finding parallelism, granularity of a parallel task, moving data is expensive, load balancing,
coordination & synchronization, performance debugging.\
*Scalability:*
The ability of hard- and software to deliver _greater computational power_ when the number of
_resources is increased_.\
*Scalability Testing:*
Primary challenge of parallel computing is _deciding how best to break up a problem_ into
individual pieces that can be computed separately.
It is _impractical_ to develop and test large applications using the _full problem size_.
The problem and number of processors are _scaled down_ at first.
_Scalability testing:_ measuring the ability of an application to perform well or better with
varying problem sizes and numbers of processors. It does _not_ test the applications _general
functionality_ or correctness.
== Strong scaling
_The number of processors is increased while the problem size remains constant_.
Results in a reduced workload per processor. Mostly used for long running CPU bound applications.\
*Amdahls Law:*
The speedup is _limited by the fraction of the serial part_ of the software that is not
amenable to parallelization. Sweet spot needs to be found. It is reasonable to use _small
amounts of resources for small problems_ and _larger quantities of resources for big problems._\
$T =$ total time, $p =$ part of the program that can be parallelized., $N =$ amount of processors\
$T = (1-p)T + T_p = T_s + T_p$\
$T_N = T_p \/ N + (1-p)T$, Speedup $<= 1\/(s + p \/ N)$, Efficiency = $T\/(N dot T_N)$\
Amdahls law _ignores the parallel overhead_. Because of that, it is _the upper limit_ of
speedup for a problem of fixed size. This seems to be a _bottleneck_ for parallel computing.\
*Examples:*
$90%$ of the computation can run parallel, what is the max speedup with $8$ processors?
$1 \/ (0.1 + 0.9\/8) approx underline(4.7)$ \
25% of the computation must be serial. What is the max speedup with $infinity$ Processors? \
$1\/ (0.25 + 0.75\/infinity) approx 1 \/0.25 = 4$ \
To gain a $500 times$ speedup on $1000$ processors,
Amdahls law requires that the proportion of serial part cannot exceed what?\
$500 = 1\/(s + (1-s) / 1000) => s + (1-s) / 1000 = 1 / 500
=> 1000s + (1-s) = 2 => 999s = 1 => s = 1 / 999 approx underline(0.1%)$
== Weak scaling
_The number of processors and the problem size is increased_. Mostly used for large
_memory-bound_ applications where the required memory cannot be satisfied by a single node.\
*Gustafson's law:*
Based on the approximations that the _parallel part scales linearly_ with the amount of
resources, and that the _serial part_ does _not increase_ with respect to the size of the problem.
_Speedup_ $= s + p dot N = s + (1-s) dot N$\
In this case, the problem size assigned to each processing element stays _constant_ and
_additional elements_ are used to solve a _larger total problem_. Therefore, this type of
measurement is justification for programs that take a lot of memory or other system resources.\
*Example:*
$64$ Processors. $5%$ of the program is serial, What is the scaled weak speedup?\
$0.05 + 0.95 dot 64 = underline(60.85)$
|
|
https://github.com/AHaliq/DependentTypeTheoryReport | https://raw.githubusercontent.com/AHaliq/DependentTypeTheoryReport/main/preamble/style.typ | typst | #import "lemmas.typ": *
#let std-bibliography = bibliography
#let setup(
title,
author,
authorid: "",
subtitle: "",
date: datetime.today(),
preface: none,
table-of-contents: outline(),
bibliography: none,
body,
) = {
set text(lang: "en")
set page(paper: "a4")
set document(title: title, author: author)
set text(font: ("Libertinus Serif", "Linux Libertine"), size: 11pt)
// preamble
page([
#align(left + horizon, block(width: 90%)[
#let v-space = v(2em, weak: true)
#text(3em)[*#title*]
#v-space
#text(1.6em, subtitle)
#grid(
columns: (auto, 1fr),
align: (left + horizon, left + horizon),
text(
size: 1.2em,
font: ("AU Passata"),
)[#upper[*Aarhus Universitet* #h(0.3em)]],
image("../resources/au_logo_black.png", width: 0.7cm)
)
])
#align(left + bottom, block(width: 90%)[
#grid(
columns: (auto, 1fr),
align: (left + horizon, left + horizon),
text(1.4em)[#author #h(0.5em)],
text(1.2em)[[#raw(authorid)]]
)
#if date != none {
// Display date as MMMM DD, YYYY
text(date.display("[month repr:long] [day padding:zero], [year repr:full]"))
}
])
])
// cover page
if preface != none {
page(
align(center + horizon)[#preface]
)
}
// preface page
set outline(
indent: auto,
fill: box(width: 1fr, repeat[#text(silver)[-]])
)
if table-of-contents != none {
table-of-contents
}
// table of contents
set page(
footer: context {
// Get current page number.
let i = counter(page).at(here()).first()
// Align right for even pages and left for odd.
let is-odd = calc.odd(i)
let aln = if is-odd { right } else { left }
// Are we on a page that starts a chapter?
let target = heading.where(level: 1)
if query(target).any(it => it.location().page() == i) {
return align(aln)[#i]
}
// Find the chapter of the section we are currently in.
let before = query(target.before(here()))
if before.len() > 0 {
let current = before.last()
let gap = 1.75em
let chapter = upper(text(size: 0.68em, current.body))
if is-odd {
align(aln)[#chapter #h(gap) #i]
} else {
align(aln)[#i #h(gap) #chapter]
}
}
}
)
{
// Custom Heading Styling
set heading(numbering: "1.1.1")
show heading.where(level: 1): it => {
colbreak(weak: true)
[§#counter(heading).display() #it.body]
}
// Custom Table Styling
set table(
fill: (x,y) => if y == 0 {
silver
},
stroke: (x,y) => if x == 0 and y == 1 {(
top: (thickness: 1pt, paint:silver),
right: (thickness: 1pt, paint:silver)
)} else if y == 1 {(
top: (thickness: 1pt, paint:silver)
)} else if x == 0 {(
right: (thickness: 1pt, paint:silver)
)} else if y > 1 {(
top: (thickness: 1pt, paint:silver)
)},
inset: 7pt,
)
show table.cell.where(y: 0): smallcaps
// Setup lemmify
show: thm-rules
body
}
// Display bibliography.
if bibliography != none {
pagebreak()
show std-bibliography: set text(0.85em)
// Use default paragraph properties for bibliography.
show std-bibliography: set par(leading: 0.65em, justify: false, linebreaks: auto)
bibliography
}
// bibliography
} |
|
https://github.com/Kasci/LiturgicalBooks | https://raw.githubusercontent.com/Kasci/LiturgicalBooks/master/CSL_old/oktoich/Hlas4/5_Piatok.typ | typst | #let V = (
"HV": (
("", "Dál jesí známenije", "Jehdá ťa raspinájema tvár vsjá víďi, izmiňášesja i trepetáše: zemľá že trjasúščisja vsjá kolebášesja, dolhoterpilíve Slóve, i zavísa cerkóvnaja stráchom razdirášesja, dosaždájemu tebí, i kámenije raspadášesja ot strácha, i sólnce lučý skrý, tvorcá svojehó vídušči ťá."),
("", "", "Káko bezzakónňijšij sobór derznú osudíti ťá sudijú bezsmértnaho, zakón dávšaho v pustýni drévle Moiséju bohovídcu? Káko žízň vsjáčeskich na drévi zrjášče uméršuju, nikákože ubojášasja, nižé vo umí pomyšľáchu, jáko tý jedín Hospóď i Vladýka tvári."),
("", "", "Rasterzájetsja rukopisánije, jéže ot víka Adáma práotca, probodénijem tvojích rébr mnohomílostive, i otrinovénoje jestestvó čelovíčeskoje kroplénijem króve tvojejá osvjatísja, zovúščeje: sláva blahoutróbiju tvojemú, sláva božéstvennomu raspjátiju tvojemú, Iisúse vsesíľne, Spáse dúš nášich."),
("", "Jáko dóbľa", "Na kresťí jáko uzrí ťa prihvoždéna Hóspodi, áhnica i Máti tvojá divľášesja, i čtó viďínije sijé, vzyváše, Sýne voždeľínne, sijá li tí nepokorívyj sobór vozdadé bezzakónnyj, íže mnóhich tvojích čudés nasladívyjsja? No sláva neizrečénnomu schoždéniju tvojemú Vladýko."),
("", "", "Na kresťí jáko uzrí ťa prihvoždéna Hóspodi, áhnica i Máti tvojá divľášesja, i čtó viďínije sijé, vzyváše, Sýne voždeľínne, sijá li tí nepokorívyj sobór vozdadé bezzakónnyj, íže mnóhich tvojích čudés nasladívyjsja? No sláva neizrečénnomu schoždéniju tvojemú Vladýko."),
("", "", "Áhnca i pástyrja ťá, jáko víďi na drévi áhnica róždšaja, rydáše Máterski, tebí viščáše: Sýne ľubézňijšij, káko na drévi krestňim povíšen jesí dolhoterpilíve? Káko rúci i nózi tvojí Slóve, prihvozdíšasja ot bezzakónnych? I króv tvojú izlijál jesí Vladýko."),
("Krestobohoródičen", "", "Jáko uzrí ťá Hóspodi, Ďíva i Máti tvojá na kresťí povíšena, divľášesja i vzirájušči hlahólaše: čtó ti vozdáša, íže mnóhich tvojích daróv nasláždšijisja Vladýko? No moľúsja, ne ostávi mené jedínu v míri: no potščísja voskresnúti, sovozstavľája práotca."),
),
"S": (
("", "", "Orúžije nepobidímoje Christé, krest tvój nám dál jesí, i sím pobiždájem prilóhi čuždáho."),
("", "", "Vsehdá imúšče Christé krest tvój na pómošč, síti vrážija udóbňi popirájem."),
("", "", "Proslavľájajsja v pámjatech svjatých tvojích Christé Bóže, i ot ních umolén byvája, nizposlí nám véliju mílosť."),
("Krestobohoródičen", "Zvánnyj svýše", "Ne rydáj mené Máti, zrjášči na drévi vísjašča tvojehó Sýna i Bóha, na vodách povísivšaho zémľu neoderžímo, i vsjú tvár sozdávšaho: íbo vostánu i proslávľusja, i ádova cárstvija sokrušú krípostiju, i potrebľú jehó vsjú sílu, i úzniki izbávľu ot zloďíjstva jehó, jáko milosérd: i Otcú mojemú privedú, jáko čelovikoľúbec."),
),
)
#let P = (
"1": (
("", "", "Otvérzu ustá mojá, i napólňatsja Dúcha, i slóvo otrýhnu caríci Máteri, i javľúsja svítlo toržestvúja, i vospojú rádujasja tojá čudesá."),
("", "", "Tý jedína zastuplénije, pribížišče i chraníteľnica rabóv tvojích jesí, Bohorodíteľnice čístaja. Sehó rádi pripádaju tí i zovú: spasí mja okajánnaho, jáko mílostiva."),
("", "", "Ďijánija skvérnaja sóvisť mojú ráňat, pred licém nosjáščuju sích obličénije: uskorí Vladýčice, i pómošč búdi mí, i préžde končíny izbávi, i spasí mja."),
("", "", "Osvjátí Vladýčice, oskvernénnoje sérdce mojé, jáže presvjatóje Slóvo róždšaja, i súščaja vsích svjaťíjšaja výšnich síl, jedína vsepítaja."),
("", "", "Na ťá nadéždu mojehó spasénija vozložích, i k tebí blahoutróbňij víroju pribihóch: ne prézri mené nadéždo nenadéžnych, nižé javí mja obrádovanije bisóm."),
),
"3": (
("", "", "Tvojá pisnoslóvcy Bohoródice, živýj i nezavístnyj istóčniče, lík sebí sovokúplšyja duchóvno utverdí, v božéstvenňij tvojéj slávi, vincév slávy spodóbi."),
("", "", "Rósu tvojehó blahoutróbija podážď mí preneporóčnaja čístaja, hrichóvnym znójem tájuščemu, i pečáľ samá ustužájušči mí, i rádosť božéstvennuju podajúšči."),
("", "", "Umá mojehó ťmú razruší Bohoródice, svítom íže v tebí, jáko blahája, i moľúsja, pokajánija mjá óbrazy utverdíti, jáko ščédra i mnohomílostiva, da spasájem ublažáju ťá."),
("", "", "Kroplénijem mílosti tvojejá, Ďívo bohorádovannaja, úhlije pohasí mojích strastéj, i uhásšij svitíľnik sérdca mojehó vozžzí, zlatýj svíščniče vseneporóčnaja."),
("", "", "Potopľájet mjá volná hrichóvnaja, i búrja bezmístnych pomyšlénij: no umilosérdisja vseneporóčnaja, i rúku mí pómošči jáko mílostiva prostrí, da spasájem ublažáju ťá."),
),
"4": (
("", "", "Neizsľídnyj Bóžij sovít, jéže ot Ďívy voploščénija, tebé výšňaho, prorók Avvakúm usmotrjája zovjáše: sláva síľi tvojéj Hóspodi."),
("", "", "Jáže vseprečúdnaja Máti Bóžija, vozsijáj mí pokajánija zarí, i razriší mrák okajánnyja mojejá duší, i otžení Ďívo, lukávaja pomyšlénija sérdca mojehó."),
("", "", "Ťá očistílišče vsích čelovíkov víroju moľú blahoslovénnaja, i prošú: mílostiva mí sudijú Sýna tvojehó sotvorí, jáko da chvalámi proslavľáju ťá."),
("", "", "Smirénnoje jedína čístaja, i prokažénnoje sérdce mojé, nečístymi strastéj navedéniji, jáko vráč iscilí, i ot rukí bisóvskija ischití."),
("", "", "Hlahólom bohodochnovénnym préžde blažénnyj Avvakúm, hóru ťá čístuju i prisínnuju narečé, prišédšaho ot júha, i tobóju voploščájema Vladýčice, vozviščája javlénňijše."),
),
"5": (
("", "", "Užasóšasja vsjáčeskaja o božéstvenňij slávi tvojéj: tý bo neiskusobráčnaja Ďívo, imíla jesí vo utróbi nad vsími Bóha, i rodilá jesí bezľítnaho Sýna, vsím vospivájuščym ťá mír podavájuščaja."),
("", "", "Umerščvlén strasťmí i pomyšléniji vseneporóčnaja, k ščedrótam tvojím pribiháju, i k téplomu tvojemú pritekáju Vladýčice, pokróvu i pómošči: jáže žízň jedína róždšaja, sérdce mojé oživí."),
("", "", "Orúžijem sňidéna mjá hrichóvnym, iscilí ďíjstvennoju tvojéju ľičbóju, jáže Spása róždšaja Hóspoda, kopijém ujázvlennaho mené rádi prečístaja, i ujazvívšaho sérdce zmíjevo."),
("", "", "Umá mojehó uvračúj sokrušénija, preneporóčnaja, i iscilí strásti duší mojejá, i unýnija ťmú potrebí, jáko da vo chvaléniji ťá pojú prisnoblažénnuju, Bohoródice vsepítaja."),
("", "", "Hrózd vinohráda, jehóže vozrastí Ďívo na drévi vísjašča víďivši, vopijáše: čádo, mstó iskopáješi, pijánstvo otpuščája vrahóm vsúje raspénšym ťá, vo vsém dolhoterpilívaho."),
),
"6": (
("", "", "Božéstvennoje sijé i vsečestnóje soveršájušče prázdnestvo, bohomúdriji Bohomátere, prijidíte rukámi vospléščim, ot nejá róždšahosja Bóha slávim."),
("", "", "Jáže jedína vsím pómošč, pomozí nám bídstvujuščym, i rúku podážď, i k pristánišču naprávi spasíteľnomu, jedína Bohoblahodátnaja."),
("", "", "Isťazánija mjá prečístaja, v čás strášnyj tý ischití, ot bisóv zlýja prélesti, i sudá, i ohňá, i ťmý, i múki."),
("", "", "Pisnoslóvľu ťá vsepítaja, slávľu čestnája velíčija tvojá: tý že nečístych mjá strastéj svobodí, i víčnyja slávy spodóbi."),
("", "", "Píti ťá dólžni jesmý, no voístinnu po dostojániju ne móžem: ťímže pojém ťá, molčánijem čtúšče neskazánnoje, jéže na tebí Ďívo, soďíjannoje tájinstvo."),
),
"S": (
("", "", "Na kresťí ťa vozvýšena, jáko uzrí prečístaja tvojá Slóve Bóžij, Máterski rydájušči viščáše: čtó nóvoje i stránnoje sijé čúdo Sýne mój? Káko žízň vsích vkušáješi smérti, oživíti mértvyja choťá, jáko milosérd?"),
),
"7": (
("", "", "Ne poslužíša tvári bohomúdriji páče sozdávšaho, no óhnennoje preščénije múžeski poprávše, rádovachusja pojúšče: prepítyj otcév Hospóď i Bóh blahoslovén jesí."),
("", "", "Nepremínnaho róždši jedína Bohoblahodátnaja, molísja čístaja, desníceju jehó preminíti mój úm k lúčšym, ľúťi preminénnyj bisóvskimi iskušéniji."),
("", "", "Caríce Ďívo, róždšaja carjá Christá, uščédri i spasí mja, strasťmí preklonénaho: víroju utverdí, i nastávi mjá ko spasénija stezí, vírnych spasénije."),
("", "", "Molítvennica mí búdi preneporóčnaja, k róždšemusja iz tebé: i ostavlénije ľútych dolhóv podážď mí, i cárstvija Bóžija božéstvennyj vchód, i píšči vosprijátija, i svíta pričástije."),
("", "", "Vseneporóčnaja Maríje, Ďívo neiskusobráčnaja čístaja, bezmírnaja bláhostiju, jáže Bóha plótiju róždšaja, tohó molí, vsjákija nás izbáviti pečáli i hrichá."),
),
"8": (
("", "", "Ótroki blahočestívyja v peščí, roždestvó Bohoródičo spasló jésť: tohdá úbo obrazújemoje, nýňi že ďíjstvujemoje, vselénnuju vsjú vozdvizájet píti tebí: Hóspoda pójte ďilá, i prevoznosíte jehó vo vsjá víki."),
("", "", "Blúdno žitijé iždív, i vsjáku skvérnu soďílav, trepéšču sudíšča, trepéšču isťazánija, trepéšču i otvíta osuždénija mojehó: pomíluj dúšu mojú okajánnuju, čístaja, i préžde smérti prosviščénije mí podážď."),
("", "", "Na ťá vsjú nadéždu spasénija mojehó vozložích, Bohomáti neiskusobráčnaja, i tebé na pómošč prizyváju vsehdá: spasí mja ot pečálej, i napástej vrážijich, i razriší plenícy zól mojích, i ot víčnyja ťmý ischití mja."),
("", "", "Javílasja jesí ánhel výšši, Bóha neizrečénno voplotívši: sehó úbo molí, Vladýčice vseneporóčnaja, plotskích iskušénij výššu býti mí, i sudá búduščaho izbávitisja Ďívo, i víčnyja múki."),
("", "", "Vód božéstvennych ispólni mjá Ďívo, jáže istóčnik vo črévi nosívšaja: izbávi ot hnója hrichóv mojích, i k žízni nastávi spasénija, čístaja, i unýnija duší mojejá okajánnyja otžení Ďívo, i ot bisóv izbávi."),
),
"9": (
("", "", "Vsják zemnoródnyj da vzyhrájetsja dúchom prosviščájem, da toržestvújet že bezplótnych umóv jestestvó, počitájuščeje svjaščénnoje toržestvó Bohomátere, i da vopijét: rádujsja vseblažénnaja Bohoródice, čístaja prisnoďívo."),
("", "", "Razruší pážiť hrichá, oskvernénnyja mojejá duší i ťilesé, Bohorádovannaja prečístaja Vladýčice, síľnoju molítvoju, tvojéju, o vseneporóčnaja! Iscilénije dávši spasíteľnoje, Vladýčnij strách prečístyj."),
("", "", "Tý mňí prosviščénije, tý mi izbavlénije i rádovanije, tý pobórnica mojá, tý mojá sláva, i pochvalá, i nadéžda, i spasénije mojé jesí preneporóčnaja, i tebí vírno poklaňájusja, i vopijú ti: spasí mja okajánnaho rabá tvojehó, i ot ádovych vrát ischití mja."),
("", "", "Spasí mja čístaja, Spása róždšaja vseščédraho, i uščédri rabá tvojehó, i k pokajánija putí nastávi, lukávaho soblázny ot sredý otžení, i tohó lovlénija izbávi mjá, i ohňá víčnaho, preneporóčnaja, ischití mja."),
("", "", "Plótiju jéže iz tebé, Slóvo preneporóčnaja oďíjavsja, voplotívsja že poživé v míri, jáko milosérd, prebýv ne chúždši, íže préžde bezplótnyj: i íže drévle vsích múčivšaho, božéstvennoju síloju nizloží."),
),
)
#let U = (
"S1": (
("", "", "Iskupíl ný jesí ot kľátvy zakónnyja čéstnóju tvojéju króviju, na kresťí prihvozdívsja, i kopijém probóďsja, bezsmértije istočíl jesí čelovíkom: Spáse náš sláva tebé."),
("", "", "Na kresťí ťa prihvozdíša judéi Spáse, ímže ot jazýk nás prizvál jesí inohdá, Christé Bóže náš, prostérl jesí dláni na ném vóleju tvojéju: kopijém že v rébra tvojá voschoťíl jesí probodén býti, mnóžestvom ščedrót tvojích čelovikoľúbče."),
("Krestobohoródičen", "", "Ďívo preneporóčnaja Máti Christá Bóha, orúžije prójde presvjatúju tvojú dúšu, jehdá raspinájema víďila jesí vóleju Sýna i Bóha tvojehó: jehóže blahoslovénnaja moľášči ne prestáj, proščénije prehrišénij nám darováti."),
),
"S2": (
("", "", "Skóro predvarí préžde dáže ne porabótimsja vrahóm chúľaščym ťá, i preťáščym nám, Christé Bóže náš: pohubí krestóm tvojím borjúščyja nás, da urazumíjut, káko móžet pravoslávnych víra, molítvami Bohoródicy, jedíne čelovikoľúbče."),
("", "", "Ujázvenu tí Vladýko, kopijém božéstvennomu rebrú, orúžija oskuďíša nevídimaho vrahá do koncá, i prestá vsjákoje nasílije zloďíjstva jehó. Ťímže poklaňájemsja tvojím spasíteľnym strastém, slávjašče božéstvennoje smotrénije tvojé."),
("", "", "Dnés ánheľskaja vójinstva, v pámjať strastotérpec prijidóša, vírnych mýsli prosvitíti, i vselénnuju blahodátiju ujasníti. Ťích rádi, Bóže umolén byvája, dáruj nám véliju mílosť."),
("Krestobohoródičen", "", "Na kresťí ťa vozvyšájema jáko uzrí prečístaja Máti tvojá, Slóve Bóžij, máterski rydájušči viščáše: čtó nóvoje i stránnoje čúdo sijé, Sýne mój? káko životé vsích vkušáješi smérti, oživíti uméršyja choťá, jáko milosérd?"),
),
"S3": (
("", "", "Krest i smérť za ný, bláže, za bezmérnuju mílosť vóleju preterpíl jesí, i súd nepráveden: jáko da osuždénija i drévnija kľátvy vsích svobodíši, léstiju v tľínije vpádšich. Ťímže i poklaňájemsja, Slóve, tvojemú raspjátiju."),
("", "", "Na drévi povíšena usmotrívšeje ťá sólnce, sólnca právdy Christá, svít pomračí. Tvár že kolebášesja, i mértviji jáko ot sná skóro iz hrobóv vostáša, Slóve, božéstvennuju pisnoslóvjašče deržávu slávy tvojejá."),
("Krestobohoródičen", "", "Neporóčnaja Máti tvojá, Christé, jáko uzrí na kresťí ťa vozvyšájema, rydájušči máterski, takovája hlahólaše: čtó nóvoje i stránnoje sijé čúdo, Sýne mój? Káko ťá bezzakónnyj sónm ko krestú prihvoždájet vsích žízň, svíte mój sladčájšij?"),
),
"K": (
"P1": (
"1": (
("", "", "Otvérzu ustá mojá i napólňatsja Dúcha, i slóvo otrýhnu caríci Máteri, i javľúsja svítlo toržestvúja, i vospojú rádujasja tojá čudesá."),
("", "", "Na kresťí rasprostérl jesí božéstvennyja dláni, dolhoterpilíve, i pohibájuščij mír prizvál jesí k poznániju deržávy tvojejá, ščédre. Ťímže veličájem blahoutróbije tvojé."),
("", "", "Zmíja vozdvíhl jésť Moiséj, proobrazúja božéstvennoje tvojé raspjátije, Slóve prebeznačáľne, ímže padé jadovítyj zmíj padéniju Adámovu chodátaj bývyj."),
("Múčeničen", "", "Vo svítlostech svjatých nýňi žíti spodóbistesja múčenicy, nepokolebímoje prijémše jávi cárstvo, jákože skazá Pável, i slávy sopričástnicy Christóvy býste."),
("Múčeničen", "", "Vozdvizájemymi volnámi nesterpímych mučénij vášich, nepohrúzim býsť korábľ, múčenicy: okormlénijem bo vsích carjá, v pristánišče dospíste pokójiščnoje."),
("Bohoródičen", "", "Orúžije, jákože rečé Simeón, sérdce tvojé prójde, jehdá víďila jesí Christá raspinájema, Ďívo Vladýčice, i jedínaho probodájema kopijém. Ťímže rydájušči boľízni preterpíla jesí."),
),
"2": (
("", "", "Otvérzu ustá mojá i napólňatsja Dúcha, i slóvo otrýhnu caríci Máteri, i javľúsja svítlo toržestvúja, i vospojú rádujasja tojá čudesá."),
("", "", "Tý jedína zastuplénije, i pribížišče, i chraníteľnica jesí rabóm tvojím Bohorodíteľnice čístaja. sehó rádi pripádajušče vopijém tí: spasí nás Vladýčice, milosérdijem tvojím."),
("", "", "Osvjatí Vladýčice oskvernénnoje sérdce mojé, jáže presvjatóe Slóvo róždšaja, i súšči vsích svjaťíjšaja výšnich síl, otrokovíce vseneporóčnaja."),
("", "", "Pádšich vozzvánije, i stojáščich jesí utverždénije, vseneporóčnaja. Ťímže moľúsja tí: pádšij mój úm hrichóm isprávi Vladýčice, da slávľu ťá."),
("", "", "Mértva mjá skorbmí i neďíjstvenna ležášča, rúku prostérši pómošči tvojejá vozstávi, i božéstvennaho vesélija ispólnena pokaží mja, Bohorodíteľnice."),
),
),
"P3": (
"1": (
("", "", "Tvojá pisnoslóvcy Bohoródice, živýj i nezavístnyj istóčniče, lík sebí sovokúpľšyja duchóvno utverdí v božéstvenňij tvojéj slávi vincév slávy spodóbi."),
("", "", "Jáko ovčá na zakolénije veďáchu ťá Christé, ľúdije prebezzakónniji, áhnca Bóžija súšča, i choťášča izbáviti óvcy ot vólka ľútaho, íchže čelovikoľúbňi vozľubíl jesí."),
("", "", "Predstál jesí sudijí sudím neprávedno, suďáj právedno vséj zemlí, i preterpíl jesí udarénije v lanítu, svobodíti mjá choťá poraboščénnaho Hóspodi, lukávomu mirodéržcu."),
("Múčeničen", "", "Stradávše svjatíji zakónno, bezzakónnyja vrahí posramíste, i vóleju umerščvľájemi za vsích vostánije, i íže smérť ischodátaivšaho poboríste zmíja."),
("Múčeničen", "", "Ot zemných vozvýsivšesja, ko blahosláviju že prišédše stradáľčeski múčenicy svjatíji, i k neveščéstvennym činóm veščéstvenniji sojediníšasja, rádosti neizrečénnyja ispolňájemi."),
("Bohoródičen", "", "Iz tebé Ďívo, obnovlénije Jévi javísja voístinnu, Bóh plótiju raždájem, i na krest vozvyšájem, nizlahája bísy, Bohoblahodátnaja Vladýčice."),
),
"2": (
("", "", "Tvojá pisnoslóvcy Bohoródice, živýj i nezavístnyj istóčniče, lík sebí sovokúpľšyja duchóvno utverdí v božéstvenňij tvojéj slávi vincév slávy spodóbi."),
("", "", "Pomíluj prečístaja Ďívo, v pučíňi žitéjsťij ľúťi mjá potopľájema, i ko pristánišču tíchomu spasénija isprávi: ťá bo jedínu nadéždu sťažách."),
("", "", "Umá mojehó ťmú razorí, Bohoródice, svítom íže v tebé jáko bláha, i moľúsja: pokajánija mjá óbrazy utverdí jáko ščédra, i mnohomílostiva, da spasájem ublažáju ťá."),
("", "", "Kroplénijem mílosti tvojejá, Ďívo Bohorádovannaja, úhlije pohasí mojích strastéj: i uhásšij svitílnik sérdca mojehó vozžzí, zlatýj svíščnice vseneporóčnaja."),
("", "", "Boľáščuju ľúťi strasťmí okajánnuju mojú dúšu, Bohorodíteľnice, jáko mílostivaja posití, i spasí mja molítvami tvojími: jáko da živót lúčšij polučív veličáju ťá."),
),
),
"P4": (
"1": (
("", "", "Neizsľídnyj Bóžij sovít, jéže ot Ďívy voploščénija, tebé výšňaho, prorók Avvakúm usmotrjája zovjáše: sláva síľi tvojéj Hóspodi."),
("", "", "Da otpústiši mjá ot úz hrichóvnych, čelovikoľúbče, tvojéju vóleju svjázan býl jesí, i na kresťí úmerl jesí jáko zloďíj: sláva mnóhomu blahoutróbiju tvojemú."),
("", "", "Jázvy preterpíl jesí Slóve Bóžij, i ponósnuju smérť, obezsmértstvuja suščestvó zemných umerščvlénoje strasťmí: sláva mnóhomu blahoutróbiju tvojemú."),
("Múčeničen", "", "Íže rádovanija Bóžija choťášče nasľídovati Dúchom vsesvjatým, rádostnoju dušéju rány preterpíša, i núždnuju smérť múčenicy, i lukávaho ujazvíša."),
("Múčeničen", "", "Rúci otsicájemi, i hlavý, i jazýki urézajemi, bohoslóvniji, i óči lišájemi svíta, i na údy ssicájemi múčenicy, ne otsíčeni že ot Bóha prebýste."),
("Bohoródičen", "", "Razdrásja rukopisánije Adámovo, kopijém probodénu tí Vladýko, Bohoródica vopijáše u krestá predstojášči, Hóspodi, i boľíznenno vosklicájušči."),
),
"2": (
("", "", "Neizsľídnyj Bóžij sovít, jéže ot Ďívy voploščénija, tebé výšňaho, prorók Avvakúm usmotrjája zovjáše: sláva síľi tvojéj Hóspodi."),
("", "", "Jáže vseneporóčnaja Máti Bóžija, vozsijáj mí pokajánija zarjú, razruší mrák okajánnyja mojejá duší, i lukávaja pomyšlénija sérdca mojehó otžení, Ďívo."),
("", "", "Jáže blahopremínnaho i blahouvítlivaho, prečístaja, Vladýku róždši, Ďívomáti, jáko blahája, o nás tohó molí vsehdá, ot čuždáho izbáviti nás."),
("", "", "Ťá očistílišče vsích čelovíkov, víroju moľú i prošú blahoslovénnaja: mílostiva mňí sudijú Sýna tvojehó sotvorí, jáko da vo chvaléniji slávľu ťá."),
("", "", "Imíja ťá, prečístaja, pomóščnicu vsehdá nikohó ubojúsja, ilí ustrašúsja: któ že li choťá skórbnaja prinestí rabú tvojemú, i ne ustrašítsja?"),
),
),
"P5": (
"1": (
("", "", "Užasóšasja vsjáčeskaja o božéstvenňij slávi tvojéj: tý bo neiskusobráčnaja Ďívo, imíla jesí vo utróbi nad vsémi Bóha, i rodilá jesí bezľítnaho Sýna, vsém vospivájuščym ťá mír podavájuščaja."),
("", "", "Víďivšeje ťá sólnca na kresťí prostirájema, sólnce skrý lučý, sijáti ne mohúščeje, tebí Spáse zašédšu, i prosviščájušču íže v noščí prélesti spjáščyja, poklaňájuščyjasja deržávi tvojéj."),
("", "", "Raspinájem za milosérdije, Hóspodi, i spasáješi mjá, ócta i žélči prijémleši vkušénije, slástnaho izbavľája nás vkušénija jáko bláh, ímže preľstíchomsja, i tlí podpadóchom."),
("Múčeničen", "", "Prélesti razoríste zímu, božéstvenniji múčenicy, Dúcha svjatáho teplotóju, i k vesňí pokója rádujuščesja dojdóste kúpno, vsím pomohájušče súščym v skórbech."),
("Múčeničen", "", "Túčami božéstvennyja króve zémľu vsjú napoíste, izsušájušče potóki bezbóžija, svjatíji múčenicy: ťímže k voďí živótňij nýňi vselístesja, o vsích moľáščesja."),
("Bohoródičen", "", "Plótiju jehóže rodilá Sýna, Bohorádovannaja, jáko víďi na drévi vozvýšena, pláčem ispólnisja, i dolhoterpíniju jehó divľášesja voístinnu: ťímže veličáše jehó snizchoždénije."),
),
"2": (
("", "", "Užasóšasja vsjáčeskaja o božéstvenňij slávi tvojéj: tý bo neiskusobráčnaja Ďívo, imíla jesí vo utróbi nad vsémi Bóha, i rodilá jesí bezľítnaho Sýna, vsém vospivájuščym ťá mír podavájuščaja."),
("", "", "Umerščvlén strasťmí i skvérnami vseneporóčnaja, k ščedrótam tvojím pribiháju, i k téplomu tvojemú pritekáju, Vladýčice, pokróvu i pómošči: žízň jedína róždšaja, sérdce mojé oživí."),
("", "", "Prosvití omračénnoje mojé sérdce, prečístaja, jáže svitodávca róždšaja, Bóha vkúpi i čelovíka: jehóže jáko Máti umolí, podáti mí izbavlénije, Hospožé, préžde strášnaho dné."),
("", "", "Umá mojehó uvračúj sokrušénija, vseneporóčnaja, iscilí strásti duší mojejá, i unýnija ťmú otžení: jáko da vo chvaléniji ťá pojú prisnoblažénnuju, Bohoródice vsepítaja."),
("", "", "Nizloží Vladýčice, vrahóv mojích šatánija: ťá bo jedínu ímam predstáteľnicu i nadéždu, i pómošč krípkuju, tý mja sobľudí, čístaja, vsjákaho izbavľájušči mjá ťích nachoždénija."),
),
),
"P6": (
"1": (
("", "", "Božéstvennoje sijé i vsečestnóje soveršájušče prázdenstvo bohomúdriji Bohomátere, prijidíte rukámi vospléščim, ot nejá róždšahosja Bóha slávim."),
("", "", "Boľízňmi, jáže preterpíl jesí raspinájem, boľízni ustávil jesí čelovíčestvu, i k neboľíznennomu žitijú vsích privódiši, blahoutróbne Hóspodi."),
("", "", "Sólnca lučý skryváchusja, cérkóvnaja že svítlosť razdirášesja, i zemľá trjasášesja, kámenije stráchom raspadášesja, na kresťí ziždíteľa zríti ne mohúšče."),
("Múčeničen", "", "Mértv zmíj býsť, múkami umerščvľájemy zrjá božéstvennyja múčeniki, i živót víčnyj nasľídujuščyja voístinnu, božéstvennoju blahodátiju ."),
("Múčeničen", "", "Mnóhija múki preterpíste, mnóhija i vincý ulučíste, mnohočíslennaja mnóžestva múčenik prísno živúščich: ťímže zól mojích mnóžestvo otženíte."),
("Bohoródičen", "", "Pristánišče búdi mí, vseneporóčnaja, v pučíňi ľútych plávajušču, jáže bídstvujuščuju vsjú tvár roždestvóm tvojím Bohorodíteľnice, spaslá jesí."),
),
"2": (
("", "", "Vozopí, proobrazúja pohrebénije tridnévnoje, prorók Jóna v kíťi moľásja: ot tlí izbávi mjá, Iisúse carjú síl."),
("", "", "Vozsijáj mí pokajánija zarjú, Vladýčice, i óblaki zlých pomyšlénij mojích razorí, óblače sólnca právednaho prisnoďívo."),
("", "", "Utolí strastéj mojích svirípuju vólnu, i búrju zlých pomyšlénij ukrotí, pristánišče velíkoje oburevájemych prisnoďívo."),
("", "", "Napój mjá umilénija pitijém, Vladýčice, sléz ríki mňí nýňi podajúšči: ímiže uhašú plámeň víčnujuščij, jedína vsepítaja."),
("", "", "Izsušájušči zól mojích svirípuju pučínu, róždšaja bláhosti voístinnu pučínu, nastávi mjá ko pristánišču božéstvennyja vóli."),
),
),
"P7": (
"1": (
("", "", "Ne poslužíša tvári bohomúdriji páče sozdávšaho, no óhnennoje preščénije múžeski poprávše, rádovachusja pojúšče: prepítyj otcév Hospóď i Bóh blahoslovén jesí."),
("", "", "Pobiždén býsť soprotivobórec, i padésja dívnym padénijem, voznésšusja Christú na drévo, i spasésja préžde osuždénnyj, vopijá jemú: íže otcév Hospóď i Bóh blahoslovén jesí."),
("", "", "Umerščvléna mjá drévom oživíl jesí na drévi Christé uméryj, i božéstvennymi úbo ránami tvojími strúpy sérdca mojehó iscilíl jesí: prepítyj otcév Hospóď i Bóh blahoslovén jesí."),
("Múčeničen", "", "Dár prijémše iscilénija, isciľáti nedúhi, i bísy ot čelovík othoňáti síloju duchóvnoju, iscilíte strásti sérdca mojehó vášimi molítvami múčenicy nepobidímiji."),
("Múčeničen", "", "Istoplénija podjémyj boríteľ, krovmí vášimi pohibáše so ťmámi jehó. Vý že vsechváľniji múčenicy, rádujuščesja vospivájete: íže otcév Hospóď i Bóh blahoslovén jesí."),
("Bohoródičen", "", "Nevísta neporóčnaja, paláta ziždíteľa, zemlé neďílannaja, prestól ohnezráčen javílasja jesí, prečístaja. Ťímže vopijém tí: rádujsja, prečístaja Vladýčice, jáže čelovíki obožívšaja Bóžijim tvojím roždestvóm."),
),
"2": (
("", "", "Spasýj vo ohní avraámskija tvojá ótroki, i chaldéji ubív, jáže právda právedno ulovľáše, prepítyj Hóspodi Bóže otéc nášich, blahoslovén jesí."),
("", "", "Ľubóviju pritekáju mnóhoju pod svjatýj tvój pokróv, ne otvratí mené tščá: no dážď mí, prečístaja, ostavlénije prehrišénij, i spasí mja, da víďivše vrazí mojí posrámjatsja."),
("", "", "Ne ubojúsja zlá, tý bo so mnóju jesí Ďívo: poženú vrahí, jáže neščádno mené hoňáščyja, i pobiždú síloju tvojéju ukripľájem, Maríje Bohorodíteľnice."),
("", "", "Ímaši jéže moščí prísno vsích, jáko róždši Vladýku, vladýčestvija mjá slástnaho i strastéj svobodí, da pojú rádujasja: rádujsja prestóle výšňaho, blahoslovénnaja."),
("", "", "Ťá jedínu pokrovíteľnicu ímam na zemlí tvój ráb, i pómošč voístinnu spasíteľnuju i tvérduju, prečístaja, Bohoproslávlennaja: i k tebí pribiháju, spasí mja ot sítej lovjáščich, Bohorodíteľnice."),
),
),
"P8": (
"1": (
("", "", "Ótroki blahočestívyja v peščí, roždestvó Bohoródičo spasló jésť: tohdá úbo obrazújemoje, nýňi že ďíjstvujemoje, vselénnuju vsjú vozdvizájet píti tebí: Hóspoda pójte ďilá, i prevoznosíte jehó vo vsjá víki."),
("", "", "Razrišáješi mjá ot úz ľítnych, v líto bezľítnyj býv, svjázan že býv vóleju, hórdaho úzam nerišímym otslál jesí Vladýko, i spasáješi mjá krestóm i strástiju: ťímže blahoslovľú ťa, Christé, vo víki."),
("", "", "Vozdvíhsja na drévo vóleju, i vsjú tvár sovozdvíhl jesí, Slóve prepítyj, beznačáľne i nevídime, íže načála i vlásti ťmý strástiju tvojéju, Christé, obličíl jesí: ťímže ťá pojém vo vsjá víki."),
("Múčeničen", "", "Vsedóste na króv svojú jáko na kolesnícu, múčenicy vsekrásniji, i k premírnym vzjáti býste selénijem, ot Christá dostójnyja póčesti prijémľušče, Hóspoda pójte, vopijúšče, i prevoznosíte jehó vo víki."),
("Múčeničen", "", "Na drevá vozvyšájemi, i v róv vmetájemi, zvirém že vdavájemi, vo óhň že i v vódu razďiléni byvájušče, strástonóscy múčenicy, rádujuščesja pojáchu: Hóspoda pójte, i prevoznosíte jehó vo víki."),
("Bohoródičen", "", "Víďivši usnúvša na drévi Christá, vsím bódrosť podajúščaho božéstvennuju i spasíteľnuju, Máti vseneporóčnaja, vosklicánijem rydáše i vzyváše: čtó sijé novíjšeje čúdo? oživľájaj vsjá, umirájet choťá."),
),
"2": (
("", "", "Ótroki blahočestívyja v peščí, roždestvó Bohoródičo spasló jésť: tohdá úbo obrazújemoje, nýňi že ďíjstvujemoje, vselénnuju vsjú vozdvizájet píti tebí: Hóspoda pójte ďilá, i prevoznosíte jehó vo vsjá víki."),
("", "", "Blúdno žitijé iždív, i vsjákuju nečistotú soďílav, trepéšču sudíšča, trepéšču isťazánija, trepéšču i otvíta osuždénija mojehó, čístaja: jáže sudijú róždšaja, predstáni mí tohdá, i izbávi mjá núždy."),
("", "", "Na ťá vsjú nadéždu spasénija mojehó vozložích, Bohomáti neiskusobráčnaja, i tebé na pómošč prizyváju vsehdá: spasí mja ot pečálej i napástej vrahá, i razriší plenícy zól mojích, i víčnyja ťmý ischití mja."),
("", "", "V čás, Ďívo, koncá mojehó rukí bisóvskija mjá ischití, i sudá i prínija, i strášnaho ispytánija, i mytárstv hórkich, i kňázja ľútaho, Bohomáti, i víčnaho osuždénija."),
("", "", "Sobľudí rabá tvojehó, Ďívo, ot vsjákaho navíta čuždáho, ťá bo ímam Vladýčice, pokróv i zastuplénije, pribížišče i utverždénije: i tebé rádi čáju izbávitisja sítej vrahá, jedína predstáteľnice róda čelovíčeskaho."),
),
),
"P9": (
"1": (
("", "", "Vsják zemnoródnyj da vzyhrájetsja dúchom prosviščájem, da toržestvújet že bezplótnych umóv jestestvó, počitájuščeje svjaščénnoje toržestvó Bohomátere, i da vopijét: rádujsja vseblažénnaja Bohoródice, čístaja prisnoďívo."),
("", "", "Stojáše sudím čelovikoľúbče, íže sudíti choťáj vsím: vincém že ternóvym uvjázlsja jesí chotíteľňi, Spáse svojéju vóleju, preslušánija, Christé, térnija iz kórene isterzája, vsím že nasaždája tvojehó blahoutróbija poznánije."),
("", "", "O káko ľúdije bezzakónniji, závistiju súšče omračéni, právedna súšča, i neporóčna ťá, svitodávče krestú predajút? Jehóže strásť sólnce zrjá pomračášesja, i svítlosť cerkóvnaja razdirášesja, i kolebáchusja osnovánija zemlí."),
("Múčeničen", "", "Soobrázni strastém Christóvym býste svjatíji múčenicy, i snasľídnicy cárstvija i svítlosti: Ťímže prosvitíte premúdriji, pivcý váša, hrichóvnaho mráka svoboždájušče, i razlíčnych obstojánij."),
("Múčeničen", "", "Užé v sámaja premúdriji nebésnaja vséľšesja, slávu že prijémše prisnosúščnuju, i pričástiji svjaščénnymi obožájemi, pomjaníte vsích nás, čtúščich víroju vsesvjaščénnuju i čestnúju vášu pámjať, prisnoslávniji."),
("Bohoródičen", "", "Prosvití, čístaja, ľubóviju vospivájuščich i veličájuščich ťá, razriší strastéj nášich ťmú, otrokovíce, ukrotí búrju i lukávaho soblázny ot sredý otžení, tý, otrokovíce, molítvami tvojími."),
),
"2": (
("", "", "Vsják zemnoródnyj da vzyhrájetsja dúchom prosviščájem, da toržestvújet že bezplótnych umóv jestestvó, počitájuščeje svjaščénnoje toržestvó Bohomátere, i da vopijét: rádujsja vseblažénnaja Bohoródice, čístaja prisnoďívo."),
("", "", "Rádujsja, jáže rádosť róždšaja, prečístaja, súščym na zemlí voístinnu. Rádujsja, spasíteľnoje pristánišče, i pokróve pritekájuščich k tebí. Rádujsja, ľístvice čístaja, vozvýsivšaja pádšich. Rádujsja, vseblažénnaja Bohoródice, upovánije dušám nášym."),
("", "", "Razruší pážiť hrichá mojehó, oskvernénnyja mojejá duší i ťilesé, Bohorádovannaja prečístaja Vladýčice, síľnoju molítvoju tvojéju, o vseneporóčnaja, iscilénije dávši spasíteľnoje, Vladýčnij strách božéstvennyj."),
("", "", "Tý mňí prosviščénije, tý mí izbavlénije i rádovanije, tý pobórnica mojá, tý mojá sláva i pochvalá, i čájanije spasénija mojehó jesí vseneporóčnaja, i tebí vírno poklaňájusja, i vopijú ti: spasí mja okajánnaho rabá tvojehó, i ot vrát ádovych ischití mja."),
("", "", "Spasí mjá čístaja, Spása róždšaja i vseščédraho, uščédri mjá rabá tvojehó, i k pokajánija putí nastávi: lukávaho soblázny ot sredý otžení, i tohó lovlénija izbávi mjá i ohňá víčnaho, preneporóčnaja, ischití mjá."),
),
),
),
"ST": (
("", "", "Sťiná búdi nám krest tvój Iisúse Spáse náš: inóho bo upovánija vírniji ne ímamy, rázvi tebé, na ném plótiju prihvóždšahosja, i podajúščaho nám véliju mílosť."),
("", "", "Dál jesí známenije bojáščymsja tebé Hóspodi, krest tvój čestnýj, ímže posramíl jesí načála ťmý i vlásti, i vozvél jesí nás na pérvoje blážénstvo. Ťímže tvojé čelovikoľúbnoje smotrénije slávim, Iisúse vsesíľne, Spáse dúš nášich."),
("", "", "Któ ne užasájetsja zrjá svjatíji múčenicy, pódviha dóbraho, ímže podvizástesja? Káko vo plóti súšče, bezplótnaho vrahá pobidíste, Christá ispovídajušče, i krestóm vooružívšesja? Ťímže dostójno javístesja bisóv prohonítelije, i várvarov pobidítelije, neprestánno moľáščesja spastísja dušám nášym."),
("Krestobohoródičen", "", "Na kresťí ťá jáko uzrí prihvoždéna, Hóspodi, áhnica i Máti tvojá divľášesja, i čtó viďínije sijé vzyváše, Sýne voždeľínne? Sijá tí nevírnyj sobór vozdadé bezzakónnyj, íže mnóhich tvojích čudés nasladívyjsja? No sláva neizhlahólannomu sošéstviju tvojemú, Vladýko."),
)
)
#let L = (
"B": (
("", "", "Drévom Adám rajá býsť izselén: drévom že kréstnym razbójnik v ráj vselísja. óv úbo vkúš, zápoviď otvérže sotvóršaho: óv že sraspinájem, Bóha ispovída tajáščahosja, pomjaní mja, vopijá, vo cárstviji tvojém."),
("", "", "Zrjášče ťá na kresťí rasprostérta, jedíne dolhoterpilíve, síly nebésnyja, nedoumíjuščesja s trépetom divľáchusja: zemľá že kolebášesja, i svitíl dobróta uhasáše neprávedno čelovikoľúbče, osuždájemu tebí, Adám osuždénnyj opravdášesja: slávľu blahoutróbije tvojé."),
("", "", "Na lóbňim voznéssja, vrážiju hlavú sokrušíl jesí: na drévi že úmer, plodóm drévnym uméršyja oživíl jesí Vladýko, i rajá žíteli javíl jesí, neprestánno slávjaščich tvojú blahostýňu, i vopijúščich: pomjaní nás vo cárstviji tvojém."),
("", "", "Jákože orúžije krest vosprijémše svjatíji múčenicy, ko opolčéniju vrahóv pómyslom dóblim izydóste: i ťích pohúbľše, netľínnym vincém uvjazóstesja, i slávu polučíste výšňuju, rádujuščesja dostoblažénniji: ťímže víroju vás ublážájem."),
("", "", "Da pokážeši jávstvenno, jéže k nám Spáse, blahoutróbije tvojé, prihvozdílsja jesí na kresťí, Otcú sojedinénnyj i Dúchu: húbu, i trósť, poruhánija i rány preterpíl jesí, choťá izbáviti ohňá víčnaho zovúščyja: pomjaní nás Spáse, vo cárstviji tvojém."),
("", "", "Nevmistímyj vezďí, nesťisňájem místom, vselísja vo svjatúju utróbu tvojú, Bohorodíteľnice prečístaja Vladýčice, i na drévi povíšen, žízň mírovi jávi istočíl jésť. Tohó umolí umertvíti mudrovánija plóti nášeja, i spastí vsích, jáko čelovikoľúbca."),
)
) |
|
https://github.com/Fviramontes8/polylux_lobo_theme | https://raw.githubusercontent.com/Fviramontes8/polylux_lobo_theme/main/README.md | markdown | MIT License | # Lobo theme for Polylux package in Typst
## Installing Polylux locally
You can use [polylux](https://github.com/andreasKroepelin/polylux) normally by importing it like this:
```typst
#import "@preview/polylux:0.3.1": *
```
But to use the lobo theme we need to use the package locally
#### Installing Polylux locally
Typst reads local packages from the `~/.local/share/typst/packages/local/`
folder and requires the folder structure for local packages to stored as
`package_name/version`, so we need to add a `polylux` folder to
`~/.local/share/typst/packages/local/` resulting in
`~/.local/share/typst/packages/local/polylux/`
Create the local folder and install polylux version 0.3.1
```sh
mkdir -p ~/.local/share/typst/packages/local/polylux/
cp ~/.local/share/typst/packages/local/polylux/
git clone https://github.com/andreasKroepolin/polylux 0.3.1 -b v0.3.1
```
You can then copy the theme to
`~/.local/share/typst/packages/local/polylux/0.3.1/themes`
```sh
cp /path/to/theme/lobo.typ ~/.local/share/typst/packages/local/polylux/0.3.1/themes
```
Make sure to update themes.typ to include the newly added theme
```sh
cd ~/.local/share/typst/packages/local/polylux/0.3.1/themes
cat '#import "lobo.typ"' >> themes/themes.typ
```
Then you can use this to import the theme into typ files
```typst
#import "@local/polylux:0.3.1": *
#import themes.lobo: *
```
|
https://github.com/xrarch/books | https://raw.githubusercontent.com/xrarch/books/main/documents/a4xmanual/main.typ | typst | #import "@preview/hydra:0.2.0": hydra
#set page(header: hydra(paper: "us-letter"), paper: "us-letter")
#set document(title: "A4X Firmware Manual")
#set text(font: "IBM Plex Mono", size: 9pt)
#show math.equation: set text(font: "Fira Math")
#show raw: set text(font: "Cascadia Code", size: 9pt)
#set heading(numbering: "1.")
#set par(justify: true)
#include "titlepage.typ"
#pagebreak(weak: true)
#set page(numbering: "i")
#counter(page).update(1)
#include "toc.typ"
#pagebreak(weak: true)
#set page(numbering: "1", number-align: right)
#counter(page).update(1)
#include "chapintro.typ"
#include "chapui.typ"
#include "chapnvram.typ"
#include "chapapt.typ"
#include "chapbooting.typ" |
|
https://github.com/typst-community/glossarium | https://raw.githubusercontent.com/typst-community/glossarium/master/tests/non-regression/only-one-empty-group.typ | typst | MIT License | #import "../../themes/default.typ": *
#show: make-glossary
#let entries = (
// (
// key: "key",
// short: "111111",
// group: "vvv"
// ),
(
key: "key2",
short: "222222",
// group: "vvv"
),
(
key: "key1",
short: "111111",
// group: "voila",
),
)
#register-glossary(entries)
#set page(numbering: "1")
#lorem(25)
@key1:pl
#gls("key2")
#lorem(45)
#print-glossary(
entries,
show-all: true,
)
|
https://github.com/Dherse/ugent-templates | https://raw.githubusercontent.com/Dherse/ugent-templates/main/masterproef/main.typ | typst | MIT License | #import "@preview/codly:0.1.0": *
#import "@preview/tablex:0.0.6": *
#import "ugent-template.typ": *
#import "../common/typstguy.typ": typstguy
// This can be removed if you don't include code:
#let code-icon(icon) = text(
font: "tabler-icons",
fallback: false,
weight: "regular",
size: 8pt,
icon,
)
// Instantiate the template
#show: ugent-template.with(
authors: ( "<NAME>", ),
title: "Demo of the UGhent template",
// This can be removed if you don't include code:
languages: (
yaml: (name: gloss("yaml", short: true), icon: code-icon("\u{f029}"), color: red),
typc: (name: "Typst", icon: typstguy, color: rgb("#239DAD"))
)
)
// Here we include your preface, go and edit it!
#include "./parts/preface.typ"
// Here we now enter the *real* document
#show: ugent-body
// Here we include your chapters, go and edit them!
#include "./parts/0_introduction.typ"
// Here we display the bibliography loaded from `references.bib`
#ugent-bibliography()
// Here begins the appendix, go and edit it!
#include "./parts/appendix.typ" |
https://github.com/SergeyGorchakov/russian-phd-thesis-template-typst | https://raw.githubusercontent.com/SergeyGorchakov/russian-phd-thesis-template-typst/main/README.md | markdown | MIT License | # Шаблон русской кандидатской диссертации
Шаблон русской кандидатской диссертации на языке разметки [Typst](https://typst.app/) - современной альтернативы LaTeX.
## Использование
В веб-приложении нажмите "Start from template" и на панели найдите `modern-russian-dissertation`.
Вы также можете инициализировать проект командой:
```bash
typst init @preview/modern-russian-dissertation
```
Будет создана новая директория со всеми файлами, необходимыми для начала работы.
## Конфигурация
Список литературы формируется из файлов `common/external.bib` и `common/author.bib`.
Список сокращений и условных обозначений формируется из данных, записанных в файле `common/acronyms.typ` `common/symbols.typ`. Список определений формируется из данных в файле `common/glossary.typ`.
## Компиляция
Для компиляции проекта из CLI используйте:
```bash
typst compile thesis.typ
```
Или если вы хотите следить за изменениями:
```bash
typst watch thesis.typ
```
## Особенности
- Стандарт ГОСТ Р 7.0.11-2011.
## Благодарности
- Благодарность авторам шаблона диссертации на [LaTeX](https://github.com/AndreyAkinshin/Russian-Phd-LaTeX-Dissertation-Template)
- [Полезные ссылки](https://github.com/AndreyAkinshin/Russian-Phd-LaTeX-Dissertation-Template/wiki/Links#%D0%BF%D1%80%D0%BE%D1%87%D0%B8%D0%B5-%D1%80%D0%B5%D0%BF%D0%BE%D0%B7%D0%B8%D1%82%D0%BE%D1%80%D0%B8%D0%B8-%D1%81-%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D1%8B%D0%BC%D0%B8-%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D0%B0%D0%BC%D0%B8) |
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/018_Modern%20Masters%202015.typ | typst | #import "@local/mtgset:0.1.0": conf
#show: doc => conf("Modern Masters 2015", doc)
#include "./018 - Modern Masters 2015/001_The Dragon's Errand.typ"
|
|
https://github.com/Anastasia-Labs/project-close-out-reports | https://raw.githubusercontent.com/Anastasia-Labs/project-close-out-reports/main/close-out-report-template/close-out-template.typ | typst | // Set the background image for the page
#let image-background = image("../images/Background-Carbon-Anastasia-Labs-01.jpg", height: 100%)
#set page(
background: image-background,
paper :"a4",
margin: (left : 20mm,right : 20mm,top : 40mm,bottom : 30mm)
)
// Set default text style
#set text(15pt, font: "Barlow")
#v(3cm) // Add vertical space
// Center-align the logo
#align(center)[#box(width: 75%, image("../images/Logo-Anastasia-Labs-V-Color02.png"))]
#v(1cm)
// Set text style for the report title
#set text(20pt, fill: white)
// Center-align the report title
#align(center)[#strong[PROJECT CLOSE-OUT REPORT]]
#v(5cm)
// Set text style for project details
#set text(13pt, fill: white)
// Display project details
#table(
columns: 2,
stroke: none,
[*Project Number*], [Placeholder],
[*Project manager*], [Placeholder],
[*Date Started*], [Placeholder],
[*Date Completed*], [Placeholder],
)
// Reset text style to default
#set text(fill: luma(0%))
// Configure the initial page layout
#set page(
background: none,
header: [
// Place logo in the header
#place(right, dy: 12pt)[#box(image(height: 75%,"../images/Logo-Anastasia-Labs-V-Color01.png"))]
#line(length: 100%) // Add a line under the header
],
header-ascent: 5%,
footer: [
#set text(11pt)
#line(length: 100%) // Add a line above the footer
#align(center)[*Anastasia Labs* \ Project Close-out Report]
],
footer-descent: 20%
)
// This command can be turned on to justify the text #set par(justify: true)
#show link: underline
#show outline.entry.where(level: 1): it => {
v(12pt, weak: true)
strong(it)
}
// Initialize page counter
#counter(page).update(0)
#set page(
footer: [
#set text(11pt)
#line(length: 100%) // Add a line above the footer
#align(center)[*Anastasia Labs* \ Project Close-out Report]
#place(right, dy:-7pt)[#counter(page).display("1/1", both: true)]
]
)
#v(100pt)
// Configure the outline depth and indentation
#outline(depth:2, indent: 1em)
// Page break
#pagebreak()
#set terms(separator: [: ],hanging-indent: 40pt)
#v(20pt)
/ Project Name: Project Name Placeholder
/ URL: #link("link")[link_placeholder_to_catalyst_proposal]
#v(10pt)
= List of KPIs
#v(10pt)
== Challenge KPIs
#v(10pt)
- *Title Placeholder:* #lorem(35)
- *Title Placeholder:* #lorem(35)
- *Title Placeholder:* #lorem(35)
#v(10pt)
== Project KPIs
#v(10pt)
- *Title Placeholder:* #lorem(50)
- *Title Placeholder:* #lorem(35)
#pagebreak()
#v(40pt)
// Section for Key achievements
= Key achievements <key-achievements>
#v(10pt)
- #lorem(25)
- #lorem(25)
=== Placeholder 1
#lorem(25) \
- #link("link1_placeholder")[Link Placeholder] \
- #link("link2_placeholder")[Link Placeholder]
#v(10pt)
// Section for Key learnings
= Key learnings <key-learnings>
#v(10pt)
- #lorem(45)
#v(10pt)
- #lorem(45)
#v(10pt)
#pagebreak()
#v(50pt)
// Section for Next steps
= Next steps <next-steps>
#v(10pt)
- #lorem(15)
- #lorem(15)
- #lorem(15)
= Final thoughts
#v(10pt)
#lorem(55)
#v(30pt)
// Section for Resources
= Resources
#v(10pt)
#box(height: 100pt, columns(3, gutter: 25pt)[
== Project
#link("link3_placeholder")[Main Github Repo Link Placeholder] \
#link("link4_placeholder")[Catalyst Proposal Link Placeholder]
=== Placeholder
#link("link5_placeholder")[Link Placeholder] \
#link("link6_placeholder")[Link Placeholder] / #link("link7_placeholder")[Link Placeholder]
=== Placeholder
#link("link8_placeholder")[Link Placeholder] \
#link("link9_placeholder")[Link Placeholder] / #link("link10_placeholder")[Link Placeholder]
])
#v(5pt)
// Center-align close-out video link
#align(center)[== Close-out Video <link-other> #link("link11_placeholder")[Link Placeholder]]
|
|
https://github.com/oliversssf2/do-math | https://raw.githubusercontent.com/oliversssf2/do-math/main/OHara/notes1.typ | typst | #set page("a5")
= Chapter 1 Markets and Market Making
- how trading mechanisms affect the formation of prices
= Chapter 2 Inventory Model
== Stoll's Model
Let $W_0$ be the initial wealth.
$tilde(W) = W_0 (1+tilde(R^*)) + (1+tilde(R_i))Q_i - (1+R_f)(Q_i-C_i)$
Also let $Q_i$ denote the true value of a transaction in stock $i$. |
|
https://github.com/SillyFreak/typst-packages-old | https://raw.githubusercontent.com/SillyFreak/typst-packages-old/main/tidy-types/gallery/test.typ | typst | MIT License | #import "@preview/tidy:0.1.0"
#import "../src/lib.typ" as tt
// #import "@local/tidy-types:0.0.1" as tt
// make the PDF reproducible to ease version control
#set document(date: none)
#let style = tidy.styles.default
#show raw.where(lang: "tidy-type"): it => style.show-type(it.text)
= Test
#tt.arr(tt.int)
|
https://github.com/zenor0/FZU-report-typst-template | https://raw.githubusercontent.com/zenor0/FZU-report-typst-template/main/fzu-report/templates/report.typ | typst | MIT License | #import "../utils/fonts.typ": 字体, 字号
#import "../utils/set-report.typ": set-report
#import "../utils/bilingual-bibliography.typ": appendix
#import "../utils/states.typ": part-state
#import "../utils/thanks.typ": thanks
#import "../utils/packages.typ": *
#import "../pages/cover-report-fn.typ": report-cover-conf
#import "../parts/abstract-report-fn.typ": abstract-conf
#import "../parts/outline-report-fn.typ": outline-conf
#import "../parts/main-body-report-fn.typ": main-body-report-conf
#let report-conf(
studentID: "10210xxxx",
author: "zenor0",
school: "计算机与大数据学院",
major: "信息安全",
advisor: "你的老师",
thesisname: "title",
major-title: "实验报告",
date: datetime(year: 2021, month: 9, day: 1),
enable-header: true,
header: none,
cnabstract: none,
cnkeywords: none,
enabstract: none,
enkeywords: none,
outlinedepth: 3,
bilingual-bib: true,
show-code-language: true,
show-code-icon: true,
doc,
) = {
show: set-report.with(bilingual-bib: bilingual-bib)
// 封面
report-cover-conf(
studentID: studentID,
author: author,
school: school,
major: major,
advisor: advisor,
major-title: major-title,
thesisname: thesisname,
date: date,
)
// 摘要
abstract-conf(
cnabstract: cnabstract,
cnkeywords: cnkeywords,
enabstract: enabstract,
enkeywords: enkeywords
)
// 目录
outline-conf(outline-depth: outlinedepth)
let icon(codepoint) = {
box(
inset: (x: 0.2em),
height: 0.8em,
baseline: 0.05em,
image(codepoint)
)
h(0.1em)
}
// 正文
if header == none {
header = thesisname
}
let my-header = box()[#grid(
columns: (1fr, 1fr),
align: (left, right),
grid(columns: 2,
align: horizon+center,
gutter: 1em,
box(image("../assets/logos/fzu-text-zhcn-black.svg", height: 1.1em)),
box(image("../assets/logos/fzu-text-enus-black.svg", height: 0.7em))
),
box(inset: 2pt)[#header | #studentID #author],
)]
show: main-body-report-conf.with(enable-header: enable-header, header: my-header)
show: setup-lovelace
show: codly-init.with()
codly(
display-name: show-code-language,
display-icon: show-code-icon,
zebra-color: rgb("#f7f7f7a0"),
languages: (
python: (name: "Python", icon: icon("../assets/icons/python.svg"), color: rgb("#3776AB")),
c: (name: "C", icon: icon("../assets/icons/c.svg"), color: rgb("#A8B9CC")),
cpp: (name: "C++", icon: icon("../assets/icons/cplusplus.svg"), color: rgb("#00599C")),
javascript: (name: "JavaScript", icon: icon("../assets/icons/javascript.svg"), color: rgb("#F7DF1E")),
typescript: (name: "TypeScript", icon: icon("../assets/icons/typescript.svg"), color: rgb("#3178C6")),
typst: (name: "Typst", icon: icon("../assets/icons/typst.svg"), color: rgb("#239DAD")),
go: (name: "Go", icon: icon("../assets/icons/go.svg"), color: rgb("#00ADD8")),
golang: (name: "Go", icon: icon("../assets/icons/go.svg"), color: rgb("#00ADD8")),
rust: (name: "Rust", icon: icon("../assets/icons/rust.svg"), color: rgb("#000000")),
)
)
doc
}
#show: report-conf.with(
date: datetime(year: 2021, month: 9, day: 1),
cnabstract: [你有这么高速运转的机械进入中国，记住我给出的原理，小的时候。就是研发人，就研发这个东西的一个原理是阴间证权管，你知道为什么会有生灵给他运转，先（仙）位。还有、还有专门饲养这个，为什么地下产这种东西，他管着、他是五世同堂旗下子孙。你以为我在给你闹着玩呢，你不、你不、你不警察吗，黄龙江一派全部带蓝牙，黄龙江、我告诉你，在阴间是、是那个化名、化名，我小舅，亲小舅，张学兰的那个、那个嫡子、嫡孙。咋的你跟王守义玩呢，她是我儿子，她都管我叫太祖奶奶。爱因斯节叶赫那拉，我是施瓦辛格。我告诉你，他不听命于杜康。我跟你说句根儿上的事，你不刑警队的吗？他不听命于杜康。为什么，他是韩国人，他属于合、合作方，合伙人，自己有自己的政权，但是你进入亚洲了，这、这块牡丹江号称小联合国，你触犯了军权就可以抓他！但是你们为了什么，你是为了碎银几两啊，还是限制你的数字啊，还是你兵搁不了，你没有主权。你这兵不硬啊，你理论不强，你都说不明白。你人情世故，你为了几个数字导致你的方向啊。因为什么这块有交警队的人，才说这话的，你天天交警队、交警队的，你、你、你干什么工作了你？你这军情我分析的，我控股人。到时候你张口了管我要军费的时候挺牛逼的。没有定向资金你们，你们的资金全是佣金，就是你那水平，你这活你给我干完了，有这个有这笔钱，不干完没有。这就是连我都是的，我的账号运转是完成阴间的事，生灵，你们的生灵怎么的，嫁接我，养的野门子，改变生理，那你上监狱，那问我这话我也不能告诉你啊。
],
cnkeywords: ("高速运转", "机械"),
enabstract: [#lorem(100)],
enkeywords: ("Keywords1", "Keywords2"),
outlinedepth: 3,
)
= CH1
```python
from rich import print
print("Hello, World!")
```
```c
#include <stdio.h>
int main() {
printf("Hello, World!");
return 0;
}
```
```cpp
#include <iostream>
int main() {
std::cout << "Hello, World!";
return 0;
}
```
= ch2
```rust
fn main() {
println!("Hello, World!");
}
```
```go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
```
```javascript
console.log("Hello, World!");
console.log("Hello, World!");
```
```typescript
console.log("Hello, World!");
console.log("Hello, World!");
```
```typst
print("Hello, World!")
print("Hello, World!")
```
#code(
```python
print("Hello, World!")
print("Hello, World!")
print("Hello, World!")
print("Hello, World!")
print("Hello, World!")
```
)
|
https://github.com/LDemetrios/Typst4k | https://raw.githubusercontent.com/LDemetrios/Typst4k/master/src/test/resources/suite/text/case.typ | typst | // Test the `upper` and `lower` functions.
--- lower-and-upper ---
#let memes = "ArE mEmEs gReAt?";
#test(lower(memes), "are memes great?")
#test(upper(memes), "ARE MEMES GREAT?")
#test(upper("Ελλάδα"), "ΕΛΛΆΔΑ")
--- upper-bad-type ---
// Error: 8-9 expected string or content, found integer
#upper(1)
|
|
https://github.com/EricWay1024/Homological-Algebra-Notes | https://raw.githubusercontent.com/EricWay1024/Homological-Algebra-Notes/master/ha/a-kc.typ | typst | #import "../libs/template.typ": *
= Koszul Complexes and (Co)homology
<koszul>
We generally follow @weibel[Section 4.5]. In this section, by an $R$-module we mean either a left or a right $R$-module.
== Koszul Complexes
#definition[
Let $R$ be a ring and let $x in Z lr((R))$ be a central element. Then we
define the *Koszul complex* $K_cx lr((x))$ of $x$ to be the chain complex
$ 0 arrow.r R dot e_x arrow.r^x R arrow.r 0 $ concentrated in degrees $1$ and $0$, where $e_x$ is a symbol to denote the generator of $K_1 lr((x))$, and the differential $R dot e_x ->^x R$ is multiplication by $x$, i.e. $d(e_x) = x$.
]
#definition[
If $bd(x) = (x_1, ..., x_n)$ is a finite sequence of central elements of $R$, then by above, we have Koszul complexes $K(x_1), ..., K(x_n)$, where we write $e_i = e_(x_i)$. Then the chain complex $K(bd(x))$ is defined as follows.
The
symbols
$ e_(i_1) and dots.h.c and e_(i_p) eq underbrace(1 times.circle dots.h.c times.circle 1 times.circle e_(i_1) times.circle dots.h.c times.circle e_(i_p) times.circle dots.h.c times.circle 1, n" terms") quad lr((1 <= i_1 lt dots.h.c lt i_p <= n)) dot.basic $
generate the free $R$-module $K_p (bd(x))$, and
the differential
$K_p lr((bold(bd(x)))) arrow.r K_(p minus 1) lr((bold(x)))$ sends
$e_(i_1) and dots.h.c and e_(i_p)$ to
$ sum_(k=1)^p lr((minus 1))^(k plus 1) x_(i_k) e_(i_1) and dots.h.c and hat(e)_(i_k) and dots.h.c and e_(i_p). $
]
#remark[
Alternatively, we could define $K(bd(x))$ as the total tensor product complex
$
Tot^xor (K(x_1) tpr K(x_2) tpr ... tpr K(x_n))
$
by which we mean an inductive relation $
K(bd(x)) = Tot^xor (K(x_1, x_2, ..., x_(n-1)), K(x_n)).
$
We omit the proof that this is an equivalent definition.
One may also understand the alternative definition by
regarding $C := K(x_1) tpr ... tpr K(x_n)$ as an "$n$-dimensional complex", a generalisation of a double complex. In particular, $C$ has in total $2^n$ terms, and a typical term in $C$ is indexed by an $n$-tuple of $0$ and $1$, whose total degree is the sum of this $n$-tuple. For example, if $n = 4$, $C$ has a term $ C_(0, 1, 1, 0) = R tpr (R dot e_(2)) tpr (R dot e_(3)) tpr R, $
which has total degree $2$ and is generated by $e_2 and e_3$.
Then $K(bd(x))$ is the total complex of $C$, where $K_p (bd(x))$ is the direct sum of all terms in $C$ which has total degree $p$. For example, when $n = 4$, $K_2 (bd(x))$ is a free module generated by $e_1 and e_2$, $e_1 and e_3$, $e_1 and e_4$, $e_2 and e_3$, $e_2 and e_4$, $e_3 and e_4$ with rank $6$.
Further,
$K_p lr((bd(x)))$ is in fact isomorphic to the $p$-th exterior
product $Lambda^p R^n$ of $R^n$, so $K (bd(x))$
is often called the *exterior algebra complex*.
// This discussion also explains the following @kpx-free.
// However, since we do not wish to define the differential rules on an "$n$-dimensional complex" in general, it is more convenient to stick to the inductive definition for the proofs.
]
#proposition[
$K(bd(x))$ is indeed a chain complex and
$K_p (bd(x))$ is a free $R$-module with rank $vec(n, p)$.
]
<kpx-free>
// #proof[
// // By the discussion above, there are $vec(n, p)$ terms in $C$ that have total degree $p$, because finding such a term in $C$ is the same as finding an binary $n$-tuple with $p$ ones and $(n-p)$ zeros. Since each term in $C$ is isomorphic to $R$, $K_p (bd(x))$ is isomorphic to the direct sum of $vec(n, p)$ $R$'s.
// By induction on $n$. Hint: recall that for binomial coefficients, $vec(n, p) = vec(n - 1, p) + vec(n-1, p-1)$.
// ]
#example[
As an example, when $n = 2$ and $bd(x)= (x_1 , x_2)$,
// we have the tensor product double complex:
// // https://t.yw.je/#N4Igdg9gJgpgziAXAbVABwnAlgFyxMJZARgBoAGAXVJADcBDAGwFcYkQAKAJQAIoIcPGAH0OAD2HEAlFJ440AJx7c+AoaIkAmGSAC+pdJlz5CKMsWp0mrdiv6CR4yTLmLlvez2l6DIDNjwCInJSCxoGFjZETg81aVclOzipH0MAk2CKSwibaKTBePlE2IcNYW0U3<KEY>
// #align(center, commutative-diagram(
// node-padding: (50pt, 50pt),
// node((0, 1), [$(R dot e_(1)) tpr (R dot e_(2))$]),
// node((1, 1), [$(R dot e_(1)) tpr R.$]),
// node((1, 0), [$R tpr R$]),
// node((0, 0), [$R tpr (R dot e_(2))$]),
// arr((0, 1), (0, 0), [$x_1 tp 1$]),
// arr((1, 1), (1, 0), [$x_1 tp 1$]),
// arr((0, 1), (1, 1), [$-1 tp x_2$]),
// arr((0, 0), (1, 0), [$1 tp x_2$]),
// ))
$K (bd(x))$ is the total complex
$
0 -> R dot (e_(1) and e_(2)) ->^(d_2) R dot e_(1) ds R dot e_(2) ->^(d_1) R -> 0,
$
where $d_2 = vec(x_2, -x_1)$ and $d_1 = (x_1, x_2)$. Note that indeed $d_1 oo d_2 = 0$.
// #align(center,image("../imgs/2023-11-25-10-34-10.png",width:80%))
// https://t.yw.je/#N4Igdg9gJgpgziAXAbVABwnAlgFyxMJZABgBpiBdUkANwEMAbAVxiRGJAF9T1Nd9CKAIzkqtRizYAlLjxAZseAkQBMo6vWatEIKQD0Vs3<KEY>
// #align(center, commutative-diagram(
// node-padding: (50pt, 30pt),
// node((0, 0), [$0$]),
// node((0, 1), [$R dot (e_(x_1) and e_(x_2))$]),
// node((0, 2), [$R dot e_(x_1) ds R dot e_(x_2)$]),
// node((0, 3), [$R$]),
// node((0, 4), [$0$]),
// // node((1, 0), [$"basis:"$]),
// // node((1, 1), [${e_(x_1) and e_(x_2) }$]),
// // node((1, 2), [${e_(x_1), e_(x_2)}$]),
// // node((1, 3), [${1}$]),
// arr((0, 0), (0, 1), []),
// arr((0, 1), (0, 2), [$(x_1, -x_2)$]),
// arr((0, 2), (0, 3), [$vec(x_1, x_2)$]),
// arr((0, 3), (0, 4), []),
// ))
// Note that in this special case, we can obtain the same formula for the differentials using @total-complex and @kpx.
]
== Koszul (Co)homology
#definition[
For an $R$-module $A$, we define the *Koszul homology* and *Koszul
cohomology* to be
$ H_q lr((bd(x) comma A)) & eq H_q lr((K lr((bd(x))) times.circle_R A)) comma\
H^q lr((bd(x) comma A)) & eq H^q lr(("Hom"_R lr((K lr((bd(x))) comma A)))) dot.basic $
]
// #TODO what is exterior product
// (There are in total $n$ terms of the tensor product and in the degree $p$ part of $K(bd(x))$ there should be $p$ terms that come from the degree $1$ part of $K(x_j)$ and thus are $e_x_(j)$, and the remaining ($n-p$) terms should come from the degree $0$ part and are $1$.)
#proposition[
$lr({H_q lr((bd(x) comma minus))})$ is a
homological $delta$-functor and
$lr({H^q lr((bold(x) comma minus))})$ is a cohomological $delta$-functor
with
$ H_0 lr((bold(x) comma A)) eq A slash bd(x) A, quad
H^0 lr((bold(x) comma A)) eq homr lr((R slash bd(x) R comma A)) eq lr({a in A colon x_i a eq 0 upright(" for all ") i}). $
]
<koszul-zero>
#proof[
Each $K_p (bd(x))$ is free and hence flat and projective, so $(K_p (bd(x)) tpr -)$ and $homr (K_p (bd(x)), -)$ are both exact functors. For any #sest $ses(A, B, C)$, we thus have a #sest of chain complexes,
$
ses(K(bd(x)) tpr A, K(bd(x)) tpr B, K(bd(x)) tpr C)
$
and a #sest of cochain complexes
$
ses(homr (K_p (bd(x)), A), homr (K_p (bd(x)), B), homr (K_p (bd(x)), C))
$
By @connecting, applying homology and cohomology to them respectively induces two #less.
Notice $K_1 (bd(x)) iso R^n$ with generators ${e_(i)}_(1 <= i <= n)$ and $K_0 (bd(x)) = R$. The differential $K_1 (bd(x)) -> K_0 (bd(x))$ sends each $e_(i)$ to $x_i$. The rest should follow easily.
]
#proposition[
There are isomorphisms
$H_p lr((bd(x) comma A)) tilde.equiv H^(n minus p) lr((bd(x) comma A))$ for all
$p$.
]
#lemma("Künneth Formula for Koszul Complexes")[
If
$C_cx$ is a chain complex of $R$-modules and $x in R$, there
are exact sequences
$ 0 arrow.r H_0 lr((x comma H_q lr((C)))) arrow.r H_q lr((K lr((x)) times.circle_R C)) arrow.r H_1 lr((x comma H_(q minus 1) lr((C)))) arrow.r 0 $
]
<kunneth-koszul>
#proof[
Again recall @homology-double, so the middle term means $H_q (Tot^ds (K(x) tpr C))$. By definition,
$ [Tot^ds (K(x) tpr C)]_n = (K_0 (x) tpr C_n) ds (K_1 (x) tpr C_(n-1)) iso C_n ds C_(n-1), $
where the differential is given by $(c_n, c_(n-1)) |-> (d(c_n) + x c_(n-1), -d(c_(n-1)))$.
Thus we can write a #sest of chain complexes:
$
ses(C, Tot^ds (K(x) tpr C), C [-1]),
$
which is associated to the long exact sequence:
$
H_(q plus 1) lr((C lr([minus 1]))) arrow.r^diff H_q lr((C)) arrow.r H_q lr((K lr((x)) times.circle C)) arrow.r H_q lr((C lr([minus 1]))) arrow.r^diff H_q lr((C)),
$
where $H_(q+1) (C[-1]) = H_q (C)$ and $H_(q) (C[-1]) = H_(q-1) (C)$. By @connecting, we can find that the connecting homomorphism $diff$ is multiplication by $x$. Now we have
$
H_q lr((C)) arrow.r^x H_q lr((C)) arrow.r H_q lr((K lr((x)) times.circle C)) arrow.r H_(q-1) lr((C)) arrow.r^x H_(q-1) lr((C)),
$
which, by @five-to-ses, leads to the #sest
$
ses(Coker(H_q (C) ->^x H_q (C)), H_q lr((K lr((x)) times.circle C)), Ker(H_(q-1) (C) ->^x H_(q-1) (C))).
$
Now since $ H_q (C) ->^x H_q (C) = (R ->^x R) tpr H_q (C), $
we find
$
Coker(H_q (C) ->^x H_q (C)) = H_0 (x, H_q (C)) space "and " space
Ker(H_q (C) ->^x H_q (C)) = H_1 (x, H_(q) (C)),
$
and the result follows.
]
Now recall that if $A$ is an $R$-module and $r in R$, then $r$ is a *zero-divisor* on $A$ if there exists non-zero $a in A$ such that $r a = 0$. Therefore, $r$ is a *non-zero-divisor* on $A$ #iff the multiplication $A ->^r A$ is injective.
#definition[
If $A$ is an $R$-module, a *regular sequence* on $A$ is a sequence of elements $(x_1, ..., x_n)$ where each $x_i in R$ such that $x_1$ is a non-zero-divisor on $A$ and each $x_i$ is a non-zero-divisor on $A over (x_1, ..., x_(i-1)) A$.
]
#lemma[
Let $A$ be an $R$-module. If $x$ is a non-zero-divisor on $A$, then $H_1 (x, A) = 0$.
]
<non-zero-h1>
#proof[
$K(x) tpr A$ is the chain complex
$0 -> A ->^x A -> 0.
$
If $x$ is a non-zero-divisor on $A$, then $H_1 (x, A) = Ker x = 0$.
]
#corollary[
If $bd(x) = (x_1, ... , x_n)$ is a regular sequence on an $R$-module $A$, then $H_q (bd(x), A) = 0$ for $q > 0$.
]
<regular-acyclic>
#proof[ By induction on $n$. The base case for $n = 1$ is given in @non-zero-h1.
Let $x = x_n$ and $bd(y) = (x_1, ..., x_(n-1))$, then $K(bd(x)) = Tot^xor (K(x) tpr K(bd(y)))$. By @kunneth-koszul (letting $C = K(bd(y)) tpr A$), we have a #sest
#math.equation(block: true, numbering: "(1)", supplement: "Short Exact Sequence",
$
ses(H_0(x, H_q (bd(y), A)), H_q (bd(x), A), H_1 (x, H_(q-1) (bd(y), A))).
$) <h0xhq>
For $q >= 2$, the flanking terms of @h0xhq are both $0$ by induction and hence $H_q (bd(x), A) = 0$.
For $q = 1$, by induction the left term of @h0xhq is $0$, so we get
$
H_1 (bd(x), A) iso H_1 (x, H_(0) (bd(y), A)) = H_1 (x, A over (x_1, ..., x_(n-1)) A) = 0
$
by @koszul-zero and @non-zero-h1, since $x$ is a non-zero-divisor on $A over (x_1, ..., x_(n-1)) A$.
]
#corollary("Koszul resolution")[
If $bd(x) = (x_1, ..., x_n)$ is a regular sequence on $R$ (viewed as an $R$-module), then $K(bd(x))$ is a free resolution of $R over I$, where $I =(x_1, ..., x_n) R$.
]
#proof[
Notice that $H_q (bd(x), R) = H_q (K(bd(x)) tpr R) iso H_q (K(bd(x)))$. When $q >= 1$, by @regular-acyclic, $H_q (K(bd(x))) = 0$. When $q = 0$, $H_0 (K(bd(x))) = R over bd(x) R = R over I$ by @koszul-zero. This indicates that $ ... -> K_2(bd(x)) -> K_1(bd(x)) -> K_0(bd(x)) -> R over I -> 0 $
is exact everywhere. Thus $K(bd(x))$ is a free resolution of $R over I$.
]
#corollary[
If $bd(x) = (x_1, ..., x_n)$ is a regular sequence on $R$, $I =(x_1, ..., x_n) R$ and $B$ is an $R$-module, then
$
H_p (bd(x), B) = Tor_p^R (R over I, B), \
H^p (bd(x), B) = Ext_p^R (R over I, B). \
$
]
#proof[
This follows from the Koszul resolution of $R over I$ and the definition (or the balancing) of $Ext$ and $Tor$.
]
#example[
Let $k$ be a field, $R = k[x, y]$ and $I = (x, y) R$. Then $k iso R over I$ and has Koszul resolution
$
0 -> R ->^vec(y, -x) R^2 ->^((x, y)) R -> k -> 0.
$
To calculate $Tor_ast^R (k, k)$, we could simply use the definition of $Tor$: delete $k$ from the sequence, apply $(k tpr -)$, and we get
$
0 -> k ->^0 k^2 ->^0 k -> 0,
$
where the differentials vanish since $x$ and $y$ are modded out in $k$. Take the homology of the above sequence and we see $ Tor_ast^R (k, k) iso cases(k comma quad &ast = 0 comma 2 comma, k^2 comma quad &ast = 1 comma, 0 comma quad &"otherwise". ) $
]
// #remark[
// #TODO Tower, Past paper, Serre...
// ]
// Suppose that $upright(x) eq lr((x_1 comma dots.h comma x_n))$ is a
// finite sequence of central elements in $R$. Then $K lr((upright(x)))$ is
// the chain complex
// $ K lr((x_1)) times.circle_R dots.h times.circle_R K lr((x_n)) dot.basic $
// Koszul resolution
// Let $x in R$ be a central element. Let $K(x)$ be the chain complex
// $
// 0->R->^x R ->0
// $
// in degrees $0,1$. We call the generator in degree $1$ $e_x$ so $d(e_x) = x$.
|
|
https://github.com/swaits/typst-collection | https://raw.githubusercontent.com/swaits/typst-collection/main/finely-crafted-cv/0.1.0/lib.typ | typst | MIT License | #import "src/resume.typ": cv, resume, company-heading, job-heading, school-heading, degree-heading
|
https://github.com/deb06/typst-templates | https://raw.githubusercontent.com/deb06/typst-templates/main/cornell_note.typ | typst | #let cornell_note(
title: [],
date: [],
name: [],
topic: [],
notes: [],
main_ideas: [],
summary: [],
) = {
let col_header = rgb("#778da9");
let col_title = rgb("#415a77");
let col_bg = rgb("#e0e1dd");
set align(left)
set text(font: "Times New Roman", size: 12pt)
page(
numbering: "1",
margin: (x: 32pt, y: 70pt),
header: locate(
loc => if [#loc.page()] == [1] {
[
#align(left,)[
#set text(
size: 24pt,
fill: col_title,
)
//Alternatively just have the header every page by removing the locate function
= #title
]
]
} else {[]}
)
)[
#set align(left)
#set text( size: 12pt)
#box(
height: 50pt,
width: auto,
[#set text(size: 12pt)
*Date*: #date \
*Name*: #name \
*Topic*: #topic \
],
)
#table(
stroke: 0.5pt, //There is still a rendering issue here with a larger stroke or with 0 stroke. Could be just a typst issue not really sure.
columns: (1fr, 3fr),
fill: (col, row) =>
if row == 0 {
col_header
} else if row == 1 and col == 0 {
col_bg
} else if row == 1 and col == 1 {
luma(240)
},
[
#set align(center)
=== Main Ideas
],
[
#set align(center)
=== Notes
],
[
#main_ideas
],
[
#notes
],
)
#table(
stroke: 0.5pt,
columns: (1fr),
fill: (_, row) =>
if row == 0 { col_header }
else if row == 1 { col_bg },
align(
center,
)[
#set text(size: 14pt)
=== Summary
],
[
#summary
],
)
]
}
|
|
https://github.com/SkytAsul/fletchart | https://raw.githubusercontent.com/SkytAsul/fletchart/main/src/internals.typ | typst | #import "@preview/fletcher:0.5.1": diagram, node, edge
#let internal-element(id, content, links, style-resolver) = {
metadata((
class: "element",
id: id,
content: content,
links: links,
style-resolver: style-resolver
))
}
#let internal-link(destination, label) = {
if type(destination) == content and destination.func() == metadata and destination.value.class == "element" {
destination = destination.value.id
} else if type(destination) != str {
panic("Wrong destination format")
}
(
destination: destination,
edge-options: (label: label),
)
}
#let flowchart-process-links(elements) = {
for id in elements.keys() {
elements.at(id).insert("predecessors", ())
}
for element in elements.values() {
for link in element.links {
let dest-element = elements.at(link.destination)
dest-element.predecessors.push(element.id)
elements.at(link.destination) = dest-element
}
}
return elements
}
#let flowchart-layout-branch(internal-elements, id, layouted, coordinates) = {
if id in layouted { return (:) }
let element = internal-elements.at(id)
let self-layouted = (:)
self-layouted.insert(id, coordinates)
let link-from = -int((element.links.len() - 1) / 2)
let link-to = link-from + element.links.len()
let link-indexes = range(link-from, link-to)
let last-x = coordinates.at(0) + link-from
for (link-index, (destination, ..rest)) in link-indexes.zip(element.links) {
let x = last-x
let y = coordinates.at(1)
if link-index == 0 or element.links.len() > 3 {
y += 1
}
if link-index == 0 {
// move prev layouted to realign with 0
}
let link-layouted = flowchart-layout-branch(internal-elements, destination, layouted + self-layouted, (x, y))
self-layouted += link-layouted
if link-layouted.len() != 0{
last-x = link-layouted.values().map(x => x.at(0)).sorted().last() + 1
}
}
return self-layouted
}
/*
Branches order depending on amount of choices:
1: 0
2: 0 1
3: -1 0 1
4: -1 0 1 2
5: -2 -1 0 1 2
*/
#let flowchart-layout(internal-elements) = {
let layouted = (:)
let last-x = 0
for element in internal-elements.values() {
layouted += flowchart-layout-branch(internal-elements, element.id, layouted, (last-x, 0))
last-x = layouted.values().map(x => x.at(0)).sorted().last() + 1
}
return layouted
}
#let flowchart-create-element-node(options, internal-element, coordinates) = {
let style = (internal-element.style-resolver)(options)
node(pos: coordinates, label: internal-element.content, ..style)
}
#let flowchart-create-link-edge(internal-link, from, to) = {
edge(vertices: (from, to), marks: "-|>", ..internal-link.edge-options)
}
#let flowchart-create(internal-elements, options) = {
internal-elements = flowchart-process-links(internal-elements)
let layouted = flowchart-layout(internal-elements)
if options.debug [
*Internal elements details:*
#internal-elements
*Elements layout positions:*
#layouted
]
let nodes = ()
let edges = ()
for element in internal-elements.values() {
nodes.push(flowchart-create-element-node(options, element, layouted.at(element.id)))
for link in element.links {
edges.push(flowchart-create-link-edge(link, layouted.at(element.id), layouted.at(link.destination)))
}
}
diagram(nodes, edges, node-stroke: 1pt, node-outset: 0pt, node-inset: .7em, debug: options.debug, spacing: 3em)
} |
|
https://github.com/MaxAtoms/T-705-ASDS | https://raw.githubusercontent.com/MaxAtoms/T-705-ASDS/main/content/fletcher-reliability.typ | typst | #import "@preview/fletcher:0.5.1" as fletcher: diagram, node, edge
#let reliabilityExample=diagram(
//debug: true,
node-stroke: black,
spacing: (.5cm, .5cm),
edge-stroke: 1pt,
node-corner-radius: 0pt,
edge-corner-radius: 0pt,
edge((0,1), "r,u,r"),
node((2,0), [A], shape: fletcher.shapes.rect),
edge((2,0), "r,r"),
node((4,0), [B], shape: fletcher.shapes.rect),
edge((4,0), "r,r,d"),
edge((0,1), "r,d,r"),
node((2,2), [C], shape: fletcher.shapes.rect),
edge((2,2), "r,u,r"),
node((4,1), [D], shape: fletcher.shapes.rect),
edge((2,2), "r,d,r"),
node((4,3), [E], shape: fletcher.shapes.rect),
edge((4,3), "r,u,r"),
edge((4,1), "r,d,r"),
edge((6,2), "u,r"),
)
|
|
https://github.com/typst-community/valkyrie | https://raw.githubusercontent.com/typst-community/valkyrie/main/tests/types/dictionary/test.typ | typst | Other | #import "/src/lib.typ" as z
#let test-dictionary = (
string: "world",
number: 1.2,
email: "<EMAIL>",
ip: "172.16.31.10",
)
#z.parse(
test-dictionary,
z.dictionary((
string: z.string(assertions: (z.assert.length.min(5),), optional: true),
number: z.number(optional: true),
email: z.email(optional: true),
ip: z.ip(optional: true),
)),
)
|
https://github.com/lucifer1004/leetcode.typ | https://raw.githubusercontent.com/lucifer1004/leetcode.typ/main/problems/p0013.typ | typst | #import "../helpers.typ": *
#import "../solutions/s0013.typ": *
= Roman to Integer
Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
#align(center)[#table(
columns: (auto, auto),
align: center,
[*Symbol*], [*Value*],
[I], [1],
[V], [5],
[X], [10],
[L], [50],
[C], [100],
[D], [500],
[M], [1000],
)]
For example, `2` is written as `II` in Roman numeral, just two one's added together. `12` is written as `XII`, which is simply `X + II`. The number `27` is written as `XXVII`, which is `XX + V + II`.
Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
- `I` can be placed before `V` (5) and `X` (10) to make 4 and 9.
- `X` can be placed before `L` (50) and `C` (100) to make 40 and 90.
- `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
Given a roman numeral, convert it to an integer.
#let roman-to-integer(s) = {
// Solve the problem here
}
#testcases(
roman-to-integer,
roman-to-integer-ref, (
(s: "III"),
(s: "LVIII"),
(s: "MCMXCIV"),
)
)
|
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/unichar/0.1.0/ucd/block-A960.typ | typst | Apache License 2.0 | #let data = (
("<NAME> TIKEUT-MIEUM", "Lo", 0),
("<NAME> TIKEUT-PIEUP", "Lo", 0),
("<NAME>ONG TIKEUT-SIOS", "Lo", 0),
("<NAME> TIKEUT-CIEUC", "Lo", 0),
("<NAME>UL-KIYEOK", "Lo", 0),
("<NAME> RIEUL-SSANGKIYEOK", "Lo", 0),
("<NAME>ONG RIEUL-TIKEUT", "Lo", 0),
("<NAME>UL-SSANGTIKEUT", "Lo", 0),
("<NAME>-MIEUM", "Lo", 0),
("<NAME>-PIEUP", "Lo", 0),
("<NAME>ONG RIEUL-SSANGPIEUP", "Lo", 0),
("<NAME>ONG RIEUL-KAPYEOUNPIEUP", "Lo", 0),
("<NAME>UL-SIOS", "Lo", 0),
("<NAME>ONG RIEUL-CIEUC", "Lo", 0),
("<NAME>ONG RIEUL-KHIEUKH", "Lo", 0),
("H<NAME>ONG MIEUM-KIYEOK", "Lo", 0),
("<NAME>UM-TIKEUT", "Lo", 0),
("<NAME>IEUM-SIOS", "Lo", 0),
("<NAME>ONG PIEUP-SIOS-THIEUTH", "Lo", 0),
("<NAME>UP-KHIEUKH", "Lo", 0),
("<NAME>ONG PIEUP-HIEUH", "Lo", 0),
("<NAME>ONG SSANGSIOS-PIEUP", "Lo", 0),
("<NAME>", "Lo", 0),
("<NAME>", "Lo", 0),
("<NAME>", "Lo", 0),
("<NAME>", "Lo", 0),
("<NAME>", "Lo", 0),
("<NAME>", "Lo", 0),
("<NAME>", "Lo", 0),
)
|
https://github.com/lucannez64/Notes | https://raw.githubusercontent.com/lucannez64/Notes/master/Evidence.typ | typst | #import "template.typ": *
// Take a look at the file `template.typ` in the file panel
// to customize this template and discover how it works.
#show: project.with(
title: "Evidence",
authors: (
"<NAME>",
),
date: "30 Juin, 2024",
)
#set heading(numbering: "1.1.")
== Pseudos
<pseudos>
- Hirew
- Δoxa
- 荣耀归于自由
- Akuvogo
- Kalah
== Quotes
<quotes>
- 정말 짜증나네
- Δψ = 0
- What one man calls God, another calls the laws of physics
- همچنین خواهد گذشت
|
|
https://github.com/PgBiel/iterino | https://raw.githubusercontent.com/PgBiel/iterino/main/src/lib.typ | typst | Apache License 2.0 | #let yield(x, state) = (x, state, false)
#let done = (none, none, true)
#let new(state, fn) = (state, fn)
#let next(iter) = {
let (state, fn) = iter
let (value, next-state, is-done) = fn(state)
(value, (next-state, fn), is-done)
}
#let from-fn(fn) = {
assert.eq(type(fn), function)
(none, fn)
}
#let from-array(arr) = {
assert.eq(type(arr), array)
(0, i => if i < arr.len() { yield(arr.at(i), i + 1) } else { done } )
}
#let range(..args) = {
assert.eq(args.named(), (:), message: "Unexpected named args for 'range'")
let args = args.pos()
assert.ne(args, (), message: "Expected at least one bound for 'range'")
assert(args.len() <= 3, message: "Expected up to 3 params for 'range'")
let start = 0
let stop = 0
let step = 1
if args.len() == 1 {
stop = args.first()
} else if args.len() == 2 {
(start, stop) = args
} else if args.len() == 3 {
(start, stop, step) = args
}
(start, i => if i <= stop { yield(i, i + step) } else { done })
}
#let map(iterator, fn: none) = {
assert.eq(type(fn), function)
let (initial-state, next) = iterator
(
initial-state,
state => {
let (value, next-state, is-done) = next(state)
if is-done {
done
} else {
yield(fn(value), next-state)
}
}
)
}
#let filter(iterator, pred: none) = {
assert.eq(type(pred), function)
let (initial-state, next) = iterator
(
initial-state,
state => {
let state = state
while true {
let (value, next-state, is-done) = next(state)
if is-done {
break
} else if pred(value) {
return yield(value, next-state)
}
state = next-state
}
// Searched all remaining items, nothing found
done
}
)
}
#let inspect(iterator, fn: none) = {
assert.eq(type(fn), function)
let (initial-state, next) = iterator
(
initial-state,
state => {
let (value, next-state, is-done) = next(state)
if is-done {
done
} else {
fn(value)
yield(value, next-state)
}
}
)
}
#let to-array(iterator) = {
let (state, next) = iterator
let arr = ()
while true {
let (value, next-state, is-done) = next(state)
if is-done {
break
}
state = next-state
arr.push(value)
}
arr
}
#let chain(iter, ..fn) = {
let fns = fn.pos().rev()
let current = iter
while fns.len() > 0 {
current = (fns.pop())(current)
}
current
}
|
https://github.com/Myriad-Dreamin/shiroa | https://raw.githubusercontent.com/Myriad-Dreamin/shiroa/main/github-pages/docs/cli/main.typ | typst | Apache License 2.0 | #import "/github-pages/docs/book.typ": book-page, cross-link
#show: book-page.with(title: "Command Line Tool")
= Command Line Tool
// todo: cross link
The `shiroa` command-line tool is used to create and build books.
After you have #cross-link("/guide/installation.typ")[installed] `shiroa`, you can run the `shiroa help` command in your terminal to view the available commands.
This following sections provide in-depth information on the different commands available.
// todo: cross link
- #cross-link("/cli/init.typ")[`shiroa init <directory>`] — Creates a new book with minimal boilerplate to start with.
- #cross-link("/cli/build.typ")[`shiroa build`] — Renders the book.
- #cross-link("/cli/serve.typ")[`shiroa serve`] — Runs a web server to view the book, and rebuilds on changes.
- #cross-link("/cli/clean.typ")[`shiroa clean`] — Deletes the rendered output.
- #cross-link("/cli/completions.typ")[`shiroa completions`] — Support for shell auto-completion.
= Note about the missing `watch` command
We suggest you to use #link("https://github.com/Enter-tainer/typst-preview")[Typst Preview plugin] for preview feature. For more details, please see #cross-link("/guide/get-started.typ")[Get Started] chapter.
|
https://github.com/LDemetrios/Typst4k | https://raw.githubusercontent.com/LDemetrios/Typst4k/master/src/test/resources/suite/loading/xml.typ | typst | --- xml ---
// Test reading XML data.
#let data = xml("/assets/data/hello.xml")
#test(data, ((
tag: "data",
attrs: (:),
children: (
"\n ",
(tag: "hello", attrs: (name: "hi"), children: ("1",)),
"\n ",
(
tag: "data",
attrs: (:),
children: (
"\n ",
(tag: "hello", attrs: (:), children: ("World",)),
"\n ",
(tag: "hello", attrs: (:), children: ("World",)),
"\n ",
),
),
"\n",
),
),))
--- xml-invalid ---
// Error: 6-28 failed to parse XML (found closing tag 'data' instead of 'hello' in line 3)
#xml("/assets/data/bad.xml")
|
|
https://github.com/frectonz/the-pg-book | https://raw.githubusercontent.com/frectonz/the-pg-book/main/book/197.%20donate.html.typ | typst | donate.html
Donate Unrestricted
March 2021The secret curse of the nonprofit world is restricted donations.
If you haven't been involved with nonprofits, you may never have
heard this phrase before. But if you have been, it probably made
you wince.Restricted donations mean donations where the donor limits what can
be done with the money. This is common with big donations, perhaps
the default. And yet it's usually a bad idea. Usually the way the
donor wants the money spent is not the way the nonprofit would have
chosen. Otherwise there would have been no need to restrict the
donation. But who has a better understanding of where money needs
to be spent, the nonprofit or the donor?If a nonprofit doesn't understand better than its donors where money
needs to be spent, then it's incompetent and you shouldn't be
donating to it at all.Which means a restricted donation is inherently suboptimal. It's
either a donation to a bad nonprofit, or a donation for the wrong
things.There are a couple exceptions to this principle. One is when the
nonprofit is an umbrella organization. It's reasonable to make a
restricted donation to a university, for example, because a university
is only nominally a single nonprofit. Another exception is when the
donor actually does know as much as the nonprofit about where money
needs to be spent. The Gates Foundation, for example, has specific
goals and often makes restricted donations to individual nonprofits
to accomplish them. But unless you're a domain expert yourself or
donating to an umbrella organization, your donation would do more
good if it were unrestricted.If restricted donations do less good than unrestricted ones, why
do donors so often make them? Partly because doing good isn't donors'
only motive. They often have other motives as well — to make a mark,
or to generate good publicity
[1],
or to comply with regulations
or corporate policies. Many donors may simply never have considered
the distinction between restricted and unrestricted donations. They
may believe that donating money for some specific purpose is just
how donation works. And to be fair, nonprofits don't try very hard
to discourage such illusions. They can't afford to. People running
nonprofits are almost always anxious about money. They can't afford
to talk back to big donors.You can't expect candor in a relationship so asymmetric. So I'll
tell you what nonprofits wish they could tell you. If you want to
donate to a nonprofit, donate unrestricted. If you trust them to
spend your money, trust them to decide how.
Note[1]
Unfortunately restricted donations tend to generate more
publicity than unrestricted ones. "X donates money to build a school
in Africa" is not only more interesting than "X donates money to Y
nonprofit to spend as Y chooses," but also focuses more attention
on X.
Thanks to <NAME>, <NAME>, <NAME>, and <NAME> for reading drafts of this.
|
|
https://github.com/ntjess/typst-tada | https://raw.githubusercontent.com/ntjess/typst-tada/main/lib.typ | typst | The Unlicense | #import "src/ops.typ"
#import "src/tabledata.typ"
#import "src/display.typ"
#import "src/helpers.typ"
#import display: to-tablex
#(import tabledata:
add-expressions,
count,
drop,
from-columns,
from-rows,
from-records,
item,
stack,
subset,
TableData,
transpose,
update-fields
)
#import ops: agg, chain, filter, group-by, sort-values
#let tada-version = toml("typst.toml").package.version
|
https://github.com/Area-53-Robotics/53E-Notebook-Over-Under-2023-2024 | https://raw.githubusercontent.com/Area-53-Robotics/53E-Notebook-Over-Under-2023-2024/giga-notebook/entries/identify-tracking.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #import "/packages.typ": notebookinator
#import notebookinator: *
#import themes.radial.components: *
#show: create-body-entry.with(
title: "Identify: Position Tracking",
type: "identify",
date: datetime(year: 2023, month: 7, day: 28),
author: "<NAME>",
witness: "<NAME>",
)
During our Tipping Point and Spin Up seasons all of our tracking in the
autonomous period was 1 dimensional and relative. This meant that the robot
could only track its position in a straight line, and was only aware of its
position in relation to its last position. This made it very easy for error to
build up, especially if movements were not totally accurate.
We decided that in order to solve this problem we would need an absolute
positioning system. This would track the robot's position in Cartesian
coordinates throughout the entire match. This has a couple advantages over our
past system.
- Tracking is now 2 Dimensional, allowing for more complex movement algorithms
- Allows for movements to be made in regard to specific points on the field
- Allows for correction of past error
#align(
center,
)[
#figure(
caption: "Depicted: the robot's position in the field measured in tiles",
)[
#image("/assets/odometry/absolute-tracking.svg", width: 75%)
]
]
= Design Constraints
- Must use official Vex sensors
- Sensors used must keep the robot within an 18" by 18" by 18" cube
= Design Goals
- Stay under 1" of error after moving for 24'
|
https://github.com/Ryoga-itf/differential-equations | https://raw.githubusercontent.com/Ryoga-itf/differential-equations/main/template.typ | typst | #let textL = 1.8em
#let textM = 1.6em
#let fontSerif = ("Noto Serif", "Noto Serif CJK JP")
#let fontSan = ("Noto Sans", "Noto Sans CJK JP")
#let project(week: -1, authors: (), date: none, body) = {
let title = "微分方程式 " + str(week) + "レポート"
set document(author: authors.map(a => a.name), title: title)
set page(numbering: "1", number-align: center)
set text(font: fontSerif, lang: "ja")
show heading: set text(font: fontSan, weight: "medium", lang: "ja")
show heading.where(level: 2): it => pad(top: 1em, bottom: 0.4em, it)
show heading.where(level: 3): it => pad(top: 1em, bottom: 0.4em, it)
// Figure
show figure: it => pad(y: 1em, it)
show figure.caption: it => pad(top: 0.6em, it)
show figure.caption: it => text(size: 0.8em, it)
// Title row.
align(center)[
#block(text(textL, weight: 700, title))
#v(1em, weak: true)
#date
]
// Author information.
pad(
top: 0.5em,
bottom: 0.5em,
x: 2em,
grid(
columns: (1fr,) * calc.min(3, authors.len()),
gutter: 1em,
..authors.map(author => align(center)[
*#author.name* \
#author.email \
#author.affiliation
]),
),
)
// Main body.
set par(justify: true)
body
}
|
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compiler/array-36.typ | typst | Other | // Error: 2-26 cannot order content and content
#([Hi], [There]).sorted()
|
https://github.com/arthurcadore/eng-telecom-workbook | https://raw.githubusercontent.com/arthurcadore/eng-telecom-workbook/main/semester-7/MEC/finalproject/homework.typ | typst | MIT License | #import "@preview/klaro-ifsc-sj:0.1.0": report
#import "@preview/codelst:2.0.1": sourcecode
#show heading: set block(below: 1.5em)
#show par: set block(spacing: 1.5em)
#set text(font: "Arial", size: 12pt)
#set highlight(
fill: rgb("#c1c7c3"),
stroke: rgb("#6b6a6a"),
extent: 2pt,
radius: 0.2em,
)
#show: doc => report(
title: "Projeto Final",
subtitle: "Mecânica dos Sólidos",
authors: ("<NAME>",),
date: "20 de Agosto de 2024",
doc,
)
= Introdução:
Este relatório tem como objetivo apresentar a resolução de um conjunto de questões relacionadas à disciplina de Mecânica dos Sólidos. As questões abordam temas como diagramas de esforço cortante e momento fletor, tensão máxima de flexão, tensão de cisalhamento, dimensionamento de eixos e pilares, entre outros.
= Parâmetros das questões:
Para este relatório, serão utilizadas as forças correspondentes a linha "A" da figura abaixo:
#figure(
figure(
rect(image("./pictures/forces.png")),
numbering: none,
caption: [Forças a serem aplicadas no trabalho]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
= Questão 1:
Desenhe os diagramas de esforço cortante e momento fletor para a viga bi-apoiada. Considere que a viga tenha secção de 12cm x 30cm. Determine qual é a tensão máxima de flexão.
#figure(
figure(
rect(image("./pictures/q1.png")),
numbering: none,
caption: [Questão 1]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
Incialmente, partimos que o somátório das forças em y é igual a 0, portanto:
$
R_1 - 52k - 26k + R_2 = 0
$
Desta forma, temos que:
$
R_1 + R_2 = 78k
$
Em seguida, determinamos que o somatório dos momentos é 0, portanto:
$
R_2 * 12 = 52k * 4 + 26k * 8
$
Desta forma, temos que:
$
R_2 = (52k * 4 + 26k * 8) / 12 = (416k)/12 = 34,666k
$
Como temos a relação de $R_1 + R_2 = 78k$, temos que:
$
R_1 + R_2 = 78k -> R_1 + 34,66666k = 78k -> R_1 = 43,333k
$
== Calculo de esforço cortante e Momento fletor:
=== Seção 1 ($0 <= x <= 4$):
Apliando a formula $-R_1 + V_(x) = 0$, temos que:
$
-43,333k + V_(x) = 0
$
Portanto:
$
V_(x) = 43,333k
$
Em seguida, para calcular o momento fletor, temos que:
$
M_(x) = V_(x) -> M_(x) = 43,333k_x
$
=== Seção 2 ($4 <= x <= 8$):
Resolvendo o balanço de forças na seção:
$
-43,333k + 52k + V_(x) = 0
$
Portanto:
$
V_(x) = -52k + 43,333k = -8,666k
$
Em seguida, para calcular o momento fletor, temos que:
$
52k (4 - 0) - 8,666k + M_(x) = 0
$
Portanto:
$
M_(x) = 208k - 8,666k_x
$
=== Seção 3 ($8 <= x <= 12$):
Resolvendo o balanço de forças na seção:
$
-43,333k + 52k + 26k + V_(x) = 0
$
Portanto:
$
V_(x) = -52k - 26k + 43,333k = -34,666k
$
Em seguida para calcular o momento fletor, temos que:
$
52k (4 - 0) + 26k (8 - 0) - 34,666k + M_(x) = 0
$
Portanto:
$
M_(x) = 416k - 34,666k_x
$
=== Gráficos:
A partir dos valores vistos acima, temos o seguinte gráfico de esforço cortante:
#figure(
figure(
rect(image("./pictures/r1.1.png")),
numbering: none,
caption: [Diagrama de esforço cortante]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
E também, apresentado abaixo, o gráfico de momento fletor:
#figure(
figure(
rect(image("./pictures/r1.2.png")),
numbering: none,
caption: [Diagrama de momento fletor]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
== Tensão máxima de flexão:
Primeiramente, calculamos o centro de gravidade "y" na secção transversal da viga:
$
y = h / 2 = 30 / 2 = 15"cm" -> y = 0,15m
$
Agora calculamos o momento de inércia:
$
I = (b * h^3) / 12 = (0,12 * 0,3^3) / 12 = (0,12 * 0,027) / 12 = 0,00027
$
Para calcular a tensão máxima de flexão, utilizamos a fórmula:
$
sigma = (M * y) / I
$
Aplicando aos valores obtidos na questão, temos que:
$
sigma = (173,33k * 0,15) / (0,00027) = (25,999k) / (0,00027) = 96294444,44 N/m^2
$
= Questão 2:
Desenhe os diagramas de esforço cortante e momento fletor para a viga bi-apoiada. A viga tem perfil retangular com medidas de 8cm x 25cm. Determine também qual é a tensão máxima de flexão.
#figure(
figure(
rect(image("./pictures/q2.png")),
numbering: none,
caption: [Questão 2]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
Inicialmente, partimos que o somátório das forças em y é igual a 0, portanto:
$
R_1 - 52k + R_2 = 0
$
Desta forma, temos que:
$
R_1 + R_2 = 52k
$
Em seguida, determinamos que o somatório dos momentos é 0, portanto:
$
R_2 * 6 = 52k * 4 -> R_2 = (52k * 4) / 6 = 34,666k
$
Como temos a relação de $R_1 + R_2 = 52k$, temos que:
$
R_1 + R_2 = 52k -> R_1 + 34,666k = 52k -> R_1 = 17,333k
$
== Calculo de esforço cortante e Momento fletor:
=== Seção 1 ($0 <= x <= 4$):
Apliando a formula $-R_1 + V_(x) = 0$, temos que:
$
-17,333k + V_(x) = 0
$
Portanto:
$
V_(x) = 17,333k
$
Em seguida, para calcular o momento fletor, temos que:
$
M_(x) = V_(x) -> M_(x) = 17,333k_x
$
=== Seção 2 ($4 <= x <= 6$):
Resolvendo o balanço de forças na seção:
$
-17,333k + 52k + V_(x) = 0
$
Portanto:
$
V_(x) = -52k + 17,333k = -34,666k
$
Em seguida, para calcular o momento fletor, temos que:
$
52k (4 - 0) - 34,666k + M_(x) = 0
$
Portanto:
$
M(x) = 208k - 34,666k_x
$
=== Gráficos:
A partir dos valores vistos acima, temos o seguinte gráfico de esforço cortante:
#figure(
figure(
rect(image("./pictures/r2.1.png")),
numbering: none,
caption: [Diagrama de esforço cortante]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
E também, apresentado abaixo, o gráfico de momento fletor:
#figure(
figure(
rect(image("./pictures/r2.2.png")),
numbering: none,
caption: [Diagrama de momento fletor]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
== Tensão máxima de flexão:
Primeiramente, calculamos o centro de gravidade "y" na secção transversal da viga:
$
y = h / 2 = 25 / 2 = 12,5"cm" -> y = 0,125m
$
Agora calculamos o momento de inércia:
$
I = (b * h^3) / 12 = (0,08 * 0,25^3) / 12 = (0,08 * 0,015625) / 12 = 0,010416
$
Para calcular a tensão máxima de flexão, utilizamos a fórmula:
$
sigma = (M * y) / I
$
Aplicando aos valores obtidos na questão, temos que:
$
sigma = (69,333k * 0,125) / (0,010416) = (8,666k) / (0,010416) = 832049,251 N/m^2
$
= Questão 3:
Desenhe os diagramas de esforço cortante e momento fletor para a viga mostrada abaixo:
#figure(
figure(
rect(image("./pictures/q3.png")),
numbering: none,
caption: [Questão 3]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
== Calculo de esforço cortante e Momento fletor:
Inicialmente, partimos que o somátório das forças em y é igual a 0, portanto:
$
R_1 - 52k - 26k + R_2 - 34k = 0
$
Desta forma, temos que:
$
R_1 + R_2 = 52k + 26k + 34k = 112k
$
Em seguida, determinamos que o somatório dos momentos é 0, portanto:
$
R_2 * 14 = 52k * 6 + 26k * 14 + 34k * 22
$
Desta forma, temos que:
$
R_2 = (52k * 6 + 26k * 14 + 34k * 22) / 14 = (1424k )/ 14 = 101,714k
$
Como temos a relação de $R_1 + R_2 = 112k$, temos que:
$
R_1 + R_2 = 112k -> R_1 + 101,714k = 112k -> R_1 = 10,286k
$
=== Seção 1 ($0 <= x <= 6$):
Apliando a formula $-R_1 + V_(x) = 0$, temos que:
$
-10,286k + V_(x) = 0
$
Portanto:
$
V_(x) = 10,286k
$
Em seguida, para calcular o momento fletor, temos que:
$
M(x) = V_(x) -> M_(x) = 10,286k_x
$
=== Seção 2 ($6 <= x <= 14$):
Resolvendo o balanço de forças na seção:
$
- 10,286k + 52k + V_(x) = 0
$
Portanto:
$
V_(x) = -52k + 10,286k = -41,714k
$
Em seguida, para calcular o momento fletor, temos que:
$
52k (6 - 0) - 41,714k + M_(x) = 0
$
Portanto:
$
M_(x) = 312k - 41,714k_x
$
=== Seção 3 ($14 <= x <= 22$):
Resolvendo o balanço de forças na seção:
$
+10,286k + 101,714k - 52k - 26k + V_(x) = 0
$
Portanto:
$
V_(x) = -52k - 26k + 101,714k + 10,286k = 34k
$
Em seguida para calcular o momento fletor, temos que:
$
52k (6 - 0) + 26k (14 - 0) - 34k + M_(x) = 0
$
Portanto:
$
M_(x) = - 748k + 34k_x
$
=== Gráficos:
A partir dos valores vistos acima, temos o seguinte gráfico de esforço cortante:
#figure(
figure(
rect(image("./pictures/r3.1.png")),
numbering: none,
caption: [ Diagrama de esforço cortante]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
E também, apresentado abaixo, o gráfico de momento fletor:
#figure(
figure(
rect(image("./pictures/r3.2.png")),
numbering: none,
caption: [ Diagrama de momento fletor]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
= Questão 4:
Determine a Tensão de cisalhamento do eixo vazado abaixo quando submetido ao momento de torção T3. \
Nota: Foi solicitado considerar outro valor para o material do eixo: Aço com modulo de elasticidade de 77GPa.
#figure(
figure(
rect(image("./pictures/q4.png")),
numbering: none,
caption: [Questão 4]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
Para calcular a tensão de cisalhamento, inicialmente, precisamos calcular o momento polar de inércia, para isso temos que:
$
tau = pi / 2 (R_2^4 - R_1^4)
$
Aplicando os valores da questão na formula, ficamos com a seguinte expressão:
$
tau = pi / 2 (0,019^4 - 0,013^4) -> tau = pi / 2 (1,30321 * 10^(-7) - 0,28561 * 10^(-7))
$
Portanto, temos que:
$
tau = pi / 2 [(1,30321 - 0,28561) * 10^(-7) ] = 1,59844 * 10^(-7)
$
Agora podemos calcular a Tensão de cisalhamento aplicando a seguinte formula:
$
T = (epsilon * J ) / C
$
Portanto:
$
8k = (epsilon * 1,59844 * 10^(-7)) / (0,019) -> 0,0152 = epsilon * 1,59844 * 10^(-7)
$
E assim calculamos a tensão de cisalhamento admissível:
$
epsilon = (0,152) / (1,59844 * 10^(-7)) = 950927.153 N/m^2
$
= Questão 5:
Considere o eixo mostrado abaixo. A tensão de cisalhamento máxima admissível para o latão é de 55MPa. Dimensione os diâmetros mínimos dos eixos AB e BC.
#figure(
figure(
rect(image("./pictures/q5.png")),
numbering: none,
caption: [Questão 5]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
== Diâmetros dos eixos BC:
Primeiramente, calculamos o momento polar de inércia para o eixo BC, para isso temos que:
$
J = pi / 2 ((d_"BC"/2)^4) -> J = pi / 2 (d_"BC"^4) / 16
$
Em seguida, podemos utilizar a formula de tensão de cisalhamento para realizar o calculo:
$
T = (epsilon * J) / C -> T = (epsilon * J) / (d/2)
$
Agora, aplicamos a formula de calculo de inércia para o eixo BC:
$
12k = (55 * 10^6 * J) / (d_"BC"/2) -> 12k = (55 * 10^6 * (pi / 2 (d_"BC"^4) / 16)) / (d_"BC"/2)
$
Desta forma, temos que:
$
12k = (55 * 10^6 * (pi / 2 (d_"BC"^4) / 16)) / (d_"BC"/2) -> 12k * d_"BC" = 2 * 55 * 10^6 * (pi / 2 (d_"BC"^4) / 16)
$
$
12k * d_"BC" = 2 * 55 * 10^6 * (pi / 2) * (d_"BC"^4) / 16 -> (12k ) / (2 * 55 * 10^6 * (pi / 32)) = d_"BC"^4 / d_"BC"
$
$
(12 * 10^3) / (110 * 10^6 * (pi / 32)) = d_"BC"^3 -> (12) / (110 * 10 ^ 3 * (pi / 32)) = d_"BC"^3
$
$
d_"BC"^3 = 0.00111119087 -> d_"BC" = 0.00111119087^(1/3) = 0.103576m "ou" 103,576"mm"
$
== Diâmetros dos eixos AB:
Para calcular o diâmetro do eixo AB, da mesma forma, iniciamos calculando o momento polar de inercia para o eixo AB, para isso temos que:
$
J = pi / 2 ((d_"AB"/2)^4) -> J = pi / 2 (d_"AB"^4) / 16
$
Em seguida, podemos utilizar a formula de tensão de cisalhamento para realizar o calculo:
$
T = (epsilon * J) / C -> T = (epsilon * J) / (d/2)
$
Agora, aplicamos a formula de calculo de inércia para o eixo AB:
$
4k = (55 * 10^6 * J) / (d_"AB"/2) -> 4k = (55 * 10^6 * (pi / 2 (d_"AB"^4) / 16)) / (d_"AB"/2)
$
$
2 * 55* 10^6 * (pi / 32) * d_"AB"^4 = 4k * d_"AB" -> 110 * 10^6 * (pi / 32) * d_"AB"^4 = 4k * d_"AB"
$
$
d_"AB"^4 / d_"AB" = (4k) / (110 * 10^6 * (pi / 32)) -> d_"AB"^4 / d_"AB" = (4 * 10^3) / (110 * 10^6 * (pi / 32)) -> d_"AB"^3 = 4 / (110 * 10^3 * (pi / 32))
$
$
d_"AB"^3 = 0.00037039695 -> d_"AB" = 0.00037039695^(1/3) = 0.071816m "ou" 71,816"mm"
$
= Questão 6:
Observe as ilustrações da estrutura apresentada abaixo.
- A Carga adicional sobre a laje localizada bem no centro tem valor 52 (kN).
- Considere a densidade do concreto armado como sendo de 2.300kg/m³.
- As paredes têm largura de 15cm e densidade de 1300kg/m³.
- Desconsidere a porta e a janela para calcular a carga das paredes.
- A espessura da laje de cobertura e da laje de piso é de 15cm.
- Os 4 pilares têm medidas de secção de 40cm x 15cm.
- As vigas de cobertura e baldrames têm secções de 15cm por 30cm.
- As sapatas (ou blocos de fundação) têm medidas de 1m x 1m x 0,50m de altura.
- Os pilares são armados com 6 barras de aço de diâmetro “d”.
Considere:
- E_aço= 200GPa
- E_conc= 20GPa.
- A carga das lajes e do peso P são descarregadas igualmente em todo o perímetro das vigas.
Determine:
- Qual a pressão exercida pelas sapatas no solo (kN/m²).
- Para as vigas, determine qual a Tensão máxima de flexão decorrente do peso próprio e da carga das paredes / lajes.
- Determine o diâmetro dos pilares considerando que a carga da laje e da viga de cobertura é descarregada 75% no concreto e 25% no aço.
#figure(
figure(
rect(image("./pictures/q6.1.png")),
numbering: none,
caption: [Questão 6 - Perspectiva Isometrica]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
#figure(
figure(
rect(image("./pictures/q6.2.png")),
numbering: none,
caption: [Questão 6 - Corte da Estrutura]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
#figure(
figure(
rect(image("./pictures/q6.3.png")),
numbering: none,
caption: [Questão 6 - Planta Baixa]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
== Peso próprio da laje (sem vigas):
Inicialmente precisamos determinar o volume da laje, para isso temos que:
$
V_"laje" = B * H * L -> V_"laje" = 4 * 0,15 * 4 = 2,4m^3
$
Em seguida, podemos calcular a massa da laje através do coeficiente de densidade do concreto armado:
$
M = V_"laje" * D_"concreto" -> P = 2,4 * 2300 = 5520"kg"
$
Utilizando o coeficiente graviacional como "g" = 9,807 m/s², temos que o peso é dado por:
$
P_"laje" = 5520 * 9,807 = 54134,64N -> P = 54,13464"kN"
$
== Peso próprio de todas as vigas:
Para calcular o peso das vigas, precisamos determinar o volume das vigas, para isso temos que:
$
V_"viga" = B * H * L -> V_"viga" = 0,15 * 0,3 * 4 = 0,18m^3
$
Em seguida, podemos calcular a massa das vigas através do coeficiente de densidade:
$
M = V_"viga" * D_"concreto" -> P = 0,18 * 2300 = 414"kg"
$
Utilizando o coeficiente graviacional como "g" = 9,807 m/s², temos que o peso é dado por:
$
P_"viga" = 414 * 9,807 = 4057,98N -> P = 4,05798"kN"
$
Agora, como são utilizadas no total 8 vigas para a construção da estrutura, temos seu peso final multiplicado por 8:
$
P_"viga" = 4,05798 * 8 = 32,46384"kN"
$
== Peso próprio dos pilares:
Para calcular o peso dos pilares, precisamos determinar o volume dos pilares, para isso temos que:
$
V_"pilar" = B * H * L -> V_"pilar" = 0,4 * 0,15 * 2,6 = 0,156m^3
$
Em seguida, podemos calcular a massa dos pilares através do coeficiente de densidade:
$
M = V_"pilar" * D_"concreto" -> P = 0,156 * 2300 = 358,8"kg"
$
Utilizando o coeficiente graviacional como "g" = 9,807 m/s², temos que o peso é dado por:
$
P_"pilar" = 358,8 * 9,807 = 3520,476N -> P = 3,520476"kN"
$
Como são utilizados 4 pilares para a construção da estrutura, temos seu peso final multiplicado por 4:
$
P_"pilar" = 3,520476 * 4 = 14,081904"kN"
$
== Peso próprio das paredes:
Para calcular o peso das paredes, precisamos determinar o volume das paredes, para isso temos que:
$
V_"paredes" = B * H * L -> V_"paredes" = 0,15 * 2,6 * 4 = 1,56m^3
$
Em seguida, podemos calcular a massa das paredes através do coeficiente de densidade:
$
M = V_"paredes" * D_"paredes" -> P = 1,56 * 1300 = 2028"kg"
$
Utilizando o coeficiente graviacional como "g" = 9,807 m/s², temos que o peso é dado por:
$
P_"paredes" = 2028 * 9,807 = 19899,816N -> P = 19,899816"kN"
$
Como são utilizadas 4 paredes para a construção da estrutura, temos seu peso final multiplicado por 4:
$
P_"paredes" = 19,899816 * 4 = 79,599264"kN"
$
== Peso próprio das sapatas:
Para calcular o peso das sapatas, precisamos determinar o volume das sapatas, para isso temos que:
$
V_"sapatas" = B * H * L -> V_"sapatas" = 1 * 1 * 0,5 = 0,5m^3
$
Em seguida, podemos calcular a massa das sapatas através do coeficiente de densidade:
$
M = V_"sapatas" * D_"concreto" -> P = 0,5 * 2300 = 1150"kg"
$
Utilizando o coeficiente graviacional como "g" = 9,807 m/s², temos que o peso é dado por:
$
P_"sapatas" = 1150 * 9,807 = 11278,5N -> P = 11,2785"kN"
$
Como são utilizadas 4 sapatas para a construção da estrutura, temos seu peso final multiplicado por 4:
$
P_"sapatas" = 11,2785 * 4 = 45,114"kN"
$
== Diâmetro das barras de aço do pilar:
Para calcular o diâmetro do pilar, primeiramente devemos definir o peso sobre ele:
$
P = P_"carga" + P_"laje" + P_"viga"
$
Portanto temos que:
$
P = 52k + 54,13464 + 32,46384 = 138,598"kN"
$
Entretanto, esse peso é dividio igualmente entre os quatro pilares, desta forma, temos que:
$
P_"1pilar" = 138,598 / 4 = 34,6495"kN"
$
Como dito pela questão que 75% da carga é descarregada no concreto e 25% no aço, temos que:
$
P_"aco" = 0,25 * 34,6495 = 8,662375"kN"
$
$
P_"concreto" = 0,75 * 34,6495 = 25,987125"kN"
$
Em seguida, podemos aplicar a formula para calcular o a área do aço na secção do pilar:
$
P_"aco"/ (E_"aco" * A_"aco") = P_"concreto" / (E_"concreto" * A_"concreto")
$
Portanto, temos que:
$
(8,662375k )/ (200 * 10^9 * A_"aco") = (25,987125k) / (20 * 10^9 * A_"concreto")
$
Como sabemos a quantidade de barras de aço, temos que:
$
(8,662375k )/ (200 * 10^9 * A_"aco") = (25,987125k) / (20 * 10^9 * (0,06 - A_"aco")) -> (8,662375k )/ (10 * A_"aco") = (25,987125k) / (0,06 - A_"aco")
$
$
(8,662375k )/ (A_"aco") = (250,987125k) / (0,06 - A_"aco") -> (29 * (8,662375k ))/ (29 * (A_"aco")) = (250,987125k) / (0,06 - A_"aco")
$
$
(250,987125k)/ (29 * A_"aco") = (250,987125k) / (0,06 - A_"aco")
$
$
1 / (29 * A_"aco") = 1 / (0,06 - A_"aco") -> 29 A_"aco" = 0,06 - A_"aco"
$
$
A_"aco" = (0,06) / 30 = 0,002m^2
$
Uma vez com a área do aço, calculada, podemos determinar o diâmetro das barras de aço:
$
0,002 = (6 * pi * d^2) / 4 -> 0,008 = 6 * pi * d^2 -> d^2 = (0,008) / (6 * pi)
$
$
d^2 = 0.00042441318 -> d = sqrt(0.00042441318) = 0.0206012m "ou" 20,6012"mm"
$
== Tensão exercida sobre o solo pelas sapatas:
Para determinar a tensão exercida sobre o solo pelas sapatas, verificando a imagem temos que a área de cada sapata no solo é de 1m^2. Dessa forma, basta verificar o peso sobre as sapatas:
- P_laje = 54,13464kN
- P_piso = 54,13464kN
- P_vigas = 32,46384kN
- P_pilares = 14,081904kN
- P_paredes = 79,599264kN
- P_sapatas = 45,114kN
Desta forma temos que:
$
P_"total" = P_"laje" + P_"piso" + P_"vigas" + P_"pilares" + P_"paredes" + P_"sapatas" + P_"carga"
$
Portanto:
$
P_"total" = 2* 54,1344k + 32,4384k + 14,0904k + 79,5994k + 45,114k + 52k
$
$
P_"total" = 331,5286"kN"
$
Como o peso está sendo dividido entre as 4 sapatas e cada uma possui uma área de contato de $1m^2$ com o solo, temos que:
$
P_"solo" = (331,5286) / 4 = 82,8821"kN"/m^2 "ou" 82,8821"Mpa"
$
== Tabela de resultados:
#figure(
figure(
table(
columns: (1fr, 1fr, 1fr),
align: (left, center, center),
table.header[Item][Estrutura][Resultado],
[1], [peso próprio da laje (sem vigas)], [54,13464 kN],
[2], [peso próprio de todas as vigas], [32,46384 kN],
[3], [peso próprio dos pilares], [14,081904 kN],
[4], [peso próprio das paredes], [79,599264 kN],
[5], [peso próprio das sapatas], [45,114 kN],
[6], [Diâmetro das barras de aço do pilar], [20,6012 mm],
[7], [Tensão exercida sobre o solo pelas sapatas], [82,8821 MPa],
),
numbering: none,
caption: [Tabela de resultados obtidos]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
== Tensão máxima de flexão:
=== Calculo dos parâmetros iniciais:
Para calcular a tensão máxima de flexão, primeiramente, precisamos calcular o momento de inércia da viga, para isso temos que:
$
I = (b * h^3) / 12 = (0,15 * 0,3^3) / 12 = 0,003375
$
Agora, como deve-se calcular a tensão máxima de flexão partindo de todos os pesos da estrutura (exceto o peso da sapata pois não é apoiada na viga), temos que:
$
P = P_"total" - "P_sapatas" = 331,5286 - 45,114 = 286,4146"kN"
$
Agora, como são utilizadas 4 vigas na estrutura, o peso é idealmente divido entre as 4:
$
P = (286,4146) / 4 = 71,60365"kN"
$
Como orientado no enunciado, o peso é idealmente distribuido pela viga, como o comprimento da mesma é de 4 metros, podemos calcular o peso distribuido:
$
P_"distribuido" = (71,60365) / 4 = 17,90025"kN/m"
$
=== Plotagem dos gráficos:
A partir dos valores vistos acima, utilizei o aplicativo "viga online" para plotar a estrutura da viga e o gráfico de momento fletor:
#figure(
figure(
rect(image("./pictures/r6.8.png")),
numbering: none,
caption: [Viga montada com a força distribuida]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
#figure(
figure(
rect(image("./pictures/r6.9.png")),
numbering: none,
caption: [Máximo momento fletor]
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
Dessa forma, podemos concluir que o maior momento fletor é de 35,796kNm.
=== Calculo da tensão máxima de flexão:
Para calcular a tensão máxima de flexão, agora verificamos o centro de gravidade "y" na secção transversal da viga:
$
y = h / 2 = 0,3 / 2 = 0,15m
$
Em seguida, aplicamos a fórmula para calcular a tensão máxima de flexão:
$
sigma = (M * y) / I
$
Portanto, temos que:
$
sigma = (35,796k * 0,15) / (0,003375) = 1.590.933,333 N/m^2 "ou" 1,590933 "MPa"
$
= Conclusão:
A partir dos conceitos vistos, desenvolvimento e resultados obtidos, podemos concluir que os calculos voltados para a determinação de tensão máxima de flexão, tensão de cisalhamento, e diâmetro de barras de aço determinam limites para os materiais que são utilizados na montagem de estruturas e são fundamentais para a análise de sua estabilidade, garantindo a segurança e estabilidade das mesmas.
= Referências Bibliográficas:
- <NAME>. Momento fletor. Youtube - JESUE REFRIGERACAO CLIMATIZACAO, 2018.
- <NAME>. Aula resumo sobre torção - versão preliminar. Youtube - <NAME>, 2023.
- <NAME>. Diametro das barras de aço. Youtube - JESUE REFRIGERACAO CLIMATIZACAO, 2018. |
https://github.com/mintyfrankie/brilliant-CV | https://raw.githubusercontent.com/mintyfrankie/brilliant-CV/main/lib.typ | typst | Apache License 2.0 | /*
* Entry point for the package
*/
/* Packages */
#import "./cv.typ": *
#import "./letter.typ": *
#import "./utils/lang.typ": isNonLatin
#import "./utils/styles.typ": overwriteFonts
/* Layout */
#let cv(
metadata,
profilePhoto: image("./template/src/avatar.png"),
doc,
) = {
// Non Latin Logic
let lang = metadata.language
let fontList = latinFontList
let headerFont = latinHeaderFont
fontList = overwriteFonts(metadata, latinFontList, latinHeaderFont).regularFonts
headerFont = overwriteFonts(metadata, latinFontList, latinHeaderFont).headerFont
if isNonLatin(lang) {
let nonLatinFont = metadata.lang.non_latin.font
fontList.insert(2, nonLatinFont)
headerFont = nonLatinFont
}
// Page layout
set text(font: fontList, weight: "regular", size: 9pt)
set align(left)
set page(
paper: "a4",
margin: (left: 1.4cm, right: 1.4cm, top: .8cm, bottom: .4cm),
footer: _cvFooter(metadata),
)
_cvHeader(metadata, profilePhoto, headerFont, regularColors, awesomeColors)
doc
}
#let letter(
metadata,
doc,
myAddress: "Your Address Here",
recipientName: "Company Name Here",
recipientAddress: "Company Address Here",
date: datetime.today().display(),
subject: "Subject: Hey!",
signature: "",
) = {
// Non Latin Logic
let lang = metadata.language
let fontList = latinFontList
fontList = overwriteFonts(metadata, latinFontList, latinHeaderFont).regularFonts
if isNonLatin(lang) {
let nonLatinFont = metadata.lang.non_latin.font
fontList.insert(2, nonLatinFont)
}
// Page layout
set text(font: fontList, weight: "regular", size: 9pt)
set align(left)
set page(
paper: "a4",
margin: (left: 1.4cm, right: 1.4cm, top: .8cm, bottom: .4cm),
footer: letterHeader(
myAddress: myAddress,
recipientName: recipientName,
recipientAddress: recipientAddress,
date: date,
subject: subject,
metadata: metadata,
awesomeColors: awesomeColors,
),
)
set text(size: 12pt)
doc
if signature != "" {
letterSignature(signature)
}
}
|
https://github.com/compsci-adl/Constitution | https://raw.githubusercontent.com/compsci-adl/Constitution/master/README.md | markdown | # The University of Adelaide Computer Science Club Constitution
This repository contains the Constitution of the club, as well as Schedule 1 to the Constitution, titled "Committee Composition"
The documents are written in Typst. More information can be found [here](https://github.com/typst/typst).
|
|
https://github.com/kotfind/hse-se-2-notes | https://raw.githubusercontent.com/kotfind/hse-se-2-notes/master/algo/lectures/main.typ | typst | #import "/utils/template.typ": conf
#import "/utils/datestamp.typ": datestamp
#show: body => conf(
title: "Алгоритмы",
subtitle: "Лекции",
author: "<NAME>, БПИ233",
year: [2024--2025],
body,
)
#datestamp("2024-09-03")
#include "2024-09-03.typ"
#datestamp("2024-09-10")
#include "2024-09-10.typ"
#datestamp("2024-09-17")
#include "2024-09-17.typ"
#datestamp("2024-09-24")
#include "2024-09-24.typ"
#datestamp("2024-10-01")
#include "2024-10-01.typ"
#datestamp("2024-10-08")
#include "2024-10-08.typ"
#datestamp("2024-10-15")
#include "2024-10-15.typ"
|
|
https://github.com/DieracDelta/presentations | https://raw.githubusercontent.com/DieracDelta/presentations/master/polylux/book/src/dynamic/alternatives-match.typ | typst | #import "../../../polylux.typ": *
#set page(paper: "presentation-16-9")
#set text(size: 50pt)
#polylux-slide[
#alternatives-match((
"1, 3-5": [this text has the majority],
"2, 6": [this is shown less often]
))
]
|
|
https://github.com/RyushiAok/iml-resume-typst | https://raw.githubusercontent.com/RyushiAok/iml-resume-typst/main/README.md | markdown | # iml-resume-typst
```sh
cd resume
typst watch --font-path c:\Windows\Fonts main.typ
```
|
|
https://github.com/tingerrr/chiral-thesis-fhe | https://raw.githubusercontent.com/tingerrr/chiral-thesis-fhe/main/src/core/styles.typ | typst | #import "/src/utils.typ" as _utils
// TODO: separate optional and mandatory styling, let the user control optional styling
#let _std = (
heading: heading,
raw: raw,
table: table,
figure: figure,
math: math,
bibliography: bibliography,
outline: outline,
)
#let outline(
_fonts: (:),
) = body => {
set _std.outline(fill: repeat(" . "))
show _std.outline.entry: it => {
link(it.element.location(), it.body)
[ ]
box(width: 1fr, it.fill)
[ ]
box(
width: measure[999].width,
align(right, it.page),
)
}
body
}
#let global(
draft: false,
_fonts: (:),
) = body => {
// TODO: do we provide the fonts within the scaffold?
set text(lang: "de", size: 11pt, font: _fonts.serif, fallback: false)
// move content left by 1cm in draft mode, this doesn't affect vertical layout
// and allows reviwers to place notes in the right margin
let margin = (top: 2.5cm, bottom: 2.5cm) + if draft {
(right: 5cm, left: 2cm)
} else {
(inside: 4cm, outside: 3cm)
}
// add a watermark to the background which cannot be selected as text
let background = if draft {
set align(center + horizon)
set text(gray.lighten(85%), 122pt)
rotate(-45deg, image("/assets/images/draft-watermark.svg"))
}
set page("a4", margin: (inside: 4cm, outside: 3cm, top: 2.5cm, bottom: 2.5cm), background: background)
body
}
#let content(
_fonts: (:),
) = body => {
// number headings up to depth 4
show _std.heading.where(level: 1): set _std.heading(numbering: "1.1", supplement: [Kapitel])
show _std.heading.where(level: 2): set _std.heading(numbering: "1.1")
show _std.heading.where(level: 3): set _std.heading(numbering: "1.1")
show _std.heading.where(level: 4): set _std.heading(numbering: "1.1")
// turn on justification eveyrwhere except for specific elements
set par(justify: true)
// show list: set par(justify: false)
// show enum: set par(justify: false)
// show terms: set par(justify: false)
show table: set par(justify: false)
show _std.raw.where(block: true): set par(justify: false)
// NOTE: this currently interferes due to a lack style rules revoking support
// show links in eastern
// show link: text.with(fill: eastern)
// always use quotes
show quote.where(block: true): set quote(quotes: true)
// show attribution also for inline quotes
show quote.where(block: false): it => {
["#it.body"]
let attr = it.attribution
if type(attr) == label {
attr = cite(it.attribution)
}
[ ]
attr
}
body
}
#let heading(_fonts: (:)) = body => {
// add pagebreaks on chapters
show _std.heading.where(level: 1): it => pagebreak(weak: true) + it
// allow users to use the syntax sugar for sections, but disable this for elemens which
// produce their own headings
set _std.heading(offset: 1)
// other mandated style rules
show _std.heading: set block(above: 1.4em, below: 1.8em)
show _std.heading: set text(font: _fonts.sans)
// show outline headings, show them without offset
show _std.outline: set _std.heading(outlined: true, offset: 0)
body
}
#let raw(theme: none, _fonts: (:)) = body => {
set _std.raw(theme: theme) if theme != none
// use the specified mono font
show _std.raw: set text(font: _fonts.mono)
show _std.raw.where(block: true): set block(
width: 100%,
inset: 1em,
stroke: (top: black + 0.5pt, bottom: black + 0.5pt),
)
// add outset line numbers
show _std.raw.where(block: true): it => {
show _std.raw.line: it => {
let num = [#it.number]
box(height: 1em, {
place(left, dx: -(measure(num).width + 1.5em), align(right, num))
it
})
}
it
}
// TODO: for as long as we can't remove styles easily, this will make fletcher diagrams look horrible
// inline raw gets a faint light gray background box to be easier to distinguish
// show _std.raw.where(block: false): it => box(
// fill: gray.lighten(75%),
// inset: (x: 0.25em),
// outset: (y: 0.25em),
// radius: 0.25em,
// it,
// )
body
}
#let table() = body => {
// the page header gets strong text and gets the a bottom hline
show _std.table.cell.where(y: 0): strong
set _std.table(stroke: (_, y) => if y == 0 {
(bottom: 0.5pt)
})
// add a stronger top and bottom hline
show _std.table: block.with(stroke: (bottom: black, top: black))
body
}
#let figure(kinds: (image, raw, table), _fonts: (:)) = body => {
// default to 1-1 numbering
set _std.figure(numbering: n => _utils.chapter-relative-numbering("1-1", n))
// use no gap
set _std.figure(gap: 0pt)
// reset all figure counters on chapters
show _std.heading.where(level: 1): it => {
kinds.map(k => counter(_std.figure.where(kind: k)).update(0)).join()
it
}
// allow all figures to break by default
show _std.figure: set block(breakable: true)
// caption placement is generally below for unknown kinds and images, but above for tables,
// listings and equations, while equations are generally not put into figures, they do have
// specific stylistic rules
show _std.figure: it => {
let body = block(width: 100%, {
if _std.figure.caption.position == top and it.caption != none {
align(left, it.caption)
v(it.gap)
}
align(center, it.body)
if _std.figure.caption.position == bottom and it.caption != none {
v(it.gap)
align(left, it.caption)
}
})
if it.placement == auto {
place(it.placement, float: true, body)
} else if it.placement != none {
place(it.placement, body)
} else {
body
}
}
set _std.figure.caption(position: bottom)
show _std.figure.where(kind: _std.raw): set _std.figure.caption(position: top)
show _std.figure.where(kind: _std.table): set _std.figure.caption(position: top)
show _std.figure.where(kind: math.equation): set _std.figure.caption(position: top)
// equations are numbered 1.1
show _std.figure.where(kind: math.equation): set _std.figure(
numbering: n => _utils.chapter-relative-numbering("1.1", n),
)
// captions are generally emph and light gray and in a sans serif font
show _std.figure.caption: emph
show _std.figure.caption: set text(fill: gray, font: _fonts.sans)
body
}
#let math() = body => {
// default to 1.1 numbering
set _std.math.equation(numbering: n => _utils.chapter-relative-numbering("(1.1)", n))
// reset equation counters on chapters
show _std.heading.where(level: 1): it => counter(_std.math.equation).update(0) + it
// use bracket as default matrix delimiter
set _std.math.mat(delim: "[")
body
}
#let bibliography() = body => {
// use alphanumeric citation style, not ieee
set cite(style: "alphanumeric")
// BUG: this prevents the formation of cite groups
// show only the alphanumeric id of the citation in purple and don't ignore the supplement
show cite.where(form: "normal"): it => {
"["
text(purple, cite(form: "full", it.key))
if it.supplement != none {
[, ]
it.supplement
}
"]"
}
// apply the same style within the bibliography back references
show _std.bibliography: it => {
let re = regex("\[(\w{2,3}\+?\d{2})\]")
show re: it => {
let m = it.text.match(re)
"["
text(purple, m.captures.first())
"]"
}
it
}
body
}
|
|
https://github.com/ludwig-austermann/typst-din-5008-letter | https://raw.githubusercontent.com/ludwig-austermann/typst-din-5008-letter/main/examples/nice_defaults.typ | typst | MIT License | #import "../letter.typ" : letter, letter-styling, block-hooks, debug-options
#let styling-options = letter-styling(
text-params: (lang: "en"),
hole-mark: false,
theme-color: green.darken(40%),
)
#let block-hooks = block-hooks(
letter-head: pad(10mm)[To be found at #link("https://github.com/ludwig-austermann/typst-din-5008-letter")],
footer: [some random footer],
subject: (content, styling: (:), extras: (:)) => {
set align(center)
set text(styling.theme-color)
strong(content)
}
)
#show: letter.with(
title: "subject of this letter",
return-information: [@name, somewhere],
address-zone: [recipient name\ recipient address],
information-field: grid(columns: 2, column-gutter: 5mm, row-gutter: 6pt)[Sender:][@name][Address:][sender address][][][][][][][][][][][Date:][@date],
name: "<NAME>",
styling-options: styling-options,
block-hooks: block-hooks,
wordings: "en-formal",
)
#for i in (3, 12, 1) {
lorem(10*i)
parbreak()
}
|
https://github.com/AHaliq/CategoryTheoryReport | https://raw.githubusercontent.com/AHaliq/CategoryTheoryReport/main/main.typ | typst | #import "preamble/style.typ"
#import "preamble/lemmas.typ": *
#show: style.setup.with(
"Category Theory",
"<NAME> <NAME>",
authorid: "202303466",
subtitle: "Projektarbejde i Datalogi 10ECTS (E24.520202U002.A)",
preface: [This report is written for the course on Category Theory undertaken as a project module: "Projektarbejde i Datalogi 10ECTS (E24.520202U002.A)", under the supervision of <NAME> and <NAME> in Aarhus University as part of a MSc Computer Science program.],
bibliography: bibliography("refs.bib"),
)
// ------------------------------------------------------------
#include "chapters/chapter1/index.typ"
#include "chapters/chapter2/index.typ"
#include "chapters/chapter3/index.typ"
#include "chapters/chapter4/index.typ"
#include "chapters/chapter5/index.typ"
#include "chapters/appendix.typ" |
|
https://github.com/mrknorman/evolving_attention_thesis | https://raw.githubusercontent.com/mrknorman/evolving_attention_thesis/main/09_conclusion/09_conclusion.typ | typst | = Conclusion <conclusion-sec>
Gravitational wave science will soon graduate from its infancy and into the routine. One could be forgiven for thinking that the most exciting days are behind us and that all that remains is an exercise in stamp collecting --- perhaps it will be a useful project to map the features of the universe, but not one that will reveal any deep fundamental truths. I think such a statement would be premature. Given the sensitivity that may be within our grasp with next-generation detectors as well as promising upgrade paths for current-generation interferometers, I think there will be ample opportunity for us to stumble upon something unexpected, or to find something we always anticipated would be there if we just looked hard enough. That being said, if we wish to one day make these discoveries, we need to continually improve the toolset with which we look, both in hardware and software. We must improve all aspects of our search pipelines with a focus on efficiency, in order that we do not lose momentum and with it public and government support. I believe that the use of machine learning will be crucial to this end, due to its flexibility and its power to be employed in domains wherein exact specifications of the problem are difficult. That being said, caution is advised when applying machine learning techniques to problems. More effort should be employed to review the possibilities within traditional data analysis techniques before jumping into machine learning solutions.
In recent years, there has been a scramble to utilise artificial neural networks for gravitational-wave data analysis, and many papers have applied many different techniques and utilised many different, sometimes flawed, validation schemes which are oftentimes divorced from the reality of detection and parameter estimation problems within a real live detection environment. This vast multitude of techniques presented by the literature ensures that it is difficult to build a picture of what specific techniques are effective, and which are not. The field suffers from a lack of standardised pipelines and comparative metrics with which to compare methods. This PhD had been an attempt to slightly ameliorate that problem, primarily by developing the GravyFlow library, and using it to attempt a more robust hyperparameter optimisation framework, as well as investigate the application of the attention mechanism for two problems in gravitational wave data analysis, CBC detection and overlapping waveform detection and parameter estimation. This chapter serves as a summary of the main results of each chapter of this thesis, and concludes with suggested future work that could further advance the ideas presented here.
== Chapter Summaries
In this subsection, we will go over the main results of each chapter and explain the scope of the work performed. @intro-sec, @gravitational-waves-sec, and @machine-learning-sec are omitted as these are introductory chapters and do not contain any results. They present a general introduction to the thesis, an introduction to gravitational wave science, and an introduction to machine learning techniques respectively.
=== #link(<application-sec>)[Application Summary]
@application-sec does not present novel work. Rather, it attempts an explanation of the methodology used throughout the thesis, a review of existing techniques, and recreates some of those existing techniques to act as a baseline for comparison of other architectures. In this chapter, we show that dense-layer neural networks are not sufficient to solve the detection problem within the criteria outlined for live detection pipelines by the LIGO-VIRGO-Kagra collaboration. We introduce Convolutional Neural Networks (CNNs) and review the literature that has previously applied this architecture to the detection. We then recreate some standout results from the literature and show that these models come much closer to approaching that of matched filtering, the current standard detection method. We comment that the need for a low false alarm rate remains the most significant barrier to the conversion of such methods into a working pipeline.
=== #link(<dragonn-sec>)[Dragonn Summary]
@dragonn-sec presents original work. In this chapter, we utilise genetic algorithms in order to optimise the hyperparameters of CNNs used for the CBC detection problem. Due to time constraints, we are not able to run the optimiser for as many generations as was hoped, and thus we do not achieve significant results other than a demonstration of the application of the optimisation method. Dispite the dissapointing performance, the optimisation does offer
=== #link(<skywarp-sec>)[Skywarp Summary]
=== #link(<crosswave-sec>)[CrossWave Summary]
== Future Work
NoiseNet
UniCron
|
|
https://github.com/bejaouimohamed/labs-EI2 | https://raw.githubusercontent.com/bejaouimohamed/labs-EI2/main/Lab%20%234%20ROS2%20using%20RCLPY%20in%20Julia/Lab-4.typ | typst | #import "Class.typ": *
#show: ieee.with(
title: [#text(smallcaps("Lab #4: ROS2 using RCLPY in Julia"))],
/*
abstract: [
#lorem(10).
],
*/
authors:
(
(
name: "<NAME>",
department: [Dept. of EE],
organization: [ISET Bizerte --- Tunisia],
profile: "bejaouimohamed",
),
(
name: "<NAME>",
department: [Dept. of EE],
organization: [ISET Bizerte --- Tunisia],
profile: "Gharbijamila",
),
)
// index-terms: (""),
// bibliography-file: "Biblio.bib",
)
= Introduction
In this report, we will explain how we have use Julia and ROS2 to create a basic ROS 2 communication setup where one node publishes messages and another node subscribes to those messages on a specified topic.
This allows for data exchange between different components of a robotic system or between multiple robotic systems.
= Creation of the publisher :
== Installation of ROS2 and writing code :
We begin first of all by sourcing our ROS2 installation by writing this command in the terminal :
```zsh
source /opt/ros/humble/setup.zsh
```
After that , we create a first julia file named *publisher* and we write this commands as shown in code below :
#let publisher=read("../Codes/ros2/publisher.jl")
#let subscriber=read("../Codes/ros2/subscriber.jl")
#raw(publisher, lang: "julia")
This code essentially simulates a ROS 2 talker node in Julia, where it continuously publishes messages to a specific topic at a certain frequency.
== Explanation of the code :
In This part , we will explain what that code does from the begining to the end :
+ It imports the necessary modules from ROS 2 Python (rclpy and std_msgs.msg).
+ Initializes the ROS 2 runtime
+ Creates a ROS 2 node named *"my_publisher"*
+ Creates a publisher for the "infodev" topic with a message type of String.
+ Enters a loop to publish message to the topic in a range from 1 to 100.
+ Constructs the public message with the format *"Hello, ROS2 from Julia!"* where i is the current loop iteration.
+ Publishes the message to the topic.
+ Logs the published message using info .
+ Sleeps for 1 second before the next iteration
+ Cleans up by shutting down the ROS 2 runtime and destroying the node
Some of the commands can give us some informations about :
- The topic *"infodev"*
```zsh
pub = node.create_publisher(str.String,
"infodev", 10)```
- The name of publisher *"my_publisher"*:
```zsh
node = rclpy.create_node("my_publisher")
```
- Message published *"Hello, ROS2 from Julia!"*
```zsh
msg = str.String(data="Hello, ROS2 from Julia!
($(string(i)))")
```
= Creation of the subscriber :
== Writing code :
Now , we create a second julia file named subscriber and we write this commands as shown in code below :
#raw(subscriber, lang: "julia")
This code creates a subscriber node in Julia that listens for messages on a specific topic in the ROS 2 system.
== Explanation of the code :
We will explain the code like we do with the first one :
- It imports the necessary ROS 2 modules (rclpy and std_msgs.msg) using PyCall and initializes the ROS 2 runtime environment.
- Creates a ROS 2 node named *"my_subscriber"*
- Defines a callback function named callback to process received messages. The function prepends *"[LISTENER] I heard: "* to the received message
- Sets up a subscription for the "infodev" topic, specifying the message type String and the callback function to handle received messages.
- Enters a loop that runs as long as the ROS 2 system is operational.
- When a message is received on the "infodev" topic, the 'callback' function is invoked to handle the message
- Once the loop exits (e.g., when the ROS 2 system shuts down), the node is destroyed to release its associated resources.
- Finally, the ROS 2 runtime environment is shut down.
without explain this command :
```zsh
node = rclpy.create_node("my_subscriber")
```
We can have the name of the subscriber which is *"my_subscriber"*
= Running the two codes :
Firstly , we start by launching The graphical tool rqt_graph by writing down this line to let the data fow between the publisher and subscriber by link it bouth of them to a node called
“infodev” like showing figure 1
```zsh
source /opt/ros/humble/setup.zsh
rqt_graph
```
#figure(
image("Images/rqt_graph.png", width: 100%),
caption: "rqt_graph",
) <fig:rqt_graph>
After, opening and running the two codes "publisher.jl" and "subscriber.jl" in the correct way and we obtain this result in the terminal :
#figure(
image("Images/pub-sub.png", width: 100%),
caption: "Minimal publisher/subscriber in ROS2",
) <fig:pub-sub>
@fig:pub-sub shows the publication and reception of the message *_"Hello, ROS2 from Julia!"_* in this terminal. The left part of the terminal shows us the message being published, while the right part demonstrates how the message is being received and heard.
we also can have the numbers of publshing and receiving the message which is one hundred times .
|
|
https://github.com/dainbow/MatGos | https://raw.githubusercontent.com/dainbow/MatGos/master/themes/26.typ | typst | #import "../conf.typ": *
= Самосопряжённые преобразования евклидовых пространств, свойства их собственных значений и собственных векторов.
#definition[
Пусть $phi: U -> V$ -- линейное отображение, $e = (bold(e_1), ..., bold(e_k))$ -- базис
в $U$, $cal(F) = (bold(f_1), ..., bold(f_n))$ -- базис в $V$.
*Матрицей отображения* $phi$ в базисах $e$ и $cal(F)$ называется матрица $A in M_(n times k) (FF)$ такая,
что
#eq[
$(phi(bold(e_1)), ..., phi(bold(e_k))) = cal(F) A$
]
]
#definition[
*Билинейной формой* на $V$ называется функция $b: V times V -> FF$, линейная по
обоим аргументам.
Множество всех билинейных форм на $V$ обозначается через $cal(B)(V)$.
]
#definition[
*Матрицей формы* $b in cal(B)(V)$ в базисе $(bold(e_1), ..., bold(e_n)) =: e$ называется
следующая матрица $B$:
#eq[
$B = (b(bold(e_i), bold(e_j)))_(i, j = 1)^n$
]
Обозначение $b <->_e B$
]
#definition[
Пусть $b in cal(B)(V)$.
Форма $b$ называется *симметрической*, если
#eq[
$forall bold(u), bold(v) in V : space b(bold(u), bold(v)) = b(bold(v), bold(u))$
]
Пространство симметрических форм на $V$ обозначается через $cal(B)^+ (V)$
]
#definition[
Пусть $b in cal(B)(V)$.
Форма $b$ называется *кососимметрической*, если выполнены следующие условия;
+ #eq[
$forall bold(u), bold(v) : space b(bold(u), bold(v)) = -b(bold(v), bold(u))$
]
+ $forall bold(u) in V : space b(bold(u), bold(u)) = 0$
]
#definition[
*Квадратичной формой*, соответствующей форме $b in cal(B)(V)$, называется
функция $h : V -> FF$ такая, что
#eq[
$forall bold(v) in V : h(bold(v)) = b(bold(v), bold(v))$
]
Квадратичные формы на $V$ образуют линейное пространство над $FF$, обозначаемое
через $cal(Q)(V)$
]
#definition[
Пусть $h in cal(Q)(V)$. Тогда $h$ называется
- *Положительно определённой*, если $forall bold(v) in V : bold(v) != bold(0) : space h(bold(v)) > 0$
- *Положительно полуопределённой*, если $forall bold(v) in V : bold(v) != bold(0) : space h(bold(v)) >= 0$
- *Отрицательно определённой*, если $forall bold(v) in V : bold(v) != bold(0) : space h(bold(v)) < 0$
- *Отрицательно полуопределённой*, если $forall bold(v) in V : bold(v) != bold(0) : space h(bold(v)) <= 0$
]
#definition[
*Полуторалинейной формой* на $V$ называется функция $b : V times V -> CC$ такая,
что
+ $b$ линейна по первому аргументу
+ $b$ сопряжённо-линейна по второму аргументу
Полуторалинейные формы на $V$ образуют линейное пространство над $FF$,
обозначаемое через $cal(S)(V)$.
]
#definition[
*Матрицей формы* $b in cal(S)(V)$ в базисе $(bold(e_1), ..., bold(e_n)) =: e$ называется
следующая матрица $B$:
#eq[
$B = (b(bold(e_i), bold(e_j)))_(i, j = 1)^n$
]
Обозначение $b <->_e B$
]
#definition[
Пусть $b in cal(S)(V)$.
Форма $b$ называется *эрмитовой*, если
#eq[
$forall bold(u), bold(v) in V : space b(bold(u), bold(v)) = overline(b(bold(v), bold(u)))$
]
Матрица $B in M_n (CC)$ называется *эрмитовой*, если $B^T = overline(B)$, или $B = B^*$,
где $B^* := overline(B^T)$ -- *эрмитово сопряжённая* к $B$ матрица.
]
#definition[
*Евклидовым* пространством называется линейное пространство $V$ над $RR$, на
котором определена положительно определённая симметрическая билинейная форма $(dot, dot)$ -- *скалярное произведение*
]
#definition[
*Эрмитовым* пространством называется линейное пространство $V$ над $CC$, на
котором определена положительно определённая эрмитова форма $(dot, dot)$ -- *эрмитово скалярное произведение*
]
#definition[
Пусть $phi in cal(L)(V)$.
Для всех $bold(u), bold(v) in V$ положим
#eq[
$f_phi (bold(u), bold(v)) := (phi(bold(u)), bold(v)) ; quad g_phi (bold(u), bold(v)) := (bold(u), phi(bold(v)))$
]
]
#definition[
Пусть $phi in cal(L)(V)$.
Оператором, *сопряжённым* к $phi$ называется оператор $phi^* in cal(L)(V)$ такой,
что $f_phi = g_(phi^*)$.
]
#definition[
Оператор $phi in cal(L)(V)$ называется *самосопряжённым*, если $phi^* = phi$.
]
#proposition[
Пусть $phi in cal(L)(V)$ -- самосопряжённый. Тогда его характеристический
многочлен $chi_phi$ раскладывается на линейные сомножители над $RR$.
]
#proof[
Пусть $V$ -- евклидово пространство с ортонормированным базисом $e$, тогда $phi_e <-> A in M_n (RR), A = A^T$.
Рассмотрим $U$ -- эрмитово пространство той же размерности с ортонормированным
базисом $cal(F)$ и оператор $psi in cal(L)(U), psi <->_cal(F) A$.
Если $V$ изначально эрмитово, то ничего не делаем и сразу рассматриваем данный
оператор.
Тогда $psi$ -- тоже самосопряжённый, имеющий одинаковый характеристический
многочлен с $phi$.
Пусть $lambda in CC$ -- корень $chi_psi$. Тогда cуществует соотвествующий ему
собственный вектор $bold(u) in U$, причём
#eq[
$lambda norm(bold(u))^2 = (psi(bold(u)), bold(u)) = (bold(u), psi(bold(u))) = overline(lambda) norm(u)^2 => lambda = overline(lambda) => lambda in RR$
]
]
#proposition[
Пусть $phi in cal(L)(V)$ -- самосопряжённый, $lambda_1, lambda_2 in RR$ -- два
различных собственных значения $phi$. Тогда $V_(lambda_1) bot V_(lambda_2)$
]
#proof[
Пусть $bold(v_1) in V_(lambda_1); bold(v_2) in V_(lambda_2)$. Тогда
#eq[
$lambda_1(bold(v_1), bold(v_2)) = (phi(bold(v_1)), bold(v_2)) = (bold(v_1), phi(bold(v_2))) = lambda_2 (bold(v_1), bold(v_2)) => (bold(v_1), bold(v_2)) = 0$
]
]
|
|
https://github.com/wenjia03/JSU-Typst-Template | https://raw.githubusercontent.com/wenjia03/JSU-Typst-Template/main/Templates/实验报告(无框）/index.typ | typst | MIT License | // 封面
#include "template/cover.typ"
// 目录
// #include "template/toc.typ"
// 正文
#include "template/body.typ"
|
https://github.com/fabriceHategekimana/master | https://raw.githubusercontent.com/fabriceHategekimana/master/main/3_Theorie/C3PO.typ | typst | #import "../src/module.typ" : *
#pagebreak()
= Système C3PO
Jusqu'à présent nous avons parlé de modèles de calcul déjà existant et abordé leur particularités fondamentales et leur apport à notre langage prototype. Nous allons maintenant commencer à explorer des routes un peu plus aventureuses et rendre le design de ce prototype plus personnalisé pour notre problème. En partant des fondements du système F, nous pouvons maintenant entreprendre d'incorporer des extensions afin d'accroître l'expressivité du langage, dans le dessein de faciliter la manipulation de structures de données complexes, notamment des tableaux multidimensionnels.
Le prototype final s'appelle C3PO suite aux différentes transformations que nous avons apportées au système F.
#pagebreak()
#Exemple[Tableau récapitulatif de l'évolution du lambda calcul jusqu'au système C3PO
#table(
columns: (auto, auto),
inset: 10pt,
align: horizon,
table.header(
[*Langage*], [*Fonctionnalité ajouté*],
),
"lambda caclul", "computation",
"lambda calcul simplement typé", "typage",
"système F", "génériques",
"système R", "int, bool, opérateurs de base, if...then...else",
"système R2", "context",
"système R2D", "types dépendants sur les entiers positifs",
"système R2D2", "fonctions générales",
"système C3PO", "tableaux",
)
]
// Arithmétique de Presburger
// https://fr.wikipedia.org/wiki/Arithm%C3%A9tique_de_Presburger
Nous allons aborder les modifications présentées dans le tableau à partir du système R.
== Système R
Le système R est juste une première tentative pour amener des éléments plus communs en programmation et avec lesquels nous allons développer notre prototype. Le but n'est pas d'imiter entièrement le langage de programmation R mais de prendre le minimum pour faire nos calculs. C'est pourquoi nous choisissons les deux types `int` et `bool` qui ont chacun leur rôle. Il est possible d'émuler ces valeurs à l'aide des éléments du système F mais c'est beaucoup plus pratique de travailler avec des valeurs plus communes.
Les nombre entiers positifs `int` vont nous permettre d'avoir une base minimum pour faire des calculs. C'est pourquoi nous ajoutons les opérateurs d'addition et de multiplication pour ne pas tomber sur des nombres à virgules ou des nombres négatifs.
#Definition()[Le type de base "int"
$ #proof-tree(eval("NUM",
$Delta tack.r "n" --> "n"$)) $
$ #proof-tree(eval("PLUS",
$Delta tack.r "E1" + "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" + "E2p" --> "E3"$)) $
$ #proof-tree(eval("TIME",
$Delta tack.r "E1" * "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" * "E2p" --> "E3"$)) $
]
Les booléens se comportent aussi de la même façon que dans les langages de programmations classiques comme python. Ils s'appuient aussi sur l'arithmétique classique.
#Definition([Le type de base "bool"
$ #proof-tree(eval("BOOL-T",
$Delta tack.r "true" --> "true"$)) $
$ #proof-tree(eval("BOOL-F",
$Delta tack.r "false" --> "false"$)) $
$ #proof-tree(eval("AND",
$Delta tack.r "E1" "and" "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1" sect "E2" --> "E3"$)) $
$ #proof-tree(eval("OR",
$Delta tack.r "E1" "or" "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1" union "E2" --> "E3"$)) $
])
Les booléens vont nous permettre d'ajouter de la logique à notre code et à simplifier le traitement conditionnel impliqué par le contrôle de flux `if...then..else` qui est un opérateur ternaire. Ce choix nous permet d'avoir une structure régulière capable d'émuler des `else if` par imbrication de contrôle de flux `ìf...then...else`.
#Definition([Les conditions
$ #proof-tree(eval("IF-T",
$Delta tack.r "if" "E1" "then" "E2" "else" "E3" --> "E2"$,
$Delta tack.r "E1" --> "true"$)) $
$ #proof-tree(eval("IF-F",
$Delta tack.r "if" "E1" "then" "E2" "else" "E3" --> "E3"$,
$Delta tack.r "E1" --> "false"$)) $
])
Il nous faut aussi des opérateurs de base pour faire des testes logique. Ces opérateurs marcherons principalement pour les entiers car c'est le cas qui nous intresse le plus. L'opérateur d'égalité marchera pour tout les types (primitifs ou structure) du moment que les deux membre de l'opération sont du même type. Il est à noté qu'on pourra utiliser les opérateurs "and" ou "or" pour créer des combinaisons de propriété plus complexes.
#Definition([Les opérateurs de bases pour les conditions
$ #proof-tree(eval("EQ",
$Delta tack.r "E1" == "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" == "E2p" --> "E3"$)) $
$ #proof-tree(eval("LOW",
$Delta tack.r "E1" < "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" < "E2p" --> "E3"$)) $
$ #proof-tree(eval("GRT",
$Delta tack.r "E1" > "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" > "E2p" --> "E3"$)) $
$ #proof-tree(eval("LOW-EQ",
$Delta tack.r "E1" <= "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" <= "E2p" --> "E3"$)) $
$ #proof-tree(eval("GRT-EQ",
$Delta tack.r "E1" >= "E2" --> "E3"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta tack.r "E2" --> "E2p"$,
$Delta tack.r "E1p" >= "E2p" --> "E3"$)) $
])
On a maintenant un noyau qui nous donne la capacité de faire des opérations sur des ensembles de valeurs définis. Ce qui va nous permettre de traiter avec des opérations plus complexes.
== Système R2
Bien que le système R nous donne plus de souplesse et de flexibilité dans nos calculs, nous pouvons toujours finir avec des représentations énormes car nous n'avons pas la possibilité de stocker temporairement des valeurs dans des variables. C'est pourquoi nous introduisons l'expression `let ... in ...`. Ce mécanisme va forcer le développement d'un contexte d'évaluation.
Il nous faut aussi une règle qui permet de vérifier que l'appel d'une variable est bel et bien valide, à savoir, que nous pouvons faire référence à une variable uniquement si elle a été préalablement définit à l'aide du mot clé "let". Nous pouvont faire ceci en créant la règle "VAR".
#Definition([Définition des variable et du contexte
$ #proof-tree(eval("LET",
$Delta tack.r "let" x: T = "E1" "in" "E2" --> "E2p"$,
$Delta tack.r "E1" --> "E1p"$,
$Delta, "x" = "E1p" tack.r "E2" --> "E2p"$
)) $
$ #proof-tree(eval("VAR",
$Delta tack.r "x" --> "E"$,
$Delta tack.r "x" = E$,
)) $
])
#pagebreak()
== Système R2D
Le système R2D va nous permettre d'introduire les types dépendants.
Les types dépendants sont des types qui dépendent de valeurs, ce qui permet d'exprimer des invariants et des contraintes plus précises directement dans le système de types. Par exemple, un vecteur de longueur n pourrait avoir un type qui dépend de n, garantissant que seules les opérations valides pour cette longueur sont permises. Cependant, les types dépendants peuvent involontairement devenir un obstacle pour les critères de notre langage. L'introduction de types dépendants rendent l'inférence de type indécidable. C'est pourquoi il est nécessaire de restreindre ses capacités. Ceci peut être fait avec l'arithmétique de Presburger.
L'arithmétique de Presburger est une théorie de l'arithmétique des entiers naturels avec l'addition, introduite par <NAME> en 1929. Elle se distingue par sa décidabilité : il existe un algorithme qui peut déterminer si une proposition donnée dans cette théorie est vraie ou fausse. Cette propriété en fait un outil précieux en informatique, en particulier dans le domaine des types dépendants.
Grâce à l'arithmétique de Presburger, on peut formaliser et vérifier des propriétés comme la somme des longueurs de deux tableaux, ou la relation entre les indices dans une matrice, directement dans le système de types. Cela augmente la capacité du compilateur à détecter les erreurs à la compilation, avant même que le programme ne soit exécuté. En outre, cela aide à garantir la correction des programmes en prouvant mathématiquement des propriétés essentielles du code.
Afin de pouvoir accueillir des génériques ainsi que des types dépendants. Nous avons la nécessité de définir un système limité et simplifié.
Avec le contexte défini, nous avons la capacité de créer des variables adoptant un certain type. La règle *VAR* permet de vérifier l'assignation d'une variable si elle est présente dans le contexte. Le term *let* illustré par la règle *T-LET* permet la création desdites variables. Si les types de l'assignation correspondent, l'expression finale retourne un certain type.
#Definition([Context pour les types et les génériques
$ #proof-tree(typing("T-LET",
$Gamma tack.r "let" "x": "T1" = "E1" "in" "E2" : "T2"$,
$Gamma tack.r "E1" : "T1"$,
$Gamma tack.r "x" : "T1" "E2" : "T2"$
)) $
$ #proof-tree(typing("VAR",
$Gamma tack.r "x": sigma$,
$Gamma tack.r "x": sigma$
)) $
])
== Système R2D2
Jusqu'à présent les fonctions étaient représentées par des lambda et se décomposaient en deux types: Les abstractions lambda, et les abstractions de type. La plupart du temps, nous sommes obligés de faire la composition des deux pour créer des fonctions génériques. C'est pourquoi l'usage d'une représentation qui combine ces deux notions sera plus facile à traiter. Nous introduisons le concept de fonctions génériques. Cette fonction permet de combiner plusieurs génériques et plusieurs paramètres en un coup et donc énormément simplifier la création de fonction en bloc.
Bien sûr, on peut toujours définir des fonctions sans générique, il suffit juste de laisser le champ des génériques vide. De même, si on ne veut pas de paramètre, on peut laisser le champ des paramètres vides. On peut créer des fonctions de cette forme:
#Exemple()[Création d'une simple fonction
```R
func<>(){7}
```
]
Comme mentionné précédemment, les fonctions sont l'un des outils les plus puissants et sophistiqués de ce langage, le but étant de pouvoir sécuriser les opérations sur des tableaux multidimensionnels. Ici, les fonctions peuvent admettre des génériques en plus des types sur chaque paramètre.
#Definition()[Typage de fonction
$ #proof-tree(typing("T-FUNC",
$Gamma tack.r "func"< overline( "a")>( overline( "x":"T")) -> "T" { "E" } : (( overline( "T")) -> "T")$,
$Gamma , overline( "x":"T") tack.r "E" : "T"$
)) $
]
Ces génériques peuvent être réservés pour contenir des types ou des valeurs et ainsi créer des fonctions spécifiques. On peut le voir quand à l'application de fonction.
#Definition()[Typage d'une application de fonction
$ #proof-tree(typing("T-FUNC-APP",
$("E1")< overline("g")>( overline( "E")) : "T"$,
$Gamma tack.r "E1" : <overline(a)>(overline( "T")) -> "T"$,
$[overline("a") \/ overline("g")]overline("T") => overline("Tp")$,
$Gamma tack.r overline("E") : overline("Tp")$)) $
]
== Système C3PO
Toutes ces fonctionnalités ont été introduites afin de favoriser la création et l'emploi de tableaux multidimensionnels. C'est pourquoi le dernier élément manquant n'est autre que la notion de tableau. Ici un tableau n'est autre qu'une liste d'éléments du même type avec une longueur déterminée.
Comme nous le verrons plus loin, l'élaboration de tableaux multidimensionnels se fera par la combinaison de plusieurs tableaux.
|
|
https://github.com/rousbound/typst-lua | https://raw.githubusercontent.com/rousbound/typst-lua/main/tests/templates/test_json.typ | typst | Apache License 2.0 | #set text(font: "New Computer Modern")
-- JSON: Nested Object
Hello #_LUADATA.json.at("nested_object").at("key")\
-- JSON:Arr.json
Hello #_LUADATA.json.at("array").at(0)\
Hello #_LUADATA.json.at("array").at(1)\
-- JSON: Mix.json
Hello #_LUADATA.json.at("mixed_types").at("key1")\
Hello #_LUADATA.json.at("mixed_types").at("key2")\
Hello #_LUADATA.json.at("mixed_types").at("key3")\
|
https://github.com/Turkeymanc/notebook | https://raw.githubusercontent.com/Turkeymanc/notebook/main/main.typ | typst | #import "/packages.typ": *
// applies the template
// the show rule essentially passes the entire document into the `notebook` function.
#show: notebook.with(
team-name: "53E", // TODO: put your team name here
season: "High Stakes",
year: "2024-2025",
theme: radial-theme, // TODO: change the theme to one you like
)
#include "./frontmatter.typ"
#include "./entries/entries.typ"
#include "./appendix.typ"
|
|
https://github.com/metamuffin/typst | https://raw.githubusercontent.com/metamuffin/typst/main/tests/typ/math/content.typ | typst | Apache License 2.0 | // Test arbitrary content in math.
---
// Test images and font fallback.
#let monkey = move(dy: 0.2em, image("/monkey.svg", height: 1em))
$ sum_(i=#emoji.apple)^#emoji.apple.red i + monkey/2 $
---
// Test tables.
$ x := #table(columns: 2)[x][y]/mat(1, 2, 3)
= #table[A][B][C] $
---
// Test non-equation math directly in content.
#math.attach($a$, t: [b])
---
// Test font switch.
#let here = text.with(font: "Noto Sans")
$#here[f] := #here[Hi there]$.
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compute/foundations-16.typ | typst | Other | #show raw: it => text(font: "PT Sans", eval("[" + it.text + "]"))
Interacting
```
#set text(blue)
Blue #move(dy: -0.15em)[🌊]
```
|
https://github.com/fufexan/cv | https://raw.githubusercontent.com/fufexan/cv/typst/modules/education.typ | typst | #import "../src/template.typ": *
#cvSection("Education")
#cvEntry(
title: [Bachelor's degree in Electronics, Telecommunications and Information Technology],
society: [Technical University of Cluj-Napoca],
date: [2021 - 2025],
location: [Cluj-Napoca],
logo: "../src/logos/utcn.svg",
description: list(),
)
#cvEntry(
title: [High school diploma in Mathematics & Informatics],
society: [Titu Maiorescu National College],
date: [2017 - 2021],
location: [Aiud],
logo: "../src/logos/cntm.png",
description: list(),
)
|
|
https://github.com/Dherse/ugent-templates | https://raw.githubusercontent.com/Dherse/ugent-templates/main/masterproef/parts/preface.typ | typst | MIT License | #import "../ugent-template.typ": *
#show: ugent-preface
= Remark on the master's dissertation and the oral presentation
This master's dissertation is part of an exam. Any comments formulated by the assessment committee during the oral
presentation of the master's dissertation are not included in this text.
= Acknowledgements <sec_ack>
Here you will include your acknowledgements, don't forget to first thank your promoter(s) followed by your supervisor(s).
#align(right)[
-- Your Name \
Place, Date
]
= Permission of use on loan
The author gives permission to make this master dissertation available for consultation and to
copy parts of this master dissertation for personal use. In the case of any other use, the copyright
terms have to be respected, in particular with regard to the obligation to state expressly the
source when quoting results from this master dissertation.
#align(right)[
-- Your Name \
Place, Date
]
= Abstract
Your short abstract goes here. Give a short summary of your work, including the main results. The abstract should be short a couple of paragraphs at most.
== Keywords
Your keywords.
#ugent-outlines(
// Whether to include a table of contents.
heading: true,
// Whether to include a list of acronyms.
acronyms: true,
// Whether to include a list of figures.
figures: true,
// Whether to include a list of tables.
tables: true,
// Whether to include a list of equations.
equations: true,
// Whether to include a list of listings (code).
listings: true,
) |
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/meta/footnote-refs_03.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Footnote ref in footnote
#footnote[Reference to next @fn]
#footnote[Reference to myself @fn]<fn>
#footnote[Reference to previous @fn]
|
https://github.com/Az-21/typst-components | https://raw.githubusercontent.com/Az-21/typst-components/main/components/code.typ | typst | Creative Commons Zero v1.0 Universal | #let code(content, background: rgb("d2f0d4"), foreground: rgb("#000000")) = box(
fill: background,
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)[#text(fill: foreground)[#raw(content)]]
/*
// @override default #raw style
#show raw.where(block: false): box.with(
fill: #rgb(#d2f0d4),
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)
*/
|
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/004%20-%20Dragon's%20Maze/009_Last%20Day.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"Last Day",
set_name: "Dragon's Maze",
story_date: datetime(day: 05, month: 06, year: 2013),
author: "<NAME>",
doc
)
#figure(image("009_Last Day/01.png", height: 40%), caption: [], supplement: none, numbering: none)
Hearth Fountain Academic was one of the most exclusive schools in Ravnica, respected for the breadth and quality of its curriculum, and unique in that it was tuition-free. Scholarships were available to all children, of any species or station, and awarded to only the brightest minds of each generation. HFA wasn't a prep school for the guilds; acclaim was earned with hard work, not zealotry, and if students weren't dedicated, they didn't last.
But this was the Last Day before summer break and, as usual, the kids got a little crazy.
Liric sat on a stone bench at the edge of the school's sculpture garden and watched as hundreds of children danced around the Hearth Fountain while it exploded with light. Most of the them wore homemade guild costumes, and the lower grades dumped colored glamours into the massive basin while the seniors shouted orders. It was his fifth year as an instructor at HFA, and this field day was as poignant as the first. No, even more so. For a single beat, his heart knifed sideways in his chest; if tonight didn't go as planned, he wouldn't be returning next year.
"Professor L! Professor L!" Liric took a deep breath and then turned. "Professor L! I have something for you; I wanted to give you this!" It was Skrygix, a goblin from his honors history class. She was running, towing her little brother with her left hand, clutching a rolled up sheet of paper in her right.
Her brother was dressed as an Az<NAME> and his painted pressboard helmet hung over his eyes. He was picking his nose. "I wan' to go to da fountain!" He pushed the helmet back.
"Okay, go play." Skrygix let him go, and he stamped off into the crowd. She called after him, "Don't get wet!" She wore a white dress with a black frock painted across the neckline, but the exclamation point was her shock of orange hair moussed up into the shape of an Orzhov aristocrat's headdress.
"I made this for you!" She punched her arm out straight and offered Liric the scroll. He took it, then unrolled it with a teacher's practiced care. It was a painting of his classroom, but with the ceiling ridiculously high, and Liric himself depicted as a bespectacled Gruul giant, crouching to fit and pointing at the board with a stick of chalk the size of a log. Liric laughed.
Skrygix smirked, but quickly looked away as Liric re-rolled the painting.
"Thank you, Skrygix, it's a good likeness. I'll have it framed, then hang it in my office here at school." He opened his bag and placed the painting inside, careful to stow it in one of the rigid compartments so that it would not bend.
"What are you doing on your break, <NAME>?"
"I'll be gone for a day or two, then back here for the rest of summer. Gardening as much as I can before it gets too hot, then preparing next year's lesson plan. Nothing exciting."
"Where are you going?"
"Hmm?"
"You said you would be gone for a couple of days." Skrygix tilted her head and studied him openly. She was tall for a goblin, tall for her age.
Liric flipped his bag closed and felt the metal catches crawl toward each other, then seal with an inaudible click. Izzet manufactured, the bag shrank its chambers and pockets around their contents and tightened across his back when jostled. It was the second-most-expensive thing he owned. Liric stood and patted Skrygix on her shoulder.
"Happy Last Day, Skrygix. Have a fun summer."
Hours later, Liric watched the sunset from the buckle of a zeppelid as it descended into the Ismeri precinct. Most of the beast's passengers stood with him at the western rail, and for a moment he imagined they saw as one: all of Ravnica's evenings beginning, drawn up like a blanket at their feet.
#figure(image("009_Last Day/02.jpg", width: 100%), caption: [], supplement: none, numbering: none)
After they anchored, Liric took his time walking the promenade. The storefronts shuttered their windows, lamps were lit, and the night traffic seeped into the streets. He had grown up here in Ismeri, and while the facades had changed, it felt more familiar than ever before. Outside a dance hall, two Rakdos bouncers compared tattoos while a dumpling vendor parked his cart. A few blocks later, a trio of toughs taunted a moa until it reared, butted one with its bronze champron, and knocked him off his feet. At the corner of 12th and Veil, Liric stopped and turned slowly in a circle. He had first kissed a girl here, Mareena, whose broad mouth and large eyes recalled something froggy, but the memory was still warm, radiant. He felt giddy. He was home.
Liric found a public bathroom and changed. His cardigan with HFA emblem went into the Izzet bag, and his gatecloak came out. In the mirror, Liric admired himself and counted backwards from eleven. When he reached zero, his reflection faded until it was nearly transparent.
On the street, the action had crested into a comfortable level of chaos, and Liric entered a building that an observer might think he chose at random. He'd never been to this exact location before, but seen from the outside, it was identical to every other operations house he'd worked from. That is, it didn't look like anything special at all. The outer door was unlocked, and when he was inside the vestibule, Liric put his hands in the pockets of his gatecloak.
His strand was there. It was a shoelace, or a ribbon, or a length of twine. The closer you looked, the more ordinary it seemed, until you stopped seeing it at all. He wound it around his wrist, and with his index finger, he traced the sign of inclusion on the inside door. The doorknob disappeared, and it opened from the opposite side.
He walked through the tenement's breakfast nook and stopped in the kitchen. To the empty room he said, "I'm here now. Where is my welcome?"
The air got brittle, and from a hidden cubby above the cabinets, an oculus appeared. It climbed down and balanced on the dishrack before hopping to the table.
#figure(image("009_Last Day/03.jpg", width: 100%), caption: [], supplement: none, numbering: none)
This was it. All of the nights spent agonizing over his plan, the tension and anxiety of the past days, everything would play out now. Liric leaned forward. The creature put its hands on his shoulders and then stared at him. It smelled salty.
As if it had always been there, the memory warden's voice whispered up through the tiled floor and into the room, a collection of saved-up kitchen noise arranged as a question.
"Have you brought a puzzle?"
"No," Liric answered, "I didn't." Dark magics prickled on his skin, and his strand buzzed, squirmed against his palm like a living thing, shielding him from the warden's probe. He suppressed the urge to shiver.
"And why not?" The question was drawn out, a rattling of plates in the cupboard, the "not" a sound like a baby tooth dropped into a cup. Liric straightened and the oculus settled back, perched on its hind legs.
"The puzzle's done. I solved it."
There was a terrifying pause before the warden laughed, soullessly. "Have it your way, agent."
Relief washed over him: he hadn't been recognized. In the corner, where there had been a broom, there was now a narrow flight of stairs, leading down.
At the bottom, the Dimir interpreter sat with his back to the door, manipulating the wall of sand. Built from an uncountable number of memories, the wall recalled past events from all the perspectives it contained. Liric felt tingly and detached, as he always did in the wall's presence. Some essential part of him was suddenly missing. He was a doll, in a world of dolls, performing a mechanical pantomime of life. #emph[These memories aren't mine] , Liric told himself. Yet still, looking into the dollhouse through the wall of sand, was the interpreter.
Liric cleared his throat. The hands that drew endless patterns and sigils in the sand slowed, dropped, and then spun his chair. He was smaller than Liric remembered—not just thinner, but shrunken. The interpreter's eyes slowly focused, then widened in surprise.
"Liric? Has it been so long? How did you..." The interpreter trailed off, stumbled when he stood. They embraced, awkwardly.
"Hi Dad," Liric said. "It has been a long time."
The last time he'd seen his father outside of an operations house was when Liric had been elevated to Dimir remainder. The ceremony had taken place in a Duskmantle atrium with only his father and a guildmage present. The mage had passed a coin stamped with Lazav's likeness over Liric's strand and sealed it end to end. A symbol of the voided circle. Only agents of the highest order could use a strand transformed in this fashion; it was a talent that couldn't be taught. His father had wept with pride, overwhelmed in knowing his son would never toil like a bookkeeper in the bowels of the undercity. Liric could walk the face of Ravnica unseen, mold the city's future as the Dimir directed, and no one would ever know who he was.
But not after tonight. Seven days earlier, Liric had found the mage who performed his remainder, the only person besides his father who could possibly remember him. Liric had left the man blanked, slumped against a column in the Dinrova.
Liric smiled with genuine affection and said, gently, "Why don't you show me what you've been working on, Dad?"
"What? Huh, yes of course!" His father faced the wall again and drew out its memories. "The guilds are poised to run the Implicit Maze. We've harvested as much as we could without arousing... ah. Look here!" In the sand, an image seen through a distant arch: Niv-Mizzet, studying a model of Ravnica. The wall shifted, became an Izzet mage Liric recognized as <NAME>, laughing while an elemental pawed at the ruins of a collapsed building.
"Lazav believes there is a prize the Dimir must have." His father was excited in a way that only the wall made him. "But then there's something different here. This one, he's important too, but I haven't seen how..." A hooded figure in blue, with a confused look that was all too familiar. Liric took a step toward his father, drew his strand out between both hands, and closed his eyes.
How many minds had he stolen from, had he vanished their most private intelligences only to dump them into walls just like this one?
At first, it had made such a grotesque sort of sense. Ravnica's collective conscience was putty that he could roll flat and mold into any shape he chose. He'd been in love with the idea, the dark anonymity, the sense that he was something other, but that was over. His father would be the last, absolutely the last, and tomorrow, he would no longer be Dimir.
It was such a delicately simple thing. Liric passed the strand slowly under his thumb and a series of glyphs popped out, one by one. The scenes running through the wall trembled and swept away. His father's hands were at his sides again. He turned around and frowned.
"I'm sorry agent... I've forgotten your name. Did you come to make a deposit?"
Liric blinked several times before he was able to speak. "We've made the deposit already. I have to leave now, I'm in a rush."
The interpreter nodded, opened his mouth to say something, then closed it again when no words came. He shrugged, and sat again before the wall of sand.
Back on the street, Liric made his way toward the library then ducked into an alley. This part of the precinct was largely untraveled at night. He pulled his strand from his pocket and glanced over his shoulder, overcome with the sudden fear that he'd been followed. There was no one there.
#figure(image("009_Last Day/04.jpg", width: 100%), caption: [], supplement: none, numbering: none)
He held it before his eyes and he plucked out the beads, watched them flare and vanish until what was in his hands looked like thread. Maybe it had unwoven from a snag in his shirt. He was just a schoolteacher now. He couldn't afford expensive clothing. When he returned to Hearth Fountain Academic, he'd bury it in the garden, cover it with a stone, and plant a fern on top.
And he would hang the caricature Skrygix had painted of him on the wall of his classroom.
|
|
https://github.com/cyp0633/hnu-bachelor-thesis-typst-template | https://raw.githubusercontent.com/cyp0633/hnu-bachelor-thesis-typst-template/master/template.typ | typst | #import "frontpage.typ"
#import "authenticity.typ"
#import "abstract.typ"
#import "outlines.typ"
#import "@preview/i-figured:0.2.4"
// 页眉
#let page_header = [
#set text(font: "Source Han Serif", size: 9pt)
#align(center + bottom)[
#pad(bottom: -6pt)[湖南大学本科生毕业论文（设计）]
]
#line(length: 100%, stroke: 1pt)
#pad(top: -9.6pt)[#line(length: 100%, stroke: 0.5pt)]
]
#let setup(
// 封面内容
title_zh: "",
title_en: "",
author: "",
id:"",
class:"",
college:"",
mentor:"",
date: datetime.today(),
// 中英文摘要
abstract_zh: [],
abstract_en: [],
keywords_zh: "",
keywords_en: "",
body,
) = {
// 正文字体：中文使用思源宋体代替宋体
set text(lang: "zh", size: 11.8pt, font: ("Times New Roman", "Source Han Serif"))
// 段落：1.5 倍行距，首行缩进 2 字符
set par(first-line-indent: 2em, leading: 1.35em)
// 表格：三线表，表内居中，改为默认行间距 from: https://st1020.com/write-thesis-with-markdown-part2/
show table.cell.where(y: 0): set text(style: "normal", weight: "bold")
set table(stroke: (_, y) => if y == 0 {
(top: 1.5pt, bottom: 0.75pt)
} else if y == 1 {
(top: 0.75pt, bottom: 0pt)
} else {
(bottom: 1.5pt, top: 0pt)
})
show table: set par(leading: 0.65em)
set table.cell(align: center + horizon)
// 表题：表上五号黑体加粗 图题：图下五号宋体加粗
show figure.where(kind: table): set figure.caption(position: top)
show figure.caption: it => {
if it.kind == "i-figured-table" or it.kind == "table" {
text(font: ("Times New Roman", "Source Han Sans"), size: 10.5pt, weight: "bold")[#it]
} else if it.kind == "i-figured-image" or it.kind == "image" {
text(font: ("Times New Roman", "Source Han Serif"), size: 10.5pt, weight: "bold")[#it]
}
}
// 列表缩进 2 字符
set enum(indent: 2em)
// 封面，标题折两行
let title1 = ""
let title2 = ""
// 解决中英文混排的折行问题
{
let title1_length = 0
let title1_codepoints = 0
// 中英文混排时，Typst 会自动在周围加共计 1 空格的空白字符。我们的做法是当英文切换为中文时，长度加一
let last_zh = true
for c in title_zh {
if title1_length >= 27 {
break
}
if c.match(regex("\p{script=Han}")) != none {
// 中文字符，宽度 2
title1_length += 2
if not last_zh {
title1_length += 1
}
last_zh = true
} else {
// 其他字符默认宽度 1
title1_length += 1
last_zh = false
}
title1 += c
title1_codepoints += 1
}
title2 = title_zh.codepoints().slice(title1_codepoints).join()
}
frontpage.frontpage[
#align(center, image("assets/hnu-text-logo.png", width: 8.01cm))
#align(center)[
#text(size: 26pt)[HUNAN UNIVERSITY]
#text(size: 45pt)[本科生毕业论文(设计)]
#v(2.5cm)
#frontpage.basic_info(title1, title2, author, id, class, college, mentor)
#v(0.5cm)
#frontpage.date2(date: date)
]
]
// 页码
set page(numbering: "I", margin: (top: 30mm, bottom: 25mm, left: 30mm, right: 20mm), header: page_header)
counter(page).update(1)
// 原创性声明和版权使用授权书
authenticity.toc
authenticity.originality_statement()
authenticity.copyright_authorization()
pagebreak()
// 中英文摘要
abstract.chinese_abstract(title_zh, keywords_zh, abstract_zh)
pagebreak()
abstract.english_abstract(title_en, keywords_en, abstract_en)
pagebreak()
// 目录
outlines.toc
pagebreak()
outlines.figures
pagebreak()
outlines.tables
// 正文页码
set page(numbering: "1")
counter(page).update(1)
// 标题编号
set heading(numbering: "1.1.1.1 ")
show heading: it => [ // 给编号和标题设置不同字体（有点逆天）
#if it.level == 1 [ // 一级标题前空一页
#pagebreak()
]
#v(0.3cm)
#set par(first-line-indent: 0em)
#if it.numbering != none [
#text(font: "Times New Roman")[#counter(heading).display()]
]
#text(font: "Source Han Sans")[#it.body]
#set par(first-line-indent: 2em)
#v(0.8625em)
]
show heading.where(depth: 1): set text(size: 16pt)
show heading.where(depth: 2): set text(size: 12pt)
show heading.where(depth: 3): set text(size: 12pt)
show heading: i-figured.reset-counters
show figure: i-figured.show-figure
show math.equation: i-figured.show-equation
body
} |
|
https://github.com/cronokirby/paper-graphical-framework-for-cryptographic-games | https://raw.githubusercontent.com/cronokirby/paper-graphical-framework-for-cryptographic-games/main/main.typ | typst | #import "paper.typ"
#import paper: definition
#let abstract = [
Ahoy
]
#show: doc => paper.template(
title: "Graphical Foundations for Cryptography",
author: (name: "<NAME>", email: "<EMAIL>"),
abstract: abstract,
doc,
)
= Introduction
= Category Theory and String Diagrams
The Fibonacci sequence is defined through the recurrence relation $F_n := F_(n - 1) + F_(n - 2)$.
$
F_n = round(1 / sqrt(5) phi.alt^n), quad phi.alt = (1 + sqrt(5)) / 2
$
== Categories
#paper.definition[
Consider the worst thing ever.
]
#paper.lemma[
Consider the worst thing ever.
]
#paper.proof[
Blah blah blah.
]
== Monoidal Categories
== Frobenius Structures
Foo bar.
=== Comonoid Structures
=== Monoid Structures
=== Extra Special Frobenius Structure
= A Concrete Model
#include "model.typ"
= Some Basic Cryptography
= Further Work
= Conclusion
|
|
https://github.com/arthurcadore/eng-telecom-workbook | https://raw.githubusercontent.com/arthurcadore/eng-telecom-workbook/main/semester-8/CSF/homework1/homework1.typ | typst | MIT License | #import "@preview/klaro-ifsc-sj:0.1.0": report
#import "@preview/codelst:2.0.1": sourcecode
#show heading: set block(below: 1.5em)
#show par: set block(spacing: 1.5em)
#set text(font: "Arial", size: 12pt)
#set text(lang: "pt")
#set page(
footer: "Engenharia de Telecomunicações - IFSC-SJ",
)
#show: doc => report(
title: "Calculo de Transmissão/Recepção em ERBs",
subtitle: "Comunicações Sem Fio",
authors: ("<NAME>",),
date: "14 de Outubro de 2024",
doc,
)
= Introdução
Neste documento, serão resolvidos alguns exercícios de comunicações sem fio, com o intuito de aplicar os conhecimentos adquiridos em sala de aula.
= Questão 1:
Em uma área rural, duas estações rádio base (ERB1 e ERB2) cobrem um segmento reto de uma rodovia. Um terminal móvel se desloca sobre a rodovia, no segmento que liga a ERB1 à ERB2, com velocidade uniforme de 90 km/h, enquanto mantém uma chamada servida pela ERB1. A direção de movimento é tal que o móvel se afasta de ERB1 enquanto se aproxima de ERB2. As duas ERBs estão distantes 2 km. Quando o móvel está a 500m da ERB1, a intensidade de sinal é de -100 dBm. O nível mínimo de sinal necessário para manter a chamada é -120 dBm.
Dados da questão:
- dt: 2 km
- V = 90 km/h
- d1 = 500 m
- Pr1 = -100 dBm
- Prmin = -120 dBm
== Distância máxima sobre o segmento da rodovia:
Qual distância máxima d sobre o segmento da rodovia deve ocorrer um handoff da chamada de ERB1 para ERB2 (considere a ERB1 posicionada em d=0).
Considerando que a potência recebida é igual a potência de sensibilidade do receptor, temos que:
$
P_r = P_o - 10n log(d/d_0) -> -120 = -100 - 40log(d) + 40log(500)
$
$
-(-120 + 100 - 107,95)/40 = log(d) -> log(d) = 3,198
$
Calculando d temos que:
$
d = 10^(3,198) = 1589,4 m
$
== Efetuar o handoff com 5 segundos de delay:
Considerando que o sistema celular leva 5 segundos para processar todas as informações e efetuar o handoff, sugira o valor mínimo de um limiar de iniciação do processo de handoff (em dBm) para evitar a queda da chamada. Considere que neste ambiente de opagação o expoente de perda de percurso vale n=4, podendo-se utilizar um modelo simplificado de perda de percurso.
Primeiro precisamos calcular a distância de handoff entre as torres, para isso, calculamos a velocidade do veiculo em m/s e o tempo que ele leva para percorrer a distância entre as torres:
$ d_"handoff" = V * t $
Desta forma temos que:
$ V = (90 "km")/h -> (25 m)/s $
Como o tempo de handoff 5 segundos temos que:
$
d_"handoff" = V . t = 25 . 5 = 125 m
$
Caso consideremos que o handoff ocorra em 5 segundos, devemos deduzir essa distância da distância total entre as torres, temos que:
$
d_"handoff" = 1589,4 m - 125 m = 1464,4 m
$
Também devemos considerar que para limitar o handoff, deve-se deduzir a potência na área de sobreposição do sinal, portanto:
$
gamma_"HO" = P_o - 10n log((d_max - d_"HO") /d_0) -> -118,57"dBm"
$
= Questão 2:
Em um sistema de telefonia móvel a relação sinal-ruído (SNR) mínima para recepção com boa qualidade é de 10 dB. Foi medido que a potência de ruído térmico no telefone móvel é de –120
dBm. Considere ainda os seguintes parâmetros:
- (a) ganhos das antenas transmissora e receptora: 3 dBi
- (b) frequência de operação: 800 MHz
- (c) altura da antena da estação base 20m;
- (d) altura da antena da estação móvel: 1,5 m;
- (e) potência de alimentação na antena da base: 1 W.
Calcule o alcance de um sinal de rádio realizado nestas condições utilizando:
== Modelo de propagação do espaço-livre
Para calcular o primeiro modelo, temos a seguinte formula: (Considerando L = 1 )
$
P_r(d) = (P_t . G_t . G_r . lambda^2) / ((4 . pi)^2 . d^2 . L) -> P_r(d) = (P_t . G_t . G_r . lambda^2) / ((4 . pi)^2 . d^2)
$
Calculando lambda, temos que:
$
lambda = (3 . 10^8) / (800 . 10^6 ) = 0,375 m -> lambda^2 = 0,375^2 = 0,140625
$
Aplicando os valores dados pela questão, temos que:
$
10^(-14) = ( 1 . 2 . 2 . 0,140625) / ((4.pi)^2 d^2) -> 10^(-14) = (0,5625) / (157,91 d^2)
$
Dessa forma, temos que:
$
1,579 . 10^12 d^2 = 0,5625 -> d^2 = 3,561^11 -> d = 596.741,149m -> 596,741 "km"
$
== Modelo de propagação de 2 raios
Para o modelo de raios, temos que:
$
P_r(d) = P_t . G_t . G_r . (h_1^2 . h_2^2) / d^4
$
Dessa forma temos que:
$
"SNR" = P_r - P_n -> 10 = p - (-120) -> p = -110 "dBm"
$
Aplicando na formula, temos que:
$
10^(-14) = 1 . 2 . 2 . (20^2 . 1,5^2 ) / d^4 -> d^4 = 3600 / 10^(-14) -> 3,600 . 10^14 -> 3,6 . 10^17
$
Dessa forma temos que:
$
d = (3,6 . 10^17)^(1/4) = 24495m -> 24,495 "km"
$
== Modelo COST231-Hata para cidade grande.
Para o modelo de Hata, temos que:
$
A(h_r) = 3,2 log^2(11,75h_r) - 4,97
$
Aplicando os valores dados pela questão, temos que:
$
A(1,5) = 3,2 log^2(11,75 . 1,5) - 4,97 -> A(1,5) = 3,2 log^2(17,625) - 4,97
$
Dessa forma, temos que:
$
A(1,5) = 3,2 . 1,552 - 4,97 -> A(1,5) = 4,969 - 4,97 = 0,001
$
$
P_l = 30 + 3 + 3 + 110 -> P_l = 146 "dB"
$
Aplicando na formula de perda de percurso, temos que:
$
1 = 69,55 + 26,16log(f) - 13,82log(h_t) - A(h_r) + (44,9 - 6,55log(h_t))log(d)
$
$
146 = 69,55 + 75,86 - 17,96 + 36,38 log(d)
$
$
log(d) = (146 - 69,55 - 75,86 + 17,96) / (36,38) -> log(d) = 0,51
$
Dessa forma, temos que:
$
d = 10^(0,51) = 3,16 "km"
$
= Questão 5:
Sejam dados: pa=15 W, Gt=12 dBi, Gr=3 dBi. Seja a potência de ruído térmico no receptor –120 dBm. Qual o máximo raio de célula para o qual uma relação sinal-ruído (SNR) de 20 dB pode ser garantida em 95% do perímetro da borda da célula? Assuma n=4, =8 dB, f=900 MHz. Calcule uma perda de percurso de referência média em d0=1 km utilizando o modelo de perda de percurso COST231-Hata sabendo-se que a altura da antena da ERB é de 20 m e a altura da antena do terminal móvel é de 1,8 m. O ambiente em questão é de área suburbana de uma cidade.
== Resolução
Inicialmente devemos calcular a perda de percurso (meio urbano) sendo d0 = 1km para o modelo de Cost231-Hata:
$
a(h_m) = (1.1 log(900) -0,7) . 1,8 - (1,56 log(900) - 0,8) = 2,954
$
Dessa forma, temos que:
$
a(h_m) = (1.1 . 2,954 - 0,7 ) . 1,8 - ( 1,56 . 2,954 - 0,8 )
$
$
(3,249 -0,7 ) . 1,8 - (4,605 - 0,8) -> 4,589 - 3,805 = 0,784 "dB"
$
Agora aplicamos o valor obtido na formula de perda de percurso:
$
L_p(d) = 46,3 + 33,9 log(900) - 13,82 log(20) - 0,784 + (44,9 -6,55 log(20) ) log(1)
$
Dessa forma temos que:
$
L_p(d) = 46,3 + (33,9 . 2,954 )- (13,82 . 1,301 ) - 0,784 + (44,9 - 6,55 . 1,301) . 0
$
$
L_p(d) = 46,3 + 100,2726 + 17,98 - 0,784 + (44,9 - 8,5255) . 0
$
$
L_p(d) = 125,807"dB"
$
Como a questão pede uma relação de 20 dB no minimo, temos que o raio da célula é igual a todo o perimetro onde a relação é de 20 dB. Assim podemos calcula-lo com base na formula de perda de percurso:
$
P_r = P_t + G_t + G_r - L_p(d)
$
$
-100 = 41,76 + 12 + 3 - L_p(d) -> L_p(d) = 41,76 + 12 + 3 + 100 = 156,76 "dB"
$
Por fim, substituimos na formula de hata novamente para calcular o raio da célula:
$
156,76 = 46,3 + 33,9 log(900) - 13,82 log(20) - 0,784 + (44,9 -6,55 log(20)) log(d)
$
Dessa forma temos que:
$
156,76 - 125,807 = (44,9 6,55 log(20)) log(d)
$
$
30,953 = (44,9 - 8,52355) log(d) -> 30,953 = 36,37645 log(d) -> log(d) = 0,8509
$
$
d = 10^(0,8509) = 7,1 "km"
$
Dessa forma, em meios urbanos temos que o raio da célula é de 7,1 km. Como a questão solicita 95% do perimetro da célula em um meio suburbano, temos que.
Em seguida, calculamos o valor para a área suburbanda através da formula de correção de Hata:
$
l_50 = l_50 -2 [log(f/28)]^2 - 5,4
$
$
l_50 = 125,807 -2 [log(900/28)]^2 -5,4 -> 125,807 - 2 [1,507]^2 -5,4
$
$
l_50 = 125,807 - 4,542 - 5,4 = 115,865 "dB"
$
Agora calculamos novamente o raio da célula para suburbano:
$
P_t = 15W -> 41,76 "dBm"
$
$
Pr_0 = 41,76 + 12 + 3 - 115,865 = 41,76 + 15 - 115,865 = -59,105 "dBm"
$
A senssibilidade no receptor é de -120 dBm, porem, com a diferença de 20 dB, temos que a sensibilidade é de -100 dBm. Dessa forma, temos como calcular a diferença de 95% do perimetro da célula:
$
P_r [P_r(d) > - 100] = 0,95
$
$
Q( ( -100 - P_r(d) )/ 8 ) = 0,95 -> (-100 - P_r(d) )/ 8 = 0,95/Q -> -1,6449
$
$
- P_r(d) = (8 . -1,6449) + 100 -> - P_r(d) = +86,84 "dBm" -> P_r(d) = -86,84 "dBm"
$
Dessa forma, o ráio da celula é de:
$
P_r(d) = P_r(d) - 10n log(d/d_0)
$
$
-86,84 = -59,105 - 10 log(d/1) -> log(d) = (-86,841 + 59,105) / (-40) = 0,6463
$
$
d_r = 10^0,6463 = 4,4 "km"
$
= Questão 8:
Uma operadora de telefonia celular pretende cobrir uma grande cidade com área de 2500 km2 usando ERBs com pa=20 W e Gt=3 dBi. Os terminais móveis têm Gr=0 dBi. Determinar o número de ERBs omnidirecionais necessárias para cobrir a cidade quando é esperado que 90% da periferia das células experimente cobertura de sinal a -90 dBm. Assuma $rho$=8 dB e f=900 MHz. O modelo de COST231-Hata é válido neste ambiente. Você pode calcular uma potência média de referência em d0=1 km usando os seguintes parâmetros: hb=20 m, hm=1,8 m.
Para resolver essa questão, devemos aplicar a formula de perda de percurso de Hata:
$
l_p(d) = 46,3 + 33,9 log(f) - 13,82 log(h_b) - a(h_m) + (44,9 - 6,55 log(h_b)) log(d)
$
Entretanto, precisamos primeiro calcular o fator de correção a(h_m) para a altura da antena do terminal móvel:
$
a(h_m) = (1,1 log(f) - 0,7) h_m - (1,56 log(f) - 0,8)
$
Dessa forma temos que:
$
a(h_m) = (1,1 log(900) - 0,7) . 1,8 - 1,56 log(900) - 0,8
$
$
a(h_m) = (1,1 . 2,9542 - 0,7) . 1,8 - (1,56 . 2,9542) - 0,8
$
$
a(h_m) = (3,24962 - 0,7) . 1,8 - (4,6055 - 0,8)
$
$
a(h_m) = 4,589 - 3,805 = 0,784 "dB"
$
Substituindo na equação de hata, temos que:
$
l_p(d) = 46,3 + 33,9 log(900) - 13,82 log(20) - 0,7838 + (44,9 - 6,55 log(20)) log(1) + 3
$
Nota: uso do "C" = 3 para a perda de penetração, pois trata-se de uma área urbana.
$
l_p(d) = 46,3 + 33,9 . 2,9542 - 13,82 . 1,3010 - 0,7838 + 3
$
$
l_p(d) = 130,72 "dB"
$
Em seguida, precisamos determinar o limite de cobertura, a partir do limite de sinal minimo de recepção do final da celula, que é de $P_r = 90"dBm"$. Dessa forma, temos que:
$
P_r = P_t + G_t + G_r - L(d)
$
$
-90 = 43 + 3 + 0 - L(d) -> L(d) = 43 + 3 - 130 = -84,28 "dB"
$
Como a questão pede 90% da periferia da célula, precisamos calcular com base na qfunc:
$
P_r[ P_r(d) > -90] = 0,9
$
$
Q( (-90 - P_r(d)) / 8) = 0,9 -> (-90 - P_r(d)) / 8 = -1,2816
$
$
-90 - P_r(d) = -1,2816 . 8 -> -P_r(d) = -10,2528 + 90 = 79,7472 "dBm"
$
Agora com o valor de perda de percurso, podemos reaplica-lo na formula para descobrir o ráio da célula:
$
P_r(d) = P_r(d_0) - 10n log (d/d_0)
$
$
-79,7472 = -84,28 - 10 . 3,5log(d/1)
$
$
log(d) = (79,7472 - 84,28) / 35 = -0,129
$
$
d = 10^(-0,129) = 0,77 "km"
$
Com base no novo ráio de cobertura das estações, podemos calcular a quantidade de ERBs necessárias para cobrir a cidade:
$
A_"cel" = pi . r^2 -> pi . 0,77^2 = 1,86 "km^2"
$
Nota: o calculo superior considera que cada ERB terá como área de cobertura um circulo de 1,38 km de raio.
Como a cidade possui uma área de 2500 km2, temos que:
$
N_"ERBs" = 2500 / 1,86 = 1344,08 "ERBs"
$
= Questão 9:
Considere uma situação de propagação em ambiente interior (indoor). A antena transmissora encontra-se inicialmente fora da edificação e a perda de penetração estimada é 30 dB. O receptor encontra-se no piso térreo e o caminho do sinal até o mesmo atravessa uma partição horizontal e uma vertical cuja perda estimada é de 15 dB por partição. A antena transmissora encontra-se a 500 m da parede externa da edificação, sendo a frequência de operação f=900 MHz, hb=20 m, hm=1,8 m, podendo-se utilizar o modelo de COST231-Hata urbano para calcular uma perda de percurso de referência. Internamente à edificação a perda de percurso é proporcional a $d^-2,5$ além das perdas de penetração e partição já mencionadas. A distância interna entre a parede interna do edifício e o receptor é de 10 metros. Calcule a perda de percurso total nesta situação entre o transmissor e o receptor.
== Resolução:
Para resolver essa questão, devemos aplicar a formula de perda de percurso de Hata:
$
l_p(d) = 46,3 + 33,9 log(f) - 13,82 log(h_b) - a(h_m) + (44,9 - 6,55 log(h_b)) log(d)
$
Entretanto, precisamos primeiro calcular o fator de correção a(h_m) para a altura da antena do terminal móvel:
$
a(h_m) = (1,1 log(f) - 0,7) h_m - (1,56 log(f) - 0,8)
$
Dessa forma temos que:
$
a(h_m) = (1,1 log(900) - 0,7) . 1,8 - 1,56 log(900) - 0,8
$
$
a(h_m) = (1,1 . 2,9542 - 0,7) . 1,8 - (1,56 . 2,9542) - 0,8
$
$
a(h_m) = (3,24962 - 0,7) . 1,8 - (4,6055 - 0,8)
$
$
a(h_m) = 4,589 - 3,805 = 0,784 "dB"
$
Substituindo na equação de hata, temos que:
$
l_p(d) = 46,3 + 33,9 log(900) - 13,82 log(20) - 0,7838 + (44,9 - 6,55 log(20)) log(500) + 3
$
Nota: uso do "C" = 3 para a perda de penetração, pois trata-se de uma área urbana.
$
l_p(d) = 46,3 + 33,9 . 2,9542 - 13,82 . 1,3010 - 0,7838 + (44,9 - 6,55 . 1,3010) + 2,6983 + 3
$
$
l_p(d) = 46,3 + 100,2726 - 17,96 - 0,7838 (44,9 - 8,51855) . 2,6983 + 3
$
$
l_p(d) = 46,3 + 100,2726 - 17,96 - 0,7838 + 98,9794 + 3
$
$
l_p(d) = 228,8716 "dB"
$
Também é necessário calcular a perda interna, conforme a própria questão aponta, a perda de percurso interna é proporcional a $d^-2,5$. Dessa forma, temos que:
$
l_p("interna") = 10 . n . log(10) -> 10 . 2,5 . log(10) = 10 . 2,5 = 25 "dB"
$
Como mencionado na questão, a perda de percurso interna é de 15 dB por partição. Como são duas partições (uma horizontal e outra vertical, temos 30 dB), acrecido da perda de penetração de 30 dB. Dessa forma, temos que:
$
l_p("total") = 228,8716 + 15 + 15 + 30 + 25 = 313,8716 "dB"
$
= Questão 10:
O provimento de cobertura celular em áreas rurais e remotas é um desafio para países como o Brasil, de grande extensão territorial. Considere uma situação em que um assinante de serviço de comunicação móvel encontra-se a 10 km da ERB. Faça uma análise dos enlaces de descida e de subida considerando os seguintes parâmetros: potências EIRP: 37 dBm na ERB; 27 dBm no TM; despreze demais ganhos e perdas no transmissor e no receptor; a potência do ruído térmico vale Pn=-120 dBm; perda de percurso pode ser modelada como L(d)=120+30log(d), sendo d a distância ERB-TM em [km]; a razão sinal ruído mínima para estabelecer o enlace é 5 dB. Analise o equilíbrio de desempenho entre os enlaces de subida e de descida. A operadora pode instalar, quando necessário, um repetidor (relay) que regenera o sinal da ERB ou do TM, transmitindo-o novamente em posição mais favorável. Suponha que o relay opera com mesma potência EIRP do TM. Nessas condições avalie a necessidade de instalar um relay para atuar em um dos enlaces. Além disso, determine uma distância ou faixa de distâncias para a instalação do relay de forma a beneficiar a comunicação rural em questão.
== Resolução:
Para resolvermos a questão inicialmente calculamos o valor minimo de recepção do sinal no receptor:
$
"SNR" = P_s - P_n -> 5 = P_s - (-120) -> P_s = -115 "dBm"
$
Dessa forma, podemos calcular a perda de percurso minima para 10km mantendo a relação de 5 dB:
$
l_p(10) = 120 + 30log(10) = 150 "dB"
$
Assim, podemos calcular a potência recebida no terminal móvel (TM) pela ERB:
$
p_t_"Erb"_"tm" = 37 - 150 = -113 "dBm"
$
Da mesma maneira, podemos calcular a recebida na ERB pelo terminal movel (TM):
$
p_t_"tm"_"Erb" = 27 - 150 = -123 "dBm"
$
A partir dessa verificação, podemos determinar a faixa de distância para instalação do relay, pois a potência recebida no terminal móvel é menor que a potência minima de recepção, o que indica a necessidade de instalação de um relay.
$
-115 = 27 - L_p -> L_p = 142 "dB"
$
Em seguida, a partir da perda máxima, calculamos a distância para instalação do relay:
$
142 = 120 + 30 log(d) = 22/30 = log(d) -> d = 10^(22/30) = 10^0,733 = 5,5 "km"
$
= Questão 13:
Um sistema móvel celular é montado em uma pequena cidade com o intuito de prover serviço de acesso à internet por banda larga móvel. Vislumbra-se o uso em terminais estacionários como computadores portáteis e do tipo tablet. Uma única célula foi instalada visando cobrir toda a área do município. O sistema provê degraus de taxa no enlace de descida de acordo com um esquema de modulação e codificação adaptativa. Uma aproximação razoável da taxa bruta de download desse sistema é dada pela função $R("SNR")="SNR"/5$ [Mbps], sendo $"SNR">0$ [dB] a razão sinal ruído.
A transmissão é interrompida se $"SNR"<=0$. A taxa máxima do sistema satura em 10 Mbps. A operadora do serviço precisa dimensionar o raio de célula para fins de informação oficial à agência reguladora. Esta por sua vez requer que a taxa mínima oferecida para que se considere o serviço como de banda larga seja de 600 kbps. Esta vazão precisa ser observada em pelo menos 98% do perímetro definido como sendo a borda da célula.
Considerando que o ambiente de propagação é caracterizado por uma perda de percurso que segue o modelo simplificado com n=3,5 e o desvio padrão do desvanecimento de larga escala na região é assumido em $rho$ = 8 dB, dimensione o raio da célula a ser informado. Outras informações do projeto:
- potência do amplificador da antena transmissora: 20 W;
- ganho da antena transmissora: 10 dBi;
- ganho da antena receptora e demais perdas e ganhos de transmissão e recepção: 0 dB;
- Pr(100 m) = - 45 dBm; (potência de referência medida a uma distância de 100 m da antena transmissora)
- potência do ruído térmico no receptor: -110 dBm.
== Resolução:
Inicialmente calculamos a potência mínima de recepção do sinal no receptor:
$
"SNR" = 3"dB" -> "SNR" = P_s - P_n -> 3 = P_s - (-110) -> P_s = -107 "dBm"
$
Como a questão pede que seja observada em pelo menos 98% do perimetro da celula, temos que:
$
P_r[P_r(d) > -107] = 0,98
$
$
Q( (-107 - P_r(d)) / 8) = 0,98 -> (-107 - P_r(d)) / 8 = -2,0537
$
$
(-107 - P_r(d)) = -16,4296 -> P_r(d) = -90,5704 "dBm"
$
Dessa forma, aplicamos esse valor na formula de perda de percurso para calcular a distância máxima:
$
P_r(d) = P_r(d_0) - 10n log(d/100)
$
$
log(d/100) = ((P_r(d_0) - P_r(d))/10n) -> log(d/100) = ((-45 - (-90,5704))/35) = 1,4537
$
$
d = 100 . 10^1,4537 = 100 . 26,59 = 2659 "m"
$
Considerando que a questão pede 98% do perímetro da célula, temos que:
$
d = 0,98 * 6,729 = 6,59 "km"
$
= Questão 17:
Você foi designado para projetar um sistema de transmissão sem fio de 4ª geração. Trata-se de um sistema voltado exclusivamente para transmissão de dados sem fio. A taxa de transmissão em uma ERB no enlace de descida deste sistema é função da razão sinal-ruído (SNR, em dB) e pode ser aproximada pela seguinte expressão: $R("SNR")="SNR"$, para $0=<"SNR"<=50$ dB; $R("SNR")=0$, para $"SNR"<0 "dB"$; $R("SNR")=50$, para $"SNR">50$ dB, em que R é a taxa de transmissão em Megabits por segundo.
Nesta primeira etapa do projeto uma única ERB será instalada no centro de uma cidade pequena e objetiva cobrir uma área circular de 10 km de raio. A Prefeitura da cidade está contratando o serviço e quer saber de antemão de você:
Dados para o projeto:
- perda de referência em d0=1km é 120 dB;
- potência de ruído térmico Pn = −120 dBm;
- modelo de propagação simplificado com n=3,5;
- potência EIRP de transmissão da ERB pt=20W.
Despreze outros ganhos, perdas e interferências.
== Taxa média observada na periferia da cidade (borda da célula);
Para calcular a taxa média observada na periferia da cidade, utilizamos a formula de perda de percurso:
$
P_l(d) = P_l("d0") + 10n log(d/10)
$
$
P_l(10) = 120 + 35 log(10/1) -> P_l(10) = 155 "dB"
$
Dessa forma, aplicando na formula temos que:
$
P_r = P_t + G_t + G_r - P_l -> P_r = 43 - 155 = -112 "dBm"
$
Dessa forma, podemos calcular a SNR do sinal nesta distância:
$
"SNR" = P_s - P_n -> "SNR" = -112 - (-120) = 8 "dB"
$
Assim, como dado pela questão, o valor da taxa é:
$
R"(SNR)" = "SNR" -> R"(8)" = 8 "Mbps"
$
== Taxa média observada em toda a área coberta.
Para calcular a taxa coberta em toda a cidade o mesmo algoritmo apresentado acima foi utilizado em um script matlab para calcular a taxa de transmissão com base no distânciamento da ERB.
#sourcecode[```matlab
close all; clear all; clc;
%% entradas da questão:
pt = 43;
ruido = -120;
d0 = 0;
df = 10000;
%% criando vetor de zeros para utilizar no laço
r = zeros(1, 10e3 +1);
%% Laço de repetição para calcular de 0 á 10km
for d = d0 : df
pl = 120 + (35*log10(d/1e3));
pr = pt - pl;
snr = pr -ruido;
if 0 <= snr && snr <=50
r(d+1) = snr;
elseif snr < 0
r(d+1) = 0;
else
r(d+1) = 50;
end
end
% Calcula a média do vetor r
media_r = mean(r);
% Exibe o valor médio no console
fprintf('Valor médio do vetor de barras: %.2f Mbps\n', media_r);
figure;
bar(r);
title('Taxa observada no ráio de cobertura');
xlabel('Distância em metros');
ylabel('Taxa [Mbps]');
grid on;
```]
#figure(
figure(
rect(image("./pictures/17.png")),
numbering: none,
caption: []
),
caption: figure.caption([Elaborada pelo Autor], position: top)
)
Valor médio do vetor de barras: $22.24 "Mbps"$ |
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/meta/ref-01.typ | typst | Other | // Error: 1-5 label does not exist in the document
@foo
|
https://github.com/tingerrr/masters-thesis | https://raw.githubusercontent.com/tingerrr/masters-thesis/main/src/de/chapters/1-intro.typ | typst | #import "/src/util.typ": *
#import "/src/figures.typ"
= Motivation
In der Automobilindustrie gibt es verschiedene Systeme, welche die Automation von Prüfständen erleichtern oder ganz übernehmen.
Eines dieser Systeme ist T4gl, eine Programmiersprache und gleichnamiges Laufzeitsystem zur Interpretation von Testskripten in Industrieprüfanlagen wie End of Line- aber auch Versuchsprüfständen.
Bei diesen Anlagen werden verschiedene Tests und Messvorgänge durchgeführt, welche bestimmte Zeitanforderungen aufweisen.
Können diese Zeitanforderungen nicht eingehalten werden, müssen Testvorgänge verworfen und wiederholt werden.
Daher ist es essentiell, dass das T4gl-Laufzeitsystem in der Lage ist, die erwarteten Testvorgänge innerhalb einer festgelegeten Zeit abzuarbeiten, ungeachtet der anfallenden Testdatenmengen.
T4gl ist eine Hochlevel-Programmiersprache, Speicherverwaltung oder Synchronization werden vom Laufzeitsystem übernommen und müssen in den meisten Fällen nicht vom Programmierer beachtet werden.
Wie in fast allen Hochlevel-Programmiersprachen, gibt es in T4gl dynamische Datenstrukturen zur Verwaltung von mehreren Elementen.
Diese werden in T4gl als Arrays bezeichnet und bieten eine generische Datenstruktur für Sequenzen, Tabellen, ND-Arrays oder Queues.
Intern wird die gleiche Datenstruktur für alle Anwendungsfälle verwendet, in welchen ein T4gl-Programmierer eine dynamische Datenstruktur benötigt, ungeachtet der individuellen Anforderungen.
Aus der Interaktion verschiedener Features des Laufzeitsystems und der Standardbibliothek der Programmiersprache kommt es, zusätzlich dazu, zu unnötig häufigen Kopien von Daten.
Schlimmer noch, durch die jetzige Implementierung wächst die Länge von Kopiervorgängen der T4gl-Arrays proportional zur Anzahl der darin verwalteten Elemente.
Bei diese Kopien kann es sich um T4gl-Arrays mit fünfzig Elementen oder Arrays mit fünf-Millionen Elementen handeln.
Durch diese unzureichende Flexibilität bei der Wahl der Datenstruktur ist es dem T4gl-Programmierer nicht möglich, die Nutzung der Datenstruktur hinreichend auf die jeweiligen Anwendungsfälle zu optimieren.
Das Laufzeitsystem kann die gestellten Zeitanforderungen nicht garantiert einhalten, da die Anzahl der Elemente in T4gl-Arrays erst zur Laufzeit bekannt ist.
Das Hauptziel dieser Arbeit ist die Verbesserung der Latenzen des T4gl-Laufzeitsystems durch Analyse und gezielte Verbesserung der Datenverwaltung von T4gl-Arrays.
Dabei werden verschiedene Lösungsansätze evaluiert, teilweise implementiert, getestet und verglichen.
= Aufbau der Arbeit
Dieses Kapitel führt das zu lösende Problem ein und beschreibt die Arbeit selbst.
Dabei werden Notation und Konventionen sowie fachspezifisches Grundwissen vermittelt.
@chap:t4gl beschreibt T4gl und dessen Komponenten genauer, sowie die Implementierung der T4gl-Arrays.
Darin wird erarbeitet, wie es zu den meist unnötigen Kopiervorgängen kommt und in welchen Fällen diese auftreten.
In @chap:non-solutions werden verschiedene Veränderungen an der Programmiersprache selbst erörtert und warum diese unzureichend oder anderweitig unerwünscht sind.
Dazu zählen verschiedene neue syntaktische Konstrukte zur statischen Analyse oder das Optimierten der Implementierung, sowie die Veränderung bestehender Semantik existierender Sprachkonstrukte.
@chap:persistence führt einen Begriff der Persistenz im Sinne von Datenstrukuren ein und befasst sich mit verschiedenen Datenstrukuren, durch welche die zeitliche Komplexität von Kopien der T4gl-Arrays reduziert werden kann.
Im Anschluss wird in @chap:impl die Implementierung einer ausgewählten Datenstruktur beschreiben.
Die daraus folgenden Implementierungen werden in @chap:benchmarks getestet und verglichen.
Zu guter Letzt wird in @chap:conclusion das Resultat der Arbeit evaluiert und weiterführende Aufgaben beschrieben.
= Komplexität
Im Verlauf dieser Arbeit wird oft von Zeit- und Speicherkomplexität gesprochen.
Komplexitätstheorie befasst sich mit der Komplexität von Algorithmen und algorithmischen Problemen, vor allem in Bezug auf Speicherverbrauch und Bearbeitungszeit.
Dabei sind folgende Begriffe relevant:
/ Zeitkomplexität:
Zeitverhalten eines Algorithmus über eine Menge von Daten in Bezug auf die Anzahl dieser @bib:clrs-09[S. 44].
/ Speicherkomplexität:
Der Speicherbedarf eines Algorithmus zur Bewältigung eines Problems @bib:clrs-09[S. 44] im Bezug auf die Problemgröße.
Wird auch für den Speicherbedarf von Datenstrukturen verwendet.
/ Amortisierte Komplexität:
Bezüglich einer Sequenz von $n$ Operationen mit einer Gesamtdauer von $T(n)$, gibt die amortisierte Komplexität den Durchschnitt $T(n)\/n$ einer einzelnen Operation an @bib:clrs-09[S. 451].
!Landau-Symbole umfassen Ausdrücke zur Klassifizierung der asymptotischen Komplexität von Funktionen und Algorithmen.
Im folgenden werden Variationen der !Knuth'schen Definitionen verwendet @bib:knu-76[S. 19] @bib:clrs-09[S. 44-48], sprich:
$
O(f) &= {
g : NN -> NN | exists n_0, c > 0
quad &&forall n >= n_0
quad 0 <= g(n) <= c f(n)
} \
Omega(f) &= {
g : NN -> NN | exists n_0, c > 0
quad &&forall n >= n_0
quad 0 <= c f(n) <= g(n)
} \
Theta(f) &= {
g : NN -> NN | exists n_0, c_1, c_2 > 0
quad &&forall n >= n_0
quad c_1 f(n) <= g(n) <= c_2 f(n)
}
$ <eq:big-o>
Bei der Verwendung von !Landau-Symbolen steht die Variable $n$ für die Größe der Daten, welche für die Laufzeit eines Algorithmus relevant sind.
Bei Operationen auf Datenstrukturen entspricht die Größe der Anzahl der verwalteten Elemente in der Struktur.
#figure(
table(columns: 2, align: left,
table.header[Komplexität][Beschreibung],
$alpha(1)$, [Konstante Komplexität, unabhängig von der Menge der Daten $n$],
$alpha(log n)$, [Logarithmische Komplexität über der Menge der Daten $n$],
$alpha(n)$, [Lineare Komplexität über der Menge der Daten $n$],
$alpha(n^k)$, [Polynomialkomplexität des Grades $k$ über der Menge der Daten $n$],
$alpha(k^n)$, [Exponentialkomplexität über der Menge der Daten $n$ zur Basis $k$],
),
caption: smartcap[
Unvollständige Liste verschiedener Komplexitätsklassen in aufsteigender Reihenfolge.
][
Unvollständige Liste verschiedener Komplexitätsklassen in aufsteigender Reihenfolge, dabei steht $alpha$ für ein Symbol aus @eq:big-o.
],
) <tbl:landau>
$O(f)$ beschreibt die Menge der Funktionen, welche die _obere_ asymptotische Grenze $f$ haben.
Gleichermaßen gibt $Omega(f)$ die Menge der Funktionen an, welche die _untere_ asymptotische Grenze $f$ haben.
$Theta(f)$ ist die Schnittmenge aus $O(f)$ und $Omega(f)$ @bib:clrs-09[S. 48, Theorem 3.1].
Trotz der Definition der Symbole in @eq:big-o als Mengen schreibt man oft $g(n) = O(f(n))$ statt $g(n) in O(f(n))$ @bib:knu-76[S. 20].
Die Vorliegende Arbeit hält sich an diese Konvention.
@tbl:landau zeigt verschiedene Komplexitäten in aufsteigender Ordnung der Funktion $f(n)$.
Unter Betrachtung der asymptotischen Komplexität werden konstante Faktoren und Terme geringerer Ordnung generell ignoriert, sprich $g(n) = 2n^2 + n = O(n^2)$.
= Legende & Konventionen
Die folgenden Konventionen und Notationen werden während der Arbeit verwendet.
Sollten bestimmte Teile der Arbeit diesen Konventionen nicht folgen, sind diese Abweichungen im umliegenden Text beschrieben.
== Texthervorhebungen
Wenn bestimmte Variablen, Werte, Typen oder Funktionen aus umliegenden Abbildungen referenziert werden, sind diese auf verschiedene Weise hervorgehoben.
@tbl:syntax zeigt verschiedene Hervorhebungen.
#import "/src/figures/util.typ": math-type, math-func
#let FingerTree = math-type("FingerTree")
#let concat = math-func("concat")
#figure(
table(columns: 2, align: (x, y) => horizon + if x == 1 { left },
table.header[Hervorhebung][Beschreibung],
[`func`, ```cpp nullptr```, ```cpp if```], [
Hervorhebungen von code- oder programmiersprachen-spezifischen Funktionen, Typen oder Variablen, verwendet Monospace-Schriftart und Syntax-Highlighting.
],
$FingerTree$, [
Typ oder Konstruktor in Pseudocode.
],
$concat$, [
Funktion in Pseudocode.
],
),
caption: [Legende von Hervorhebungen im Lauftext.],
) <tbl:syntax>
== Grafiken
@tbl:legend beschreibt die Konventionen für Grafiken, vor allem Grafiken zu Baum- oder Listenstrukturen.
Diese Konventionen sollen vor allem Konzepte der Persistenz (siehe @chap:persistence) vereinfachen.
#let fdiag = fletcher.diagram.with(node-stroke: 0.075em)
#let node = fletcher.node.with((0, 0), `n`)
#figure(
table(columns: 2, align: (x, y) => horizon + if x == 1 { left },
table.header[Umrandung][Beschreibung],
fdiag(node(stroke: green)), [
Geteilte Knoten, d.h. Knoten, welche mehr als einen Referenten haben.
],
fdiag(node(stroke: red)), [
Kopierte (nicht geteilte) Knoten, d.h. Knoten, welche durch eine Operation kopiert wurden statt geteilt zu werden, z.B. durch eine Pfadkopie.
],
fdiag(node(stroke: (paint: gray, dash: "dashed"))), [
Visuelle Orientierungshilfe für folgende Abbildungen, kann hypothetischen oder gelöschten Knoten darstellen.
Die genaue Bedeutung ist im umliegenden Text beschrieben.
],
fdiag(node(extrude: (-2, 0))), [
Instanzknoten, d.h. Knoten, welche nur Verwaltungsinformationen enthalten, wie die Instanz eines `std::vector`.
],
),
caption: [Legende der Konventionen in Datenstrukturgrafiken.],
) <tbl:legend>
== Notation
In Pseudocode werden sowohl mathematische Symbolik, wie die zur Kardinalität von Mengen $abs(M)$, als auch Programmierkonventionen übernommen, zum Beispiel die Syntax für Feldzugriffe $x.y$.
#let Typ = math-type("Typ")
#figure(
table(columns: 2, align: (x, y) => horizon + if x == 1 { left },
table.header[Syntax][Beschreibung],
$x.y$, [
Feldzugriff, $x$ ist eine Datenstruktur mit einem Feld $y$, dann gibt $x.y$ den Wert des Feldes $y$ in $x$ zurück.
],
$abs(x)$, [
Längenzugriff, ist $x$ ein Vektor, ein Baum, eine Hashtabelle, etc. (ein Kontainertyp), gibt $abs(x)$ die Anzahl der Elemente in $x$ zurück.
],
$[x, y, ...]$, [
Sequenzkonstruktor, erzeugt eine Sequenz aus den Elementen $x$, $y$, usw.
Der Typ von Sequenzen wird als $[Typ]$ geschrieben, wobei $Typ$ der Typ der Elemente in der Sequenz ist.
],
),
caption: [Legende der Notationen in Pseudocode.],
) <tbl:notation>
|
|
https://github.com/Myriad-Dreamin/tinymist | https://raw.githubusercontent.com/Myriad-Dreamin/tinymist/main/crates/tinymist-query/src/fixtures/hover/builtin_var3.typ | typst | Apache License 2.0 |
#(sys.version /* ident */ );
|
https://github.com/maxds-lyon/lokiprint | https://raw.githubusercontent.com/maxds-lyon/lokiprint/main/templates/typst/.template/shared/flex.typ | typst | #let column(gap, children) = grid(
columns: 1,
gutter: gap,
..children
)
#let row(gap, children) = {
let (first, ..other) = children
// set par(leading: gap)
first
for child in other {
h(gap)
child
}
}
#let flex(gap: 0pt, direction: column, body) = {
let non-empty-children = body.children.filter(child => (
child.fields().len() != 0 and ("children" not in child.fields() or child.children.len() != 0)
))
direction(
gap,
non-empty-children,
)
} |
|
https://github.com/justmejulian/typst-documentation-template | https://raw.githubusercontent.com/justmejulian/typst-documentation-template/main/utils/pintorita.typ | typst | #let pintorita(body, caption: [], factor: none) = {
import "@preview/pintorita:0.1.1"
let content = {
if factor == none {
pintorita.render(body.text)
} else {
pintorita.render(body.text, factor: factor)
}
}
figure(
content,
caption: caption
)
}
#let pintoritaFile(url, caption: [], factor: none) = {
let raw = raw(read(url))
pintorita(raw, caption: caption, factor: factor)
}
|
Subsets and Splits