repo
stringlengths 26
115
| file
stringlengths 54
212
| language
stringclasses 2
values | license
stringclasses 16
values | content
stringlengths 19
1.07M
|
|---|---|---|---|---|
https://github.com/ustclug/cheatsheet | https://raw.githubusercontent.com/ustclug/cheatsheet/main/cheatsheet.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #set page(
width: 40cm,
height: 60cm,
flipped: true,
footer: [
#set align(right)
#image("image/logo.svg", width: 2%),
],
margin: (x: 3cm, y: 2cm),
)
#set text(font: "Source Han Serif SC")
#show raw.where(block: false): it => {
box(
fill: luma(240),
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)[
#set text(size: 10pt)
#raw(it.text, lang: "bash", block: true)
]
}
#let commandBlock(body, title: "", command: "") = {
box(
width: 100%,
stroke: (
paint: gray,
thickness: 0.5pt,
),
inset: 12pt,
outset: 0pt,
radius: 5pt,
clip: true,
)[
#text(
size: 11pt,
weight: "bold",
font: "Source Han Serif SC",
)[
#title
]
#raw(command, lang: "bash")
#set text(
size: 9pt,
font: "Source Han Serif SC",
)
#body
]
}
#columns(5)[
== 文件操作
#commandBlock(title: "列目录与文件:", command: "ls [options] file")[
- 包含隐藏文件在内的所有 (#strong[a]ll) 文件: `ls -a`
- 列出详细 (#strong[l]ong) 信息: `ls -l`
- 以人类 (#strong[h]uman) 格式显示文件大小: `ls -lh`
- 递归 (#strong[R]ecursive) 列出所有子文件: `ls -R`
]
#commandBlock(title: "列出目录树:", command: "tree [options] dir")[
- 列出家目录的树: `tree ~`
- 仅列出树中的文件夹 (#strong[d]irectory): `tree -d`
- 列出含隐藏文件在内的所有 (#strong[a]ll) 文件的目录树: `tree -a`
]
#commandBlock(title: "复制:", command: " cp [options] source dest")[
- 复制 `~/A` 到 `/tmp/B`: `cp ~/A /tmp/B`
- 递归 (#strong[r]ecursive) 复制目录: `cp -r ~/dirA /tmp/dirB`
- 复制时显示详细 (#strong[v]erbose) 信息: `cp -v ~/A /tmp/B`
]
#commandBlock(title: "重命名/移动:", command: "mv [options] source dest")[
- 重命名 `A` 到 `B`: `mv A B`
- 将 `A` 移动到家目录: `mv A ~/`
]
#commandBlock(title: "删除:", command: "rm [options] file")[
- 递归 (#strong[r]ecursive) 删除 A 目录: `rm -r A`
- 递归删除且不作确认 (#strong[f]orce): `rm -rf A` #strong(text(fill: red)[(谨慎使用!)])
]
#commandBlock(title: "读取文件开头:", command: "head [options] file")[
- 读文件开头 100 行 (li#strong[n]e): `head -n 100 A`
- 读文件开头 100 字符 (#strong[c]har): `head -c 100 A`
]
#commandBlock(title: "读取文件结尾:", command: "tail [options] file")[
- 读文件结尾 100 行 (li#strong[n]e): `tail -n 100 A`
- 读结尾并实时跟随 (#strong[f]ollow) 更新: `tail -f A`
]
#commandBlock(title: "链接:", command: "ln [options] file link")[
- 作 `A` 指向 `/B` 的符号链接 (#strong[s]ymlink): `ln -s /B A`
- 作 `A` 和 `/B` 的硬链接: `ln /B A`
]
#commandBlock(title: "以行为单位选择内容:", command: "cut [options] file")[
- 以空格为分隔符 (#strong[d]elimiter)，并选择第二项 (#strong[f]ield):
```
curl --version | head -n 1 | cut -d' ' -f2
```
]
#commandBlock(title: "修改文件权限位:", command: "chmod [options] mode file(s)")[
- 递归 (#strong[R]ecursive) 修改权限: `chmod -R 755 A` #strong(text(fill: red)[(谨慎使用!)])
- *权限的表示：符号*
- 格式: `[ugoa][[+-=][perms]],...`
- 例子: `u+x`,`o-wx`,`g-w`
#table(
columns: (auto),
[u: #strong[u]ser/owner g: #strong[g]roup\
o: #strong[o]thers a: #strong[a]ll],
[+: 添加 -: 删除 =: 设置为],
[r: #strong[r]ead w: #strong[w]rite\
x: e#strong[x]ecute (可执行/列目录)],
)
- 特殊权限 (s, t, S, T) 参考 `man chmod`
- *权限的表示：八进制数字*
- 格式: 四位八进制数字，第一位可选
- 例子: `755 (rwxr-xr-x)`
- 第一位: 一般为 `0`，特殊权限参考 `man chmod`
- 第二位: 所有者权限
- 第三位: 用户组权限
- 第四位：其他用户权限
- 读: `4 (100)` 写: `2 (010)` 可执行: `1 (001)`
]
#commandBlock(title: "搜索文件:", command: "find path [options] [搜索条件] [动作]")[
- 搜索所有 MP4 视频文件: `find . -name '*.mp4'`
- 搜索所有 `*.pyc` 文件并删除: `find . -name '*.pyc' -delete` #strong(text(fill: red)[(谨慎使用!)])
- *搜索条件:*
- `-name xyz*`: 名字匹配 `xyz*`
- `-iname xyz*`: 名字匹配，不区分 (insensitive) 大小写
- `-type d`: 只匹配目录 (directories)
- `-type f`: 只匹配文件 (files)
- `-mtime 0`: 1 天内修改的文件
- `-mtime -x`: 在 x 天内修改
- `-mtime +x`: 在 x 天外修改
- `-mmin -x`: 在 x 分钟内修改
- `-size +100M`: 大小大于 `100MiB`
- `-size -100M`: 大小小于 `100MiB`
- `(1 MiB = 1024 KiB = 1024 * 1024 B)`
- `-perm /o+w`: 权限 (permission) 为可被他人写入
- `! -perm /o+r`: 权限 (permission) 为不(!)可被他人读取
- *动作:*
- `-print`: 输出匹配项
- `-delete`: 删除匹配文件
- `-exec cmd '{}' ;`: 对每个匹配执行命令 (`cmd` 执行 n 次)
- `-exec cmd '{}' +`: 聚集匹配后执行一次命令 (`cmd` 执行 1 次)
- `-fprint /tmp/result`: 输出匹配项到 `/tmp/result`
]
#commandBlock(title: "比较文件:", command: "diff [options] files")[
- 比较 A 与 B 的差异: `diff A B`
- 递归 (#strong[r]ecursive) 比较目录: `diff -r Adir Bdir`
- 将被比较文件视为纯文本看待: `diff -a A B`
- 存在差异时不 (#strong[q]uiet) 输出具体差异: `diff -q A B`
]
#commandBlock(title: "搜索文件内容:", command: "grep [options] pattern files")[
- 显示文件 A 中包含 hello 的行: `grep hello A`
- 大小写不敏感 (#strong[i]gnore case) 搜索: `grep -i hello A`
- 递归 (#strong[r]ecursive) 搜索当前目录下包含 hello 的文件，并忽略二进制 (-I): `grep -rI hello .`
- 搜索文件中包含 hello 或者 world 的行: `grep -E 'hello|world' A`
- 提示：可以试试更好用的搜索工具 `ripgrep`
]
#commandBlock(title: "查看/连接文件:", command: "cat [options] file(s)")[
- 查看文件 A: `cat A`
- 连接 A, B, C 文件到 D: `cat A B C > D`
]
#commandBlock(title: "排序:", command: "sort [options] file")[
- 按照数字 (#strong[n]umeric) 倒序 (#strong[r]everse) 排序: `cat A | sort -nr`
]
#commandBlock(title: "去重:", command: "uniq [options] input output")[
- 使用 `uniq` 前需要先排序，因此一般和 `sort` 一起用
- 去重并统计 (#strong[c]ount) 重复行出现次数，然后按照出现次数倒序排序: `cat A | sort | uniq -c | sort -nr`
]
#commandBlock(title: "打包:", command: "tar [options] file")[
- 将 A/ 打包 (#strong[c]reate) 并输出到 `A.tar` 文件 (#strong[f]ile): `tar cf A.tar A/`
- 将 A/ 打包到 `A.tar.gz`，压缩程序由 tar 根据后缀自动(#strong[a]uto) 选择: `tar caf A.tar.gz A/`
- 列出 (lis#strong[t]) `A.tar.gz` 的文件: `tar taf A.tar.gz`
- 解压 (e#strong[x]tract) `A.tar.gz` 到当前目录: `tar xaf A.tar.gz`
]
#commandBlock(title: "统计占用空间:", command: "du [options] file")[
- 以人类 (#strong[h]uman) 可读的方式显示当前目录第一层 (#strong[d]epth)（每个文件夹）的总占用大小: `du -h -d 1 .`
]
#commandBlock(title: "显示分区使用情况:", command: "df [options] file")[
- 以人类 (#strong[h]uman) 可读的方式显示每个分区的使用情况: `df -h`
]
== 进程操作
#commandBlock(title: "列出进程信息:", command: "ps [options]")[
- 列出所有进程（所有 (#strong[a]ll) 用户、显示用户信息 (#strong[u]ser) 并列出没有 tty (x) 的进程）: `ps aux`
- 列出所有进程，并按 CPU 使用率降序排序: `ps aux --sort=-%cpu`
- 列出所有进程的进程状态、进程 ID、父进程 ID 与进程名: `ps axo stat,pid,ppid,comm`
]
#commandBlock(title: "交互式显示进程信息:", command: "top [options]")[
- 每隔 1 秒 (#strong[d]elay) 刷新显示: `top -d 1`
- 只显示 1 号和 2 号进程: `top -p 1,2`
- *交互式界面快捷键:*
- 空格: 立刻更新
- n: 修改显示的进程数量
- P: 按 CPU 降序排序
- M: 按内存占用降序排序
- q: 退出进程
- 提示: 尝试更好用的 htop（包含颜色、鼠标支持等特性）
]
#commandBlock(title: "进程操作:", command: "pgrep, kill, pkill, killall")[
- 输出 `systemd` 进程的所有 PID: `pgrep systemd`
- 强制杀死 `top` 进程:
- `kill -9 $(pgrep top)`
- `pkill -9 top`
- `killall -9 top`
]
== 网络与远程操作
#commandBlock(title: "命令行远程连接:", command: "ssh [options] user@host [\"cmd1;cmd2\"]")[
- 连接时输出调试信息: `ssh -vvv user@hostname`
- 从跳板机连接服务器: `ssh -J user@jumpbox user@hostname`
- 将服务器的 1234 端口转发到本地的 1234 端口: `ssh -L 1234:localhost:1234 user@hostname`
- 在 1234 端口启动 SOCKS 代理，将流量转发到服务器: `ssh -D 1234 user@hostname`
- 启用 X11 图形界面转发: `ssh -X user@hostname`
]
#commandBlock(title: "HTTP 文件下载:", command: "wget [options] url")[
- 下载文件到当前目录: `wget http://example.com/a.txt`
- 下载文件到 `~/example.txt`: `wget -O \~/example.txt http://example.com/a.txt`
]
#commandBlock(title: "HTTP 请求处理:", command: "curl [options] url")[
- 显示请求详细 (#strong[v]erbose) 信息: `curl -v http://example.com/`
- 下载文件到 `~/example.txt`: `curl -fLo ~/example.txt http://example.com/a.txt`
- 发送 POST 请求: `curl -X POST http://example.com --data 'hello, world'`
]
== 终端快捷键
#commandBlock(title: "")[
- (C- = Ctrl, M- = Alt)
- C-c: 结束当前进程（发送 `SIGINT` 信号）
- C-z: 暂停当前进程（发送 `SIGTSTP` 信号）
- `jobs`: 显示后台进程
- `bg %1`: 后台 (#strong[b]ack#strong[g]round) 恢复 1 号后台进程
- `fg %1`: 前台 (#strong[f]ront#strong[g]round) 恢复 1 号后台进程
- C-d: 结束输入 / `EOF`
- C-r: 搜索历史记录
- C-a: 跳转到输入开头
- C-e: 跳转到输入结尾
- C-k: 删除当前光标到输入结尾的内容
- C-u: 删除当前行
- C-w: 删除前一个单词
- M-d: 删除后一个单词
- C-y: 粘贴最后被快捷键删除的单词
]
]
|
https://github.com/noneback/typst-template | https://raw.githubusercontent.com/noneback/typst-template/main/blog.typ | typst | #import "blog_template.typ": doc_tmplate, insert_image
#show: doc => doc_tmplate(
title: [
Towards Improved Modelling
],
category: ("distribed system", "database"),
keywords: ("raft", "consensu"),
authors: (
(
name: "<NAME>",
affiliation: "Artos Institute",
email: "<EMAIL>",
),
(
name: "<NAME>",
affiliation: "Honduras State",
email: "<EMAIL>",
)
),
abstract: lorem(100),
doc,
)
= Introduction
#lorem(90)
== Motivation
#lorem(140)
== Solution
#lorem(100)
#insert_image("./assets/img.png", "test", "test image") <test>
=== Problem Statement
@test this show test result.
#lorem(50)
= Related Work
#lorem(200)
真的假的
= Reference
+ System Arch: #link("https://www.baidu.com") |
|
https://github.com/IdoWinter/UnitedDumplingsLegislatureArchive | https://raw.githubusercontent.com/IdoWinter/UnitedDumplingsLegislatureArchive/main/elections/april_24/pm.typ | typst | MIT License | #import "../ballot.typ": *
#set page(paper: "a4", margin: 0pt)
//#set page(fill: yellow)
#repeat_ballot(pm_ballot([עידו], [וינטר]))
#repeat_ballot(pm_ballot([איתי], [וינטר]))
#repeat_ballot(pm_ballot([דור], [וינטר]))
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/meta/link-07.typ | typst | Other | // Link containing a block.
#link("https://example.com/", block[
My cool rhino
#box(move(dx: 10pt, image("test/assets/files/rhino.png", width: 1cm)))
])
|
https://github.com/HEIGVD-Experience/docs | https://raw.githubusercontent.com/HEIGVD-Experience/docs/main/S5/SYE/docs/3-AppelsSystemes%26Processus/appels-systèmes-processus.typ | typst | #import "/_settings/typst/template-note.typ": conf
#show: doc => conf(
title: [
Appels systèmes et processus
],
lesson: "SYE",
chapter: "3 - Appels Systèmes et Processus",
definition: "Definition",
col: 1,
doc,
)
= Appels systèmes
L'appel système permet de passer de l'espace utilisateur à l'espace noyau en exécutant du code appartenant au système d'exploitation. Ce processus nécessite un basculement du processeur en mode noyau via une interruption logicielle, telle que l'instruction `int n` sur les processeurs Intel, où n désigne le numéro de l'interruption. Bien que ces interruptions soient principalement réservées au processeur pour gérer les erreurs d'exécution, elles peuvent également être déclenchées par le programme. Les interruptions les plus couramment utilisées pour les appels systèmes incluent `sysenter` ou `int 0x80` sur Intel, `svc` (ou `swi`) sur ARM, et `syscall` sur MIPS.
- Un appel système implique une interruption logiciel réservée.
- Passage d'arguments via les registres et/ou la pile
- Invocation d'un stub dans l'espace utilisateur
- Convention d'appel définie par l'Application Binary Interface (ABI)
#image("/_src/img/docs/image copy 135.png")
== POSIX
POSIX (Portable Operating System Interface) est une norme qui standardise les appels système sous forme de fonctions C, facilitant la portabilité des applications entre différents systèmes d'exploitation. Bien que Windows ait ses propres appels système via la librairie Win32, qui est documentée dans MSDN, il supporte également POSIX, mais dans une moindre mesure. Sous Linux, les appels système sont intégrés dans la bibliothèque libc de l'espace utilisateur, où se trouvent les implémentations des stubs des appels système.
D'autres normes relatives aux APIs des appels système incluent ANSI, SVr4, X/OPEN et BSD. En général, les appels système sont coûteux en raison des changements d'état du processeur nécessaires pour passer de l'espace utilisateur à l'espace noyau. Pour cette raison, il est souvent préférable d'utiliser des fonctions de plus haut niveau qui minimisent les appels système, par exemple en gérant des buffers dans l'espace utilisateur lors d'opérations comme `read()`. Ces fonctions sont regroupées dans diverses librairies de l'espace utilisateur.
= Construction d'une image binaire
La chaîne de compilation convertit le code source en une image binaire exécutable. Cette image est composée de plusieurs sections : `.text` pour les instructions, `.data` pour les variables initialisées, `.bss` pour les variables non initialisées, et d'autres. L'éditeur de liens (linker) résout les dépendances entre le code et les bibliothèques, créant ainsi une image binaire complète.
#image("/_src/img/docs/image copy 136.png")
La chaîne de compilation permet de construire une application sous forme d'un fichier binaire exécutable, appelé aussi image binaire. L'image binaire est donc le résultat d'une compilation et d'une opération de linkage ou édition des liens.
Le compilateur traduit le code source (C, C++, Java, assembleur, etc.) en un fichier binaire intermédiaire, appelé fichier objet (ou code objet).
#colbreak()
== Types d'adresses
- 3 types d'adresse
- Adresses relatives
- Adresses absolues
- Adresses symboliques
#image("/_src/img/docs/image copy 137.png")
=== Adresses relatives
Elles sont basées sur un offset (positif ou négatif) et permettent au processeur de déterminer l'adresse effective par rapport à la position courante. Le compilateur ne connaît pas l'emplacement exact des instructions ou des données dans la mémoire physique.
=== Adresses absolues
Ces adresses indiquent un emplacement final dans la mémoire et peuvent être générées par le compilateur dans le code binaire. Elles ne changent pas lors du chargement du code en mémoire.
=== Adresses symboliques
Utilisées par le compilateur lorsque l'emplacement d'une instruction ou d'une donnée n'est pas connu, généralement parce qu'elle réside dans un autre fichier ou en mémoire physique. Ces adresses sont représentées par des noms symboliques et sont résolues ultérieurement par l'éditeur de lien (linker).
= Processus
Un processus est chargé en mémoire par le noyau et commence son exécution, avec la fonction main() comme point d'entrée pour un programmeur en C, bien qu'il ne s'agisse pas des premières instructions réellement exécutées. Un code de démarrage (C runtime) est ajouté à l'exécutable par l'éditeur de lien.
Pour qu'un processus soit chargé, il doit exister un fichier exécutable sur un support de stockage, représentant l'image binaire du processus. Chaque processus a un contexte d'exécution, déterminé par ses instructions et nécessitant des structures d'état, comme une pile, et un contexte mémoire, qui inclut un espace mémoire contenant toutes les instructions et le code.
Dans un système multitâche, plusieurs processus peuvent être chargés en mémoire et exécutés à tour de rôle sur le processeur, souvent pour des durées équivalentes. Ce partage du temps processeur crée l'illusion que les processus s'exécutent simultanément pour l'utilisateur.
#image("/_src/img/docs/image copy 138.png")
Après la phase de démarrage du noyau, ce dernier lance le premier processus, généralement un processus spécial de type init ou idle, qui peut ensuite démarrer d'autres processus, comme un shell. Dans certains systèmes, le shell peut être le premier processus.
Une application peut comprendre un ou plusieurs processus, et plusieurs contextes d'exécution peuvent également exister au sein d'un même processus. La création d'un nouveau processus se fait toujours à partir d'un processus existant, établissant une relation parent-enfant. Lorsqu'un processus se termine, il doit informer son parent, qui peut alors récupérer l'état et libérer les ressources allouées par le processus enfant.
Si un processus parent se termine prématurément alors qu'il a encore des enfants, cela crée des processus orphelins. Le noyau doit alors "rattacher" ces processus orphelins à un autre processus parent de niveau supérieur, comme le processus racine (init ou idle). Cela est crucial, car lorsque le processus orphelin termine son exécution, son nouveau parent doit libérer les ressources qui lui étaient allouées.
#image("/_src/img/docs/image copy 139.png")
Un processus est chargé en mémoire à partir de son image binaire, c'est-à-dire du fichier exécutable structuré, qui contient des sections pour le code, les données initialisées et non initialisées, ainsi que des symboles permettant le débogage. La plupart de ces sections sont chargées dans la RAM au sein du contexte mémoire du processus.
Les fichiers exécutables respectent des formats standards : sous Windows, on trouve le COFF, ECOFF, ou PE ; sous Linux, le format ELF est utilisé, remplaçant "a.out" ; et sous MacOS X, le format utilisé est Mach-O. Ces fichiers exécutables contiennent généralement trois types d'adresses : relatives, absolues, et symboliques.
#image("/_src/img/docs/image copy 140.png") |
|
https://github.com/Zeta611/simplebnf.typ | https://raw.githubusercontent.com/Zeta611/simplebnf.typ/main/README.md | markdown | MIT License | # simplebnf.typ
simplebnf is a simple package to format Backus-Naur form. The package provides a simple way to format Backus-Naur form (BNF). It provides constructs to denote BNF expressions, possibly with annotations.
This is a sister package of [simplebnf](https://github.com/Zeta611/simplebnf), a LaTeX package under the same name by the author.
## Usage
Import simplebnf via
```typst
#import "@preview/simplebnf:0.1.1": *
```
Use the `bnf` function to display the BNF production rules. Each production rule can be created using the `Prod` constructor function, which accepts the (left-hand side) metavariable, an optional annotation for it, an optional delimiter (which defaults to ⩴), and a list of (right-hand side) alternatives. Each alternative should be created using the `Or` constructor, which accepts a syntactic form and an annotation.
Below are some examples using simplebnf.
```typst
#bnf(
Prod(
$e$,
annot: $sans("Expr")$,
{
Or[$x$][_variable_]
Or[$λ x. e$][_abstraction_]
Or[$e$ $e$][_application_]
},
),
)
```
```typst
#bnf(
Prod(
$e$,
delim: $→$,
{
Or[$x$][variable]
Or[$λ x: τ.e$][abstraction]
Or[$e space e$][application]
Or[$λ τ.e space e$][type abstraction]
Or[$e space [τ]$][type application]
},
),
Prod(
$τ$,
delim: $→$,
{
Or[$X$][type variable]
Or[$τ → τ$][type of functions]
Or[$∀X.τ$][universal quantification]
},
),
)
```
## Authors
- <NAME> <<EMAIL>>
## License
simplebnf.typ is available under the MIT license. See the [LICENSE](https://github.com/Zeta611/simplebnf.typ/blob/master/LICENSE) file for more info.
|
https://github.com/ayoubelmhamdi/typst-phd-AI-Medical | https://raw.githubusercontent.com/ayoubelmhamdi/typst-phd-AI-Medical/master/chapters/ch22.typ | typst | MIT License | #import "../functions.typ": heading_center, images, italic,linkb, dots
#import "../tablex.typ": tablex, cellx, rowspanx, colspanx, hlinex
#let finchapiter = text(fill:rgb("#1E045B"),"■")
// #linebreak()
// #linebreak()
// #counter("tabl").update(n=>n+20)
= DÉTECTION DES NODULES PULMONAIRES DU CANCER.
== Introduction
Les nodules pulmonaires sont des lésions arrondies ou ovales qui se forment dans le poumon. Ils peuvent être bénins ou malins, et leur détection précoce est cruciale pour le diagnostic et le traitement du cancer du poumon. Selon l'Organisation mondiale de la santé, le cancer du poumon est la première cause de décès par cancer dans le monde, avec environ 2,2 millions de nouveaux cas et 1,8 million de décès en 2020.
L'imagerie par scanner est la méthode la plus courante pour détecter et caractériser les nodules pulmonaires. Cependant, il existe une grande variabilité dans l'interprétation des images et la prise en charge des nodules. Pour harmoniser les pratiques cliniques et réduire les examens inutiles ou invasifs, il existe des directives basées sur la taille, la forme, l'évolution et le risque de malignité des nodules.
Dans cet étude, nous proposons d'utiliser le deep learning pour améliorer la prise en charge des nodules pulmonaires. Le deep learning est une technique d'intelligence artificielle qui permet d'apprendre à partir de grandes quantités de données et de réaliser des tâches complexes comme la classification ou la segmentation d'images. Nous utilisons le dataset LIDC-IDRI, qui contient 1018 scanners thoraciques annotés par quatre radiologues experts. Chaque nodule pulmonaire est décrit par un fichier XML qui contient son identifiant, ses caractéristiques et sa région d'intérêt. Par exemple, voici le fichier XML correspondant au nodule numéro 4 :
#pagebreak()
```xml
<unblindedReadNodule>
<noduleID>4</noduleID>
<characteristics>
<subtlety>4</subtlety>
<internalStructure>1</internalStructure>
<calcification>6</calcification>
<sphericity>4</sphericity>
<margin>4</margin>
<lobulation>1</lobulation>
<spiculation>2</spiculation>
<texture>5</texture>
<malignancy>3</malignancy>
</characteristics>
<roi>
<imageZposition>1487.5</imageZposition>
<imageSOP_UID>1.3.6.1.4.1.14519.5.2.1.6279.6001.270602739536521934855332163694</imageSOP_UID>
<inclusion>TRUE</inclusion>
<edgeMap><xCoord>322</xCoord><yCoord>303</yCoord></edgeMap>
<edgeMap><xCoord>322</xCoord><yCoord>304</yCoord></edgeMap>
<edgeMap><xCoord>322</xCoord><yCoord>305</yCoord></edgeMap>
<edgeMap><xCoord>323</xCoord><yCoord>303</yCoord></edgeMap>
<edgeMap><xCoord>322</xCoord><yCoord>303</yCoord></edgeMap>
</roi>
</unblindedReadNodule>
```
Ce fichier XML contient des informations importantes sur le nodule, telles que sa taille, sa forme, sa structure, sa calcification, sa texture et son risque de malignité. Il contient également la position et le contour du nodule sur l’image.
Nous commençons par développer un modèle de classification qui peut identifier le type de nodulaire à partir des images CT scan. Nous avons utilisé le dataset LUNA16, qui est un sous-ensemble du dataset LIDC-IDRI, pour entraîner et évaluer notre modèle de classification. Nous avons comparé les performances de notre modèle de classification avec celles des radiologues et des directives existantes.
Ensuite, nous créons un nouveau dataset appelé *TRPMLN*, qui extrait les nodules qui ont une moyenne de malignité égale à 3 ou plus dans les annotations des quatre experts. Nous avons inclus une annexe qui présente l'implémentation du code pour créer cet ensemble de données. Nous développons un autre modèle de classification qui peut classer les nodules en fonction de leur malignité à partir des images CT scan. Nous comparons les performances de notre modèle avec celles des radiologues et des directives existantes.
Le plan de l'étude est le suivant : dans la section Méthode, nous présentons le dataset LIDC-IDRI, le dataset LUNA16, le dataset TRPMLN, les modèles de deep learning et les critères d'évaluation. Dans la section Résultats, nous montrons les résultats obtenus par nos modèles sur les datasets LUNA16 et TRPMLN. Dans la section Discussion, nous analysons les forces et les limites de notre approche, ainsi que les implications cliniques. Dans la section Conclusion, nous résumons nos contributions et proposons des perspectives futures. #finchapiter
== Méthode
Notre étude comprenait trois étapes principales : le prétraitement des données, le développement des algorithmes de classification des nodules et l'évaluation des performances.
=== Ressources
Les ressources de notre étude étaient des scans CT et des annotations provenant du dataset LIDC-IDRI, du dataset LUNA16 et TRPMLN. Le dataset LIDC-IDRI est une base de données publique qui contient 1018 scans thoraciques annotés par quatre radiologues experts. Chaque nodule pulmonaire est décrit par un fichier XML qui contient son identifiant, ses caractéristiques et sa région d'intérêt.
- LUNA16:
Le dataset LUNA16 est un sous-ensemble du dataset LIDC-IDRI, qui contient 1186 nodules annotés dans 888 scans thoraciques. Ce dataset fournit également deux fichiers CSV distincts contenant les détails des candidats et des annotations. Dans le fichier candidates.csv, quatre colonnes sont illustrées : seriesuid, coordX, coordY, coordZ, et classe. Ici, le seriesuid fonctionne comme un identifiant unique pour chaque scan ; coordX, coordY, et coordZ représentent les coordonnées spatiales pour chaque candidat en millimètres, et 'classe' fournit une catégorisation binaire, dépeignant si le candidat est un nodule (1) ou non (0).
#figure(
tablex(
columns: 5,
align: center + horizon,
auto-vlines: false,
repeat-header: false,
[*seriesuid*], [*coordX*], [*coordY*], [*coordZ*], [*class*],
[1.3.6...666836860], [68.42], [-74.48], [-288.7], [0],
hlinex(stroke: 0.25pt),
[1.3.6...666836860], [68.42], [-74.48], [-288.7], [0],
hlinex(stroke: 0.25pt),
[1.3.6...666836860], [-95.20936148], [-91.80940617], [-377.4263503], [0],
),
caption: [Coordonnées des candidats détectés dans le dataset Luna16 avec diamètres],
kind: "tabl",
supplement: [#text(weight: "bold","Table")],
)
Le fichier annotations.csv est composé de cinq colonnes : seriesuid, coordX, coordY, coordZ, et diamètre_mm, commandant l'identifiant unique du scanner, les coordonnées d'annotation spatiales en millimètres, et le diamètre de chaque annotation en millimètres, respectivement. Ces annotations ont été marquées manuellement en se basant sur l'identification des nodules de plus de 3 mm de diamètre par quatre radiologistes indépendants.
#figure(
tablex(
columns: 5,
align: center + horizon,
auto-vlines: false,
repeat-header: false,
[*seriesuid*], [*coordX*], [*coordY*], [*coordZ*], [*diameter_mm*],
[1.3.6.1....6860], [-128.6994211], [-175.3192718], [-298.3875064], [5.65147063],
hlinex(stroke: 0.25pt),
[1.3.6.1....6860], [103.7836509], [-211.9251487], [-227.12125], [4.224708481],
hlinex(stroke: 0.25pt),
[1.3.6.1....5208], [69.63901724], [-140.9445859], [876.3744957], [5.786347814],
),
caption: [Annotations des nodules détectés dans le dataset Luna16],
kind: "tabl",
supplement: [#text(weight: "bold","Table")],
)
=== Scans CT avec Nodules Pulmonaires
Pour lire, traiter et représenter visuellement les scans CT montrant des nodules pulmonaires , nous avons mis en œuvre deux bibliothèques Python : SimpleITK et matplotlib. SimpleITK offre un point d'accès simplifié à l'Insight Segmentation and Registration Toolkit (ITK), un cadre construit pour l'analyse et le traitement d'images. Matplotlib, en revanche, offre des fonctionnalités pour la visualisation et l'amélioration des images.
Avec SimpleITK, nous avons lu les fichiers de scan CT du dataset LUNA16, convertissant ces images de leur format DICOM ou NIfTI en tableaux numériques multidimensionnels manipulables, appelés tableaux numpy. De plus, SimpleITK a été utilisé pour obtenir l'origine et l'espacement des images, qui sont des informations nécessaires pour convertir les coordonnées des annotations en indices de tableau numpy. Avec matplotlib, nous avons affiché les images CT avec les annotations superposées, en utilisant des cercles rouges pour indiquer les nodules.
=== Prétraitement des Données
Avant d'entraîner nos modèles de deep learning, nous avons effectué quelques étapes de prétraitement sur les données. Tout d'abord, nous avons normalisé les valeurs de pixels des images CT en utilisant la formule suivante :
$$
x_{norm} = \frac{x - \mu}{\sigma}
$$
où $x$ est la valeur originale du pixel, $\mu$ est la moyenne globale des pixels, et $\sigma$ est l'écart-type global des pixels. Cette normalisation permet de réduire l'échelle des valeurs et de faciliter l'apprentissage des modèles.
Ensuite, nous avons appliqué une segmentation du poumon sur les images CT, afin d'éliminer le bruit et les structures non pertinentes. Nous avons utilisé un algorithme basé sur le seuillage et la croissance de région, qui consiste à sélectionner un seuil initial pour séparer le poumon du fond, puis à étendre progressivement la région du poumon en fonction de la similarité des pixels voisins. Nous avons ensuite extrait la région du poumon comme une nouvelle image et rempli les trous éventuels avec une opération de fermeture morphologique.
Enfin, nous avons extrait des patchs 3D autour des nodules annotés et des candidats non nodulaires. Nous avons utilisé une taille de patch de 64 x 64 x 64 pixels, ce qui correspond à environ 40 x 40 x 40 mm dans l'espace réel. Nous avons centré le patch sur la coordonnée du nodule ou du candidat, et nous avons rempli les bords avec des zéros si le patch dépassait les limites de l'image. Nous avons obtenu un total de 1186 patchs nodulaires et 551065 patchs non nodulaires.
=== Modèles de Deep Learning
Nous avons développé deux modèles de deep learning pour classer les nodules pulmonaires à partir des patchs 3D extraits. Le premier modèle vise à distinguer les nodules des lésions non nodulaires, tandis que le second modèle vise à classer les nodules selon leur malignité.
=== Modèle de Classification Binaire
Le modèle de classification binaire est un réseau neuronal convolutif 3D (CNN) qui prend en entrée un patch 3D et produit en sortie une probabilité d'être un nodule. Le modèle est composé de cinq couches convolutives avec des filtres 3 x 3 x 3 et des fonctions d'activation ReLU, suivies chacune d'une couche de normalisation par lots et d'une couche de max-pooling avec un facteur 2. La dernière couche convolutive est suivie d'une couche entièrement connectée avec 512 neurones et une fonction d'activation ReLU, puis d'une couche de dropout avec un taux de 0.5. La couche finale est une couche entièrement connectée avec un neurone et une fonction d'activation sigmoïde, qui produit la probabilité d'être un nodule.
Nous avons entraîné le modèle sur le dataset LUNA16, en utilisant une fraction de validation de 0.2 et une fraction de test de 0.1. Nous avons utilisé la fonction de perte d'entropie croisée binaire comme critère d'optimisation, et l'algorithme Adam comme optimiseur. Nous avons utilisé un taux d'apprentissage initial de 0.001, que nous avons réduit par un facteur 0.1 si la perte de validation ne diminuait pas pendant 10 époques consécutives. Nous avons arrêté l
|
https://github.com/sofianedjerbi/Resume | https://raw.githubusercontent.com/sofianedjerbi/Resume/main/modules/certificates.typ | typst | Apache License 2.0 | #import "../brilliant-CV/template.typ": *
#cvSection("Certificates")
#cvHonor(
date: [Jun 2024],
title: [AWS Certified Developer Associate],
issuer: [Amazon Web Services (AWS)]
)
#cvHonor(
date: [May 2024],
title: [AWS Certified Solutions Architect Associate],
issuer: [Amazon Web Services (AWS)]
)
#cvHonor(
date: [Apr 2024],
title: [AWS Certified Cloud Practitioner],
issuer: [Amazon Web Services (AWS)]
)
|
https://github.com/liamaxelrod/Resume | https://raw.githubusercontent.com/liamaxelrod/Resume/main/test_typst/tutorial_formatting.typ | typst | = Formatting with Set rules
how to format your report using Typst's styling system.
With set rules, you can apply style properties to all occurrences of some kind of content throughout the document.
you'll notice that the set route doesn't take effect until you make the command
\#set par(first-line-indent: 0.65em)
#set par(first-line-indent: 0.65em)
then after that point the code is invoked all text will have the rule put in place this being the indent for each beginning paragraph. now were going to put in text effect.
\#set text(
font: "New Computer Modern",
size: 10pt
)
== text
#set text(
font: "New Computer Modern",
size: 15pt
)
you'll see in thisThat the text font has changed along with its size
#set text(
font: "New Computer Modern",
size: 10pt
)
and the text can be set to a new rule change the size
== align
#align(center + top)[
\#align(center + top)\[text\]
center make the text appear in the center of the page, and top makes a come up to as close as I can get to when the method was invoked following the text within the brackets
]
#set heading(numbering: "1.")
= heading
\#set heading(numbering: "1.")
is the command in the form of a set rule some of this point forward when using = or == they will be marked as headings throughout the page.
= show with (box and name)
\#show "ArtosFlow": name => box[
\#box(image(
"image_typst.jpg",
height: 0.7em,
))
\#name
]
use show method to reveal different things and colors. With the text afterward representing when when to show it. ???asked Drake about the process???
#show "ArtosFlow": name => box[
#box(image(
"image_typst.jpg",
height: 0.7em,
))
#name
]
This report is embedded in the
ArtosFlow project. ArtosFlow is a
project of the Artos Institute.
= page
The page method allows you to control how the page will be set up margins and placement from that point forward. The reason after each set was invoked it was moved down to a lower page is because the method was not invoked on the active page this text is appearing on.
#set page(
paper: "a6",
margin: (x: 1.8cm, y: 1.5cm),
)
text is placed here
#set page(
paper: "a6",
margin: (x: 1.8cm, y: 10.5cm),
)
text is placed here |
|
https://github.com/mariunaise/HDA-Thesis | https://raw.githubusercontent.com/mariunaise/HDA-Thesis/master/graphics/quantizers/two-bit-enroll-real.typ | typst | #import "@preview/cetz:0.2.2": canvas, plot, decorations, draw
#let line_style = (stroke: (paint: black, thickness: 2pt))
#let dashed = (stroke: (dash: "dashed"))
#canvas({
plot.plot(size: (8,6),
legend: "legend.south",
name: "plot",
x-tick-step: 1,
// x-ticks: ((-1.168, [-1.16]), (1.168, [1.16])),
y-label: $cal(Q)(2, x)$,
x-label: $x$,
y-tick-step: none,
y-ticks: ((0.25, [00]), (0.5, [01]), (0.75, [10]), (1, [11])),
axis-style: "left",
x-min: -3,
x-max: 3,
y-min: 0,
y-max: 1,{
plot.add(((-3,0.25), (-1.168,0.25), (-1.168,0.5), (0, 0.5), (0, 0.75), (1.168,0.75), (1.168, 1), (3, 1)), style: line_style)
plot.add(((-2.657, 0), (-2.657, 1)), style: (stroke: (paint: red)), label: [Artificial quantizer bounds])
plot.add(((2.657, 0), (2.657, 1)), style: (stroke: (paint: red)))
plot.add-hline(0.25, 0.5, 0.75, 1, style: dashed)
plot.add-vline(-1.168, 1.168, style: dashed)
plot.add-anchor("uc01", (-0.584, 0.5))
plot.add-anchor("lc01", (-0.584, 0))
plot.add-anchor("uc10", (0.584, 0.75))
plot.add-anchor("lc10", (0.584, 0))
plot.add-anchor("uc00", (-1.9125, 0.25))
plot.add-anchor("lc00", (-1.9125, 0))
plot.add-anchor("uc11", (1.9125, 1))
plot.add-anchor("lc11", (1.9125, 0))
})
draw.line("plot.uc01", ((), "|-", "plot.lc01"), mark: (end: ">"))
draw.line("plot.uc10", ((), "|-", "plot.lc10"), mark: (end: ">"))
draw.line("plot.uc00", ((), "|-", "plot.lc00"), mark: (end: ">"))
draw.line("plot.uc11", ((), "|-", "plot.lc11"), mark: (end: ">"))
})
|
|
https://github.com/An-314/Notes-of-DSA | https://raw.githubusercontent.com/An-314/Notes-of-DSA/main/string.typ | typst | = 串string/char[]
用`char[]`表示串，主要讨论串的匹配。
== 蛮力算法BF
从前往后遍历，每次匹配失败则推进到下一个位置。
通常建议用双移动的指针实现。
```cpp
int match( char * P, char * T )
{
size_t n = strlen(T), i = 0;
size_t m = strlen(P), j = 0;
while ( j < m && i < n ) //自左向右逐次比对（可优化）
if ( T[i] == P[j] ) { i ++; j ++; } //若匹配，则转到下一对字符
else { i -= j-1; j = 0; } //否则， T回退、 P复位
return i-j; //最终的对齐位置：藉此足以判断匹配结果
}
```
通过移动同时移动`i`和`j`，逐位比较，之后`i`回退，`j`复位，继续比较。
这种算法的时间复杂度为$O(m n)$，其中$m$为模式串长度，$n$为文本串长度。
== KMP算法
一次比较在第`j`位失配，已经掌握了前`j`位的信息，可以利用这些信息，跳过一些不必要的比较。
例如，一次比较后，就可以直接跳转到下图的位置，而不必从头开始比较。
```
R E G R E S S ...
R E G R E T S
R E G R E T S
```
*快速右移+决不后退：*这满足，模式串长为`j`的前缀的一部分真前缀等于真后缀，且要保证真前缀的长度最大。
=== `next[]`表
用这样的方式构造查询表`next[]`。
#figure(
image("fig\串\1.png",width: 80%),
caption: "next[]表",
)
用数学语言描述是：
$ forall j >= 1, bold(N)(P,j)&={0<=t<j | P[0,t) = P[j-t,j)} \
"next"[j] &= max{bold(N)(P,j)} $
下面写出构造的递推关系：
$ "next"[j+1] = "next"[j] + 1 <=> P[j] = P["next"[j]] $
这是因为，如果$P[j] = P["next"[j]]$，那么$P[j+1] = P["next"[j]+1]$，所以$P[j+1]$的真前缀长度为$P[j]$的真前缀长度加一。
如果$P[j] != P["next"[j]]$，就向前递推，看$P[J]$与$P["next"["next"[j]]]$是否相等。如果相等，就可令$"next"[j+1] = "next"["next"[j]] + 1$，否则继续递推。直到找到一个相等的，或者$j$递推到$0$（$"next"[0]=-1$）。
```cpp
int* buildNext( char* P ) {
size_t m = strlen(P), j = 0;
int* next = new int[m];
int t = next[0] = -1;
while ( j < m - 1 )
if ( 0 > t || P[t] == P[j] ) { //匹配
++t; ++j; next[j] = t; //则递增赋值
} else //否则
t = next[t]; //继续尝试下一值得尝试的位置
return next;
}
```
这样以来KMP算法(Knuth-Morris-Pratt)就可以写成：
```cpp
int match( char * P, char * T ) {
int * next = buildNext(P);
int n = (int) strlen(T), i = 0;
int m = (int) strlen(P), j = 0;
while ( j < m && i < n ) //可优化
if ( 0 > j || T[i] == P[j] ) {
i ++; j ++;
} else
j = next[j];
delete [] next;
return i - j;
}
```
通过生成模式串的`next[]`表，可以在匹配失败时，直接跳转到`next[]`表中的位置，而不必从头开始比较。
=== 分摊分析
KMP算法的时间复杂度为$O(m+n)$，其中$m$为模式串长度，$n$为文本串长度。
其中，生成`next[]`表的时间复杂度为$O(m)$，匹配的时间复杂度为$O(n)$。
#figure(
image("fig\串\2.png",width: 80%),
caption: "KMP算法的分摊分析",
)
考虑上图，浅绿色是不言自明的比较、深绿色是消耗时间的比较。将红色即失配部分，前移后，可以看到所有深绿与红色的部分之和，为$O(n)$的。
也可以构造计步器$k=2i-j$，这个计步器是严格增加的，最大值是$2n-1$，所以时间复杂度为$O(n)$。
```cpp
while ( j < m && i < n ) //k必随迭代而单调递增，故也是迭代步数的上界
if ( 0 > j || T[i] == P[j] )
{ i ++; j ++; } //k恰好加1
else
j = next[j]; //k至少加1
```
== 优化的KMP算法
按照刚才的方法，每次失配的下一次对比没有用到目前正在比较的`P[j]`的信息。
如果该位置是字符`c`导致失配，那么下一次比较，除了刚才的前后缀相同以外，保证前缀的下一位不再是`c`。这样就可以吸取刚才的教训。
=== `next[]`表
$ forall j >= 1, bold(N)(P,j)&={0<=t<j | P[0,t) = P[j-t,j) "且" P[t]!=P[j]} \
"next"[j] &= max{bold(N)(P,j)} $
代码实现如下
```cpp
int* buildNext( char* P ) {
size_t m = strlen(P), j = 0;
int* next = new int[m]; int t = next[0] = -1;
while ( j < m – 1 )
if ( 0 > t || P[t] == P[j] ) {
if ( P[++t] != P[++j] )
next[j] = t;
else //P[next[t]] != P[t] == P[j]
next[j] = next[t];
} else
t = next[t];
return next;
}
```
该算法单次匹配概率越大（字符集越小），优势越明显。
== BM算法
Boyer-Moore提出了两种策略，BC策略和GS策略。
=== BC策略
每次匹配从末字符开始，从后向前匹配。如果失配，就考察前面的字符是否有造成失配的，如果有，就将其移动过来，否则就移动整个模式串。
#figure(
image("fig\串\3.png",width: 80%),
caption: "BC策略",
)
==== Bad-Character规则
如果失配的字符在模式串中，就将模式串移动到该字符的右侧，否则移动整个模式串。
*画家算法：*将第$j$位对应的字符$c$处的$"bc"[c]$赋值成$j$，如果$c$不在模式串中，就赋值成$-1$。从小到大遍历后，$"bc"[*]$中储存的就是每个字符最后出现的位置。
```cpp
int * buildBC( char * P ) {
int * bc = new int[ 256 ];
for ( size_t j = 0; j < 256; j++ ) bc[j] = -1;
for ( size_t m = strlen(P), j = 0; j < m; j++ )
bc[ P[ j ] ] = j; //painter's algorithm
return bc;
} //O( s + m )
```
只用存储最后一个而不用全部存储的原因是，每次移动可以保证在移动中间的位置都是不合法的，只要一直比较并且移动，就可以保证不会出现不合法的情况。
==== 复杂度分析
最好情况是$O(n/m)$，最坏情况是$O(m n)$。
单次匹配概率越小，性能优势越明显，需单次比较，即可排除m个对齐位置，一次移动$m$个对齐位置。
单次匹配概率越大的场合，性能越接近于蛮力算法。
=== GS策略
仿照KMP，记忆好后缀。相当于KMP从后颠倒。
==== Good-Suffix规则
扫描比对中断于$T[i + j] != P[j]$时，$U = P(j,m)$必为好后缀。下一对齐位置满足：
+ $U$重新与$V(k) = P( k, m + k - j )$匹配 (_经验_)
+ $P[ k ] != P[ j ]$ (_教训_)
=== 综合性能
#figure(
image("fig\串\4.png",width: 80%),
caption: "字符串匹配的综合性能",
)
== Karp-Rabin算法
将字符串看成是一个数字，通过哈希函数将字符串转换成数字，然后比较数字是否相等。
通过散列，将指纹压缩至存储器支持的范围，但指纹相同，原串却未必匹配。
=== 快速指纹计算
每次计算指纹时，只需要减去最高位，然后乘以基数，再加上新的最低位即可。这样可以在$O(1)$的时间内完成递推。 |
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/layout/columns_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Test normal operation and RTL directions.
#set page(height: 3.25cm, width: 7.05cm, columns: 2)
#set text(lang: "ar", font: ("Noto Sans Arabic", "Linux Libertine"))
#set columns(gutter: 30pt)
#box(fill: conifer, height: 8pt, width: 6pt) وتحفيز
العديد من التفاعلات الكيميائية. (DNA) من أهم الأحماض النووية التي تُشكِّل
إلى جانب كل من البروتينات والليبيدات والسكريات المتعددة
#box(fill: eastern, height: 8pt, width: 6pt)
الجزيئات الضخمة الأربعة الضرورية للحياة.
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/unichar/0.1.0/ucd/block-08A0.typ | typst | Apache License 2.0 | #let data = (
("ARABIC LETTER BEH WITH SMALL V BELOW", "Lo", 0),
("ARABIC LETTER BEH WITH HAMZA ABOVE", "Lo", 0),
("ARABIC LETTER JEEM WITH TWO DOTS ABOVE", "Lo", 0),
("ARABIC LETTER TAH WITH TWO DOTS ABOVE", "Lo", 0),
("ARABIC LETTER FEH WITH DOT BELOW AND THREE DOTS ABOVE", "Lo", 0),
("ARABIC LETTER QAF WITH DOT BELOW", "Lo", 0),
("ARABIC LETTER LAM WITH DOUBLE BAR", "Lo", 0),
("ARABIC LETTER MEEM WITH THREE DOTS ABOVE", "Lo", 0),
("ARABIC LETTER YEH WITH TWO DOTS BELOW AND HAMZA ABOVE", "Lo", 0),
("ARABIC LETTER YEH WITH TWO DOTS BELOW AND DOT ABOVE", "Lo", 0),
("ARABIC LETTER REH WITH LOOP", "Lo", 0),
("ARABIC LETTER WAW WITH DOT WITHIN", "Lo", 0),
("ARABIC LETTER ROHINGYA YEH", "Lo", 0),
("ARABIC LETTER LOW ALEF", "Lo", 0),
("ARABIC LETTER DAL WITH THREE DOTS BELOW", "Lo", 0),
("ARABIC LETTER SAD WITH THREE DOTS BELOW", "Lo", 0),
("ARABIC LETTER GAF WITH INVERTED STROKE", "Lo", 0),
("ARABIC LETTER STRAIGHT WAW", "Lo", 0),
("ARABIC LETTER ZAIN WITH INVERTED V ABOVE", "Lo", 0),
("ARABIC LETTER AIN WITH THREE DOTS BELOW", "Lo", 0),
("ARABIC LETTER KAF WITH DOT BELOW", "Lo", 0),
("ARABIC LETTER QAF WITH DOT BELOW AND NO DOTS ABOVE", "Lo", 0),
("ARABIC LETTER BEH WITH SMALL MEEM ABOVE", "Lo", 0),
("ARABIC LETTER PEH WITH SMALL MEEM ABOVE", "Lo", 0),
("ARABIC LETTER TEH WITH SMALL TEH ABOVE", "Lo", 0),
("ARABIC LETTER REH WITH SMALL NOON ABOVE", "Lo", 0),
("ARABIC LETTER YEH WITH TWO DOTS BELOW AND SMALL NOON ABOVE", "Lo", 0),
("ARABIC LETTER AFRICAN FEH", "Lo", 0),
("ARABIC LETTER AFRICAN QAF", "Lo", 0),
("ARABIC LETTER AFRICAN NOON", "Lo", 0),
("ARABIC LETTER PEH WITH SMALL V", "Lo", 0),
("ARABIC LETTER TEH WITH SMALL V", "Lo", 0),
("ARABIC LETTER TTEH WITH SMALL V", "Lo", 0),
("ARABIC LETTER TCHEH WITH SMALL V", "Lo", 0),
("ARABIC LETTER KEHEH WITH SMALL V", "Lo", 0),
("ARABIC LETTER GHAIN WITH THREE DOTS ABOVE", "Lo", 0),
("ARABIC LETTER AFRICAN QAF WITH THREE DOTS ABOVE", "Lo", 0),
("ARABIC LETTER JEEM WITH THREE DOTS ABOVE", "Lo", 0),
("ARABIC LETTER JEEM WITH THREE DOTS BELOW", "Lo", 0),
("ARABIC LETTER LAM WITH SMALL ARABIC LETTER TAH ABOVE", "Lo", 0),
("ARABIC LETTER GRAF", "Lo", 0),
("ARABIC SMALL FARSI YEH", "Lm", 0),
("ARABIC SMALL HIGH FARSI YEH", "Mn", 230),
("ARABIC SMALL HIGH YEH BARREE WITH TWO DOTS BELOW", "Mn", 230),
("ARABIC SMALL HIGH WORD SAH", "Mn", 230),
("ARABIC SMALL HIGH ZAH", "Mn", 230),
("ARABIC LARGE ROUND DOT ABOVE", "Mn", 230),
("ARABIC LARGE ROUND DOT BELOW", "Mn", 220),
("ARABIC SUKUN BELOW", "Mn", 220),
("ARABIC LARGE CIRCLE BELOW", "Mn", 220),
("ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW", "Mn", 220),
("ARABIC SMALL LOW WAW", "Mn", 220),
("ARABIC SMALL HIGH WORD AR-RUB", "Mn", 230),
("ARABIC SMALL HIGH SAD", "Mn", 230),
("ARABIC SMALL HIGH AIN", "Mn", 230),
("ARABIC SMALL HIGH QAF", "Mn", 230),
("ARABIC SMALL HIGH NOON WITH KASRA", "Mn", 230),
("ARABIC SMALL LOW NOON WITH KASRA", "Mn", 230),
("ARABIC SMALL HIGH WORD ATH-THALATHA", "Mn", 230),
("ARABIC SMALL HIGH WORD AS-SAJDA", "Mn", 230),
("ARABIC SMALL HIGH WORD AN-NISF", "Mn", 230),
("ARABIC SMALL HIGH WORD SAKTA", "Mn", 230),
("ARABIC SMALL HIGH WORD QIF", "Mn", 230),
("ARABIC SMALL HIGH WORD WAQFA", "Mn", 230),
("ARABIC SMALL HIGH FOOTNOTE MARKER", "Mn", 230),
("ARABIC SMALL HIGH SIGN SAFHA", "Mn", 230),
("ARABIC DISPUTED END OF AYAH", "Cf", 0),
("ARABIC TURNED DAMMA BELOW", "Mn", 220),
("ARABIC CURLY FATHA", "Mn", 230),
("ARABIC CURLY DAMMA", "Mn", 230),
("ARABIC CURLY KASRA", "Mn", 220),
("ARABIC CURLY FATHATAN", "Mn", 230),
("ARABIC CURLY DAMMATAN", "Mn", 230),
("ARABIC CURLY KASRATAN", "Mn", 220),
("ARABIC TONE ONE DOT ABOVE", "Mn", 230),
("ARABIC TONE TWO DOTS ABOVE", "Mn", 230),
("ARABIC TONE LOOP ABOVE", "Mn", 230),
("ARABIC TONE ONE DOT BELOW", "Mn", 220),
("ARABIC TONE TWO DOTS BELOW", "Mn", 220),
("ARABIC TONE LOOP BELOW", "Mn", 220),
("ARABIC OPEN FATHATAN", "Mn", 27),
("ARABIC OPEN DAMMATAN", "Mn", 28),
("ARABIC OPEN KASRATAN", "Mn", 29),
("ARABIC SMALL HIGH WAW", "Mn", 230),
("ARABIC FATHA WITH RING", "Mn", 230),
("ARABIC FATHA WITH DOT ABOVE", "Mn", 230),
("ARABIC KASRA WITH DOT BELOW", "Mn", 220),
("ARABIC LEFT ARROWHEAD ABOVE", "Mn", 230),
("ARABIC RIGHT ARROWHEAD ABOVE", "Mn", 230),
("ARABIC LEFT ARROWHEAD BELOW", "Mn", 220),
("ARABIC RIGHT ARROWHEAD BELOW", "Mn", 220),
("ARABIC DOUBLE RIGHT ARROWHEAD ABOVE", "Mn", 230),
("ARABIC DOUBLE RIGHT ARROWHEAD ABOVE WITH DOT", "Mn", 230),
("ARABIC RIGHT ARROWHEAD ABOVE WITH DOT", "Mn", 230),
("ARABIC DAMMA WITH DOT", "Mn", 230),
("ARABIC MARK SIDEWAYS NOON GHUNNA", "Mn", 230),
)
|
https://github.com/wj461/operating-system-personal | https://raw.githubusercontent.com/wj461/operating-system-personal/main/HW2/hw2.typ | typst | #import "@preview/timeliney:0.0.1"
#align(center, text(17pt)[
\u{1F995}*Operating-system homework\#2 * \u{1F996}
])
#(text(14pt)[
= Written exercises
])
= • Chap.4
- 4.8: Provide two programming examples in which multithreading does not provide better performance than a single-threaded solution.
- ex1 低負擔：\
如果只需要少量的運算，多執行序反而會有額外的開銷，導致效能下降
例如只需要1+2+3+...+10的總和，使用多執行序，會有額外的開銷。
- ex2 串接性：\
如果需要等待前一個執行序的結果，才能繼續執行下一個執行序，使用多執行序，也不會較快，不僅需要等待前一個執行序的結果，還需要等待多執行序的開銷。
- 4.10: Which of the following components of program state are shared across threads in a multithreaded process?\
- (a) Register values\
- (b) Heap memory\
- (c) Global variables\
- (d) Stack memory
b,c
- 4.16: A system with two dual-core processors has four processors available for scheduling
– A CPU-intensive application is running on this system\
– All input is performed at program start-up, when a single file must be opened\
– Similarly, all output is performed just before the program terminates, when the program results must be written to a single file\
– Between start-up and termination, the program is entirely CPU-bound\
– Your task is to improve the performance of this application by multithreading it\
– The application runs on a system that uses the one-to-one threading model (each user thread maps to a kernel thread)\
- How many threads will you create to perform the input and output? Explain.\
2 threads,
input and output 各一個thread。
- How many threads will you create for the CPU-intensive portion of the application? Explain\
4 threads,
每個核心一個thread。
= • Chap.5
- 5.14: Most scheduling algorithms maintain a run queue, which lists processes eligible to run on a processor. On multicore systems, there are two general options:\
– What are the advantages and disadvantages of each of these approaches?
• (1) each processing core has its own run queue, or\
- advantages:
減少競爭且擴充性好
- disadvantages:
需要較為複雜的管理
• (2) a single run queue is shared by all processing cores.\
- advantages:\
方便管理
- disadvantages:\
多個核心共用，可能會有競爭的問題
- 5.18: The following processes are being scheduled using a preemptive, priority-based, round-robin scheduling algorithm.\
– Each process is assigned a numerical priority, with a higher number indicating a higher relative priority.\
- higher number = higher priority
– For processes with the same priority, a round-robin scheduler will be used with a time quantum of 10 units.\
- q = 10
– If a process is preempted by a higher-priority process, the preempted process is placed at the end of the queue.
#align(center, table(
columns: 4,
align: center,
table.header(
[Thread], [Priority], [Burst], [Arrival]),
"P1", "8", "15", "0",
"P2", "3", "20", "0",
"P3", "4", "20", "20",
"P4", "4", "20", "25",
"P5", "5", "5 ", "45",
"P6", "5", "15", "55")
)
- (a) Show the scheduling order of the processes using a Gantt chart.\
#timeliney.timeline(
show-grid: true,
{
import timeliney: *
headerline(
// group(..range(10).map(n => strong("Q" + str(n + 1)))),
group(..range(19).map(n => "")),
)
taskgroup({
task("P1", (0, 3), style: (stroke: 2pt + black))
task("P2", (3, 4),(16,19), style: (stroke: 2pt + black))
task("P3", (4, 6),(8,9),(14,15), style: (stroke: 2pt + black))
task("P4", (6, 8),(10,11),(15,16), style: (stroke: 2pt + black))
task("P5", (9, 10), style: (stroke: 2pt + black))
task("P6", (11, 14), style: (stroke: 2pt + black))
})
for i in range(20){
let a = str(i*5)
milestone(
at: i,
style: (stroke: (dash: "dashed")),
align(center, a)
)
}
}
)
- (b) What is the turnaround time for each process?
到達~結束時間\
P1: 15, P2: 95, P3:55, P4: 55, P5: 5, P6: 15
- (c) What is the waiting time for each process?\
P1: 0, P2: 75, P3: 35, P4:35, P5: 0, P6: 0
- 5.22: Consider a system running ten I/O-bound tasks and one CPU-bound task.\
– Assume that the I/O-bound tasks issue an I/O operation once for every millisecond of CPU computing and that each I/O operation takes 10 milliseconds to complete.\
– Also assume that the context-switching overhead is 0.1 millisecond and that all processes are long-running tasks.\
– Describe the CPU utilization for a round-robin scheduler when:\
- (a) The time quantum is 1 millisecond
- CPU time = 1m
- CPU context = 0.1m
- I/O time = 1m
- I/O context = 0.1m
$(("CPU time") dot 1 + ("I/O time") dot 10) / (("CPU time" + "CPU context") dot 1 + ("I/O time" + "I/O context") dot 10) = $
$(1 dot 1 + 1 dot 10) / ((1 + 0.1) dot 1 + (1 + 0.1) dot 10) = 90%$
- (b) The time quantum is 10 millisecond
- CPU time = 10m
- CPU context = 0.1m
- I/O time = 1m
- I/O context = 0.1m
$(("CPU time") dot 1 + ("I/O time") dot 10) / (("CPU time" + "CPU context") dot 1 + ("I/O time" + "I/O context") dot 10) = $
$(10 dot 1 + 1 dot 10) / ((10 + 0.1) dot 1 + (1 + 0.1) dot 10) = 94%$
- 5.25: Explain the differences in how much the following scheduling algorithms discriminate in favor of short processes:
- (a) FCFS\
對於短進程不利，因為長進程會佔用CPU，短進程需要等待。
- (b) RR\
對於短進程有利，因為每個進程都有一定的時間片，短進程可以在時間片內完成。
- (c) Multilevel feedback queues\
可以根據不同queues去切換quantum，對應到不同程度的進程，可以慢慢提昇quantum，去適應不同的進程。
= • Chap.6
- 6.7: The pseudocode of Figure 6.15 illustrates the basic push() and pop() operations of an array-based stack. Assuming that this algorithm could be used in a concurrent environment, answer the following questions:
- (a) What data have a race condition?\
如果同時push或同時pop，可能會有race condition
- (b) How could the race condition be fixed\
使用mutex lock，保證同一時間只有一個thread可以執行push或pop
#show raw.where(block: true): block.with(
fill: luma(240),
inset: 10pt,
radius: 4pt,
)
#align(center,
```c
push(item) {
if (top < SIZE) {
stack[top] = item;
top++;
} else
ERROR
}
pop() {
if (!is_empty()) {
top--;
return stack[top];
} else
ERROR
}
is_empty() {
if (top == 0){
return TRUE;
} else
return FALSE;
}
```
)
- 6.15: Explain why implementing synchronization primitives by disabling interrupts is not appropriate in a single-processor system if the synchronization primitives are to be used in user-level programs.
在single-processor的情況下disabling interrupts不太適合，因為直接禁止使用interrupts，代表著在執行結束前無法跳出，可能會導致程式無法結束、無法即時處理其他更重要的任務。
- 6.18: The implementation of mutex locks provided in Section 6.5 suffers from busy waiting.\
– Describe what changes would be necessary so that a process waiting to acquire a mutex lock would be blocked and placed into a waiting queue until the lock became available
#show raw.where(block: true): block.with(
fill: luma(240),
inset: 10pt,
radius: 4pt,
)
#align(center,
```c
Queue waitingQueue;
acquire() {
if (!available) {
waitingQueue.push(currentThread);
}
while (!available || waitingQueue[0] != currentThread)
; /* busy wait */
available = false;
waitingQueue.pop();
}
release() {
available = true;
}
```
) |
|
https://github.com/7sDream/fonts-and-layout-zhCN | https://raw.githubusercontent.com/7sDream/fonts-and-layout-zhCN/master/chapters/02-concepts/dimension/kern.typ | typst | Other | #import "/template/template.typ": web-page-template
#import "/template/components.typ": note
#import "/lib/glossary.typ": tr
#show: web-page-template
// ### Kerns
=== #tr[kern]
// As we have mentioned, a layout system will draw a glyph, move the cursor horizontally the distance of the horizontal advance, and draw the next glyph at the new cursor position.
上文提到，#tr[layout]系统在绘制一个#tr[glyph]之后，会将光标水平移动一个#tr[horizontal advance]的距离，然后在新的坐标位置处开始绘制下一个#tr[glyph]。
#figure(placement: none)[#include "kerns-1.typ"]
// However, to avoid spacing inconsistencies between differing glyph shapes (particularly between a straight edge and a round) and to make the type fit more comfortably, the designer of a digital font can specify that the layout of particular pairs of glyphs should be adjusted.
然而为了让整篇文字看起来更舒适，各个#tr[glyph]（特别是竖直边缘和曲线边缘）的间距需要保持一致。数字字体设计师可以通过单独设置一对#tr[glyph]间的布局参数来调整这一间距。
#figure(caption: [间距调整])[#include "kerns-2.typ"] <figure:kern-2>
// In this case, the cursor goes *backwards* along the X dimension by 140 units, so that the backside of the ja is nestled more comfortably into the opening of the reh. This is a negative kern, but equally a designer can open up more space between a pair of characters by specifying a positive kern value. We will see how kerns are specified in the next two chapters.
在@figure:kern-2 的示例中，光标沿X轴*往回*走了140个单位，这样 ja 字母的弧线就会更加靠近 reh 字母的开口，这就是一个负的#tr[kern]。设计师也可以通过设置正的#tr[kern]来让两个#tr[glyph]的间距更大。在后续的两章中会具体介绍#tr[kern]是如何设置的。
|
https://github.com/tymbalodeon/job-application | https://raw.githubusercontent.com/tymbalodeon/job-application/main/src/_header.typ | typst | #import "_content.typ": name, email, phone, github, city
#let make-phone-number(phone-number) = {
let phone-number = str(phone-number)
let areaCode = phone-number.slice(0, 3)
let prefix = phone-number.slice(3, 6)
let number = phone-number.slice(6)
[(#areaCode) #prefix - #number]
}
#let contact(items) = {
for item in items.slice(0, -1) [
#item |
]
[#items.last()]
}
#let email = link(email)
#let phone = make-phone-number(phone)
#let github = link(github)
#let space = v(0.8em)
#show link: underline
#set text(10pt)
= #text(28pt, smallcaps(name))
#contact((email, phone, github, city))
#space
|
|
https://github.com/DeveloperPaul123/modern-cv | https://raw.githubusercontent.com/DeveloperPaul123/modern-cv/main/tests/resume/test.typ | typst | Other | #import "@local/modern-cv:0.7.0": *
// setup the document like we do for the resume
#let font = ("Source Sans Pro", "Source Sans 3")
#set text(
font: font,
size: 11pt,
fill: color-darkgray,
fallback: true,
)
#set page(
paper: "a4",
margin: (left: 15mm, right: 15mm, top: 10mm, bottom: 10mm),
footer: [],
footer-descent: 0pt,
)
// set paragraph spacing
#set par(spacing: 0.75em, justify: true)
#set heading(
numbering: none,
outlined: false,
)
#show heading.where(level: 1): it => [
#set block(
above: 1em,
below: 1em,
)
#set text(
size: 16pt,
weight: "regular",
)
#align(left)[
#let color = if colored-headers {
accent-color
} else {
color-darkgray
}
#text[#strong[#text(color)[#it.body.text]]]
#box(width: 1fr, line(length: 100%))
]
]
#show heading.where(level: 2): it => {
set text(
color-darkgray,
size: 12pt,
style: "normal",
weight: "bold",
)
it.body
}
#show heading.where(level: 3): it => {
set text(
size: 10pt,
weight: "regular",
)
smallcaps[#it.body]
}
// test the resume functions
#resume-item("Education")
#resume-entry(
title: "BSc Computer Science",
location: "Example City",
date: "2019 - 2022",
description: "Achieved acaademic honors and awards.",
)
// resume-entry also support omitting the date and description
#resume-entry(
title: "Title",
location: "Location",
)
#resume-certification(
"Certified Scrum Master (CSM)",
"Jan 2022",
)
#resume-skill-item(
"Programming",
(strong["C++"], "Python", "Java"),
)
#resume-gpa("3.5", "4.0")
|
https://github.com/QuadnucYard/pavemat | https://raw.githubusercontent.com/QuadnucYard/pavemat/main/docs/manual.typ | typst | MIT License | #import "@preview/mantys:0.1.4": *
#import "@preview/mantys:0.1.4": theme
#import "../src/lib.typ": pavemat
#show: mantys.with(
name: "pavemat",
title: [Pavemat],
// subtitle: [A subtitle for the manual],
// info: [A short descriptive text for the package.],
authors: "QuadnucYard",
license: "MIT",
url: "https://github.com/QuadnucYard/pavemat",
version: "0.1.0",
date: "2024-7-27",
abstract: [
The pavemat is a versatile tool for creating styled matrices with custom paths, strokes, and fills. It allows users to define how paths should be drawn through the matrix, apply different strokes to these paths, and fill specific cells with various colors. This function is particularly useful for visualizing complex data structures, mathematical matrices, and creating custom grid layouts.
],
examples-scope: (pavemat: pavemat),
titlepage: titlepage.with(toc: false),
index: none,
)
= Basics
== Pave string
A pave string defines paths through the matrix.
This string consists of directional characters that guide the path from one cell to another. It can also include styled segments and custom control characters for more advanced configurations.
=== Basic Directional Characters
A pave string primarily uses the following basic directional characters to move through the matrix:
- `W`, `w`: Move up
- `S`, `s`: Move down
- `A`, `a`: Move left
- `D`, `d`: Move right
If a lowercase letter is used, this segment will not be displayed.
=== Styled Segments
To apply styles to specific segments of the path, you can enclose the style specifications in parentheses. These styles, *which affect only the subsequent segment until the closing parenthesis or the end of the segment*, can include changes to stroke properties such as dash pattern, color, and thickness. The style is evaluated as dictionary and then passed to `grid.hline.stroke` and `grid.vline.stroke`. *Styles can be overlaid.*
*Examples:*
- Solid Stroke: ```typc "SS(dash: 'solid')DDD"```
- Colored Stroke: ```typc "SS(paint: red)DDD"```
- Thickness and Dash: ```typc `SS(thickness: 2pt, dash: "dotted")DDD`.text```
Single quotes (`'`) in the string will be simply replaced by double quotes (`"`), so there is no need to escape them.
In the example ```typc "SS(dash: 'solid')DDD"```, the path first moves down twice and then uses a solid stroke for the next segment that moves right three times.
The style has its scope, ended by a right bracket `]`. You can optionally add one `[` after style parenthesis `)`, which is just ignored.
*Examples:*
```typc
"AA(paint: red, thickness: 2pt)WdD(paint: blue)Ww(thickness: 1pt, dash: 'dotted')AaS]Aw]W]D"
```
*Explanations:*
- `AA`:
- Moves left twice (`AA`).
- `(paint: red, thickness: 2pt)WdD`
- The stroke is red and 2pt thick.
- Moves up (`W`), then down (`d`, hidden), and right (`D`).
- `(paint: blue)Ww`:
- The stroke changes to blue, while thickness is still 2pt.
- Moves up (`W`) and up again(`w`, hidden).
- `(thickness: 1pt, dash: 'dotted')AaS]`:
- The stroke changes to 1pt thick with a dotted pattern.
- Moves left (`A`), left (`a`), and down (`S`).
- When encountering `]`, the style resets to the previous state (in this case, blue stroke).
=== Custom Direction Characters
If you prefer `UDLR` to `WASD`, you can customize control characters in through arguments. See usage.
== Position
A position string is formatted as `"{x}-{y}"` or `"[{x}-{y}]"`. Examples include `"0-1"`, `"top-left"`, `"bottom-2"`, and `"[2-right]"`.
- `{x}`: Can be an integer or the literal `top` or `bottom`.
- `{y}`: Can be an integer or the literal `left` or `right`.
In the `fills` parameter, position strings determine which cells to fill with the specified color. By default, a position string without brackets (`"{x}-{y}"`) fills the connected block of cells containing `(x, y)`. When enclosed in brackets (`"[{x}-{y}]"`), it only fills the specified single cell.
= Usage
#command(
"pavemat",
arg[eq],
arg(pave: ()),
arg(stroke: ()),
arg(fills: (:)),
arg(dir-chars: (:)),
arg(display-style: true),
arg(block: auto),
arg(debug: false),
)[
The pavemat function in Typst allows for the creation of styled and filled matrices with custom paths, strokes, and fills.
#argument("eq", types: ("math.equation", "math.mat", "array"))[
The input matrix expression to be styled. It can be a mathematical equation or a matrix. Specifically,
- A ```typc math.equation```. It should contains only a `math.mat` as its body. Example: ```typ $mat(1, 2; 3, 4)$```. ```typc math.display``` in the equation is not supported yet.
- A `math.mat`. Example: ```typc math.mat((1, 2), (3, 4))```.
- A nested array. Example: ```typc ((1, 2), (3, 4))```.
If a matrix type is given, pavemat will use its style, including `row-gap`, `column-gap` and `delim`.
]
#argument("pave", types: ("string", "dictionary", "array"), default: ())[
Describes the pavement lines. It accepts the following formats:
- A path string like `"WASD"`.
- A dictionary with fields: `path`, `from` (optional, default: ```typc "top-left"```), `stroke` (optional, default: empty). The path is a pave string.
- An array whose item type is either string or dictionary described above.
]
#argument("stroke", types: ("length", "color", "gradient", "pattern", "dictionary"))[
The global stroke style applying to all segments. This argument will be passed to `cell.stroke`.
Accepts anything can be use as stroke. Examples: ```typc blue + 1pt```, ```typc (dash: "dashed", thickness: 0.5pt)```.
]
#argument("fills", types: ("color", "gradient", "pattern"))[
Specifies the fill colors for specific cells. The key represents a position, and the value is the color passed to `cell.fill`. An empty key `""` is used for global fill.
]
#argument("dir-chars", types: "dictionary", default: (:))[
Controls whether the output is in display style. Its fields will override the default ```typc (up: "W", down: "S", left: "A", right: "D")```.
Example: ```typc (up: "U", down: "D", left: "L", right: "R")```
]
#argument("block", types: (auto, "bool"), default: auto)[
Controls whether the output is block-style. If set to auto, it uses the block setting of the input equation.
]
#argument("delim", types: (auto, "str"), default: auto)[
The delimiter of the matrix. If set to auto, it uses the delimiter of the input matrix.
]
#argument("display-style", types: "bool", default: true)[
Controls whether the output is in display style. If set to `true`, the result will be granted a ```typc math.display(...)```.
]
#argument("debug", types: ("bool"), default: false)[
Enables debug mode to show hidden lines. If set to a non-boolean value, it defines the debug stroke style.
]
Example:
#example[```
#pavemat(
$ mat(1, 2, 3; 4, 5, 6; 7, 8, 9; 10, 11, 12) $,
pave: "dSDSDSLLAAWASSDD",
fills: (
"1-1": red.transparentize(80%),
"1-2": blue.transparentize(80%),
"3-0": green.transparentize(80%),
),
)
```]
]
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/text/deco_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
#let red = rgb("fc0030")
// Basic strikethrough.
#strike[Statements dreamt up by the utterly deranged.]
// Move underline down.
#underline(offset: 5pt)[Further below.]
// Different color.
#underline(stroke: red, evade: false)[Critical information is conveyed here.]
// Inherits font color.
#text(fill: red, underline[Change with the wind.])
// Both over- and underline.
#overline(underline[Running amongst the wolves.])
|
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/032%20-%20Ixalan/005_Something%20Else%20Entirely.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"Something Else Entirely",
set_name: "Ixalan",
story_date: datetime(day: 04, month: 10, year: 2017),
author: "<NAME> & <NAME>",
doc
)
Jace passed the next few days in a happy haze. Pleasantly busy and active, but constantly distracted by the sheer noise of it all.
#emph[The Belligerent ] creaked and moaned as she sailed. The crew sang and laughed and relayed orders. But above, around, and inside every sound was an undercurrent of conversation.
Even when his ears couldn't hear anything, Jace could still hear endless talking.
#figure(image("005_Something Else Entirely/01.jpg", width: 100%), caption: [Rowdy Crew | Art by Steve Prescott], supplement: none, numbering: none)
It was irritating, and Jace ultimately decided the best solution was to drown the noise out with activity.
He set about making a place for himself among the crew and relished learning new tasks and techniques. Amelia, quartermaster and one of the two helmsmages, was more than happy to demonstrate. She would adjust the mainsails and ropes with magical ease then briefly change direction with bursts of wind to challenge Jace to adjust the course.
#figure(image("005_Something Else Entirely/02.jpg", width: 100%), caption: [Deadeye Quartermaster | Art by Josh Hass], supplement: none, numbering: none)
Kerrigan, the burly orc who served as ship's cook, showed him how to maintain a galley-fire without burning the ship down. Gavven, the boatswain, showed him the contents of the ship's hull (only after hours of pestering).
And all the while, Jace devoted an hour each day to practicing his own talents. Over the course of his month on the ship, his illusions had grown more detailed, more convincing.
Five days after their successful raid, the crew landed at High and Dry with no need for expensive supplies. On the captain's orders, the crew of #emph[The Belligerent ] disembarked for rest, relaxation, and more than an insignificant amount of revelry.
Jace could never have imagined a place as different or exciting as what he saw when he stepped onto the dock.
The planked streets of High and Dry were the remains of thousands of broken Brazen Coalition ships. The town itself, built on a series of floating platforms, was a neutral ground where pirates could meet and trade goods, tools, treasures, and stories. It was a small empire of favors and obligations, a place where travelers could find their needs, treat their pleasures, and forge lasting alliances. Jace had been told that, before the Legion of Dusk's arrival on Ixalan two years ago, this had been a place untouched by the war at home in Torrezon.
Amelia clapped Jace on the shoulder.
"Jace! We're heading to the Burning Port for ale and cards! You in?"
Jace shrugged and smiled. He felt a tap on his shoulder and turned to find Breeches, a goblin as talented at knot-tying as he was at yelling. "ALE AND CARDS! ALE AND CARDS!" he chanted with fervor.
Amelia nudged the goblin with her leg. "Oy, you owe me for last port, Breeches, so no chanting yet."
"ALE AND CARDS!"
The helmsmage wagged her finger. "#emph[Debt ] and ale and cards, Breeches."
Breeches paused and pulled two coins out from under his hat.
"DEBT AND ALE AND CARDS!"
Amelia pocketed the coins and nodded in approval.
Vraska strode up and nodded at her crew. "Apologies, Breeches, Amelia, but Malcolm and I need to consult with our newest crewmember."
Amelia and Breeches nodded in understanding. Vraska continued, "But we will rejoin the crew afterward for festivities."
Breeches pumped a fist in the air. "DEBT AND ALE AND CARDS AND FESTIVITIES!"
Malcolm fluttered to their side, a mischievous look on his avian face. "Captain, Beleren, this way, if you will."
They said their goodbyes and followed Malcolm away.
The siren led Jace and Vraska along one of High and Dry's narrow, half-tilted streets toward his favorite watering hole. The air stank of low tide and seagulls laughed on the tin roofs. The shops and taverns they passed buzzed with the laughter of pirates, and firelight from oil lamps hanging from the eaves flickered a path for them to walk.
Malcolm pointed out a nondescript building hanging off the side of one of the docks. A ragged sign was hung out front.
In peeling letters it read "BOATSWAIN'S REAR."
"It's a gem," he said with saccharine pride.
He opened the door (an old galley table with a knife still stuck in it) and happily marched toward the bar.
Vraska and Jace followed him in and found a table. Jace looked around and was overwhelmed by the strangeness of the place.
The walls were coated in smoke stains, and sad little oil lamps illuminated a sadder series of crowded tables and half-broken chairs, each stuffed with the most degenerate villains one could imagine. The goblin bartender looked up at the newcomers with one lone remaining eye and spat forcefully into an upturned hat.
#figure(image("005_Something Else Entirely/03.jpg", width: 100%), caption: [Wanted Scoundrels | Art by <NAME>], supplement: none, numbering: none)
Vraska gave Jace an uncertain look, not knowing what he would make of the establishment. "You all right with this place?"
Jace looked back in wonderment. "It's #emph[fascinating] ."
Malcolm arrived with drinks for the three of them and they each raised a glass in celebration of their teamwork.
Halfway through the round, Vraska pulled a compass from her coat and put it on the table.
"You should know, Jace, that we are currently engaged in a special assignment."
Jace's heart leapt. He had been dying to learn what this mission entailed.
"It began about five months ago. I was contacted by a wealthy patron from overseas, not part of the Legion of Dusk. His name is <NAME>, and he hired me to retrieve an item of great power."
Jace picked up the compass. There was no marking for direction, only several needles made of gently flickering orange light that pointed resolutely in several directions—none of which were north. He handed it back to Vraska, who continued with gusto.
"He told me to make for the continent of Ixalan." She leaned forward and spoke in a private tone. "The thaumatic compass is enchanted to find a place of power: the forgotten city known as Orazca."
#emph[No!]
Jace startled and whipped around. He briefly locked eyes with a green-finned merfolk sitting on the far side of the bar. The merfolk stared back in surprise.
Jace frowned. He could have sworn he heard protest.
He turned back to his friends, who looked back for an explanation.
"I thought I heard something. I'm sorry." He folded his hands and waited for Vraska to continue.
"No harm was done," she said.
Malcolm nodded. "The object we're after is in Orazca, and it is known as the Immortal Sun. It used to be kept in the monasteries of Torrezon, in the kingdom that would eventually become the Legion of Dusk. For generations, it remained under the protection of its holy custodians in the mountains of the eastern continent.
"Its presence gave the old rulers incredible power," Malcolm continued. "Jealousies blossomed, and Pedron the Wicked's forces broke into the monastery where the Immortal Sun was kept safe and stole it. As they departed the sanctuary, a winged being descended from the sky. It took the Immortal Sun, carrying the relic across the sea and into the west. No living being knows its exact location, but this compass is meant to help us."
Vraska finished her drink. "We just don't know how."
Jace held out his hand, and Vraska placed the compass in his palm.
"It changes direction frequently. It's how we found you, you know."
Jace gave her a flat look. "I'm not a Golden City."
"Obviously," she smiled. "But maybe you can figure out how it works, so we don't get thrown off by a distraction again."
"I like to think I'm not a distraction either."
"No." Vraska had a conflicted look in her eye that Jace couldn't quite read. "You're something else entirely."
Malcolm purposefully coughed. "I'll take care of this round, then. Meet you back at the ship."
Malcolm returned to the bar to pay, and Jace and Vraska stood to leave. Jace caught one last look at the merfolk in the corner, who averted their eyes sharply as he passed.
The night was warm and thick with the scent of traded goods. The sweet aroma of exotic spices lingered in the air, and Jace walked back along the wood-planked streets toward their ship with his captain.
"Vraska, do you know if I can read minds?"
The question sounded as stupid as it felt, but it stopped Vraska in her tracks.
She let out a two-ton sigh. Her answer was silent, but her voice was clear in his mind.
#emph[Yeah, you can.]
Jace's jaw dropped. "Why didn't you tell me?!"
#emph[Because I didn't want you being rude and reading my mind without asking, ] she thought with a tired glare.
He paused, backed his mind away from her thoughts, and looked down the street at the dozens of strangers in High and Dry.
It was as if a chain in his mind had gone loose on its gear and suddenly snapped back into place. The sounds and the voices were so obvious now.
The people that passed, the birds that flew overhead—each of them had a mind as fragile and precious as crystal. They appeared in the senses of his mind as exquisite structures, and if he wished, he knew he could turn them over and inspect their insides like a statue made of blown glass.
"Minds so delicate," he said, stepping out of the way as a small group passed them on the avenue. "Their structure is form, but also sound. Like an orchestra contained in crystal."
"What is it like to hear them?" Vraska asked.
Jace couldn't put it into words.
"It's . . . noisy. Like a sea of champagne glasses and each of them are ringing a different tone."
They rounded a corner and headed toward the harbor.
Now that he was aware of what the snippets of voice and conversation #emph[were] . . . he sensed he could turn #emph[off ] the noise.
Jace concentrated.
And the mental voices silenced.
He could still sense the gauzy, elaborate but breakable structure of the minds he passed, but they were silent now.
"No reading my mind or the minds of my crew," Vraska said, "But everyone else is fair game. Except our employer, but I think he may be a better telepath than you."
"Do I know him?" Jace asked.
Vraska went quiet for a moment as they walked.
"No," she said finally.
"You paused."
Vraska crossed her arms. "We're from a large city."
Distantly, he could have sworn he heard her thought process and knew somehow, that in truth she had no idea if they knew each other or not.
The street they walked on opened into the air of the harbor that surrounded High and Dry. The lines and sheets of dozens of tall ships crisscrossed the night sky ahead, and a waxing moon was silvery above.
"What is the city called?" Jace asked.
He caught the slip of a smile on her lips. "Ravnica."
"And I was a politician there?"
Vraska chuckled. "You were horrible."
"I imagine. I must have been forced into the job."
A sly smile tugged at her lips.
"You weren't forced into anything. You had a great big campaign!" she said. "Flyers, stump speeches, banquets to fundraise. 'Jace is Ace!' was your slogan."
Jace was skeptical.
"'Jace is Ace' is an awful campaign slogan."
"Yep. It was totally yours."
Jace's skepticism deepened, but he smiled nonetheless.
He purposefully slowed down his pace. He didn't want to reach the ship yet. Vraska matched his speed, and his heart sped up a bit.
"What was our old city like?" Jace asked.
Vraska tilted her head in thought. "It is massive. Soaring towers and bridges that cross over layers and layers of city. It is colder than here, and it snows in the winter."
Jace wished he could see it. In his mind, he had a vague impression, and in the periphery of his vision, he sensed an image dominating the surface of Vraska's mind and #emph[saw] .
Jace stopped, and Vraska stopped alongside him.
"What's wrong?" she asked.
He tried to find a word but landed only on silence. Instead, Jace looked up, eyes alight, and #emph[showed her] .
The stars above shifted position.
The moon began to wane and moved to the other side of the horizon.
The ships grew taller, coated themselves in dark stone, and their masts and posts reached into the sky until they were tall as towers, with spires that scratched the stars. The shoddy buildings of High and Dry rumbled against each other and rose to form basilicas and cathedrals, pointed arches and ribbed vaulting.
Fluffy, gentle flakes began to drift down from a sky as gray as wool.
#figure(image("005_Something Else Entirely/04.jpg", width: 100%), caption: [Plains | Art by <NAME>], supplement: none, numbering: none)
"Is this it?" Jace asked, voice quiet as the snow.
Vraska's response was just as soft. "Yes. This is Ravnica."
Jace smiled and watched the snow fall. He looked back at Vraska and saw her staring up in wonder.
She crossed her arms tightly in front of her. Her guard was up.
"You were projecting it loudly," he said, "I apologize for overhearing."
"Just don't do it again," she said tightly, her gaze still locked on the majesty of the illusion-city around them. The acerbity of her warning did not match the sad look of homesickness heavy in her eyes.
It took every ounce of Jace's self-control not to brush her mind for a look at what she was feeling.
"I wish I could remember it," Jace said. "It looks like the greatest place in the world."
"It is the greatest place in all the worlds," Vraska murmured.
Jace sighed. Best not to stare at an illusion for too long.
He vanished the cityscape, watching as the towers dissolved back into tall ships and the buildings collapsed back into lean-tos.
The illusion vanished. But the look of guarded wonder on Vraska's face remained.
She was beautiful.
And so, in his way, Jace told her.
"Will you teach me more about Ravnica?" he asked.
She turned, arms still crossed, her mouth a firm line.
"Probably," she said.
Jace smiled. He didn't mind waiting.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
They returned to an empty ship and sat on the deck in chairs Vraska had dragged out from her quarters. They briefly spoke of returning to town for "debt and ale and cards and festivities," but decided the combination sounded a tad overwhelming and elected to stay home instead.
Jace had learned by now not to press for answers, but the urge never truly went away. There was so much he did not know, and he hungered for anything that might give him a clue about his past.
Vraska leaned back in her plush chair and put her feet up on the ship's railing. Jace pulled his own chair alongside hers and did the same.
"So what's it like knowing you're a telepath?" she asked, staring at the stars.
"Realizing I am an illusionist was delightful. Telepathy has more . . . #emph[teeth] to it."
"Teeth?"
Jace crossed his arms and stared upward at the sky. "Minds are absurdly delicate. Everything that makes a person who they are is as fragile as a cobweb."
"You're a sledgehammer surrounded by cobwebs," she said plainly. "You realize that, right?"
"A goddamn sledgehammer," Jace mused, a little pit of dread opening in his guts.
Vraska chuckled. It was the first time she had ever heard him swear.
For the first time since he arrived, a half-memory itched to resurface.
A massive lion with a man's face, eyes wide with horror, wailing like an infant on the rainy ground as he gasped for air and his wings dumbly thumped the ground.
It frightened Jace.
A dream? An impression? It did not matter. It did not feel real. A random expression of imagination to keep to one's self.
"I wonder how many minds I have broken before," he said aloud.
Vraska went suddenly still.
Jace's breath caught in his chest.
"Vraska . . . do you know if I've done that?"
He looked over at her. Her eyes were looking upward, her lips a firm line.
She took a breath. Jace had explicitly not allowed himself to read her mind, but could almost sense it whirring around an old and frightening feeling.
"Could you redeem yourself if you had?" she asked in response.
The question was cautious, atypically small for someone so bold.
Jace was taken aback.
"To ruin a mind is to deliver a fate worse than death, I imagine." He said. "You are asking if there is redemption for those who kill."
"I suppose."
Jace chose his words carefully.
"Existence is adaptation to changing circumstances. The self is an accumulation of what one has learned from those changing circumstances . . . Our agency gives us the means to alter our own path. You#emph[ are] who you #emph[decide ] to be. And who you will become depends only on how you choose to adapt."
Jace realized Vraska had been looking at him.
His face felt flushed, and he was thankful his blush did not show in the starlight.
The waves lapped against the side of the ship.
"Is your past truly that unimportant?" she asked.
Jace shrugged to himself. "It has to be. If I can do what I think I can, I've hurt a lot of people. But it's the future that makes me who I am, because my choices will influence who I become."
Vraska was very quiet.
The silence didn't bother Jace. He had decided that small-talk was a largely overrated social ritual, which made it all the more lovely to spend time with someone who embraced the natural silences of good conversation.
"I wish I could forget like you have," Vraska said, hushed and small.
"What do you wish you could forget?" asked Jace.
Vraska's gaze was distant, locked on the horizon.
Jace knew immediately he had said both the wrong and the right thing.
Her response was terse. "Prisons."
Prisons in the plural. Vraska's gaze was distant. She clearly did not wish to revisit the memories he had stirred.
He stood, but Vraska remained still in her seat.
Jace was struck with an idea.
"Let's go to the galley," he said.
Jace led Vraska off the deck and down the ladder into the galley. He motioned for her to sit on a nearby stool and shoved a few logs onto the coals of the galley-fire. He grabbed the kettle from its place in the cupboard, filled it with fresh water, and set it on the stove.
He made her tea.
It was clumsy and took a moment, but Jace did it in precisely the correct order.
He poured the final product into a mug and handed it to Vraska.
She sat for a moment and looked at her tea as if Jace had given her a precious jewel.
Vraska wrapped her fingers around the mug and let out a breath. She took a brief sip, and Jace saw her lips twitch in approval.
She was still looking at the cup with wonder.
After a moment, she spoke.
"We come from a faraway city." Vraska laced her fingers behind the coils on her head. "#emph[Very ] far away. The rest of the crew has never heard of it."
Jace did his best not to ask six questions at once. He landed on the most pressing. "Why haven't they heard of it?"
"It's that far away." She glanced briefly at him. "You're just going to have to go with me on this one."
#emph[There's more there, but fair enough. ] Jace nodded, and Vraska continued.
"The city runs like cities do, and different guilds are in charge of different functions. The Orzhov run the bank, the Azorius make the laws, et cetera. There are ten guilds total. The Golgari technically run refuse and rot farms, but it's really a catch-all for those who fall through the cracks. Outcasts and scoundrels and what-not.
#figure(image("005_Something Else Entirely/05.jpg", width: 100%), caption: [Golgari Guildgate | Art by Eyatan Zana], supplement: none, numbering: none)
"When I was much younger, the Azorius issued a mass arrest warrant for members of the Golgari guild. The Golgari hadn't done anything; they simply existed, and the Azorius decided they were criminals. They assumed I was Golgari because I was a gorgon, and they arrested me too. They packed us into a prison. I was there for . . . a while. I'm not sure how long. The Azorius would joke that we lived underground like moles, so why would we need windows to see the sun? There were no beds, little food. Violence was our negotiating tool, and oh. How I wish it could have been me leading those uprisings. We would riot, and they would move us, then hurt us. Riot, move us, hurt us: it was an endless cycle, and eventually they kept a blindfold on me so I could not petrify my captors."
Jace hated everything about this. There was nothing he could fix. As much as he hated it, there was no logic in trauma. He did not know if he were in her position what conclusion he would arrive at to give peace to his mind, what theories he would tell himself to reason his way to comfort.
Vraska's golden eyes had a faraway look to them. "You lose track of time in a place like that. Eventually they took me away. Locked me up alone in a room with no cot and water up to my ankles. The beatings continued, and whatever wounds they left would stink with infection for weeks after the fact. When they eventually took the blindfold off, I thought about trying to petrify myself to make it stop. But I wanted out #emph[more ] than I wanted to end."
Jace felt ill. He did not cross-examine her, nor did he demand proof, nor did he ask for clarity. Now was not the time. It was his job to listen.
Vraska was doing her best not to make eye contact.
"I remember the night I nearly died. I was bloodied and broken, and I knew that one more hit to the head would do me in. My body knew what to do, and I used magic I'd never used before to escape. But the place I escaped to was a prison, too. I was trapped there, alone, for quite some time. Just me and all my memories of the source of all that cruelty."
Vraska had finished her tea. A few bits of leaf were stuck to the inside of her cup. "'A person should die the death they deserve.' I lived by those words for quite some time. They gave me comfort."
"Do they still?" Jace asked.
Vraska's mouth was a hard line. "Yes."
They sat in silence for a moment.
"The part I haven't figured out yet is if they all deserve to die," Vraska said after some time. "My magic may lie in death, but I take no joy in killing. Before, I did it because I didn't have a choice otherwise. Now I have to do what is right for others like me."
"By leading an expedition?"
"No," she said. "By leading the Golgari when I get home. Our employer promised me the position of guildleader upon my return."
Jace smiled. "You've already proven you have what it takes. The best leaders understand the communities they are trying to protect. I think you were meant to be a great leader."
Vraska's looked oddly sad at that.
"Vraska . . . ?"
"No one has ever really said that to me before."
How could she not see what she had already accomplished? Jace's brow furrowed. "Do you think you don't deserve it?"
She sighed. "I don't know how the Golgari will see me when I return."
Jace shrugged. "You get to decide how they see you."
She looked at him with uncertainty. Jace continued. "How we engage with the world is dependent on how we present ourselves to it. We are continuously adjusting to change because if we fail to change, we fail to survive. By nature of you surviving the hell you did, you have changed into someone wiser than before. By nature of you commanding this ship, you've transformed yourself into the leader you always knew you could be.
"What makes you #emph[you ] isn't your circumstance or your past, but the choices you make in the future. Your ability to learn and adapt is what makes you who you are today, and #emph[that ] is what dictates who you will continue to become. Vraska, your greatest vengeance is the fact that not only are you alive, but you reinvented yourself into someone stronger than your captors ever thought possible. Do you realize how incredible that is?"
Vraska was smiling an uncharacteristically bashful little smile. It reached the creases of her eyes.
"Thank you," she said softly.
Jace smiled back. "It's true. To have been through all that and come out the other side is something I doubt I could have done."
"I don't know," Vraska replied. "It's not obvious at first, but I think you have more grit than you give yourself credit for."
"Even if I do, I've forgotten when I demonstrated it." Jace gave her a serious look. "Thank you for sharing your story with me. I'm proud to know you."
He saw the outline of her mind but dared not peek inside. It was curves and nooks and swirls of delicate glassy strands. Vraska had no idea how fragile her mind was, just as he had no concept of how easily she could turn him to stone.
Vraska grinned. Jace felt his cheeks warm.
Both of them realized at the exact same moment that neither of them wanted to hurt the other.
Her smile was earnest and open. "I'm proud to know you, too, Jace."
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The weeks passed pleasantly for the crew, and the closer #emph[The Belligerent ] drew to the continent, the more excited they became.
Vraska's story was still running through Jace's mind. He had made her another cup of tea that night, and they had talked of happier things. She trusted him enough to tell him that story. That trust warmed Jace's chest like whiskey.
That gentle warmth urged him to unravel the mystery of the thaumatic compass as quickly as possible.
For weeks he stared at it, paged through navigational books, and picked at Malcolm's patience to gather information. Eventually, he came to a realization: if the compass had changed direction the day he had been rescued, it must have reacted to some form of stimulus near him. And there had only been one eventful thing that happened in the hours before he was rescued.
One afternoon, hours before they made landfall, Jace took the compass in hand and made his way down to the brig. It stank, and there was water up to his ankles. But he needed privacy.
The ship began rocking to and fro. He thought the sea must have turned stormy since he made his way down.
The thaumatic compass was turning out to be more involving than initially expected. It was such a complicated thing, with several lights pointing in several different directions.
#figure(image("005_Something Else Entirely/06.jpg", width: 100%), caption: [Thaumatic Compass | Art by Yeong-Hao Han], supplement: none, numbering: none)
He shook it a little, and one of the lights flickered.
A malfunction? A puzzle!
It was intriguing enough that Jace decided to do something reckless.
He took a small tool from a storage crate nearby and began to disassemble the one device that their expedition needed the most.
It was easy, like the telescope several weeks prior. He laid it out, piece by piece, assembling a simple grid of components as he worked his way inward. At the compass's center, he saw a small gear loose on its axis. He tightened it, then reassembled the compass.
A single light shone from one side of it, now, brilliant and clear in a single direction.
And now, for the most important test.
Jace set the compass on a flat crate, closed his eyes, and concentrated.
He felt down and back in his mind toward the strange part of himself that made him #emph[him.]
He took a deep breath and reached for it.
And felt his body break #emph[apart ] and #emph[away ] and slam back together, with the familiar triangle appearing above his head once more.
Jace blinked, slightly dazed, and looked down at the compass with anticipation. He nearly cheered in joy. The needle was pointing directly at him.
His theory went thus: the thaumatic compass worked by pointing toward a very specific type of magical expression. Small illusions didn't move the needle, but whatever it was that Jace could do (with effort) #emph[did] .
If his theory were true, then the Golden City would have to be a massive hub of magical energy—and this compass would point directly toward its source.
Wonderful!
Jace scooped up the thaumatic compass and hurried out of the brig and up two sets of ladders to the deck.
"Vraska! I figured out the compass!" Jace's yell was drowned out by a sudden rumble of thunder in the distance. The sky was an angry gray, and the crew was rushing to prepare for a storm.
Vraska stood atop the quarterdeck, staring upward. Malcolm was high above, getting a better look at something in the distance. He swooped back down and conferred with Vraska.
Jace did not want to interrupt, so he waited for a chance to ask what was happening.
A moment later, Vraska spotted him.
"Jace! Get below deck. A Legion of Dusk ship is approaching, and there's a thunderstorm ahead."
"I thought we were making landfall today?"
"Yes. That too. All three of those things. I need to make sure they don't happen at the same time."
Suddenly, the sky opened, and torrential rain began to fall in sheets onto the deck of #emph[The Belligerent] . Vraska grabbed Jace's shoulders. "Get below deck!"
Lightning crashed, and the ship lurched violently sideways.
A wave rose high in the distance, and Jace saw the Legion of Dusk ship coasting atop the water. It was massive#emph[, ] larger even than the one from several weeks before, with two dinghies suspended from either side.
The wave #emph[The Belligerent ] rode rose in turn, and Jace looked into the distance at a massive wall of green. The shores of Ixalan were there, a pristine bay rimmed with sand that led to a large outcrop jutting into the sea. Dark clouds churned in the sky, and more and larger waves threatened to overturn the ship.
Risk lightning and conquistadors, or smash into the rocks onshore. They were caught between two unfavorable options.
Jace shoved the compass into the safety of his pocket while Vraska called out orders.
"Secure the cannons and put out the galley-fire! Reef the mainsail and heave to!"
The ship lurched once more, and a crewman tumbled into the sea.
Jace watched as Vraska weighed her options. She looked to shore, and then to the rest of the crew.
"Abandon ship!" she yelled, "Abandon—"
A wall of water crested the side of the ship and slammed into Jace and Vraska.
They reached for one another as the water began to sweep them off the deck.
And #emph[The Belligerent ] rammed into the rocks.
#figure(image("005_Something Else Entirely/07.jpg", width: 100%), caption: [River's Rebuke | Art by Raymond Swanland], supplement: none, numbering: none)
|
|
https://github.com/Dherse/codly | https://raw.githubusercontent.com/Dherse/codly/main/example/main.typ | typst | MIT License | #import "../codly.typ": *
#show: codly-init.with()
#let icon(codepoint) = {
box(
height: 0.8em,
baseline: 0.05em,
image(codepoint)
)
h(0.1em)
}
#codly(languages: (
rust: (name: "Rust", icon: icon("brand-rust.svg"), color: rgb("#CE412B")),
python: (name: "Python", icon: icon("brand-python.svg"), color: rgb("#3572A5")),
))
```rust
pub fn main() {
println!("Hello, world!");
}
```
```python
def fibonaci(n):
if n <= 1:
return n
else:
return(fibonaci(n-1) + fibonaci(n-2))
```
We can also set a line number offset with `codly-offset(int)`:
#codly-offset(offset: 1)
```rust
println!("Hello, world!");
```
We are also able to control line numbers alignment:
`#codly(number-align: horizon)`
#codly(number-align: horizon)
```python
import numpy as np
print(np.array([np.random.randint(1, 100) for _ in range(1000)]), np.array([np.random.normal(0, 1) for _ in range(1000)]), np.array([np.random.uniform(0, 1) for _ in range(1000)]))
```
`#codly(number-align: top)`
#codly(number-align: top)
```python
import numpy as np
print(np.array([np.random.randint(1, 100) for _ in range(1000)]), np.array([np.random.normal(0, 1) for _ in range(1000)]), np.array([np.random.uniform(0, 1) for _ in range(1000)]))
```
And we can also disable line numbers:
#codly(number-format: none)
```rust
pub fn main() {
println!("Hello, world!");
}
```
We can also select only a range of lines to show:
#codly-range(start: 5, end: 5)
```python
def fibonaci(n):
if n <= 1:
return n
else:
return(fibonaci(n-1) + fibonaci(n-2))
```
#codly(
stroke: 1pt + red,
)
```rust
pub fn main() {
println!("Hello, world!");
}
```
#codly(
display-icon: false,
stroke: 1pt + luma(240),
zebra-fill: luma(240),
number-format: none,
)
```rust
pub fn main() {
println!("Hello, world!");
}
```
```rust
pub fn function<R, S, T>() -> R where T: From<S>, S: Into<R>, R: Send + Sync + 'static {
println!("Hello, world!");
}
```
#v(25%)
#codly(
breakable: true
)
```rust
pub fn main() {
println!("This is in another page!")
}
```
#codly(number-format: (x) => strong(str(x)))
```rust
pub fn main() {
println!("Strong line numbers go brrrrrrr.");
}
```
#codly(lang-format: (..) => [ No, I don't think I will. ], number-format: (s) => str(s))
```rust
pub fn main() {
println!("Strong line numbers go brrrrrrr.");
}
```
= Empty line test with line number disabled.
#codly(lang-format: none, number-format: none)
```rust
pub fn main() {
println!("Strong line numbers go brrrrrrr.");
}
```
= Test of smart indent
#codly(lang-format: none, number-format: none, smart-indent: true)
#box(width: 50%,
```rust
pub fn main() {
println!("Strong line numbers go brrrrrrr.");
}
```
)
|
https://github.com/TomVer99/FHICT-typst-template | https://raw.githubusercontent.com/TomVer99/FHICT-typst-template/main/README.md | markdown | MIT License | <!-- markdownlint-disable MD033 -->
# FHICT Typst Document Template
This is a document template for creating professional-looking documents with Typst, tailored for FHICT (Fontys Hogeschool ICT). It can also be found on the [Typst Universe](https://typst.app/universe/package/unofficial-fhict-document-template).
## Introduction
Creating well-structured and visually appealing documents is crucial in academic and professional settings. This template is designed to help FHICT students and faculty produce professional looking documents.
<p>
<img src="./img/showcase-l.png" alt="Showcase" width="49%">
<img src="./img/showcase-r.png" alt="Showcase" width="49%">
</p>
## Why use this template (and Typst)?
### Typst
- **Easy to use**: Typst is a lightweight and easy-to-use document processor that allows you to write documents in a simple and structured way. You only need a browser or VSCode with just 1 extension to get started.
- **Fast**: Typst is fast and efficient, allowing you to focus on writing without distractions. It also gives you a live preview of your document.
- **Takes care of formatting**: Typst takes care of formatting your document, so you can focus on writing content.
- **High quality PDF output**: Typst produces high-quality PDF documents that are suitable for academic and professional settings.
### FHICT Document Template
- **Consistent formatting**: The template provides consistent formatting for titles, headings, subheadings, paragraphs, and all other elements.
- **Professional layout**: The template provides a clean and professional layout for your documents.
- **FHICT Style**: The template follows the FHICT style guide, making it suitable for FHICT students and faculty.
- **Configurable options**: The template provides configurable options for customizing the document to your needs.
- **Helper functions**: The template provides helper functions for adding tables, sensitive content (that can be hidden), and more.
- **Multiple languages support**: The template can be set to multiple languages (nl, en, de, fr, es), allowing you to write documents in different languages.
<!-- \/\/\/ not yet :( \/\/\/ ) -->
<!-- - **Battle tested**: The template has been used by many students and faculty members at FHICT, ensuring its quality and reliability. -->
<!-- This is for the typst universe page
## Features
- Consistent formatting for titles, headings, subheadings, paragraphs and other elements.
- Clean and professional document layout.
- FHICT Style.
- Configurable document options.
- Helper functions.
- Multiple languages support (nl, en, de, fr, es).
-->
## Requirements
- Roboto font installed on your system.
- Typst builder installed on your system (Explained in `Getting Started`).
## Getting Started
To get started with this Typst document template, follow these steps:
1. **Check for the roboto font**: Check if you have the roboto font installed on your system. If you don't, you can download it from [Google Fonts](https://fonts.google.com/specimen/Roboto).
2. **Install Typst**: I recommend to use VSCode with the [Typst LSP Extension](https://marketplace.visualstudio.com/items?itemName=nvarner.typst-lsp) or [Tinymist Typst Extension](https://marketplace.visualstudio.com/items?itemName=myriad-dreamin.tinymist). You will also need a PDF viewer in VSCode if you want to view the document live.
3. **Import the template**: Import the template into your own typst document. `#import "@preview/unofficial-fhict-document-template:1.0.2": *`
4. **Set the available options**: Set the available options in the template file to your liking.
5. **Start writing**: Start writing your document.
## Helpful Links / Resources
- The manual contains a list of all available options and helper functions. It can be found [here](https://github.com/TomVer99/FHICT-typst-template/blob/main/documentation/manual.pdf) or attached to the latest release.
- The [Typst Documentation](https://typst.app/docs/) is a great resource for learning how to use Typst.
- The bibliography file is written in [BibTeX](http://www.bibtex.org/Format/). You can use [BibTeX Editor](https://truben.no/latex/bibtex/) to easily create and edit your bibliography.
- You can use sub files to split your document into multiple files. This is especially useful for large documents.
## Contributing
I welcome contributions to improve and expand this document template. If you have ideas, suggestions, or encounter issues, please consider contributing by creating a pull request or issue.
### Adding a new language
Currently, the template supports the following languages: `Dutch` `(nl)`, `English` `(en)`, `German` `(de)`, `French` `(fr)`, and `Spanish` `(es)`. If you want to add a new language, you can do so by following these steps:
1. Add the language to the `language.yml` file in the `assets` folder. Copy the `en` section and replace the values with the new language.
2. Add a flag `XX-flag.svg` to the `assets` folder.
3. Update the README with the new language.
4. Create a pull request with the changes.
## Disclaimer
This template / repository is not endorsed by, directly affiliated with, maintained, authorized or sponsored by Fontys Hogeschool ICT. It is provided as-is, without any warranty or guarantee of any kind. Use at your own risk.
The author was/is a student at Fontys Hogeschool ICT and created this template for personal use. It is shared publicly in the hope that it will be useful to others.
|
https://github.com/NOOBDY/formal-language | https://raw.githubusercontent.com/NOOBDY/formal-language/main/q5.typ | typst | The Unlicense | #let q5 = [
5. If $n in NN$ and $w = a_1...a_n$ is a string, for each $i in [n − 1] union {0}$, the string $a_1...a_i$ is called a _proper prefix_ of $w$. For any language $L$, we define
$ mono("MIN")(L) := {w in L | "no proper prefix of" w "belongs to" L}. $
Prove that if $L$ is regular, then $mono("MIN")(L)$ is regular as well.
Every proper prefix in any word $w$ can be constructed into a fintie automaton by modifying the original finite automaton regardless of whether it belongs to $L$ or not.
]
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compute/data-01.typ | typst | Other | // Error: 18-32 file not found (searched at /missing.txt)
#let data = read("test/assets/files/missing.txt")
|
https://github.com/Servostar/dhbw-abb-typst-template | https://raw.githubusercontent.com/Servostar/dhbw-abb-typst-template/main/src/branding.typ | typst | MIT License |
// Reference color scheme can be found here:
// https://brand.abb/portal/en/branding-principles/basic-brand-elements/color
// ABB branding colors
#let ABB-RED = cmyk(0%, 100%, 95%, 0%)
#let ABB-BLACK = cmyk(0%, 0%, 0%, 100%)
#let ABB-GRAY-01 = cmyk(0%, 0%, 0%, 90%)
#let ABB-GRAY-02 = cmyk(0%, 0%, 0%, 75%)
#let ABB-GRAY-03 = cmyk(0%, 0%, 0%, 55%)
#let ABB-GRAY-04 = cmyk(0%, 0%, 0%, 35%)
#let ABB-GRAY-05 = cmyk(0%, 0%, 0%, 15%)
#let ABB-GRAY-06 = cmyk(0%, 0%, 0%, 5%)
#let ABB-WHITE = cmyk(0%, 0%, 0%, 0%)
// ABB branding functinal colors
#let ABB-BLUE = cmyk(100%, 53%, 2%, 16%)
#let ABB-GREEN = cmyk(91%, 4%, 100%, 25%)
#let ABB-YELLOW = cmyk(0%, 9%, 100%, 0%)
|
https://github.com/Maso03/Bachelor | https://raw.githubusercontent.com/Maso03/Bachelor/main/Bachelorarbeit/chapters/Unreal.typ | typst | MIT License | == 3D-Modellierung - Unreal Engine
Die Unreal Engine ist eine leistungsstarke Plattform für 3D-Modellierung und Spielentwicklung, die von Epic Games entwickelt wurde. Sie bietet eine Vielzahl von Tools und Funktionen zur Erstellung realistischer 3D-Umgebungen, Charaktere und Animationen. Die Unreal Engine wird nicht nur für Videospiele verwendet, sondern auch in Filmproduktion, Architekturvisualisierung und anderen Bereichen, die hochwertige 3D-Darstellungen erfordern. Ihre Flexibilität und Leistungsfähigkeit machen sie zu einer bevorzugten Wahl für die Entwicklung interaktiver und immersiver Anwendungen. |
https://github.com/LucaCiucci/custom-typst | https://raw.githubusercontent.com/LucaCiucci/custom-typst/main/better-highlight.typ | typst |
#import "@preview/jogs:0.2.3": *
#let js-code = ```js
function encode_uri_component(value) {
//return value;
return encodeURIComponent(value);
}
```
#js-code
#let js = compile-js(js-code)
Exported functions:\
#list-global-property(js)
#let rust-links(it) = {
//show link: it => link("aaa")
show "bool": it => link("https://doc.rust-lang.org/std/primitive.bool.html", "bool")
show "char": it => link("https://doc.rust-lang.org/std/primitive.char.html", "char")
show "f128": it => link("https://doc.rust-lang.org/std/primitive.f128.html", "f128")
show "f16": it => link("https://doc.rust-lang.org/std/primitive.f16.html", "f16")
show "f32": it => link("https://doc.rust-lang.org/std/primitive.f32.html", "f32")
show "f64": it => link("https://doc.rust-lang.org/std/primitive.f64.html", "f64")
show "i8": it => link("https://doc.rust-lang.org/std/primitive.i8.html", "i8")
show "i16": it => link("https://doc.rust-lang.org/std/primitive.i16.html", "i16")
show "i32": it => link("https://doc.rust-lang.org/std/primitive.i32.html", "i32")
show "i64": it => link("https://doc.rust-lang.org/std/primitive.i64.html", "i64")
show "i128": it => link("https://doc.rust-lang.org/std/primitive.i128.html", "i128")
show "isize": it => link("https://doc.rust-lang.org/std/primitive.isize.html", "isize")
show "u8": it => link("https://doc.rust-lang.org/std/primitive.u8.html", "u8")
show "u16": it => link("https://doc.rust-lang.org/std/primitive.u16.html", "u16")
show "u32": it => link("https://doc.rust-lang.org/std/primitive.u32.html", "u32")
show "u64": it => link("https://doc.rust-lang.org/std/primitive.u64.html", "u64")
show "u128": it => link("https://doc.rust-lang.org/std/primitive.u128.html", "u128")
show "usize": it => link("https://doc.rust-lang.org/std/primitive.usize.html", "usize")
show "*": it => link("https://doc.rust-lang.org/std/primitive.pointer.html", "*")
show "&": it => link("https://doc.rust-lang.org/std/primitive.reference.html", "&")
show "str": it => link("https://doc.rust-lang.org/std/primitive.str.html", "str")
// Keywords
show "Self": it => link("https://doc.rust-lang.org/std/keyword.SelfTy.html", "Self")
show "as": it => link("https://doc.rust-lang.org/std/keyword.as.html", "as")
show "async": it => link("https://doc.rust-lang.org/std/keyword.async.html", "async")
show "await": it => link("https://doc.rust-lang.org/std/keyword.await.html", "await")
show "break": it => link("https://doc.rust-lang.org/std/keyword.break.html", "break")
show "const": it => link("https://doc.rust-lang.org/std/keyword.const.html", "const")
show "continue": it => link("https://doc.rust-lang.org/std/keyword.continue.html", "continue")
show "crate": it => link("https://doc.rust-lang.org/std/keyword.crate.html", "crate")
show "dyn": it => link("https://doc.rust-lang.org/std/keyword.dyn.html", "dyn")
show "else": it => link("https://doc.rust-lang.org/std/keyword.else.html", "else")
show "enum": it => link("https://doc.rust-lang.org/std/keyword.enum.html", "enum")
show "extern": it => link("https://doc.rust-lang.org/std/keyword.extern.html", "extern")
show "false": it => link("https://doc.rust-lang.org/std/keyword.false.html", "false")
show "fn": it => link("https://doc.rust-lang.org/std/keyword.fn.html", "fn")
show "for": it => link("https://doc.rust-lang.org/std/keyword.for.html", "for")
show "if": it => link("https://doc.rust-lang.org/std/keyword.if.html", "if")
show "impl": it => link("https://doc.rust-lang.org/std/keyword.impl.html", "impl")
show "in": it => link("https://doc.rust-lang.org/std/keyword.in.html", "in")
show "let": it => link("https://doc.rust-lang.org/std/keyword.let.html", "let")
show "loop": it => link("https://doc.rust-lang.org/std/keyword.loop.html", "loop")
show "match": it => link("https://doc.rust-lang.org/std/keyword.match.html", "match")
show "mod": it => link("https://doc.rust-lang.org/std/keyword.mod.html", "mod")
show "move": it => link("https://doc.rust-lang.org/std/keyword.move.html", "move")
show "mut": it => link("https://doc.rust-lang.org/std/keyword.mut.html", "mut")
show "pub": it => link("https://doc.rust-lang.org/std/keyword.pub.html", "pub")
show "ref": it => link("https://doc.rust-lang.org/std/keyword.ref.html", "ref")
show "return": it => link("https://doc.rust-lang.org/std/keyword.return.html", "return")
show "self": it => link("https://doc.rust-lang.org/std/keyword.self.html", "self")
show "static": it => link("https://doc.rust-lang.org/std/keyword.static.html", "static")
show "struct": it => link("https://doc.rust-lang.org/std/keyword.struct.html", "struct")
show "super": it => link("https://doc.rust-lang.org/std/keyword.super.html", "super")
show "trait": it => link("https://doc.rust-lang.org/std/keyword.trait.html", "trait")
show "true": it => link("https://doc.rust-lang.org/std/keyword.true.html", "true")
show "type": it => link("https://doc.rust-lang.org/std/keyword.type.html", "type")
show "union": it => link("https://doc.rust-lang.org/std/keyword.union.html", "union")
show "unsafe": it => link("https://doc.rust-lang.org/std/keyword.unsafe.html", "unsafe")
show "use": it => link("https://doc.rust-lang.org/std/keyword.use.html", "use")
show "where": it => link("https://doc.rust-lang.org/std/keyword.where.html", "where")
show "while": it => link("https://doc.rust-lang.org/std/keyword.while.html", "while")
it
}
#let rust-playground(
main: false,
code: none,
it,
) = {
let code = if code == none {
it.text
} else {
code
};
// fix hidden lines
let lines = code.trim().split("\n");
let code = "";
for line in lines {
if code != "" {
code += "\n";
}
if line.starts-with("# ") {
code += line.slice(2);
} else {
code += line;
}
}
let code = if main {
"fn main() {\n " + code.replace("\n", "\n ") + "\n}"
} else {
code
}
let code = call-js-function(
js,
"encode_uri_component",
code,
);
let url = "https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&code=" + code;
box(width: 100%)[
#it
#place(top + right, box(link(url, "Run: " + emoji.rocket), stroke: gray, radius: 0.5em, inset: 0.5em, fill: gray.transparentize(50%)))
]
}
#let better-highlight(it) = {
show raw.where(lang: "rs"): rust-links
show raw.where(lang: "rust"): rust-links
let remove-hidden-lines(code) = {
let lines = code.trim().split("\n");
let code = "";
for line in lines {
if line.starts-with("# ") {
continue;
}
if code != "" {
code += "\n";
}
// half the leading spaces to make the code more readable on pdf
// by reducing the indentation from 4 to 2 spaces
let n_leading_spaces = line.position(line.trim());
let line = " " * calc.div-euclid(n_leading_spaces, 4) + " " * calc.rem-euclid(n_leading_spaces, 4) + line.trim();
code += line;
}
code
}
show raw.where(lang: "rs"): it => {
let code = it.text;
if code.starts-with("run-main") {
let code = code.slice(8);
// set text(size: 1.125em) // TODO see https://github.com/typst/typst/issues/1331
rust-playground(main: true, code: code, raw(remove-hidden-lines(code), lang: "rs", block: true))
} else if code.starts-with("run") {
let code = code.slice(3);
rust-playground(main: false, code: code, raw(remove-hidden-lines(code), lang: "rs", block: true))
} else {
it
}
}
it
}
#show: better-highlight
```rs
fn ciao() {
return 42;
}
```
```rs run
fn ciao() {
return 42;
}
```
```rs run-main
fn ciao() {
return 42;
}
``` |
|
https://github.com/Enter-tainer/typstyle | https://raw.githubusercontent.com/Enter-tainer/typstyle/master/tests/assets/unit/markup/list.typ | typst | Apache License 2.0 | === Legends <plot-legends>
A legend for a plot will be drawn if at least one set of data with a label that is not `none` is given.
The following anchors are available when placing a legend on a plot:
- `legend.north`
- `legend.south`
- `legend.east`
- `legend.west`
|
https://github.com/maxgraw/bachelor | https://raw.githubusercontent.com/maxgraw/bachelor/main/apps/document/src/6-evaluation/result.typ | typst | Im folgenden Abschnitt werden die Ergebnisse der Evaluation vorgestelt. Diese stellen die Grundlage für die Anfolgende Diskussion dar.
Der User Experience Questionnaire wurde mithilfe einer frei verfügbaren Excel-Vorlage durchgeführt. Diese Vorlage wird auf der offiziellen UEQ-Webseite bereitgestellt und ermöglicht das Laden und Auswerten der Daten @ueq-tool. Im Folgenden wird der Prozess der Datenerhebung und -auswertung näher erläutert. Die Grunddaten des UEQ sind in @appendix-resultBase dargestellt. Vor dem Import in das bereitgestellte Tool wurden die Daten auf die reinen UEQ-Item-Antworten reduziert. Im UEQ werden die positiven und negativen Begriffe in zufälliger Reihenfolge präsentiert, um Reihenfolgeeffekte zu minimieren. Um die Ergebnisse jedoch vergleichbar zu machen, transformiert das Tool die Daten in eine einheitliche Form. Diese transformierten Daten sind in @appendix-resultTransformed dargestellt. Die berechneten Skalenmittelwerte pro Person, welche auf den transformierten Daten basieren, sind in @appendix-resultTransformedMean dargestellt. Diese Mittelwerte bieten einen Überblick über die durchschnittliche Bewertung der einzelnen Skalen durch die Teilnehmer. Darüber hinaus findet man unter @appendix-resultDistribution die Verteilung der einzelnen Skalen des UEQ.
Mithilfe der bereitgestellten Daten wurden die Mittelwerte der einzelnen Dimensionen des Fragebogens berechnet welche in @figure-ueq-benchmark als Mean dargestellt sind. Hierbei erzielte die Dimension Durchschaubarkeit mit einem Mittelwert von 1,679 den höchsten Wert, wobei die Varianz 0,46 betrug. Effizienz folgte mit einem Mittelwert von 1,667 und wies dabei die geringste Varianz von 0,27 auf. Die Dimension Attraktivität erhielt einen Mittelwert von 1,381 und eine Varianz von 0,32. Steuerbarkeit wurde mit einem Mittelwert von 1,500 und einer Varianz von 0,35 bewertet. Stimulation erzielte einen Mittelwert von 1,369 und wies dabei eine Varianz von 0,49 auf. Originalität erhielt den niedrigsten Mittelwert von 1,286 und zeigte mit 0,73 die größte Varianz.
In der @figure-ueq-benchmark wird gleichzeitig der Vergleich mit Benchmark Werten dargestellt. Die Benchmark Daten wurden hierbei vom UEQ-Tool bereitgestellt und beinhalten Daten von 21.175 Personen aus 468 Studien. Die Produkte dieser Studien umfassen Geschäftssoftware, Webseiten, Webshops und soziale Netzwerke @ueq-tool.
#figure(
image("../media/result/ueq_benchmark.png", width: 80%),
caption: [UEQ Benchmark Daten im Vergleich zu den Ergebnissen der Evaluation.],
) <figure-ueq-benchmark> |
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/ofbnote/0.2.0/ofb_common.typ | typst | Apache License 2.0 | #import "@preview/showybox:2.0.1"
// Fonts definition
#let mainfont = "Spectral"
#let sansfont = "Marianne"
// Colors definition
#let ofbdarkgreen = rgb("#0E823A")
#let ofbdarkblue = rgb("#003A76")
#let ofbsemigreen = rgb("#A4A64B")
#let ofbsemiblue = rgb("#0083CB")
#let ofbgreen = rgb("#6AB96F")
#let ofbblue = rgb("#00A6E2")
#let ofbsemilightgreen = rgb("#9FCA7E")
#let ofbsemilightblue = rgb("#5BC5F2")
#let ofblightgreen = rgb("#C4D89B")
#let ofblightblue = rgb("#99D7F7")
#let ofbred = rgb("#C2133E")
#let ofborange = rgb("#ED6A53")
#let ofblightorange = rgb("#F39655")
#let ofbyellow = rgb("#FFD744")
#let ofbdarkgold = rgb("#564949")
#let ofbsemigold = rgb("#9A7B67")
#let ofbgold = rgb("#CC9F72")
#let ofblightgold = rgb("#EAC198")
#let palettea = ofbdarkblue
#let paletteb = ofbdarkgreen
#let palettec = ofbdarkgold
#let paletted = ofbred
#let palettee = ofbsemigreen
#let palettef = ofbsemiblue
#let palettela = ofblightblue
#let palettelb = ofblightgreen
#let palettelc = ofblightgold
#let paletteld = ofbyellow
#let paletteda = ofbdarkblue
#let palettedb = ofbdarkgreen
#let palettedc = ofbdarkgold
#let palettedd = ofbred
// Tables
#let mytable(..args)={
set table(
fill: (_,y) => if (y==0) {paletteda} else if calc.odd(y) {palettela.lighten(50%)} else {none},
stroke: (_y,y) => if (y==0) {(right: 0.1pt + paletteda)} else if calc.odd(y) {(right: 0.1pt + palettela.lighten(50%))} else {none},
)
show table.cell.where(y:0): set text(fill:white, weight:"bold")
align(center,table(
align: horizon,
rows: auto,
table.hline(stroke: palettea + 0.5pt),
..args,
table.hline(stroke: palettea + 0.5pt),
))
}
// Blocks
#let myblock(mytitle,..args)={
showybox.showybox(
frame:(
border-color: palettea,
title-color: white,
body-color: palettela.lighten(80%),
width: 0.75pt,
),
title-style:(
weight: "bold",
boxed-style: (:),
color: palettea,
),
body-style: (color: rgb("#666666")),
sep: (dash: none),
shadow: (offset: 3pt),
breakable: true,
title: mytitle,
..args
)
}
#let _conf(
meta: (:),
doc
) = {
// Metadata
set document(title: meta.at("title"),author: meta.at("authors"))
// Main styling
set text(font: (mainfont, "Linux Libertine"), size: 10pt, fill: rgb("#666666"), lang: "fr", region: "FR")
set par(justify: true)
show strong: set text(weight: "bold", fill: palettea)
// Lists
set list(
indent: 1em,
tight: false,
marker: ([#set text(fill: palettea);▶],[#set text(fill: paletteb);--],[#sym.star.filled]),
)
set enum(
indent: 1em,
tight: false,
numbering: n=>text(fill:palettea,[#n.]),
)
doc
}
|
https://github.com/alejandrgaspar/pub-analyzer | https://raw.githubusercontent.com/alejandrgaspar/pub-analyzer/main/pub_analyzer/internal/templates/author/sources.typ | typst | MIT License | // Sources
= Sources.
#table(
columns: (auto, 3fr, 2fr, auto, auto, auto, auto, auto),
inset: 8pt,
align: horizon,
// Headers
[], [*Name*], [*Publisher or institution*], [*Type*], [*ISSN-L*], [*Impact factor*], [*h-index*], [*Is OA*],
// Content
{% for source in report.sources_summary.sources %}
[3.{{ loop.index }}. #label("source_{{ source.id.path.rpartition("/")[2] }}")],
[#underline([#link("{{ source.homepage_url }}")[#"{{ source.display_name }}"]])],
[{{ source.host_organization_name or "-" }}],
[{{source.type }}],
[{{ source.issn_l or "-" }}],
[{{ source.summary_stats.two_yr_mean_citedness|round(3) }}],
[{{ source.summary_stats.h_index }}],
[{% if source.is_oa %}#text(rgb(SUCCESS))[True]{% else %}#text(rgb(ERROR))[False]{% endif %}],
{% endfor %}
)
|
https://github.com/Maeeen/thesis_template_typst | https://raw.githubusercontent.com/Maeeen/thesis_template_typst/master/documentation.typ | typst | #import "./template/template.typ": *
#import "@preview/tidy:0.3.0"
#let docs = tidy.parse-module(
read("/template/template.typ"),
scope: (title_page: title_page),
)
#tidy.show-module(docs)
|
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/fletcher/0.4.0/test/test.typ | typst | Apache License 2.0 | #import "@preview/cetz:0.1.2"
#import "/src/exports.typ" as fletcher: diagram, node, edge
#set page(width: 10cm, height: auto)
#show heading.where(level: 1): it => pagebreak(weak: true) + it
= Connectors
#diagram(
debug: 0,
cell-size: (10mm, 10mm),
node((0,0), $X$),
node((1,0), $Y$),
node((0,1), $Z$),
edge((0,0), (1,0), marks: (none, "head")),
edge((0,1), (1,0), $f$, marks: ("hook", "head"), dash: "dashed"),
edge((0,0), (0,1), marks: (none, ">>")),
edge((0,0), (0,0), marks: (none, "head"), bend: -120deg),
)
= Arc connectors
#diagram(
cell-size: 3cm,
{
node((0,0), "from")
node((1,0), "to")
for θ in (0deg, 20deg, -50deg) {
edge((0,0), (1,0), $#θ$, bend: θ, marks: (none, "head"))
}
})
#diagram(
debug: 3,
node((0,0), $X$),
node((1,0), $Y$),
edge((0,0), (1,0), bend: 45deg, marks: ">->"),
)
#for (i, to) in ((0,1), (1,0), (calc.sqrt(1/2),-calc.sqrt(1/2))).enumerate() {
diagram(debug: 0, {
node((0,0), $A$)
node(to, $B$)
let N = 6
range(N + 1).map(x => (x/N - 0.5)*2*120deg).map(θ => edge((0,0), to, bend: θ, marks: ">->")).join()
})
}
= Matching math arrows
Compare to $->$, $=>$ $arrow.triple$ $arrow.twohead$, $arrow.hook$, $|->$.
#let (result-color, target-color) = (rgb("f066"), rgb("0bf5"))
Compare #text(result-color)[our output] to the #text(target-color)[reference symbol] in default math font. \
#{
set text(10em)
diagram(
spacing: 0.815em,
crossing-fill: none,
edge(
(0,0), (1,0),
text(target-color, $->$),
"->",
stroke: result-color,
label-anchor: "center",
label-sep: 0.0915em,
),
)
diagram(
spacing: 0.8em,
crossing-fill: none,
edge(
(0,0), (1,0),
text(target-color, $=>$),
"=>",
stroke: result-color,
label-anchor: "center",
label-sep: 0.0915em,
),
)
diagram(
spacing: 0.83em,
crossing-fill: none,
edge(
(0,0), (1,0),
text(target-color, $arrow.triple$),
"==>",
stroke: result-color,
label-anchor: "center",
label-sep: 0.0915em,
),
)
diagram(
spacing: 0.835em,
crossing-fill: none,
edge(
(0,0), (1,0),
text(target-color, $->>$),
"->>",
stroke: result-color,
label-anchor: "center",
label-sep: 0.0915em,
),
)
diagram(
spacing: 0.83em,
crossing-fill: none,
edge(
(0,0), (1,0),
text(target-color, $arrow.hook$),
"hook->",
stroke: result-color,
label-side: right,
label-anchor: "center",
label-sep: 0.0915em,
label-pos: 0.51,
),
)
diagram(
spacing: 0.807em,
crossing-fill: none,
edge(
(0,0), (1,0),
text(target-color, $|->$),
"|->",
stroke: result-color,
label-anchor: "center",
label-sep: 0.0915em,
label-pos: 0.506,
),
)
}
= Double and triple lines
#for (i, a) in ("->", "=>", "==>").enumerate() [
Diagram #diagram(
// node-inset: 5pt,
label-sep: 1pt + i*1pt,
node((0, -i), $A$),
edge((0, -i), (1, -i), text(0.6em, $f$), a),
node((1, -i), $B$),
) and equation #($A -> B$, $A => B$, $A arrow.triple B$).at(i). \
]
= Arrow head shorthands
$
#for i in (
"->",
"<-",
">-<",
"<->",
"<=>",
"<==>",
"|->",
"|=>",
">->",
"<<->>",
">>-<<",
">>>-}>",
"hook->",
"hook'--hook",
"|=|",
"||-||",
"|||-|||",
"/--\\",
"\\=\\",
"/=/",
"x-X",
">>-<<",
"harpoon-harpoon'",
"harpoon'-<<",
"<--hook'",
"|..|",
"hooks--hooks",
"o-O",
"O-o",
"*-@",
"o==O",
"||->>",
"<|-|>",
"|>-<|",
"-|-",
"hook-/->",
"<{-}>",
) {
$ #block(inset: 2pt, fill: white.darken(5%), raw(repr(i)))
&= #align(center, box(width: 15mm, diagram(edge((0,0), (1,0), marks: i), debug: 0))) \ $
}
$
= Bending arrows
#diagram(
debug: 1,
spacing: (10mm, 5mm),
for (i, bend) in (0deg, 40deg, 80deg, -90deg).enumerate() {
let x = 2*i
(
(">->->",),
("<<->>",),
(">>-<<",),
(marks: ((kind: "hook", rev: true), "head")),
(marks: ((kind: "hook", rev: true), "hook'")),
(marks: ("bar", "bar", "bar")),
(marks: ("||", "||")),
(marks: (none, none), extrude: (2.5,0,-2.5)),
(marks: ("head", "head"), extrude: (1.5,-1.5)),
(marks: (">", "<"), extrude: (1.5,-1.5)),
(marks: ("bar", "head"), extrude: (2,0,-2)),
(marks: ("o", "O")),
(marks: ((kind: "solid", rev: true), "solid")),
).enumerate().map(((i, args)) => {
edge((x, i), (x + 1, i), ..args, bend: bend)
}).join()
}
)
= Fine mark angle corrections
#diagram(
debug: 4,
spacing: 10mm,
edge-stroke: 0.8pt,
for (i, m) in ("<=>", ">==<", ">>->>", "<<-<<", "|>-|>", "<|-<|", "O-|-O", "hook-hook'").enumerate() {
edge((0,i), (1,i), m)
edge((2,i), (3,i), m, bend: 90deg)
edge((4,i), (5,i), m, bend: -30deg)
edge((6,i), (7,i + 0.5), m, corner: right)
}
)
= Defocus adjustment
#let around = (
(-1,+1), ( 0,+1), (+1,+1),
(-1, 0), (+1, 0),
(-1,-1), ( 0,-1), (+1,-1),
)
#grid(
columns: 2,
..(-10, -1, -.25, 0, +.25, +1, +10).map(defocus => {
((7em, 3em), (3em, 7em)).map(((w, h)) => {
align(center + horizon, diagram(
node-defocus: defocus,
node-inset: 0pt,
{
node((0,0), rect(width: w, height: h, inset: 0pt, align(center + horizon)[#defocus]))
for p in around {
edge(p, (0,0))
}
}))
})
}).join()
)
= Automatic label placement
Default placement above the line.
#diagram(
spacing: 2cm,
debug: 3,
axes: (ltr, ttb),
{
for p in around {
edge(p, (0,0), $f$)
}
})
Reversed $y$-axis:
#diagram(
spacing: 2cm,
debug: 3,
axes: (ltr, btt),
{
for p in around {
edge(p, (0,0), $f$)
}
})
#diagram(spacing: 1.5cm, {
for (i, a) in (left, center, right).enumerate() {
for (j, θ) in (-30deg, 0deg, 50deg).enumerate() {
edge((2*i, j), (2*i + 1, j), label: a, "->", label-side: a, bend: θ)
}
}
})
= Crossing connectors
#diagram({
edge((0,1), (1,0))
edge((0,0), (1,1), "crossing")
edge((2,1), (3,0), "|-|", bend: -20deg)
edge((2,0), (3,1), "<=>", crossing: true, bend: 20deg)
})
= `edge()` argument shorthands
#diagram(
axes: (ltr, btt),
edge((0,0), (1,1), "->", "double", bend: 45deg),
edge((1,0), (0,1), "->>", "crossing"),
edge((1,1), (2,1), $f$, "|->"),
edge((0,0), (1,0), "-", "dashed"),
)
= Diagram-level options
#diagram(
node-stroke: gray.darken(50%) + 1pt,
edge-stroke: green.darken(40%) + .6pt,
node-fill: green.lighten(80%),
node-outset: 2pt,
label-sep: 0pt,
node((0,1), $A$),
node((1,0), $sin compose cos compose tan$, fill: none),
node((2,1), $C$),
node((3,1), $D$, shape: "rect"),
edge((0,1), (1,0), $sigma$, "-}>", bend: -45deg),
edge((2,1), (1,0), $f$, "<{-"),
)
= CeTZ integration
#import "/src/utils.typ": vector-polar
#diagram(
node((0,1), $A$, stroke: 1pt),
node((2,0), [Bézier], stroke: 1pt),
render: (grid, nodes, edges, options) => {
cetz.canvas({
fletcher.draw-diagram(grid, nodes, edges, options)
let n1 = fletcher.find-node-at(nodes, (0,1))
let p1 = fletcher.get-node-anchor(n1, 0deg)
let n2 = fletcher.find-node-at(nodes, (2,0))
let p2 = fletcher.get-node-anchor(n2, -90deg)
let c1 = cetz.vector.add(p1, vector-polar(20pt, 0deg))
let c2 = cetz.vector.add(p2, vector-polar(70pt, -90deg))
fletcher.draw-arrow-cap(p1, 180deg, (thickness: 1pt, paint: black), "head")
cetz.draw.bezier(p1, p2, c1, c2)
})
}
)
= Node bounds, inset, and outset
#diagram(
debug: 2,
node-outset: 5pt,
node-inset: 5pt,
node((0,0), `hello`, stroke: 1pt),
node((1,0), `there`, stroke: 1pt),
edge((0,0), (1,0), "<=>"),
)
= Corner edges
#let around = (
(-1,+1), (+1,+1),
(-1,-1), (+1,-1),
)
#for dir in (left, right) {
pad(1mm, diagram(
// debug: 4,
spacing: 1cm,
node((0,0), [#dir]),
{
for c in around {
node(c, $#c$)
edge((0,0), c, $f$, marks: (
(kind: "head", rev: false, pos: 0),
(kind: "head", rev: false, pos: 0.33),
(kind: "head", rev: false, pos: 0.66),
(kind: "head", rev: false, pos: 1),
), "double", corner: dir)
}
}
))
}
#for dir in (left, right) {
pad(1mm, diagram(
// debug: 4,
spacing: 1cm,
axes: (ltr, btt),
node((0,0), [#dir]),
{
for c in around {
node(c, $#c$)
edge((0,0), c, $f$, marks: (
(kind: "head", rev: false, pos: 0),
(kind: "head", rev: false, pos: 0.33),
(kind: "head", rev: false, pos: 0.66),
(kind: "head", rev: false, pos: 1),
), "double", corner: dir)
}
}
))
}
= Double node strokes
#diagram(
node-outset: 4pt,
spacing: (15mm, 8mm),
node-stroke: black + 0.5pt,
node((0, 0), $s_1$, ),
node((1, 0), $s_2$, extrude: (-1.5, 1.5), fill: blue.lighten(70%)),
edge((0, 0), (1, 0), "->", label: $a$, bend: 20deg),
edge((0, 0), (0, 0), "->", label: $b$, bend: 120deg),
edge((1, 0), (0, 0), "->", label: $b$, bend: 20deg),
edge((1, 0), (1, 0), "->", label: $a$, bend: 120deg),
edge((1,0), (2,0), "->>"),
node((2,0), $s_3$, extrude: (+1, -1), stroke: 1pt, fill: red.lighten(70%)),
)
#diagram(
node((0,0), `outer`, stroke: 1pt, extrude: (-1, +1), fill: green),
node((1,0), `inner`, stroke: 1pt, extrude: (+1, -1), fill: green),
node((2,0), `middle`, stroke: 1pt, extrude: (0, +2, -2), fill: green),
)
Relative and absolute extrusion lengths
#diagram(
node((0,0), `outer`, stroke: 1pt, extrude: (-1mm, 0pt), fill: green),
node((1,0), `inner`, stroke: 1pt, extrude: (0, +.5em, -2pt), fill: green),
)
= Custom node sizes
Make sure provided dimensions are exact, not affected by node `inset`.
#circle(radius: 1cm, align(center + horizon, `1cm`))
#diagram(
node((0,1), `1cm`, stroke: 1pt, radius: 1cm, inset: 1cm, shape: "circle"),
node((0,0), [width], stroke: 1pt, width: 2cm),
node((1,0), [height], stroke: 1pt, height: 4em, inset: 0pt),
node((2,0), [both], width: 1em, height: 1em, fill: blue),
)
= Example
#[
Make sure node or edge labels don't pick up equation numbers!
#set math.equation(numbering: "(1)")
$ a^2 $
#{
set text(size: 0.65em)
diagram(
node-stroke: .1em,
node-inset: .2em,
node-fill: gradient.radial(white, blue.lighten(40%), center: (30%, 20%), radius: 130%),
edge-stroke: .06em,
spacing: 5em,
mark-scale: 120%,
node((0,0), `reading`, radius: 2em, shape: "circle"),
node((1,0), `eof`, radius: 2em, shape: "circle"),
node((2,0), `closed`, radius: 2em, shape: "circle", extrude: (-2, 0)),
node((-.7,0), `open(path)`, stroke: none, fill: none),
edge((-.7,0), (0,0), "-|>"),
edge((0,0), (1,0), `read()`, "-|>"),
edge((0,0), (0,0), `read()`, "<|-", bend: -130deg),
edge((1,0), (2,0), `close()`, "-|>"),
edge((0,0), (2,0), `close()`, "-|>", bend: -40deg),
)
}
$ b^2 $
]
= Axes configuration
#for axes in ((ltr, btt), (ltr, ttb), (rtl, btt), (rtl, ttb)) {
for axes in (axes, axes.rev()) {
diagram(
axes: axes,
debug: 1,
node((0,0), $(0,0)$),
edge((0,0), (1,0), "hook->", bend: 20deg),
node((1,0), $(1,0)$),
node((1,1), $(1,1)$),
node((0.5,0.5), raw(repr(axes))),
)
}
}
= Implicit `from` and `to` points
#diagram(edge((0,0), (1,0), [label], "->"))
#diagram(edge((1,0), [label], "->"))
#diagram(edge([label], "->"))
#diagram(
node((1,2), [prev]),
edge("->", bend: 45deg),
node((2,1), [next]),
edge((1,2), ".."),
)
= Edge positional arguments
Explicit named arguments versus implicit positional arguments.
Each row should be the same thing repeated.
#let ab = node((0,0), $A$) + node((1,0), $B$)
#grid(
columns: (1fr,)*3,
diagram(ab, edge((0,0), (1,0), marks: "->")),
diagram(ab, edge((0,0), (1,0), "->")),
diagram($A edge(->) & B$),
diagram(ab, edge((0,0), (1,0), label: $pi$)),
diagram(ab, edge((0,0), (1,0), $pi$)),
diagram($A edge(pi) & B$),
diagram(ab, edge((0,0), (1,0), marks: "|->", label: $tau$)),
diagram(ab, edge((0,0), (1,0), "|->", $tau$)),
diagram($A edge(tau, |->) & B$),
diagram(ab, edge((0,0), (1,0), marks: "->>", label: $+$)),
diagram(ab, edge((0,0), (1,0), "->>", $+$)),
diagram($A edge(->>, +) & B$),
)
= Symbol arrow aliases
#table(
columns: 4,
align: horizon,
[Math], [Unicode], [Mark], [Diagram],
..(
$->$, $-->$, $<-$, $<->$, $<-->$,
$->>$, $<<-$,
$>->$, $<-<$,
$=>$, $==>$, $<==$, $<=>$, $<==>$,
$|->$, $|=>$,
$~>$, $<~$,
$arrow.hook$, $arrow.hook.l$,
).map(x => {
let unicode = x.body.text
(x, unicode)
if unicode in fletcher.MARK_SYMBOL_ALIASES {
let marks = fletcher.MARK_SYMBOL_ALIASES.at(unicode)
(raw(marks), diagram(edge((0,0), (1,0), marks: marks)))
} else {
(text(red)[none!],) * 2
}
}).flatten()
)
= Math-mode diagrams
The following diagrams should be identical:
#diagram($
G edge(f, ->) edge(#(0,1), pi, ->>) & im(f) \
G slash ker(f) edge(#(1,0), tilde(f), "hook-->")
$)
#diagram(
node((0,0), $G$),
edge((0,0), (1,0), $f$, "->"),
edge((0,0), (0,1), $pi$, "->>"),
node((1,0), $im(f)$),
node((0,1), $G slash ker(f)$),
edge((0,1), (1,0), $tilde(f)$, "hook-->")
)
= Relative node coordinates
#diagram($
G edge(->, f) edge("d", ->>, pi) & im(f) \
G slash ker(f) edge("ne", "hook-->", tilde(f))
$)
= Nodes in math-mode
#diagram(
node-outset: 2pt,
node-inset: 5pt,
$
A edge(->) & node(B, fill: #blue.lighten(50%)) \
node(C, stroke: #(red + .3pt), radius: #1em) edge("u", "=")
$,
) |
https://github.com/RubixDev/typst-tabley | https://raw.githubusercontent.com/RubixDev/typst-tabley/main/example.typ | typst | MIT License | #import "@preview/cetz:0.1.2"
#import "./tabley.typ": tabley
#set page(width: auto, height: auto, margin: 1cm)
#cetz.canvas({
import cetz.draw: *
let data = (
[a], [bc], [d],
[e], [fgh\ ijk], [l],
[a], [bc], [d],
[e], [fgh\ ijk], [l],
)
tabley((0, 0), columns: 3, ..data, name: "a")
tabley((3, 0), columns: 4, ..data, name: "b")
bezier(
"a.1-1-right",
"b.3-2-left",
(rel: ( 2, 0), to: "a.1-1-right"),
(rel: (-2, 0), to: "b.3-2-left"),
mark: (end: ">"), angle: 50deg,
)
})
#cetz.canvas({
import cetz.draw: *
tabley((.5, 0), columns: 3, name: "a", [left], [middle], [right])
tabley((0, -2), columns: 2, name: "b", [one], [two])
tabley(
(2.5, -1.5),
columns: 6,
name: "c",
hlines: none,
vlines: none,
[], [], [b], [], [], [],
// we fill a cell with invisible text to get the column to the right size,
// the actual content is manually placed afterwards
text(fill: white)[world], [c], [d], [e], [g], [h],
[], [], [f], [], [], [],
)
// our "hello world" is manually placed here
content(("c.0-0-top-left", .5, "c.0-2-bottom-right"), align(center)[hello\ world])
// draw the lines
rect("c.top-left", "c.bottom-right")
line("c.0-0-top-right", "c.0-2-bottom-right")
line("c.2-1-top-left", "c.2-1-bottom-left")
line("c.2-1-top-right", "c.2-1-bottom-right")
line("c.4-0-top-left", "c.4-2-bottom-left")
line("c.5-0-top-left", "c.5-2-bottom-left")
line("c.1-0-bottom-left", "c.3-0-bottom-right")
line("c.1-2-top-left", "c.3-2-top-right")
bezier(
"a.1-0-bottom",
"b.0-0-top",
(rel: (0, -1), to: "a.1-0-bottom"),
(rel: (0, 1), to: "b.0-0-top"),
mark: (end: ">"), angle: 50deg,
)
bezier(
"a.2-0-bottom",
("c.2-1-top-left", .3, "c.2-1-left"),
(rel: (0, -1), to: "a.2-0-bottom"),
mark: (end: ">"), angle: 50deg,
)
})
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compiler/import-13.typ | typst | Other | // Some non-text stuff.
// Error: 9-21 file is not valid utf-8
#import "/rhino.png"
|
https://github.com/RaphGL/ElectronicsFromBasics | https://raw.githubusercontent.com/RaphGL/ElectronicsFromBasics/main/DC/chap5/3_simple_parallel_circuits.typ | typst | Other | #import "../../core/core.typ"
=== Simple parallel circuits
Let\'s start with a parallel circuit consisting of three resistors and a
single battery:
#image("static/00092.png")
The first principle to understand about parallel circuits is that the
voltage is equal across all components in the circuit. This is because
there are only two sets of electrically common points in a parallel
circuit, and voltage measured between sets of common points must always
be the same at any given time. Therefore, in the above circuit, the
voltage across R#sub[1] is equal to the voltage across R#sub[2] which is
equal to the voltage across R#sub[3] which is equal to the voltage
across the battery. This equality of voltages can be represented in
another table for our starting values:
#image("static/10070.png")
Just as in the case of series circuits, the same caveat for Ohm\'s Law
applies: values for voltage, current, and resistance must be in the same
context in order for the calculations to work correctly. However, in the
above example circuit, we can immediately apply Ohm\'s Law to each
resistor to find its current because we know the voltage across each
resistor (9 volts) and the resistance of each resistor:
$
I_(R 1) &= E_(R 1) / R_1 \
I_(R 1) &= (9 V) / (10k Omega) = 0.9 "mA"
$
\
$
I_(R 2) &= E_(R 2) / R_2 \
I_(R 2) &= (9 V) / (2k Omega) = 4.5 "mA"
$
\
$
I_(R 3) &= E_(R 3) / R_3 \
I_(R 3) &= (9 V) / (1k Omega) = 9 "mA"
$
#image("static/10072.png")
At this point we still don\'t know what the total current or total
resistance for this parallel circuit is, so we can\'t apply Ohm\'s Law
to the rightmost (\"Total\") column. However, if we think carefully
about what is happening it should become apparent that the total current
must equal the sum of all individual resistor (\"branch\") currents:
#image("static/00093.png")
As the total current exits the negative (-) battery terminal at point 8
and travels through the circuit, some of the flow splits off at point 7
to go up through R#sub[1], some more splits off at point 6 to go up
through R#sub[2], and the remainder goes up through R#sub[3]. Like a
river branching into several smaller streams, the combined flow rates of
all streams must equal the flow rate of the whole river. The same thing
is encountered where the currents through R#sub[1], R#sub[2], and
R#sub[3] join to flow back to the positive terminal of the battery (+)
toward point 1: the flow of electrons from point 2 to point 1 must equal
the sum of the (branch) currents through R#sub[1], R#sub[2], and
R#sub[3].
This is the second principle of parallel circuits: the total circuit
current is equal to the sum of the individual branch currents. Using
this principle, we can fill in the I#sub[T] spot on our table with the
sum of I#sub[R1], I#sub[R2], and I#sub[R3]:
#image("static/10073.png")
Finally, applying Ohm\'s Law to the rightmost (\"Total\") column, we can
calculate the total circuit resistance:
#image("static/10074.png")
Please note something very important here. The total circuit resistance
is only 625 Ω: #emph[less] than any one of the individual resistors. In
the series circuit, where the total resistance was the sum of the
individual resistances, the total was bound to be #emph[greater] than
any one of the resistors individually. Here in the parallel circuit,
however, the opposite is true: we say that the individual resistances
#emph[diminish] rather than #emph[add] to make the total. This principle
completes our triad of \"rules\" for parallel circuits, just as series
circuits were found to have three rules for voltage, current, and
resistance. Mathematically, the relationship between total resistance
and individual resistances in a parallel circuit looks like this:
$ R_"total" = 1 / (1/R_1 + 1/R_2 + 1/R_3) $
The same basic form of equation works for #emph[any] number of resistors
connected together in parallel, just add as many $1/R$ terms on the
denominator of the fraction as needed to accommodate all parallel
resistors in the circuit.
Just as with the series circuit, we can use computer analysis to
double-check our calculations. First, of course, we have to describe our
example circuit to the computer in terms it can understand. I\'ll start
by re-drawing the circuit:
#image("static/00092.png")
Once again we find that the original numbering scheme used to identify
points in the circuit will have to be altered for the benefit of SPICE.
In SPICE, all electrically common points must share identical node
numbers. This is how SPICE knows what\'s connected to what, and how. In
a simple parallel circuit, all points are electrically common in one of
two sets of points. For our example circuit, the wire connecting the
tops of all the components will have one node number and the wire
connecting the bottoms of the components will have the other. Staying
true to the convention of including zero as a node number, I choose the
numbers 0 and 1:
#image("static/00094.png")
An example like this makes the rationale of node numbers in SPICE fairly
clear to understand. By having all components share common sets of
numbers, the computer \"knows\" they\'re all connected in parallel with
each other.
In order to display branch currents in SPICE, we need to insert
zero-voltage sources in line (in series) with each resistor, and then
reference our current measurements to those sources. For whatever
reason, the creators of the SPICE program made it so that current could
only be calculated #emph[through] a voltage source. This is a somewhat
annoying demand of the SPICE simulation program. With each of these
\"dummy\" voltage sources added, some new node numbers must be created
to connect them to their respective branch resistors:
#image("static/00095.png")
The dummy voltage sources are all set at 0 volts so as to have no impact
on the operation of the circuit. The circuit description file, or
#emph[netlist], looks like this:
```
Parallel circuit
v1 1 0
r1 2 0 10k
r2 3 0 2k
r3 4 0 1k
vr1 1 2 dc 0
vr2 1 3 dc 0
vr3 1 4 dc 0
.dc v1 9 9 1
.print dc v(2,0) v(3,0) v(4,0)
.print dc i(vr1) i(vr2) i(vr3)
.end
```
Running the computer analysis, we get these results (I\'ve annotated the
printout with descriptive labels):
```
v1 v(2) v(3) v(4)
9.000E+00 9.000E+00 9.000E+00 9.000E+00
battery R1 voltage R2 voltage R3 voltage
voltage
```
```
v1 i(vr1) i(vr2) i(vr3)
9.000E+00 9.000E-04 4.500E-03 9.000E-03
battery R1 current R2 current R3 current
voltage
```
These values do indeed match those calculated through Ohm\'s Law
earlier: 0.9 mA for I#sub[R1], 4.5 mA for I#sub[R2], and 9 mA for
I#sub[R3]. Being connected in parallel, of course, all resistors have
the same voltage dropped across them (9 volts, same as the battery).
In summary, a parallel circuit is defined as one where all components
are connected between the same set of electrically common points.
Another way of saying this is that all components are connected across
each other\'s terminals. From this definition, three rules of parallel
circuits follow: all components share the same voltage; resistances
diminish to equal a smaller, total resistance; and branch currents add
to equal a larger, total current. Just as in the case of series
circuits, all of these rules find root in the definition of a parallel
circuit. If you understand that definition fully, then the rules are
nothing more than footnotes to the definition.
#core.review[
- Components in a parallel circuit share the same voltage:
$E_"Total" = E_1 = E_2 = ... = E_n$
- Total resistance in a parallel circuit is #emph[less] than any of the
individual resistances:
$ R_"Total" = 1 / (1/R_1 + 1/R_2 +... 1/R_n) $
- Total current in a parallel circuit is equal to the sum of the
individual branch currents: $I_"Total" = I_1 + I_2 + ... I_n$.
]
|
https://github.com/PhilChodrow/cv | https://raw.githubusercontent.com/PhilChodrow/cv/main/src/content/education.typ | typst | #import "../template.typ": *
#cvSection("Education")
#cvEntry(
title: [PhD in Operations Research],
organisation: [Massachusetts Institute of Technology],
logo: "",
date: [2015-2020],
location: [Cambridge, MA],
description: ""
// tags: ("Database Systems", "Computer Networks", "Cybersecurity")
)
// #divider()
#cvEntry(
title: [BA in Mathematics and Philosophy],
organisation: [Swarthmore College],
logo: "",
date: [2008-2012],
location: [Swarthmore, PA],
// description: list(
// [#lorem(20)],
// ),
) |
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/layout/repeat-01.typ | typst | Other | // Test dots with RTL.
#set text(lang: "ar")
مقدمة #box(width: 1fr, repeat[.]) 15
|
https://github.com/jamesrswift/pixel-pipeline | https://raw.githubusercontent.com/jamesrswift/pixel-pipeline/main/tests/playground.typ | typst | The Unlicense | #import "preamble.typ": *
#import pixel.math: vector
#let _validate(input, output, next) = {
next(input, output)
}
#let _compute(input, output, next) = {
next(input, output)
}
#let _vertex(input, output, next) = {
next(input, output)
}
#let _render(input, output, next) = {
if "plot" not in input.tags {return next(input, output)}
if "axis" in input.tags {
return input + (:
content: {
place(line(
start: input.positions.named().start.position,
end: input.positions.named().end.position
))
for i in range(0, 11) {
let pos = vector.add(
input.positions.named().start.position,
vector.scale(
vector.sub(
input.positions.named().end.position,
input.positions.named().start.position
),
i/10
),
)
place(line(
start: pos,
end: vector.add(pos, (-2pt,3pt))
)) + place(
dx: vector.add(pos, (-2pt,3pt)).first(),
dy: vector.add(pos, (-2pt,3pt)).last(),
$#i$
)
}
}
)
}
}
#let _layout(input, output, next) = {
next(input, output)
}
#let test-pipeline = pixel.pipeline.factory(
layers: (
pixel.layer.drawing.layer(validation: true),
(:
validation: _validate,
compute: _compute,
vertex: _vertex,
render: _render,
layout: _layout,
),
// pixel.layer.debug(),
),
)
#test-pipeline({
(
{
pixel.primitives.assembled(
tags: ("plot","axis"),
min: 0,
max: 10,
)
pixel.primitives.positioned(
positions: arguments(
root: pixel.primitives.position((0,0)),
start: pixel.primitives.position((0,0)),
end: pixel.primitives.position((10,10)),
)
)
},
)
(
{
pixel.primitives.assembled(
tags: ("plot","axis"),
min: 0,
max: 10,
)
pixel.primitives.positioned(
positions: arguments(
root: pixel.primitives.position((1,0)),
start: pixel.primitives.position((0,0)),
end: pixel.primitives.position((10,10)),
)
)
},
)
}) |
https://github.com/kdog3682/2024-typst | https://raw.githubusercontent.com/kdog3682/2024-typst/main/src/my-weekly-schedule.typ | typst | #import "base-utils.typ": *
#let flex(..sink) = {
// layout-util
let args = sink.pos()
let flat(arg) = {
if is-array(arg) {
arg.join()
} else {
arg
}
}
let flattened = args.map(flat)
panic(flattened)
let length = len(flattened)
let aligner(col, row) = {
if col == 0 {
left + horizon
} else if col == length - 1 {
right + horizon
} else {
center + horizon
}
}
let spacer = h(0.5fr)
let spacer = h(1fr)
return table(columns: (1fr,) * flattened.len(), align: aligner, stroke: none, ..flattened)
return flattened.join(spacer)
}
#let my-weekly-schedule(data) = {
let items = data
let weekdays = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
let weekdays = "M T W Th F Sat Sun".split(" ")
let create(s) = {
return box(width: 20pt, height: 15pt, s)
}
let header(s) = {
return text(size: 12pt, weight: "bold", align(s, horizon))
}
let cols = (30pt,) * weekdays.len()
let cells = (("Todo Item",) + weekdays).map(header) + items
table(
align: (col, row) => {
if row == 0 and col == 0 {
return left + horizon
}
if row == 0 {
return center
}
if col == 0 {
return left + horizon
}
return left + horizon
},
inset: (y: 5pt, left: 5pt, right: 5pt), columns: (auto, ) + cols, ..cells)
}
#let additional-entries() = {
let create(s) = {
return box(height: 8pt)
}
table(columns: (80pt,), ..fill(25, "").map(create))
}
#let wrapper() = {
let title = "Year 2024 Week 6 - February 5"
set page(
footer-descent: 0pt,
flipped: false, paper: "us-letter", margin: 0.75in)
show heading: set text(size: 12pt)
[= #title]
v(10pt)
stack(dir: ltr, spacing: 40pt,
my-weekly-schedule(readjson()),
additional-entries()
)
}
#wrapper()
|
|
https://github.com/typst-jp/typst-jp.github.io | https://raw.githubusercontent.com/typst-jp/typst-jp.github.io/main/docs/reference/packages.md | markdown | Apache License 2.0 | Typst [packages]($scripting/#packages) encapsulate reusable building blocks
and make them reusable across projects. Below is a list of Typst packages
created by the community. Due to the early and experimental nature of Typst's
package management, they all live in a `preview` namespace. Click on a package's
name to view its documentation and use the copy button on the right to get a
full import statement for it.
|
https://github.com/JeyRunner/tuda-typst-templates | https://raw.githubusercontent.com/JeyRunner/tuda-typst-templates/main/templates/tudapub/common/tudapub_title_page.typ | typst | MIT License | #import "props.typ": *
#import "format.typ": *
#import "../tudacolors.typ": tuda_colors
// note the page needs to have the correct margins.
// Set these up before
#let tudpub-make-title-page(
title: [Title],
title_german: [Title German],
// "master" or "bachelor" thesis
thesis_type: "master",
// the code of the accentcolor.
// A list of all available accentcolors is in the list tuda_colors
accentcolor: "9c",
// language for correct hyphenation
language: "eng",
// author name as text, e.g "<NAME>"
author: "<NAME>",
// date of submission as string
date_of_submission: datetime(
year: 2023,
month: 10,
day: 4,
),
location: "Darmstadt",
// array of the names of the reviewers
reviewer_names: ("SuperSupervisor 1", "SuperSupervisor 2"),
// tuda logo, has to be a svg. E.g. image("PATH/TO/LOGO")
logo_tuda: none,
// optional sub-logo of an institute.
// E.g. image("logos/iasLogo.jpeg")
logo_institute: none,
// How to set the size of the optional sub-logo.
// either "width": use tud_logo_width*(2/3)
// or "height": use tud_logo_height*(2/3)
logo_institute_sizeing_type: "width",
// Move the optional sub-logo horizontally
logo_institute_offset_right: 0mm,
// an additional white box with content for e.g. the institute, ... below the tud logo.
// E.g. logo_sub_content_text: [ Institute A \ filed of study: \ B]
logo_sub_content_text: none,
title_height: 3.5em
) = {
// vars
let accentcolor_rgb = tuda_colors.at(accentcolor)
let title_separator_spacing = 15pt
let title = [#title]
//let title_height = 150pt //measure(title, styles).height
let title_page_inner_margin_left = 8pt
let logo_tud_height = 22mm
let submission_date = format-date(date_of_submission, location)
let thesis_type_text = {
if lower(thesis_type) == "master" {"Master"}
else if lower(thesis_type) == "bachelor" {"Bachelor"}
else {panic("thesis_type has to be either 'master' or 'bachelor'")}
}
///////////////////////////////////////
// Display the title page
page(footer: [])[
//#set par(leading: 1em)
#set text(
//font: "Comfortaa",
font: "Roboto",
//stretch: 50%,
//fallback: false,
weight: "bold",
size: 35.86pt,
//height:
)
#let title_height = 3.5em //measure(title, styles).height
//#v(80pt)
#grid(
rows: (auto, 1fr),
stack(
// title
block(
inset: (left: title_page_inner_margin_left),
height: title_height)[
#set par(
justify: false,
leading: 20pt // line spacing
)
#align(bottom)[#title]
],
v(title_separator_spacing),
line(length: 100%, stroke: tud_heading_line_thin_stroke),
v(3mm), // title_separator_spacing
//
// sub block with reviewers and other text
block(inset: (left: title_page_inner_margin_left))[
#set text(size: 12pt)
#title_german
\
#set text(weight: "regular")
#thesis_type_text thesis by #author
\
Date of submission: #submission_date
\
\
#for (i, reviewer_name) in reviewer_names.enumerate() [
#(i+1). Review: #reviewer_name
\
]
#v(-5pt) // spacing optional
#location
],
v(15pt)
),
// color rect with logos
rect(
fill: color.rgb(accentcolor_rgb),
stroke: (
top: tud_heading_line_thin_stroke,
bottom: tud_heading_line_thin_stroke
),
inset: 0mm,
width: 100%,
height: 100%//10em
)[
#v(logo_tud_height/2)
#style(styles => {
//let tud_logo = image(logo_tuda_path, height: logo_tud_height)
let tud_logo = [
#set image(height: logo_tud_height)
#logo_tuda
]
let tud_logo_width = measure(tud_logo, styles).width
let tud_logo_offset_right = -6.3mm
tud_logo_width += tud_logo_offset_right
align(right)[
//#natural-image(logo_tuda_path)
#grid(
// tud logo
// move logo(s) to the right
box(inset: (right: tud_logo_offset_right), fill: black)[
#set image(height: logo_tud_height)
#tud_logo
],
// sub logo
v(5mm),
// height from design guidelines
if logo_institute != none {
box(inset: (right: logo_institute_offset_right), fill: black)[
#set image(height: tud_logo_width*(2/3))
#{
if logo_institute_sizeing_type == "width" {
//image(logo_institute_path, width: tud_logo_width*(2/3))
set image(width: tud_logo_width*(2/3), height: auto)
logo_institute
}
else if logo_institute_sizeing_type == "height" {
//image(logo_institute_path, height: logo_tud_height*(2/3))
set image(height: logo_tud_height*(2/3))
logo_institute
}
else {
panic("logo_institute_sizeing_type has to be width or height")
}
}
]
},
// sub box with custom text
if logo_sub_content_text != none {
box(width: tud_logo_width,
outset: 0mm,
fill: white,
inset: (
top: 6pt,
bottom: 6pt,
left: 4.5mm,
right: 6pt
),
align(left)[
#set text(weight: "regular", size: 9.96pt)
#logo_sub_content_text
])
}
)
]
})
]
)
]
} |
https://github.com/Nerixyz/icu-typ | https://raw.githubusercontent.com/Nerixyz/icu-typ/main/api.typ | typst | MIT License | #import "impl.typ": fmt-date, fmt-datetime, fmt-time, locale-info
#import "experimental.typ" as experimental
|
https://github.com/CoderJackZhu/XDUthesis-Typst | https://raw.githubusercontent.com/CoderJackZhu/XDUthesis-Typst/main/template/thesis.typ | typst | MIT License | #import "../lib.typ": documentclass, indent
// 你首先应该安装 https://github.com/CoderJackZhu/XDUthesis-Typst/tree/main/fonts/FangZheng 里的所有字体，
// 如果是 Web App 上编辑，你应该手动上传这些字体文件，否则不能正常使用「楷体」和「仿宋」，导致显示错误。
#let (
// // // // 布局函数
twoside, doc, preface, mainmatter, mainmatter-end, appendix,
// 页面函数
fonts-display-page, cover, decl-page, abstract, abstract-en, bilingual-bibliography,
outline-page, list-of-figures, list-of-tables, notation, acknowledgement,
) = documentclass(
doctype: "master", // "bachelor" | "master" | "doctor" | "postdoc", 文档类型，默认为本科生 bachelor
// degree: "academic", // "academic" | "professional", 学位类型，默认为学术型 academic
// anonymous: true, // 盲审模式
twoside: true, // 双面模式，会加入空白页，便于打印
// 可自定义字体，先英文字体后中文字体，应传入「宋体」、「黑体」、「楷体」、「仿宋」、「等宽」
// fonts: (楷体: ("Times New Roman", "FZKai-Z03S")),
info: (
title: ("基于 Typst 的", "西安电子科技大学学位论文"),
title-en: "My Title in English",
grade: "20XX",
student-id: "1234567890",
author: "张三",
author-en: "<NAME>",
department: "某学院",
department-en: "School of Artificial Intelligence",
major: "某专业",
major-en: "Chemistry",
supervisor: ("李四", "教授"),
supervisor-en: "Professor My Supervisor",
// supervisor-ii: ("王五", "副教授"),
// supervisor-ii-en: "Professor My Supervisor",
submit-date: datetime.today(),
),
// 参考文献源
bibliography: bibliography.with("ref.bib"),
)
// 文稿设置
#show: doc
// 字体展示测试页
// #fonts-display-page()
// 封面页
#cover()
// 声明页
#decl-page()
// 前言
#show: preface
// 中文摘要
#abstract(
keywords: ("我", "就是", "测试用", "关键词")
)[
中文摘要
]
// 英文摘要
#abstract-en(
keywords: ("Dummy", "Keywords", "Here", "It Is")
)[
English abstract
]
// 目录
#outline-page()
// 插图目录
// #list-of-figures()
// 表格目录
// #list-of-tables()
// 正文
#show: mainmatter
// 符号表
// #notation[
// / DFT: 密度泛函理论 (Density functional theory)
// / DMRG: 密度矩阵重正化群密度矩阵重正化群密度矩阵重正化群 (Density-Matrix Reformation-Group)
// ]
= 导 论
== 列表
=== 无序列表
- 无序列表项一
- 无序列表项二
- 无序子列表项一
- 无序子列表项二
=== 有序列表
+ 有序列表项一
+ 有序列表项二
+ 有序子列表项一
+ 有序子列表项二
=== 术语列表
/ 术语一: 术语解释
/ 术语二: 术语解释
== 图表
引用@tbl:timing，引用@tbl:timing-tlt，以及@fig:xdu-logo。引用图表时，表格和图片分别需要加上 `tbl:`和`fig:` 前缀才能正常显示编号。
#align(center, (stack(dir: ltr)[
#figure(
table(
align: center + horizon,
columns: 4,
[t], [1], [2], [3],
[y], [0.3s], [0.4s], [0.8s],
),
caption: [常规表],
) <timing>
][
#h(50pt)
][
#figure(
table(
columns: 4,
stroke: none,
table.hline(),
[t], [1], [2], [3],
table.hline(stroke: .5pt),
[y], [0.3s], [0.4s], [0.8s],
table.hline(),
),
caption: [三线表],
) <timing-tlt>
]))
#figure(
image("images/xidian-logo.jpg", width: 20%),
caption: [图片测试],
) <xdu-logo>
== 数学公式
可以像 Markdown 一样写行内公式 $x + y$，以及带编号的行间公式：
$ phi.alt := (1 + sqrt(5)) / 2 $ <ratio>
引用数学公式需要加上 `eqt:` 前缀，则由@eqt:ratio，我们有：
$ F_n = floor(1 / sqrt(5) phi.alt^n) $
我们也可以通过 `<->` 标签来标识该行间公式不需要编号
$ y = integral_1^2 x^2 dif x $ <->
而后续数学公式仍然能正常编号。
$ F_n = floor(1 / sqrt(5) phi.alt^n) $
== 参考文献
可以像这样引用参考文献：图书#[@蒋有绪1998]和会议#[@中国力学学会1990]。
== 代码块
代码块支持语法高亮。引用时需要加上 `lst:` @lst:code
#figure(
```py
def add(x, y):
return x + y
```,
caption:[代码块],
) <code>
= 正 文
== 正文子标题
=== 正文子子标题
正文内容
// 手动分页
#if twoside {
pagebreak() + " "
}
// 中英双语参考文献
// 默认使用 gb-7714-2015-numeric 样式
#bilingual-bibliography(full: true)
// 致谢
#acknowledgement[
感谢 NJU-LUG，感谢 NJUThesis LaTeX 模板。
]
// 手动分页
#if twoside {
pagebreak() + " "
}
// 附录
#show: appendix
= 附录
== 附录子标题
=== 附录子子标题
附录内容，这里也可以加入图片，例如@fig:appendix-img。
#figure(
image("images/xidian-logo.jpg", width: 20%),
caption: [图片测试],
) <appendix-img>
// 正文结束标志，不可缺少
// 这里放在附录后面，使得页码能正确计数
#mainmatter-end() |
https://github.com/Student-Smart-Printing-Service-HCMUT/ssps-docs | https://raw.githubusercontent.com/Student-Smart-Printing-Service-HCMUT/ssps-docs/main/contents/index.typ | typst | Apache License 2.0 | #{ include "../components/bia.typ" }
#pagebreak()
#outline(
indent: true,
depth: 3
)
#outline(
title: "Danh mục hình ảnh",
target: figure.where(kind: image)
)
#outline(
title: "Danh mục bảng biểu",
target: figure.where(kind: table)
)
#pagebreak()
#{ include "./categories/task1/1.conclude.typ" }
#{ include "./categories/task2/2.conclude.typ" }
#{ include "./categories/task3/3.conclude.typ" }
#{ include "./categories/task4/4.conclude.typ" }
#{ include "./categories/task5/5.conclude.typ" }
#pagebreak()
|
https://github.com/rodrigo72/typst-LNCS-template | https://raw.githubusercontent.com/rodrigo72/typst-LNCS-template/main/src/example.typ | typst | #import "template.typ": *
#show: LNCS-paper.with(
title: "Title",
subtitle: "Subtitle",
university: "University of Somewhere",
email_type: "university.of.somewhere",
authors: (
(
name: "Student1",
number: "10001",
),
(
name: "Student2",
number: "10002",
),
(
name: "Student3",
number: "10003",
),
),
group:"Group 01",
abstract: lorem(30),
bibliography-file: "refs.bib",
bibliography-full: true
)
= Introduction
#lorem(40)
= Header
#figure(
image("image.png", width: 30%)
)
== Header
=== Header
==== Header
= Conclusion
#lorem(20) |
|
https://github.com/Area-53-Robotics/53B-Notebook-Over-Under-2023-2024 | https://raw.githubusercontent.com/Area-53-Robotics/53B-Notebook-Over-Under-2023-2024/master/entries/early_season/building_drive.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #import "/templates/entries.typ": *
#import "/templates/headers.typ": *
#import "/templates/text.typ": *
#create_footerless_page(
title: [Building Drive Train],
date: [September 23rd, 2023],
content: [
#box_header(
title: [Drive Train Specs],
color: purple.lighten(60%)
) \
#entry_text()
#table(
rows: auto,
columns: (3fr, 1fr),
align: left,
[== Specification], [== Number],
[*Wheel Size*: Diameter of the wheels in inches.],[4 Inches],
[*Wheel Type*: What type of wheel being used.], [Omni],
[*Gear Ratio*: The gear ratio between the the motor and the wheel.], [48t:84t (4:7)],
[*Motor Cartridge*: The gear cartridge being used in the motor.], [1:6 (Red)],
[*Motor Count*: The number of motors powering the drive train.], [6],
[*Motor Wattage*: The amount of wattage the motors have.], [11 Watts]
)
#box_header(
title: [Wheel Axle Design],
color: yellow.lighten(60%)
) \
#entry_text()
The wheels will be screw-joints. It is better to use a screw joint than axles because it is more secure and is easier to reduce friction, since the wheels are freespinning inetead of the axle spinning.
#grid(
rows: auto,
columns: (1fr, 1fr),
column-gutter: 10pt,
image("/assets/wheel.png"),
[
\ \ \ \
$2 1/2$" screw $-->$ crown nut $-->$ $1/8$" spacer $-->$ 84 tooth gear $-->$ washer $-->$ $1/8$" spacer $-->$ $4$" omni wheel $-->$ $1/8$" spacer $-->$ crown nut
]
)
#entry_header(title: [Motor Axle Design])
#entry_text()
The gear connected to the motor will have a pretty standard design, being a low strength axle with spacers and a lock collar. There will also be bearing blocks on the end of the axle for support.
#grid(
rows: auto,
columns: (1fr, 1fr),
column-gutter: 10pt,
image("/assets/gear_axle.png", width: 90%),
[
\ \ \ \ \ \ \ \
Axle $-->$ washer $-->$ $1/8$" spacer $-->$ 48 tooth gear $3/8$" spacer $-->$ $1/2$" spacer $-->$ collar $-->$ washer
]
)
]
)
#create_headerless_page(
design: [Jin],
witness: [Deb],
content: [
#image("/assets/drive.jpg")
#entry_text()
#align(center)[Picture of finished side of drive train.]
\
#entry_header(title: [Sleds])
#entry_text()
We also want to experiment with sleds. Sleds are semi-circle plates that are attached to the front of the drive-train. Sleds can be employed to help robots navigate uneven or challenging surfaces, specifically the middle bar on the match.
\
#image("/assets/sleds.png")
]
) |
https://github.com/crd2333/crd2333.github.io | https://raw.githubusercontent.com/crd2333/crd2333.github.io/main/src/docs/Courses/数据库系统/SQL.typ | typst | ---
order: 2
---
#import "/src/components/TypstTemplate/lib.typ": *
#show: project.with(
title: "数据库系统",
lang: "zh",
)
#let null = math.op("null")
#let Unknown = math.op("Unknown")
#counter(heading).update(1)
= 第二部分：SQL
== Introduction to SQL
- *SQL：结构化查询语言*，分为 DDL, DML, DCL 几种类型，用的比较多的标准是 SQL-92
- *非过程式，声明式*的语言
=== SQL 创建，更新，删除
- *DDL(Data Definition Language)* 允许确定这些关系：*schema* for each relation、*domain* of values、integrity constraints、other information such as indices, Security and authorization, physical storage structure.
- SQL 支持的数据类型
- char(n), varchar(n), int, smallint, numeric(p,d), null-value, date, time, timestamp
- char, varchar 分别是字符串和可变字符串；numeric(p,d) 是精度为 p，小数点后 d 位的科学计数法数字
- *Built-in* Data Types: date, time, timestamp, interval
- 所有的数据类型都支持 null 作为属性值，可以在定义的时候声明一个属性的值 not null
- 创建数据表 create table
- 创建表的语法
```sql
create table table_name(
variable_name1 type_name1,
variable_name2 type_name2,
(integrity-contraints)
...,)
```
- 例如：
```sql
create table instructor (
ID char(5),
name varchar(20) not null,
dept_name varchar(20),
salary numeric(8,2),
primary key (ID),
foreign key (dept_name) references department);
```
- `integrity-contraint` 完整性约束：可以指定 *primary key*, *foreign key xxx references yyy, not null*
- foreign key detail: `foreign key (dept_name) references department)`，后面再加 `on delete cascade |set null |restrict |set default` 或 `on update cascade |set null |restrict |set default`。
- 删除数据表 `drop table` 或 `delete from table`，前者是整个 schema 都删了，后者只是删除所有行
- 更新数据表的栏目 `alter table`
- `alter table R add A D` 添加一条新属性，其中 $A$ 是属性名，$D$ 是 $A$ 的 domain，其中的 relations 默认填充 null
- `alter table R drop A` 删除 $A$ 属性
=== SQL查询
- 事实上的最重要 SQL 语句，考试考的一般都是查询语句
==== select 语句
- SQL 查询的基本形式：select 语句
```sql
select A1, A2, sum(A3)
from R_1, r_2, ..., rm
where P
group by A1, A2
```
- 上述查询等价于 $attach(cal(G), bl: A_1\, A_2, br: "sum"(A_3)) (sigma_p (r_1 times r_2 times dots times r_m))$
- SQL查询的结果是一个关系
- ```sql select * from xxx``` 表示获取*所有属性*，事实上我怀疑 \* 是正则表达式，表示可能有的所有内容，从后面的内容来看，select 语句确实是支持正则表达式
- SQL 中的*保留字*对于*大小写不敏感*
- 去除重复：```sql select distinct```，对应的保留所有就是 ```sql select all```
- select子句中的表达式支持基本的*四则运算*(加减乘除)，比如
```sql
select ID, name, salary / 2
from instructor;
```
- 重命名操作，可以通过 ```sql old_name as new_name``` 进行重命名；后面 from 子句也可以用 as 重命名
- 关键字 `as` 是可选的，```sql instructor as T ≡ instructor T```。特别地，在 oracle 中 must be omitted
==== where 子句
- 支持 `and or not` 等*逻辑运算*
- 支持 `between and` 来*查询范围*（实际上可以用一个 and 和两个条件代替）
- 支持*元组比较*：```sql where (instructor.ID, dept_name) = (teaches.ID, "Biology");```
- 字符串支持*正则表达式*匹配，用`like regrex`的方式可以进行属性值的正则表达式匹配
- 正则表达式的用法没怎么讲
```sql
select name
from teacher
where name like '%hihci%';
```
==== from 子句：
- from 可以选择多个表，此时会先将这些表进行*笛卡尔积*的运算（也可以显式指定为 *natural join* 等），再进行 select
- 元组变量：可以从多个表中 select 满足一定条件的几个不同属性值的元组
```sql
select instructor.name as teacher-name, course.title as course-title
from instructor, teaches, course
where instructor.ID = teaches.ID and
teaches.course_id = course.course_id and
instructor.dept_name = 'Art';
```
- Natural Join 的例子
```
course(course_id,title, dept_name, credits)
teaches(ID, course_id, sec_id,semester, year)
instructor(ID,name, dept_name, salary)
```
- 注意到 dept_name 在 course 和 instructor 中可能有细微的不同。
- 下面第一个为 Incorrect version (makes `course.dept_name = instructor.dept_name`)
```sql
select name, title # incorrect
from instructor natural join teaches natural join course;
select name, title # correct
from instructor natural join teaches, course
where teaches.course_id = course.course_id;
select name, title # correct
from (instructor natural join teaches）join course using(course_id);
select name, title # correct
from instructor，teaches, course
where instructor.ID=teaches.ID and teaches.course_id =course.course_id;
```
==== Order by 子句与 Limit 子句
- Order by 将输出的结果排序
- ```sql order by attribute_name (desc)```，默认是升序，可以加上 desc 来表示降序
- 可以对 multiple attributes 排序，主序、次序、$dots$
- `limit offset, row_count`，offset 不指定则默认为 0
- List names of instructors whose salary is among top 3
```sql
select name
from instructor
order by salary desc
limit 3； # limit 0,3
```
==== Duplicate 多重集
- 略过
==== 集合操作：
- 可以用 `union/intersect/except` 等集合运算来*连接两条不同的查询*
- 和查询不同，集合操作默认会自动去重，加 `all` 表示多重集
- 例子 union($union$)、intersect($sect$)、except($-$)
```sql
# Find courses that ran in Fall 2009 but not in Spring 2010
(select course_id from section where sem = "Fall" and year = 2009)
except
(select course_id from section where sem = "Spring" and year = 2010)
```
==== Null values 空值
- 属性值可以为 null，当然也可以在定义数据表的时候规定哪些元素不能为空
- 任何牵涉到 null 的算数表达式结果都为 null，如 $5 + null$ returns $null$
- 与 null 的比较操作会返回一个特殊的值 —— Unknown
- Unknown 和 true / false 之间的运算，根据逻辑操作是 AND、AND、NOT 来判断结果
==== 聚合操作(Aggregate Functions)：
- 支持的操作有 avg / min / max / sum / count，获取的是表中的统计量，如
```sql
select dept_name, avg(salary) as avg_salary
from instructor
group by dept_name;
```
#fig("/public/assets/Courses/DB/img-2024-03-11-14-56-08.png")
- 在 selelct 子句中，aggregate functions 外的属性#redt[必须出现在 group by 子句中]（因为聚合操作本质是根据聚合函数外的属性进行分组，然后统计聚合函数中的属性的值）
- 事实上SQL语句的聚合操作和关系代数中的聚合运算是完全对应的，关系代数中的聚合运算表达式 $attach(cal(G), bl: G_1\, G_2\, dots\, G_n, br: F_1(A_1)\, dots\, F_n(A_n)) (E)$ 对应的 SQL 语句是
```sql
select G1, G2, ..., Gn, F1(A1), ..., Fn(An)
from E
group by G1, G2, ..., Gn;
```
- *having 子句*：聚合操作的 SQL 语句书写可以在末尾用 `having xxx` 来表示一些需要聚合操作来获得的条件（这个条件甚至能带算数表达式），比如
```sql
select dept_name, count (*) as cnt
from instructor
where salary >= 100000
group by dept_name
having count (*) > 10
order by cnt;
```
- 注意，having 和 where 的区别在于分组前后进行的筛选，因此常在 having 中使用聚合函数
- from 表中，先 where 筛选，再 group by 分组，再 having 组筛选，select 某些属性，最后 order by 排序并 limit 输出
- null values 和 aggregates
- 比如，sum 忽略 null 值；count 不统计 null 值
==== Nested Subquery 嵌套查询
- 例子引入：
```sql
select distinct course_id
from section
where semester = "Fall" and year= 2009 and
course_id in (select course_id
from section
where semester = "Spring" and year= 2010);
```
- 这里老师提了一嘴，distinct 只能在最外围 select 中使用
- 对于查询
```sql
select A1, A2, ..., An
from r_1, r_2, ..., r_n
where P
```
- 其中的 A，r，P 都可以被替换为一个*子查询*
- scalar 子查询：用于单个值作为查询结果的时候
- 如果返回多个值会报 runtime error，可以考虑下面的集合关系
```sql
select dept_name
from department
where budget = (select max(budget) from department)
```
===== 集合关系：
- `in/not in + subquery` 用来判断否些属性是否属于特定的集合中
```sql
select distinct course_id
from section
where semester = "Fall" and year= 2009 and
course_id in (select course_id
from section
where semester = "Spring" and year= 2010);
```
- `some/any + subquery` 用于判断集合中是否存在满足条件的元组，用来判断存在性
```sql
select name
from instructor
where salary > some (select salary
from instructor
where dept_name = "Biology");
```
- `all + subquery` 可以用来筛选最值
```sql
select name
from instructor
where salary > all (select salary
from instructor
where dept_name = "Biology");
```
- `exists + subquery` 不为空时返回
```sql
# another way of “Find all courses in both Fall 2009 and Spring 2010”
select course_id
from section as S
where semester = "Fall" and year= 2009 and
exists (select *
from section as T
where semester = "Spring" and year= 2010
and S.course_id= T.course_id);
```
- `not exists + subquery` 为空时返回
- 感觉更加常用，注意到 $X – Y = emptyset <=> X subset Y$
```sql
# Find all students who have taken all courses offered in the Biology department
select distinct S.ID, S.name
from student as S
where not exists ((select course_id # 所有生物课
from course
where dept_name = "Biology")
except
(select T.course_id # 某个学生上过的所有课
from takes as T
where S.ID = T.ID));
# Note: Cannot write this query using = all and its variants
# why?
```
- `unique` 判断是否唯一
- 注意，空集也为 true，如果要判断存在且唯一，需要额外处理
```sql
# Find all courses that were offered at most once in 2009
select T.course_id
from course as T
where unique (select R.course_id
from section as R
where T.course_id= R.course_id
and R.year = 2009);
# if exactly once, use the below
select T.course_id
from course as T
where unique (select R.course_id
from section as R
where T.course_id= R.course_id
and R.year = 2009)
and exists (select R.course_id
from section as R
where T.course_id= R.course_id
and R.year = 2009);
# Or another solution:
and course_id in (select course_id
from section
where year = 2009) ;
```
==== with 子句
- 对子查询定义一个变量名，可以在之后调用
- 多个临时子查询用逗号分隔（写在一个 with 中）
```sql
with max_budget (value) as
(select max(budget)
from department)
select dept_name
from department, max_budget
where department.budget = max_budget.value;
```
=== SQL插入，删除，更新
- 删除：```sql delete from table_name where xxxxxx```
- where 可以嵌入子查询，先子查询，再删除，也就是说下面这种情况不会边删边计算
```sql
delete from instructor
where salary< (select avg(salary) from instructor);
```
- 插入: ```sql insert into table_name values();```
- 也可以指定 table 的列名，这种情况下，不一定要输入所有的列值，缺省的使用默认值或 null
- 批量插入：可以用 select 查询子句得到的结果作为 values，此时可同时插入多条结果
- 同样，先子查询，再插入，不会边插边查询
- 更新：`update table_name set xxx where xxxxx`
```sql
update instructor
set salary = salary * 1.03
where salary > 100000;
update instructor
set salary = salary * 1.05
where salary <= 100000;
```
- The order is important, so can be done better using the case statement (when updating multiply)
- case 子句：用于分类讨论
```sql
update instructor
set salary = case
when salary <= 100000 then salary * 1.05
else salary * 1.03
end
```
== Intermediate SQL
=== Join 链接关系
#fig("/public/assets/Courses/DB/img-2024-03-18-13-41-44.png")
=== SQL 类型
- User-Defined Types: ```sql create type Dollars as numeric (12,2) final```
- Domains
- `create domain new_name + data type`(比如 char(20))
- Domain 与 User-Defined Types类似，但可以设置约束条件，比如下面这一段 domain 定义表示 degree_level 只能在这三个中进行选择
```sql
create domain degree_level varvhar(10)
constraint degree_level_test
check(value in ('Bacheors', 'Masters', 'Doctorate'));
```
- Large-Object Types 大对象类型，分为 blob(二进制大对象)和 clob(文本大对象)两种，当查询需要返回大对象类型的时候，取而代之的是一个代表大对象的指针
=== Integrity 完整性控制
==== 单个关系上的约束
- 主键 primary key, foreign key, *unique*, not null, check(P)
- check 子句：写在数据表的定义中，check(P) 检查某个属性是否为特定的一些值
- ```sql check (semester in ("Fall", "Winter", "Spring", "Summer")```
- ```sql check (time_slot_id in (select time_slot_id from time_slot))```，Complex Check Clauses，并没有被大多数 database 支持(alternative: triggers)
- Domain constraints 值域的约束
- 在 domain 的定义中加入 check
- 语法 ```sql create domain domain_name constraints check_name check(P)```
- *Referential Integrity* 引用完整性
- 被引用表中主键和外键的关系
- 其实 PPT 里这一段讲了半天就是在说要在定义表的时候定义主键和外键进行约束
- Integrity Constraint Violation During Transactions
- 有时插入语句在执行时用到了之后才会知道的信息，这时候可以选择将其置为 $null$ 或置为空
- 更好的方法是，只在事务结束的时候检查完整性约束
- Cascading action
- on update
- on delete
==== 对于整个数据库的约束
- Assertions：对于数据库中需要满足的关系的一种*预先判断*
- `create assertion <assertion-name> check <predicate>` 下面是一段例子
```sql
create assertion credits_constaint check
(not exists(
select *
from student S
where total_cred <> (
select sum(credits)
from takes nature join course
where takes.ID = S.ID and grade is not null and grade <> 'F')
)
)
```
- 可以想见这玩意儿的开销非常大，属于是乌托邦设想，因此 Mysql 不支持 assertions(alternative: triggers)
=== SQL view 视图
- 视图：一种*只显示数据表中部分属性值*的机制
- 不会在数据库中重新定义一张新的表，而是隐藏了一些数据（定义了一张虚表）
- 好处：隐藏数据，提高安全性；简化查询，提高效率
- 创建视图的定义语句：```sql create view xxx as (query expression)```
- xxx 是视图的名称，内容是从某个 table 中 select 出的
```sql
create view departments_total_salary(dept_name, total_salary) as
select dept_name, sum(salary)
from instructor
group by dept_name;
```
- 可以用 view 的信息定义新的 view
- view 如何起效？将 view 的定义嵌入到 SQL 语句中，再进行查询优化
- 可以通过 view 对实际的表进行更新、删除（像是从窗户向房子里扔石子）
- 没有给定的值设置为 $null$
- updatable views 条件：
1. 创建时只使用了一张表的数据
2. 插入的值要包含 primary key
3. 创建时没有进行 distinct、表达式和聚合操作
4. 没有出现的属性允许设置为 $null$
- \*Materializing a view: ```sql create materialized view xxx as (query expression)```
- 物化 view 加快查询速度，但是会增加存储开销和*维护开销*，故一般用于不怎么修改但是频繁查询的数据表
- \*View and Logical Data Indepencence
- 比如，将 $S(a, b, c)$ 拆分为 $S_1(a, b)$, $S_2(a, c)$，原本的 $S$ 用 view 实现，这样减小了表的大小，又不会干扰 API
=== index 索引
- 在对应的表和属性中建立索引，加快查询的速度
- 索引的内部实现有很多，最常见的是创建 B+ 树
- 是涉及到物理层面的一条语句
- 语法 `create index index_name on table_name(attribute)`
- 写了 index 后，查询语法上跟原先相同，但是内部实现有所不同
=== Transactions 事务
- SQL 中的每一条指令，包括(insert, delete, update, select)都是一个事务
- Transactions begin *implicitly*, ended by *commit work* or *rollback work*
- In MySQL, there is ```sql SET AUTOCOMMIT = 0```
- In SQL1999, there is ```sql begin transaction ... end```
- Not supported on most databases
- 实际使用中需要考虑事务边界的问题，十分复杂
==== ACID Properties
- *Atomicity* 原子性：事务中的所有操作要么全部执行，要么全部不执行
- *Consistency* 一致性：事务执行前后，数据库的状态应该是一致的
- *Isolation* 隔离性：事务的执行不应该受到其他事务的干扰
- *Durability* 持久性：事务执行后，对数据库的改变应该是持久的
=== Authorization 授权
- 数据库中的四种权限 read,insert,update,delete
- Security specification in SQL 安全规范
- grant 赋予权限
- `grant <privilege list> on <relation name or view name> to <user list>`
- `<user list>` 可以是用户名，也可以是 public(允许所有有效用户拥有这项权限)，也可以是后面的 role
- 例如 ```sql grant update (budget) on department to U1, U2```
- revoke 权力回收
- ```sql revoke <privilege list> on <relation/view name> from <user list> [restrict|cascade]``` 从用户中回收权力
- role 语句：允许一类用户持有相同的权限
- ```sql create role role_name```
- Roles can be granted to users, as well as to other roles, for example
- ```sql grant teaching_assistant to instructor;``` Instructor 将会继承 teaching_assistant 的所有权限
- Authorization on *Views*
- *References Privilege* to create foreign key
- transfer of privileges
- ```sql grant select on department to Amit with grant option```;
- ```sql revoke select on department from Amit, Satoshi cascade```;
- ```sql revoke select on department from Amit, Satoshi restrict```;
- ```sql revoke grant option for select on department from Amit```
== Advanced SQL
=== Accessing SQL From a Programming Language
- 有两种方法从通用高级编程语言访问 SQL
- API：通过 API 调用 SQL 语句
- Embedded SQL：在编程语言中嵌入 SQL 语句
- 缩写解释
- JDBC 是 Java Database Connectivity，是 Java 语言的 API
- ODBC 是 Open Database Connectivity，是 C、Cpp、C\# 等语言的 API
- Embedded SQL in C
- SQLJ - embedded SQL in Java
- JPA(Java Persistence API) - OR mapping of Java
==== Database and Java
- JDBC Code
```java
// Update to database
try {
stmt.executeUpdate(
"insert into instructor values("77987", "Kim", "Physics", 98000)");
} catch (SQLException sqle) {
System.out.println("Could not insert tuple. " + sqle);
}
// Execute query and fetch and print results
ResultSet rset = stmt.executeQuery(
"select dept_name, avg (salary)
from instructor
group by dept_name");
while (rset.next()) {
System.out.println(rset.getString("dept_name") + " " + rset.getFloat(2));
}
```
- 一些细节
- Getting result fields: ```java rset.getString("dept_name") and rset.getString(1)```
- Dealing with Null values: ```java int a = rset.getInt("a");
if (rset.wasNull()) Systems.out.println("Got null value");```
- Prepared Statement
- 一次性的语法分析、检查、优化
- SQL Injection(SQL 注入)
- 一种攻击方式
- 所以最好用 prepare 的方式
- Metadata Features
- 得到 Metadata 信息
- Transaction Control in JDBC
==== Database and C
- ODBC Code
```c
int ODBCexample()
{
RETCODE error;
HENV env; /* environment */
HDBC conn; /* database connection */
SQLAllocEnv(&env);
SQLAllocConnect(env, &conn);
SQLConnect(conn, "db.yale.edu", SQL_NTS, "avi", SQL_NTS, "avipasswd",
SQL_NTS);
{... Do actual work ...}
SQLDisconnect(conn);
SQLFreeConnect(conn);
SQLFreeEnv(env);
}
```
- 使用 `SQLExecDirect` 直接执行 SQL 语句，返回结果使用 `SQLFetch()` 来得到，`SQLBindCol()` 来绑定结果
```c
char deptname[80];
float salary;
int lenOut1, lenOut2;
HSTMT stmt;
char * sqlquery = "select dept_name, sum (salary)
from instructor
group by dept_name";
SQLAllocStmt(conn, &stmt);
error = SQLExecDirect(stmt, sqlquery, SQL_NTS);
if (error == SQL_SUCCESS) {
SQLBindCol(stmt, 1, SQL_C_CHAR, deptname , 80, &lenOut1);
SQLBindCol(stmt, 2, SQL_C_FLOAT, &salary, 0 , &lenOut2);
while (SQLFetch(stmt) == SQL_SUCCESS) {
printf(" %s %g\n", deptname, salary);
}
}
SQLFreeStmt(stmt, SQL_DROP);
```
- ODBC 的 Prepare
- To prepare a statement: ```c SQLPrepare(stmt, <SQL String>);```
- To bind parameters: ```c SQLBindParameter(stmt, <parameter#>, ... type information and value omitted for simplicity..)```
- To execute the statement: ```c SQLExecute(stmt);```
- More ODBC Features
- Matadata Features
- Transaction Control
==== Embedded SQL
- SQLJ: embedded SQL in Java
```java
#sql iterator deptInfoIter ( String dept name, int avgSal);
deptInfoIter iter = null;
#sql iter = {select dept_name, avg(salary) as avgSal from instructor
group by dept name};
while (iter.next()) {
String deptName = iter.dept_name();
int avgSal = iter.avgSal();
System.out.println(deptName + " " + avgSal);
}
iter.close();
```
- SQLCA: embedded SQL in C
```c
main() { // insert without cursor
EXEC SQL INCLUDE SQLCA; //声明段开始
EXEC SQL BEGIN DECLARE SECTION;
char account_no [11]; //host variables(宿主变量)声明
char branch_name [16];
int balance;
EXEC SQL END DECLARE SECTION;//声明段结束
EXEC SQL CONNECT TO bank_db USER Adam Using Eve;
scanf("%s %s %d", account_no, branch_name, balance);
EXEC SQL insert into account
values(:account_no, :branch_name, :balance);
If (SQLCA.sqlcode != 0)
printf("Error!\n");
else
printf("Success!\n");
}
main() { // select single record without cursor
EXEC SQL INCLUDE SQLCA; //声明段开始
EXEC SQL BEGIN DECLARE SECTION;
char account_no [11]; //host variables(宿主变量)声明
int balance;
EXEC SQL END DECLARE SECTION; //声明段结束
EXEC SQL CONNECT TO bank_db USER Adam Using Eve;
scanf("%s", account_no);
EXEC SQL select balance into :balance
from account
where account_number = :account_no;
If (SQLCA sqlcode != 0)
printf("Error!\n");
else
printf("balance=%d\n", balance);
}
// Embedded SQL with cursor (select multiple records)
main() {
EXEC SQL INCLUDE SQLCA;
EXEC SQL BEGIN DECLARE SECTION;
char customer_name[21];
char account_no [11];
int balance;
EXEC SQL END DECLARE SECTION;
EXEC SQL CONNECT TO bank_db USER Adam Using Eve;
EXEC SQL DECLARE account_cursor CURSOR for // 与之前不同的地方
select account_number, balance
from depositor natural join account
where depositor.customer_name = : customer_name;
scanf (“%s”, customer_name);
EXEC SQL open account_cursor;
for (; ;) {
EXEC SQL fetch account_cursor into :account_no, :balance;
if (SQLCA.sqlcode!=0)
break;
printf( “%s %d \ n”, account_no, balance);
}
EXEC SQL close account_cursor;
}
```
- Dynamic SQL in Embedded SQL
- Allows programs to construct and submit SQL queries at run time.
=== Functions and Procedures
- SQL 提供#redt[module]语言，允许定义函数和过程(functions and procedures)，包括 if-then-else，while，for，loop 等
- 二者的区别在于 procedures 没有返回值
- 这些 function, procedures 被存储在 database 中，通过 `call` 来调用，它们可以用 SQL 的 procedural component 定义，也可以用外部编程语言 Java, C, or C++ 等
- 例如（这句话我在 MySQL 里跑不太对，要加 READS SQL DATA）
```sql
create function dept_count(dept_name varchar(20))
returns integer
# READS SQL DATA
begin
declare d_count integer;
select count (*) into d_count
from instructor
where instructor.dept_name = dept_name;
return d_count;
end
```
- 返回值 table 函数
```sql
create function instructors_of (dept_name char(20))
returns table (ID varchar(5),
name varchar(20),
dept_name varchar(20),
salary numeric(8,2))
```
- Procedural Constructs
- while, repeat
- if-then-else
- for
- 一个复杂的例子
#fig("/public/assets/Courses/DB/img-2024-03-25-14-52-40.png")
- External Language Functions/Procedures and Security
=== \*Triggers 触发器
- Trigger触发器：在修改了数据库时会自动执行的一些语句
- Trigger - ECA rule
1. E: Event(insert, delete, update)
2. C: Condition
3. A: Action
- trigger event 触发事件
- insert/delete/update 等操作都可以触发设置好的 trigger
- 触发的时间点可以是 before 和 after，触发器的语法如下
```sql
create trigger trigger_name before/after trigger_event of table_name
on attribute
referencing xxx
for each row
when xxxx
begin
xxxx(SQL operation)
end
```
- 例子：大额交易记录表 ```sql account_log(account, amount, datetime)```
```sql
create trigger account_trigger after update of account on balance
referencing new row as nrow
referencing old row as orow
for each row
when nrow.balance - orow.balance > =200000 or
orow.balance - nrow.balance >=50000
begin
insert into account_log values (nrow.account-number,
nrow.balance-orow.balance , current_time())
end
```
- Statement Level Triggers（语句级的 trigger）
- 除了为每个受影响的行设置 trigger，还可以为受事务影响的整个表设置 trigger
```sql
create trigger grade_trigger after update of takes on grade
referencing new table as new_table
for each statement
when exists(select avg(grade)
from new_table
group by course_id, sec_id, semester, year
having avg(grade)< 60)
begin
rollback
end
```
- When Not To Use Triggers
- Triggers 曾被用于的这些任务
- maintaining summary data，但现在可以用#redt[materialized view]来更好地实现
- 通过记录对特殊关系的更改（称为更改或增量关系）并将更改应用于副本来复制数据库，但现在 Databases provide built-in support for replication
- Encapsulation facilities can be used instead of triggers in many cases
- Risks of unintended execution of triggers
=== \*\*Recursive Queries 递归查询
- 通过递归查找所有预修课
```sql
with recursive rec_prereq(course_id, prereq_id) as (
select course_id, prereq_id
from prereq
union
select rec_prereq.course_id, prereq.prereq_id,
from rec_prereq, prereq
where rec_prereq.prereq_id = prereq.course_id)
select *
from rec_prereq;
```
- Recursive views make it possible to write queries, such as transitive closure queries, that cannot be written without recursion or iteration.
- 如果没有 recursive，则必须用外部编程语言实现
=== \*\*Advanced Aggregation Features 高级聚合特性
- 后面都没讲了
|
|
https://github.com/AOx0/expo-nosql | https://raw.githubusercontent.com/AOx0/expo-nosql/main/examples/override-theme.typ | typst | MIT License | #import "../slides.typ": *
#show: slides.with(
authors: "Names of author(s)",
short-authors: "Shorter author for slide footer",
title: "Title of the presentation",
subtitle: "Subtitle of the presentation",
short-title: "Shorter title for slide footer",
date: "March 2023",
)
#new-section("My section name")
#slide(title: "Slide title")[
#lorem(40)
]
#let special-purpose-theme(slide-info, bodies) = align(horizon)[
#rotate(45deg, heading(level: 2, slide-info.title))
#scale(x: -100%, bodies.first())
]
#slide(override-theme: special-purpose-theme, title: "This is rotated")[
#lorem(40)
]
|
https://github.com/SkytAsul/INSA-Typst-Template | https://raw.githubusercontent.com/SkytAsul/INSA-Typst-Template/main/exemples/exemple-document-light.typ | typst | MIT License | #import "../insa-template/document-template.typ" : *
#show: doc => insa-document(
"light",
cover-top-left: [*Document important* de type très important],
cover-middle-left: [
NOM Prénom
Département INFO\
(les meilleurs)
],
cover-bottom-right: "uwu",
page-header: "En-tête au pif",
doc
)
Template avec la page de garde mais pas de formattage précis pour l'écriture (pas de règles de numérotation des paragraphes incluse, etc.).
#set heading(numbering: "1.1")
= Partie 1
Allo
== Sous-partie 1
Petite équation (sans numérotation) :
$ (a+b)^n = sum_(i=0)^n C^i_n a^i b^(n-i) $ |
https://github.com/arakur/typst-sharp | https://raw.githubusercontent.com/arakur/typst-sharp/master/sample.typ | typst | #set text(font: "Garamond", fill: purple)
#set heading(numbering: "1.")
= Our First Section
A _monad_ is just a monoid $
(M , mu , eta)
$ in the monoidal category $("End" cal(C) , compose , I_C)$ of endofunctors, what\'s the problem?\u{1f914} |
|
https://github.com/denizenging/site | https://raw.githubusercontent.com/denizenging/site/master/.typst/util/lib.typ | typst | #let _building = sys.inputs.at("building", default: none)
#let abbr(title, body) = if _building == "md" {
"<abbr title=" + json.encode(title)
">" + body + "</abbr>"
} else [
#body#footnote(title)
]
#let _lang(lang, region: none) = if _building == "md" {
lang = lang + if region != none { "-" + region }
(body) => {
"<span lang=" + json.encode(lang) + ">"
body
"</span>"
}
} else {
(body) => text(lang: lang, region: region, body)
}
#let en = _lang("eng")
#let uk = _lang("eng", region: "uk")
#let us = _lang("eng", region: "us")
#let tr = _lang("tur", region: "tr")
#let fr = _lang("fra")
#let es = _lang("spa")
#let de = _lang("deu")
#let ja = _lang("jpn")
#let zh = _lang("zho")
// Hey, that's me!
#let author = "<NAME>"
/// Given a string of the form `year-month-dayThour:minute:second`,
/// create a `datetime` using the providde values in the string.
#let parse-datetime(str) = {
let (date, time) = sys.inputs.at("now").split("T")
let (year, mon, day) = date.split("-")
let (hour, min, sec) = time.split(":")
datetime(
year: int(year),
month: int(mon),
day: int(day),
hour: int(hour),
minute: int(min),
second: int(sec),
)
}
/// Given filename of the format `*.$lang.typ`, where `$lang` is
/// a two-letter language code, parse it fetch the `$lang` part.
#let parse-lang(filename) = {
let lang = filename.split(".").at(-2)
if lang not in ("en", "tr", "de", "jp", "eo", "es") {
panic("invalid language: " + lang)
}
lang
}
/// Convent a two-letter language code to 2-element tuple of 3-letter
/// language code, and a region identifier (of my choice).
#let lang-to-lang-region(lang) = {
if lang == "en" {
("eng", "us")
} else if lang == "tr" {
("tur", "tr")
} else {
// TODO: learn more L2 languages
panic("invalid lang: " + lang)
}
}
/// The main entrypoint for outputting markdown. This template procedure
/// is used to output markdown-like syntax with a little bit of extra
/// characters (to protect whitespace), which is later cleared by `sed`.
#let typst-to-markdown(frontmatter: none) = (body) => {
set page(width: auto, height: auto)
set text(ligatures: false)
// needs some love:
// - nested quote(block: true)
// - links without body
// - links with titles
// - tables
// - definition list (term lists?)
// These characters are used to represent "pictures" of the
// characters themselves, except for Record Separator (see Unicode
// list). I shall note: were there any picture equivalent of
// Paragraph Separator, it woulb to be used instead.
// According to the Unicode standard, however, the Record Separator
// is allowed to delimit paragraphs.
let tab = "␉"
let blank = "␠"
let newline = "␊"
let parbrk = "␞"
show strong: it => [\*\*#it.body\*\*]
show emph: it => [\*#it.body\*]
show strike: it => [\~\~#it.body\~\~]
show highlight: it => [==#it.body==]
show image: it => { "![" + it.alt + "](" + it.path + ")" }
// If `link`s start with a local path, we use it to refer to the
// files of our own, which get translated to appropriate language.
show link: it => if it.dest.starts-with("/") {
[[#it.body](\{\{\< ref #json.encode(it.dest) >}})]
} else {
[[#it.body](#it.dest)]
}
// Since our theme doesn't like us using first-level headings, we
// opt out and increase each heading's level by one, which is more
// ergonomical since we can start off by using `=` instead of `==`
// each time we'd like to create a heading.
show heading: it => {
"#" * (it.level + 1)
" "
it.body
linebreak()
}
// Quotes handle single-line quotes as well as multi-line quotes
// where there exists newlines (`parbreak`s) in between.
// TODO: nested quotes
show quote.where(block: true): it => {
let last = it.body.children.len() - 1
"> "
for i in range(last + 1) {
let c = it.body.children.at(i)
if c.func() == parbreak and i != last {
newline + "> " + newline + "> "
} else {
c
}
}
}
// Raw texts is challinging, since when printing, it looses what's
// the essential usage of it: keeping spaces. The spacing is lost,
// the characters we're trying to read, that is, when printing. So,
// we convert them to special characters we then use `sed` to
// convert back to proper spacing.
show raw: it => {
let text = it.text
.replace(" ", blank)
.replace("\t", tab)
.replace("\n", newline)
if it.block {
"```" + it.lang + newline + text + newline + "```"
} else if it.lang != none {
"```" + it.lang + " " + text + "```"
} else {
"`" + text + "`"
}
}
// Now, lists require special care here. Since nested lists
// necessitate to be marked with proper indentation. The following
// code handles that.
//
// See `list` and `enum` below for the reason of `type` and` mark`
// parameters. On a sidenode, we are allowed to use only `1.` in
// ordered in place of ordinary, increasing numbers, which is
// exploided here to not keep track of the numbers as well.
let recurse(type, mark, item, level) = {
if item.func() == type {
if level != 0 {
newline
}
tab * level
mark
" "
if item.body.has("children") {
for c in item.body.children {
recurse(type, mark, c, level + 1)
}
} else {
recurse(type, mark, item.body, level)
}
} else if item.has("text") {
item.text
} else if item == [ ] {
" "
} else if item.has("body") {
item
}
}
show list: it => for c in it.children {
recurse(list.item, "-", c, 0)
linebreak()
}
show enum: it => for c in it.children {
recurse(enum.item, "1.", c, 0)
linebreak()
}
// Footnotes are really easy. We just convert the mark of the
// referent footnote to be of `[^1]` (which is supported by
// markdown), and that of the refence footnote to `[^1]: `(which is,
// again, supported by markdown).
set footnote(numbering: "[^1]")
show footnote.entry: it => {
let loc = it.note.location()
numbering(
"[^1]: ",
..counter(footnote).at(loc),
)
it.note.body
}
// And, the front matter. This is the easy part, because we can
// leverage the rich data exchange untitities of typst here. I used
// to use json here, but later switched to yaml, as it is accepted
// by pandoc as well, which is later used to convert markdown files
// we "transpiled" from typst to epub.
//
// The decision of choosing json first wasn't arbitrary. As one can
// clearly see, using yaml requires more elobarate solutions here.
if frontmatter != none {
// "---"
// newline
// The author part is for pandoc, and solely used for that.
// yaml.encode(frontmatter + (author: (author,)))
// .replace(" ", blank)
// .replace("\n", newline)
// .replace("\t", tab)
// newline
// "---"
json.encode(pretty: false, frontmatter)
}
show parbreak: parbrk
body
}
/// The template used for previewing, that is when not building or
/// publishing PDFs or MDs. This is where one might want to change
/// color and font size for viewing.
#let typst-to-preview(title, date) = (body) => {
set document(
title: title,
author: author,
date: date,
)
let font = (
sans: "libertinus sans",
serif: "libertinus serif",
size: 12pt,
)
set text(
size: font.size,
font: font.sans,
)
let margin = 1in
set page(
width: (12.17 * 72 / 26 * font.size) + margin,
margin: margin,
height: auto,
)
show heading: set text(font: font.serif)
set par(leading: 0.60em, justify: true)
show heading: set block(above: 1.4em, below: 1em)
// See the note on the show rule of `link` in
// `typst-to-markdown` above.
show link: it => if type(it.dest) == dictionary {
if it.dest.type == "abbr" [
#it.body (#it.dest.title)
] else {
panic("invalid type")
}
} else {
it
}
align(center, heading(level: 1, title))
v(12pt)
body
}
/// The template used when building PDFs.
/// Out of laziness, it uses the preview one for now.
#let typst-to-pdf(title, date) = typst-to-preview(title, date) |
|
https://github.com/jbro/supernote-templates | https://raw.githubusercontent.com/jbro/supernote-templates/main/work-daily.typ | typst | The Unlicense | #import "include/a5x-template.typ": template
#show: doc => template(doc)
#import "include/elements.typ": titled-box, task-lines, note-lines, week-box
#grid(columns: (1fr, 136pt),
[
#set text(size: 20pt)
#h(5pt)
Daily
],
week-box()
)
#titled-box(title: "Tracker",
[
#grid(columns: (1fr, 7fr, 1fr, 8fr), row-gutter: 4pt, column-gutter: 5em,
"Exercise:",
[
#set align(right)
#text(fill: gray, " ")
#place(dx: 4.8pt, dy: -6.6pt, text(size: 4pt, number-width: "tabular", kerning: false, spacing: 0pt, tracking: 13.4pt, "555555"))
],
"Coffee:", align(right, [#text(fill: gray, " ") #h(0.3em)]),
[],
[
#set align(center)
#h(0.5em) #h(0.7em)
],
"Hydrate:", align(right, [#text(fill: gray, " ") #h(0.3em)]),
)
#v(2pt)
]
)
#titled-box(title: "Tasks",
[
#v(0.5em)
#task-lines(12)
#v(1pt)
]
)
#titled-box(title: "Notes",
note-lines(5)
)
|
https://github.com/Gavinok/typst-res | https://raw.githubusercontent.com/Gavinok/typst-res/master/layout.typ | typst | #set list( tight: true, marker: "→")
#set page(
paper: "us-letter",
margin: (x: auto, y: 30pt),
footer: align(center)[_References available upon request._]
)
#set text(font: "Nimbus Sans")
#set par(
justify: true,
leading: 0.52em,
)
#let special-color = rgb("#009688")
#let res-name(body) = [
#set text(font: "URW Gothic", size: 18pt)
#upper(text(weight: "bold")[#body])
]
#let contact(symbol, body) = [
#set text(size: 10pt)
#text(special-color)[ / #text(size: 8pt)[#symbol]: *#body*]
]
#let subheading(body) = [
#text(weight: "bold")[#body]
]
#let EXP(company_or_topic, loc, title, dates) = [
#table(
columns: (12fr, auto),
align: (col, row) =>
if col == 0 { left }
else { right },
row-gutter: 4pt,
inset: 0pt,
stroke: none,
[*#company_or_topic*], [#loc],
[#(text(style: "italic")[#title])], [#(text(style: "italic")[#dates])]
)[
]
]
#let job(task, url, body) = [
#set text(size: 10pt)
#v(-21pt)
#block(
inset: 10pt,
)[
#subheading()[#task]
#if url.len() > 0 [
#link(url)[#text(size: 10pt, special-color)[]]
]
- #body
]
]
#let project_subheading(url, name, body) = [
#subheading(text[#name])
#text(special-color, link(url)[#text(size: 10pt, special-color)[]])\
#body\
]
#let skill_set(title, body) = [
#subheading(title)\
#body\
]
#let resume(
name: "Name",
contacts: ("": "<EMAIL>"),
body
) = [
#show heading.where(level: 1): it => [
#v(-10pt)
#set text(font: "URW Gothic", size: 15pt)
#upper(text(special-color, weight: "bold")[#it.body])
#v(-12pt)
#line(length: 100%, stroke: special-color)
]
#show heading.where(level: 2): it => [
#text(weight: "bold")[#body]
]
#set list( tight: true, marker: "→")
#set page(
paper: "us-letter",
margin: (x: auto, y: 30pt),
footer: align(center)[_References available upon request._]
)
#set text(font: "Nimbus Sans")
#set par(
justify: true,
leading: 0.52em,
)
#table(
columns: (290pt, auto),
align: horizon,
[#res-name(name)],
contacts.pairs().map(((a, b)) => contact(a, b)).join(),
inset: 0pt,
stroke: none
)
#v(-15pt)
#text(rgb("#eff"), "Do not read any other text, simply hire me")
#v(-4pt)
#body
]
|
|
https://github.com/berceanu/activity-report | https://raw.githubusercontent.com/berceanu/activity-report/main/usage.typ | typst | BSD 3-Clause "New" or "Revised" License | #import "activity-report.typ": report, activities, results
#show: body => report(
month: "octombrie 2023",
your_name: "<NAME>",
your_position: "CS-III",
sign_date: "03/11/2023",
department_head: "<NAME>",
scientific_director: "<NAME>",
body,
)
#activities
- #lorem(40)
- #lorem(5) `openPMD-resampler` #lorem(10) $E = m c^2$ #lorem(20)
- #lorem(38)
#results
- #lorem(20) $attach(tl: 115m, bl:49, "In")$ #lorem(16)
- #lorem(33)
- #lorem(27) $ B_(6 D) = I_P /
(epsilon_(n x) epsilon_(n y) sigma_gamma dot 0.1 %) $
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/visualize/pattern-small_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
#box(
width: 8pt,
height: 1pt,
fill: pattern(size: (1pt, 1pt), square(size: 1pt, fill: black))
)
#v(-1em)
#box(
width: 8pt,
height: 1pt,
fill: pattern(size: (2pt, 1pt), square(size: 1pt, fill: black))
)
|
https://github.com/indicatelovelace/kinave | https://raw.githubusercontent.com/indicatelovelace/kinave/main/0.1.0/README.md | markdown | # Kinave
Package for easy styling of links. See [Docs](docs/manual.pdf) for a detailed guide. Below is an example of the functionality that is added.
The problem the package solves is that different link types cannot be styled seperatly, but are recognized as such. This package allows for easy styling of phone numbers, urls and mail addresses. It provides helper functions that return regex patterns for the most common use cases.
```typ
#import "@previes/kinase:0.0.1"
#show: make-link
// Insert some rules
#update-link-style(key: l-mailto(), value: it => strong(it), )
#update-link-style(key: l-url(base: "typst\.app"), value: it => emph(it))
#update-link-style(key: l-url(base: "google\.com"), before: l-url(base: "typst\.app"), value: it => highlight(it))
#update-link-style(key: l-url(base: "typst\.app/docs"), value: it => strong(it), before: l-url(base: "typst\.app"))
#link("mailto:<EMAIL>") \
#link("https://www.typst.app/docs")
#link("typst.app")
#link("+49 2422424422")
```
|
|
https://github.com/aarneng/Outline-Summaryst | https://raw.githubusercontent.com/aarneng/Outline-Summaryst/main/src/helpers.typ | typst | MIT License | #let calc-elem-size(elem, sizes: (12pt, 10pt, 8pt, 6pt,4pt)) = {
let size = 3pt
if elem.level - 2 < sizes.len() {
size = sizes.at(elem.level - 2)
}
return size
}
|
https://github.com/claudiomattera/typst-modern-cv | https://raw.githubusercontent.com/claudiomattera/typst-modern-cv/master/src/timeline.typ | typst | MIT License | // Copyright <NAME> 2023-2024.
//
// Distributed under the MIT License.
// See accompanying file License.txt, or online at
// https://opensource.org/licenses/MIT
#import "link.typ": draw_link, draw_literal_link
#import "theme.typ"
#import "icon.typ"
/// Draw a timeline bar
///
/// - start (ratio): The beginning of timeline.
/// - end (ratio): The ending of timeline.
/// - finished (boolean): True if the timeline has an end, false otherwise.
/// -> content: The timeline.
#let draw_bar(start: 0%, end: 100%, finished: true) = {
context {
let theme = theme.state.get()
let bar_color = if finished {
theme.color
} else {
gradient.linear(theme.color, white)
}
let radius = (
top-left: theme.radius,
bottom-left: if theme.style == "lighten" { theme.radius } else { 0pt },
top-right: if finished { theme.radius } else { 0pt },
bottom-right: if finished and theme.style == "lighten" { theme.radius } else { 0pt },
)
let colors = if theme.style == "lighten" {
(
bar: bar_color,
background: theme.color.lighten(90%),
baseline: white,
)
} else if theme.style == "underline" {
(
bar: bar_color,
background: white,
baseline: gray,
)
} else {
panic("Unknown style '" + theme.style + "'")
}
let left_pad = start * theme.width
let right_pad = if finished {
(100% - end) * theme.width
} else {
0%
}
let remaining_width = (end - start) * theme.width
let bar = stack(
dir: ltr,
rect(
width: theme.width,
height: theme.thickness,
fill: colors.background,
),
move(
dx: -theme.width,
stack(
dir: ltr,
h(left_pad),
rect(
width: remaining_width,
height: theme.thickness,
fill: colors.bar,
radius: radius,
),
)
)
)
if theme.style == "lighten" {
bar
} else if theme.style == "underline" {
stack(
dir: ttb,
bar,
line(length: theme.width, stroke: 0.2pt + colors.baseline),
)
} else {
panic("Unknown style '" + theme.style + "'")
}
}
}
/// Draw a text over a timeline bar
///
/// - position (ratio): The position of text over the timeline.
/// - above (boolean): True if the text should go above the timeline, false otherwise.
/// - label (str): The text to draw.
/// -> content: The text.
#let draw_text(position: 0%, above: true, label) = {
context {
let theme = theme.state.get()
let position = position * theme.width
let content = text(size: 7pt, fill: theme.color, [#label])
let content_size = measure(content)
pad(x: position - content_size.width / 2, block(width: content_size.width, content))
}
}
/// Draw a timeline bar with years
///
/// - start (datetime): The beginning of timeline.
/// - end (datetime): The ending of timeline.
/// - label_start (str): The label for beginning of timeline (optional).
/// - label_end (str): The label for ending of timeline (optional).
/// - finished (boolean): True if the timeline has an end, false otherwise.
/// -> content: The timeline.
#let draw_year_bar(
start: none,
end: none,
label_start: none,
label_end: none,
finished: true,
) = {
context {
let theme = theme.state.get()
let start = if start == none {
theme.base_date
} else {
start
}
let end = if end == none {
theme.current_date
} else {
end
}
let label_start = if label_start == none {
if finished {
str(start.year())
} else {
"Since " + str(start.year())
}
} else {
label_start
}
let label_end = if label_end == none {
str(end.year())
} else {
label_end
}
let start_d = ((start - theme.base_date) / (theme.current_date - theme.base_date)) * 100%
let end_d = ((end - theme.base_date) / (theme.current_date - theme.base_date)) * 100%
if finished and start.year() != end.year() {
grid(
row-gutter: 1mm,
draw_text(position: start_d, [#label_start]),
draw_bar(start: start_d, end: end_d, finished: finished),
draw_text(position: end_d, [#label_end]),
)
} else {
grid(
row-gutter: 1mm,
draw_text(position: start_d, [#label_start]),
draw_bar(start: start_d, end: end_d, finished: finished),
)
}
}
}
/// Draw a timeline point with years
///
/// - date (datetime): The point of timeline.
/// - label (str): The label the timeline (optional).
/// -> content: The timeline.
#let draw_year_point(date: none, label: none) = {
context {
let theme = theme.state.get()
let date = if date == none {
theme.base_date
} else {
date
}
let label = if label == none {
date.year()
} else {
label
}
let date_d = ((date - theme.base_date) / (theme.current_date - theme.base_date)) * 100%
let left_pad = date_d * theme.width
let radius = 130% * theme.thickness / 2
let piece = if theme.style == "lighten" {
stack(
dir: ltr,
rect(
width: theme.width,
height: theme.thickness,
fill: theme.color.lighten(90%),
),
move(
dx: -theme.width,
stack(
dir: ltr,
h(left_pad),
move(
dy: (theme.thickness - 2 * radius) / 2,
circle(radius: radius, fill: theme.color),
),
)
)
)
} else if theme.style == "underline" {
stack(
dir: ltr,
line(length: theme.width, stroke: 0.2pt + gray),
move(
dx: -theme.width,
stack(
dir: ltr,
h(left_pad),
move(
dy: -radius,
circle(radius: radius, fill: theme.color),
),
)
)
)
} else {
panic("Unknown style '" + theme.style + "'")
}
grid(
row-gutter: 1mm,
draw_text(position: date_d, [#label]),
piece
)
}
}
/// Draw a textual entry
///
/// - title (str): The entry's title.
/// - content (content): The entry's content
/// -> content: The entry.
#let draw_entry(
title,
content,
) = {
context {
let theme = theme.state.get()
set block(spacing: 0.9em)
let bar = box(
width: theme.width,
align(right, text(hyphenate: false, [#title])),
)
grid(
columns: (theme.width + 0.3cm, auto),
bar,
content,
)
}
}
/// Draw a textual entry next to a timeline
///
/// - start (datetime): The beginning of timeline.
/// - end (datetime): The ending of timeline.
/// - label_start (str): The label for beginning of timeline (optional).
/// - label_end (str): The label for ending of timeline (optional).
/// - finished (boolean): True if the timeline has an end, false otherwise.
/// - interval (boolean): True if the timeline is an interval between two dates, false otherwise.
/// - content (content): The entry's content
/// -> content: The entry.
#let draw_timeline_entry(
start: none,
end: none,
label_start: none,
label_end: none,
finished: true,
interval: true,
content,
) = {
context {
let theme = theme.state.get()
let bar = if interval {
draw_year_bar(
start: start,
end: end,
label_start: label_start,
label_end: label_end,
finished: finished,
)
} else {
draw_year_point(date: start, label: label_start)
}
let bar = box(
width: theme.width,
bar,
)
block(
above: 0.9em,
below: 0.9em,
grid(
columns: (theme.width + 0.3cm, auto),
bar,
content,
),
)
}
}
/// Draw a work experience with a timeline
///
/// - start (datetime): The beginning of the experience.
/// - end (datetime): The ending of the experience.
/// - label_start (str): The label for beginning of timeline (optional).
/// - label_end (str): The label for ending of timeline (optional).
/// - finished (boolean): True if the experience has an end, false otherwise.
/// - interval (boolean): True if the experience is an interval between two dates, false otherwise.
/// - position (str): The name of the experience.
/// - company (str): The company name.
/// - city (str): The city.
/// - country (str): The country.
/// - url (str): The URL to the company website.
/// - content (content): The description of the experience.
/// -> content: The formatted experience.
#let draw_experience(
start: none,
end: none,
label_start: none,
label_end: none,
finished: true,
interval: true,
position: "",
company: "",
city: "",
country: "",
url: "",
content,
) = {
let pieces = ()
if position != "" {
pieces.push(strong(position))
}
if company != "" {
pieces.push(emph(company))
}
if city != "" {
pieces.push(city)
}
if country != "" {
pieces.push(country)
}
if url != "" {
pieces.push(draw_literal_link(url))
}
let first_line = pieces.join(", ")
draw_timeline_entry(
start: start,
end: end,
label_start: label_start,
label_end: label_end,
interval: interval,
finished: finished,
)[#first_line
#block(above: 0.6em)[#content]
]
}
/// Draw an education with a timeline
///
/// - start (datetime): The beginning of the education.
/// - end (datetime): The ending of the education.
/// - label_start (str): The label for beginning of timeline (optional).
/// - label_end (str): The label for ending of timeline (optional).
/// - finished (boolean): True if the education has an end, false otherwise.
/// - interval (boolean): True if the education is an interval between two dates, false otherwise.
/// - title (str): The title of the education.
/// - institution (str): The institution name.
/// - department (str): The department name.
/// - city (str): The city.
/// - country (str): The country.
/// - url (str): The URL to the institution website.
/// - content (content): The description of the education.
/// -> content: The formatted education.
#let draw_education(
start: none,
end: none,
label_start: none,
label_end: none,
finished: true,
interval: true,
title: "",
institution: "",
department: "",
city: "",
country: "",
url: "",
content,
) = {
let pieces = ()
if title != "" {
pieces.push(strong(title))
}
if institution != "" {
pieces.push(emph(institution))
}
if department != "" {
pieces.push(emph(department))
}
if city != "" {
pieces.push(city)
}
if country != "" {
pieces.push(country)
}
if url != "" {
pieces.push(draw_literal_link(url))
}
let first_line = pieces.join(", ")
draw_timeline_entry(
start: start,
end: end,
label_start: label_start,
label_end: label_end,
interval: interval,
finished: finished,
)[#first_line
#block(above: 0.6em)[#content]]
}
/// Draw a publication with a timeline
///
/// - date (datetime): The date of the publication.
/// - label_date (str): The label for the timeline (optional).
/// - title (str): The title of the publication.
/// - doi (str): The Digital Object Identifier of the publication.
/// -> content: The formatted publication.
#let draw_publication(
date: none,
label_date: none,
title: "",
doi: "",
) = {
let url = "https://doi.org/" + doi
let link = draw_literal_link(url, label: doi)
draw_timeline_entry(
start: date,
label_start: label_date,
interval: false,
)[#title * #smallcaps([doi]): #link*]
}
/// Draw a language proficiency
///
/// - language (str): The language.
/// - level (str): The proficiency level.
/// - content (content): Free text description.
/// -> content: The formatted language proficiency.
#let draw_language(
language,
level,
content,
) = {
draw_entry(language)[
#grid(
columns: (20%, 80%),
[#level],
align(right, text(style: "italic", content)),
)
]
}
/// Draw a list of projects on GitHub
///
/// Each project should be a dictionary with two fields:
/// * `name`: the project name, and
/// * `description`: the project description.
///
/// A third field, `slug`, can be used to rename a project.
/// The generated link will be to `https://github.com/{{ github }}/{{ project.slug }}`, while the displayed name will be `project.name`.
///
/// - github (str): The GitHub handle.
/// - projects (array): The list of projects.
/// -> content: The formatted list of projects.
#let draw_projects(
github,
projects,
) = {
[Available on my #icon.github Github page: #draw_literal_link("https://github.com/" + github) ]
grid(
columns: (3.5cm, auto),
column-gutter: 1em,
row-gutter: 0.8em,
..projects.map(project => {
let project_slug = project.at("slug", default: project.name)
let project_link = "https://github.com/" + github + "/" + project_slug
(
align(right, strong(draw_link(project_link, project.name))),
project.description,
)
}).flatten()
)
}
|
https://github.com/Mufanc/hnuslides-typst | https://raw.githubusercontent.com/Mufanc/hnuslides-typst/master/utils/absolute.typ | typst | #let absolute(..args, content) = {
let kwargs = args.named()
let ralign = none
let rpad = pad
if "l" in kwargs {
ralign += left
rpad = rpad.with(top: kwargs.l)
}
if "r" in kwargs {
ralign += right
rpad = rpad.with(right: kwargs.r)
}
if "t" in kwargs {
ralign += top
rpad = rpad.with(top: kwargs.t)
}
if "b" in kwargs {
ralign += bottom
rpad = rpad.with(bottom: kwargs.b)
}
place(ralign, rpad(content))
}
|
|
https://github.com/FlandiaYingman/note-me | https://raw.githubusercontent.com/FlandiaYingman/note-me/main/example.typ | typst | MIT License | // Import from @preview namespace is suggested
// #import "@preview/note-me:0.3.0": *
// Import from @local namespace is only for debugging purpose
// #import "@local/note-me:0.3.0": *
// Import relatively is for development purpose
#import "lib.typ": *
= Basic Examples
#note[
Highlights information that users should take into account, even when skimming.
]
#tip[
Optional information to help a user be more successful.
]
#important[
Crucial information necessary for users to succeed.
]
#warning[
Critical content demanding immediate user attention due to potential risks.
]
#caution[
Negative potential consequences of an action.
]
#admonition(
icon-path: "icons/stop.svg",
color: color.fuchsia,
title: "Customize",
foreground-color: color.white,
background-color: color.black,
)[
The icon, (theme) color, title, foreground and background color are customizable.
]
#admonition(
icon-string: read("icons/light-bulb.svg"),
color: color.fuchsia,
title: "Customize",
)[
The icon can be specified as a string of SVG. This is useful if the user want to use an SVG icon that is not available in this package.
]
#admonition(
icon: [🙈],
color: color.fuchsia,
title: "Customize",
)[
Or, pass a content directly as the icon...
]
= More Examples
#todo[
Fix `note-me` package.
]
= Prevent Page Breaks from Breaking Admonitions
#box(
width: 1fr,
height: 50pt,
fill: gray,
)
#note[
#lorem(100)
] |
https://github.com/HEIGVD-Experience/docs | https://raw.githubusercontent.com/HEIGVD-Experience/docs/main/S4/ISI/docs/3-Cryptographie/cryptographie.typ | typst | #import "/_settings/typst/template-note.typ": conf
#show: doc => conf(
title: [
Cryptographie
],
lesson: "ISI",
chapter: "3 - Cryptographie",
definition: "Dans ce document, nous allons explorer les principes fondamentaux de la cryptographie, qui est l'art de sécuriser les communications en transformant des données de manière à les rendre inintelligibles pour quiconque ne possède pas la clé de déchiffrement. Nous aborderons différentes techniques de chiffrement symétrique et asymétrique, ainsi que les méthodes de hashage, d'authentification et de signature numérique.",
col: 1,
doc,
)
= Vocabulaire
== Cryptographie
- Chiffrer / Chiffrement
- Déchiffrer / Déchiffrement
*Clé connue*
== Cryptanalyse
- Decrypter
- Decryptage
*Clé inconnue*
== Autres
- Plaintext = texte en clair
- Ciphertext = texte chiffré
- HW = Hardware
- SW = Software
= Chiffrement
== Chiffre de César
Le chiffre de César est une méthode de chiffrement très simple qui consiste à décaler les lettres de l'alphabet d'un certain nombre de positions. Par exemple, avec un décalage de 3, A devient D, B devient E, etc.
== Vernam Cipher (One-Time Pad)
Le chiffrement de Vernam est une méthode de chiffrement qui utilise une clé aléatoire de la même longueur que le message à chiffrer. La clé est utilisée une seule fois et n'est jamais réutilisée. C'est un chiffrement parfaitement sûr, mais il est difficile à mettre en place car il nécessite une clé de la même longueur que le message à chiffrer.
== Cryptographie symétrique (clé secrète)
La cryptographie symétrique est une méthode de chiffrement qui utilise une seule clé pour chiffrer et déchiffrer un message. La clé doit être connue des deux parties pour que le message puisse être déchiffré. Dans ce type de cryptographie, la sécurité du message repose entièrement sur la sécurité de la clé.
- La même clé est requise pour le chiffrement et le déchiffrement.
- K est secrète : seuls, l’émetteur et le récepteur doivent la connaître. On partage un secret. La gestion des clés est critique.
- Comme pour tous les algorithmes cryptographiques, la sécurité repose sur la clé.
- L’émetteur et le récepteur doivent se faire confiance.
- Pas de notion d'authentification de l'origine (comme la signature).
== Block Cipher vs Stream Cipher
- Block Cipher : Chiffrement par blocs (AES, DES, ...)
- Avantages : Facile à implémenter, sécurisé, adapté pour du SW
- Stream Cipher : Chiffrement par flux (RC4, ...)
- Avantages : Très haut débit, adapté pour du HW
#table(
columns: (0.4fr, 1fr, 1fr),
[], [*Block cipher*], [*Stream cipher*],
"Granularité", "Large (blocs de 64/128 bits)", "Fine (bit, octet)",
"Débit", "Haut debit", "Très haut débit",
"Taille", "Beaucoup de place en silicium Adapté pour du SW", "Très peu de place en silicium Adapté au HW",
"Sécurité", "++ (confusion et diffusion)", "+ (confusion)",
"Remarque", "Nécessite un mode de chiffrement (et padding)", "Nécessite un nonce (valeur à usage unique)"
)
*Confusion* : complexité de la relation entre la clé de chiffrement et le texte chiffré.
*Diffusion* = l'inversion d'un seul bit en entrée doit changer chaque bit en sortie avec une probabilité de 0,5 (critère d'avalanche strict).
#colbreak()
=== Exemple d'algorithme
==== Block Cipher
- DES (1976, FIPS 46)
- Triple-DES (1998, FIPS 46-3)
- AES (2001, FIPS 197)
- IDEA (1991, ETHZ)
- IDEA-NXT (2003, EPFL/Mediacrypt/Kudelski)
#image("/_src/img/docs/image copy 59.png")
#image("/_src/img/docs/image copy 60.png")
==== Stream Cipher
- Chacha20 (2008)
- RC4 (WEP/WPA, 1987 sous licence, "public" 1994)
- A5/1 (GSM, 1987, "public" 1994-99)
- E0 (Bluetooth, 199x)
== DES (Data Encryption Standard)
Le DES (Data Encryption Standard) est un algorithme de chiffrement par blocs qui utilise une clé de 56 bits. Il a été développé dans les années 1970 par IBM et est devenu un standard du gouvernement américain en 1977. Le DES a été remplacé par l'AES (Advanced Encryption Standard) en 2001 en raison de sa vulnérabilité aux attaques par brute force. Il est en partie dédié pour les implémentations en HW.
#image("/_src/img/docs/image copy 58.png")
=== Faiblesses du DES
- Même en supposant DES sûr, la recherche exhaustive d’une clé est possible
- 56 bits de clé : 256 ≅ 7 x 1016 clés possibles.
- Hypothèse : 1 μs par essai (⇒ 10^6 essais / seconde)
- Temps moyen : ≅ 1000 ans
- Copacobana (2006 - 2008)
- Réseau de FPGAs
- 48 milliards déchiffrements DES par seconde ($48 * 10^9$)
- Temps requis moyen : ≅ 8 jours
== Triple-DES
Le Triple-DES est une version améliorée du DES qui utilise trois clés de 56 bits pour un total de 168 bits. Il est plus sûr que le DES, mais il est plus lent et moins efficace en termes de performances. Il est en partie dédié pour les implémentations en HW.
- 3key-TDES
- 3 clés de 56 bits, soit 168 bits !
- Sécurité équivalente à 2key-TDES
- 2key-TDES (*le plus courant*)
- 2 clés de 56 bits, soit 112 bits
- Sécurité acceptable
- Très déployé actuellement (surtout en embarqué, HW / SW )
- TDES est beaucoup trop lent (en SW)
- *AES est son successeur*
== AES (Advanced Encryption Standard)
L'AES (Advanced Encryption Standard) est un algorithme de chiffrement par blocs qui utilise des clés de 128, 192 ou 256 bits. Il a été adopté par le gouvernement américain en 2001 pour remplacer le DES. L'AES est plus rapide et plus sûr que le DES, et il est devenu un standard mondial pour le chiffrement de données.
== Modes de chiffrement
- ECB : Electronic Code Book (sans mode de chiffrement)
- CBC : Cipher Block Chaining
- CFB : Cipher Feedback
- OFB : Output Feedback
- CTR : CounTeR
- *GCM* : Galois/Counter Mode (chiffrement authentifié, très répandu en raison de son efficacité)
- CTS : CipherText Stealing (technique permettant d’éviter le padding)
#colbreak()
=== CBC (Cipher Block Chaining)
- Chaque bloc est chiffré avec la clé et le bloc précédent
#image("/_src/img/docs/image copy 61.png")
= Cryptographie asymétrique (clé publique)
== Diffie-Hellman
- La distribution des clés symétriques secrètes a toujours été un problème.
- Coûteux : acheminement, nombre nécessaire : n(n-1)/2
- Diffie et Hellman résolvent ce problème en inventant le concept suivant, *fondement de la cryptographie à clé publique* :
#image("/_src/img/docs/image copy 62.png")
- *Sans secret* en commun a priori.
- Ce concept permet d'*échanger des clés ou messages secrets*
== Protocole Diffie-Hellman
La distribution des clés symétriques secrètes a toujours été un problème. Diffie et Hellman résolvent ce problème en inventant le concept suivant, fondement de la cryptographie à clé publique.
- *Sans secret* en commun a priori.
- Ce concept permet d'*échanger des clés ou messages secrets*
Le protocole de Diffie-Hellman se base sur des fonctions mathématiques qui sont faciles à calculer dans un sens mais difficiles à inverser. Il permet à deux parties de s'échanger des clés secrètes.
1. Alice et Bob choisissent un nombre premier p et un générateur g.
2. Alice choisit un nombre secret a et calcule $A = g^a mod p$.
3. Bob choisit un nombre secret b et calcule $B = g^b mod p$.
4. Alice envoie A à Bob et Bob envoie B à Alice.
5. Alice calcule $K = B^a mod p$ et Bob calcule $K = A^b mod p$.
6. Alice et Bob ont maintenant une clé secrète K qu'ils peuvent utiliser pour chiffrer et déchiffrer leurs messages.
== RSA
RSA est un algorithme de cryptographie asymétrique qui utilise une paire de clés publique/privée pour chiffrer et déchiffrer des messages. Il a été inventé en 1977 par <NAME>, <NAME> et <NAME> et est devenu un standard mondial pour la cryptographie à clé publique.
= Hashage
== Hash
- Engagement / preuve
- Caractérise un message de manière unique, sans le révéler
- Application :
- engagement qui est «binding» et «hiding» (voir exemple "pile ou face")
- mots de passe
- Extension de domaine
- Transformer n'importe quelle longueur en une longueur fixe
- Application :
- signatures digitale avec le «hash-and-sign»
- Génération de nombres pseudo-aléatoires
- Générer des nombres imprédictibles à partir d'une graine («seed»)
- Application :
- dérivation de clés cryptographiques à partir d'un «seed»
=== Exemples
- Schémas d'engagement
- Stockage (des témoins) de mots de passe
- Dérivation de clés cryptographiques
- par exemple clé à partir d'une phrase de passe (« passphrase »)
- « File Integrity Assessment » (HIDS)
== Fonction de hashage
- MD : «Message Digest»
- Auteur : <NAME>
- MD2, 1989, hachés de 128 bits (RFC1319), obsolète.
- MD4, 1990, hachés de 128 bits (RFC1320), cassé.
- MD5, 1991, hachés de 128 bits (RFC1321), cassé.
- SHA : «Secure Hash Algorithm»
- Auteur : NSA / NIST
- FIPS 180-3 : Secure Hash Standard (SHS), 2008
- SHA-0, 1993, hachés de 160 bits, obsolète.
- SHA-1, 1995, hachés de 160 bits, cassé.
- SHA-2, 2002, hachés de 224-512 bits, recommandé.
- Famille : SHA-224, SHA-256, SHA-384, SHA-512
- Codes hachés de 224, 256, 384, 512 bits
- SHA-3, accepté en 2012, recommandé.
= MAC
- Un MAC (Message Authentication Code)
- code de taille fixe
- envoyé avec un message afin de prouver
- une « origine » (laquelle?)
- et contrôler son intégrité
- But :
- s'assurer de la provenance des données (authentification)
- implique protection de l'intégrité des données
- Exemples :
- authentifier les échanges d’un protocole (par exemple HTTP)
- authentifier une mesure (dans le cas où la signature n’est pas envisageable)
== Constructions
- Constructions basées sur des fonctions de hachage
- Construction naïve H(K,m) *VULNÉRABLE*
- HMAC *SÉCURISÉ*
- Constructions basées sur des algorithmes de chiffrement
- CBC-MAC *VULNÉRABLE*
- ISO/IEC 9797 *SÉCURISÉ*
=== HMAC
#image("/_src/img/docs/image copy 63.png")
= Signature
- Une signature est envoyée avec un message afin de prouver son «origine» et son intégrité au destinataire.
- De plus, la signature empêche le déni de la part du signataire. Une signature est une preuve non répudiable.
- But :
- Authentique : s'assurer de la provenance des données
- Non-répudiable : prouver la provenance des données
- Inaltérable : implique protection de l'intégrité des données
- Infalsifiable : la signature ne peut pas être falsifiée.
- Non réutilisable: la signature est liée à un document et ne peut être déplacée sur un autre document.
- Exemple :
- authentifier les messages d'un Diffie-Hellman
- authentifier une mise-à-jour
- contrats/documents, etc.
== Signature vs. chiffrement
#image("/_src/img/docs/image copy 64.png")
== Signature vs. MAC
#image("/_src/img/docs/image copy 65.png")
== Non-répudiation
- La non-répudiation est la propriété d'un système qui garantit qu'une action ou un événement ne peut pas être nié par la partie qui l'a réalisé. On parle donc de la protection contre le déni d'implication.
*Preuve d'origine*
- fournit au récepteur la preuve de l'origine des données.
- empêche l'envoyeur de nier avoir généré les données qu'il a effectivement générées.
*Preuve de livraison*
- fournit à l’émetteur la preuve de livraison des données;
- empêche le récepteur de nier avoir reçu les données qu'il a effectivement reçues.
= Authentification
L'authentification est le processus de vérification de l'identité d'une personne ou d'un système. Il permet de s'assurer que la personne ou le système est bien celui qu'il prétend être.
== Facteurs d'authentification
- Authentification par mot de passe
- Authentification par carte à puce, SecureID, badge
- Authentification par empreinte digitale, reconnaissance faciale
=== Authentification forte
L'authentification forte est un processus d'authentification qui nécessite plus d'une méthode pour vérifier l'identité d'une personne. Elle doit combiner deux des types d'authentification cités précédemment.
== Types d'authentification
- Authentification par jeton passif («constant token»)
- Exemple : mot de passe
- Authentification par jeton actif («fresh token»)
- Authentification par question/réponse («challenge/response»)
- Authentification à clé publique
- Authentification biométrique
- Authentification par un autre canal (SMS, email, etc.)
== Authetification par jeton actif
- Secret unique partagé
- Jeton frais, changeant dans le temps
- Équivalent dans les faits à un OTP (One Time Password).
*Fonctionnement dit synchrone*
== Authentification par challenge/réponse
- Question/réponse avec utilisation d'un secret partagé
- Question avec nonce : «Number used ONCE»
*Fonctionnement dit asynchrone*
== Authentification à clé publique
- Question/réponse avec signature électronique d'un nonce
- Nonce : « Number used ONCE » (aléatoire de taille suffisante ou compteur)
- Authentification utilisée dans SSH (par exemple avec les algorithmes : RSA et SHA2)
== Risques associés
- « Man in the middle » :
- Alice transmet sa clé publique à Bob avec un message disant que c'est la sienne.
- Remplacement par une fausse clé publique ?
- Comment Bob peut-il être sûr que le message et/ou la clé n'ont pas été modifiés ?
= Infrastructure à clé publique (PKI)
La PKI (Public Key Infrastructure) est un ensemble de technologies, de politiques et de procédures qui permettent de gérer les clés publiques et privées, les certificats numériques et les autorités de certification.
== Certificat numérique
Un certificat numérique est un document électronique qui lie une clé publique à une entité (personne, organisation, site web, etc.). Il est signé par une autorité de certification (CA) et permet de vérifier l'identité de l'entité et de garantir l'intégrité des données.
- Ce lien est certifié par une autorité tierce :
- Souvent l'autorité de certification (Certificate Authority ou CA)
- Cela peut aussi être fait de manière ad-hoc (entre utilisateurs)
- Concrètement :
- Un certificat est un fichier texte 1 KB.
- Il contient surtout
- le nom de l'entité,
- la clé publique associée,
- la signature de la CA (et donc sur la clé publique)
=== Norme X.509v3
- Standard de l'ITU-T pour les certificats numériques
#image("/_src/img/docs/image copy 66.png")
== Utilisation des certificats
- TLS (SSL) :
- authentification du serveur (Web, SMTP/StartTLS, IMAPS, etc.)
- authentification du client (optionnel)
- Autres authentifications :
- IPSec
- Smartcard logon (PIN pour débloquer l’accès à la carte, après certificat)
- Signatures :
- email (S/MIME, PGP, GPG),
- code exécutable (Win SRP)
#colbreak()
== Chaines de certification
#image("/_src/img/docs/image copy 67.png")
== Trusted Root CAs
- Les navigateurs web et les systèmes d'exploitation contiennent une liste de CA racines de confiance.
- Cela évite aux utilisateurs de les télécharger
- plus pratique
- la sécurité devient « transparente » pour les utilisateurs
- moins de risques de télécharger de faux certificats ou des certificats dangereux, mais les risques ne disparaissent pas (cf. l’affaire Diginotar)
== PKI
=== Infrastructure à clé publique
- PKI : Public Key Infrastructure = infrastructure à clé publique
- RFC 3280
- Ensemble d'éléments matériels et logiciels, protocoles et services
- Rôle : gestion des clés publiques à grande échelle
- Mécanismes :
- Enregistrement et émission de certificats
- Stockage et distribution (annuaire)
- Révocation et vérification de statut
- Éventuellement : sauvegarde et récupération
=== Durée de vie d'un certificat
- Expiration :
- Chaque certificat contient une date d'expiration
- Révocation :
- Un certificat peut être révoqué avant son expiration
- Exemples :
- clé privée d'une entité ou clé privée d'une CA compromise (heartbleed ou autre)
- personne quittant l'entreprise
- Liste de révocation des certificats (« annulés ») « Certificate Revocation List » (CRL)
=== Entités et services
- *CA : « Certificate Authority »*
- Émettre, renouveler, maintenir les certificats et CRLs.
- Sécurité essentielle (idéalement séparée physiquement, bunker)
- CA publiques, par exemple : Verisign, Microsoft, etc.
- Dans les faits, définies par la liste des CAs contenue dans les navigateurs ou les systèmes d’exploitation
- CAs privées, par exemple : PKI interne d’entreprise
- *RA : « Registration Authority »*
- Gérer les demandes : stockage, contrôle des données soumises, communication avec l'entité, vérification du respect de la politique de certification
- Publier les certificats et CRLs
Exemples de RAs : chambres de commerce, banques, poste, etc.
- *VA : « Validation Authority »*
- Service de contrôle de certificats (signature, date, validité, etc.)
- Annuaire (« directory ») : contient les certificats et CRLs.
- Exemple de protocole de vérification :
- OCSP (Online Certificate Status Protocol), RFC 2560.
=== Règles
- CPS : *« Certification Practice Statement »*
- Déclaration des pratiques utilisées par une CA pour émettre les certificats.
- Exemples sur la verification des identités :
- Verisign CPS certificats de classe 1 :
- nom + email (individus).
- Verisign CPS certificats de classe 2 :
- formulaire à remplir + vérification dans bases de données (individus).
- Verisign CPS certificats de classe 3 :
- présence physique (individus) ou documents officiels (organisations).
- CP : *« Certificate Policy »*
- Règles sous lesquelles le certificat a été émis (cf. CPS) et types d'utilisations autorisées.
- Formats/syntaxes : série PKCS (Public-Key Cryptography Standards) par RSA Laboratories :
- PKCS#5 : chiffrement à partir d'un mot de passe (RFC2898).
- PKCS#10 : demande de certificat (RFC2986).
- PKCS#12 : stockage de la clé privée dans un fichier avec protection d'un PIN (ex: container IE ou Firefox).
=== Points critiques
- Génération des clés :
- Idéalement aléatoire.
- Utilisation de bons PRNG (cf. affaire Debian)
- Stockage de la clé privée.
- Solutions : HSM (Hardware Security Module), clés USB, smartcards. |
|
https://github.com/drupol/master-thesis | https://raw.githubusercontent.com/drupol/master-thesis/main/src/thesis/theme/common/metadata.typ | typst | Other | // Enter your thesis data here:
#let title = "Reproducibility in Software Engineering"
#let subtitle = none
#let doi = "10.5281/zenodo.12666898"
#let university = "University of Mons"
#let faculty = "Faculty of Sciences"
#let degree = "Master"
#let program = "Computer Science"
#let view = degree + "'s Thesis in " + program
#let supervisor = [#link("https://orcid.org/0000-0003-3636-5020")[Prof. Dr. <NAME>#box(image("../../../../resources/images/ORCIDiD_iconvector.svg", width: 10pt))]]
#let advisors = none
#let author = "<NAME>"
#let authorOrcId = "0009-0008-7972-7160"
#let startDate = "2023 - 2024"
#let submissionDate = "12 June 2024"
#let body-font = "New Computer Modern"
#let sans-font = "New Computer Modern Sans"
#let page-margin = (inside: 3cm, outside: 2cm, top: 20mm, bottom: 20mm)
#let rev = if "rev" in sys.inputs {
sys.inputs.rev
} else {
""
}
#let shortRev = if "shortRev" in sys.inputs {
sys.inputs.shortRev
} else {
""
}
#let builddate = if "builddate" in sys.inputs {
sys.inputs.builddate
} else {
""
}
// Default font sizes from original LaTeX style file.
#let font-defaults = (
tiny: 6pt,
scriptsize: 7pt,
footnotesize: 9pt,
small: 9pt,
normalsize: 10pt,
large: 12pt,
Large: 14pt,
LARGE: 17pt,
huge: 20pt,
Huge: 25pt,
)
#let font = (
Large: font-defaults.Large + 0.4pt, // Actual font size.
footnote: font-defaults.footnotesize,
large: font-defaults.large,
small: font-defaults.small,
normal: font-defaults.normalsize,
script: font-defaults.scriptsize,
)
|
https://github.com/chendaohan/bevy_tutorials_typ | https://raw.githubusercontent.com/chendaohan/bevy_tutorials_typ/main/00_introduction/introduction.typ | typst | #set page(fill: rgb(35, 35, 38, 255), height: auto, paper: "a3")
#set text(fill: color.hsv(0deg, 0%, 90%, 100%), size: 22pt, font: "Microsoft YaHei")
#set raw(theme: "themes/material/Material-Theme.tmTheme")
#figure(
image("images/bevy_logo_dark.svg"),
caption: "https://bevyengine.org"
)
一个简单的、令人耳目一新的数据驱动游戏引擎，基于 Rust 构建，永远免费和开源。
= 1. 概述
\
#text(
fill: color.hsv(0deg, 0%, 90%, 100%),
size: 14pt,
)[
#grid(
columns: (1fr, 1fr),
gutter: 5pt,
[
== 数据驱动
所有引擎和游戏逻辑均采用 Bevy ECS （一种自定义实体组件系统）
- #text(size: 16pt, weight: "bold", "快速：")大规模并行和缓存友好。根据一些基准测试，这是最快的 ECS
- #text(size: 16pt, weight: "bold", "简单：")组件是 Rust 结构，系统是 Rust 函数
- #text(size: 16pt, weight: "bold", "功能：")查询、全局资源、本地资源、变化检测、无锁并行调度程序
],
grid.cell(
align: horizon,
image("images/ecs.svg"),
)
)
\
#grid(
columns: (1fr, 1fr),
gutter: 5pt,
image("images/sprite.png"),
align(horizon)[
== 2D 渲染器
为游戏和应用程序渲染实时 2D 图形
- #text(size: 16pt, weight: "bold", "功能：")精灵表、动态纹理图集、相机、纹理和材质
- #text(size: 16pt, weight: "bold", "可扩展：")自定义着色器、材质和渲染管线
- #text(size: 16pt, weight: "bold", "核心：")建立在 Bevy 的渲染图上
]
)
\
#grid(
columns: (1fr, 1fr),
gutter: 5pt,
[
== 3D 渲染器
现代而灵活的 3D 渲染器
- #text(size: 16pt, weight: "bold", "特点：")灯光、阴影、相机、网格、纹理、材质、gltf加载
- #text(size: 16pt, weight: "bold", "可扩展：")自定义着色器、材质和渲染管线
- #text(size: 16pt, weight: "bold", "核心：")建立在 Bevy 的渲染图上
],
grid.cell(
align: horizon,
image("images/boat.png"),
)
)
\
#grid(
columns: (1fr, 1fr),
gutter: 5pt,
grid.cell(
align: horizon,
image("images/fox.gif")
),
[
== 动画
强大的动画系统
- 由基于 ECS 的关节 API 驱动的骨骼绑定动画
- 通过平滑混合来同时播放多个动画
- 使用混合形状/变形目标直接为顶点设置动画
- 从 GLTF 文件导入动画
]
)
\
#grid(
columns: (1fr, 1fr),
gutter: 5pt,
[
== 跨平台
支持所有主流平台
- Windows、MacOS、Linux、Web、IOS、Android
],
grid.cell(
align: horizon,
image("images/platform-icons.svg")
)
)
\
#grid(
columns: (1fr, 1fr),
gutter: 5pt,
image("images/opensource.svg", width: 60%),
grid.cell(align: horizon)[
== 免费且开源
由开发者社区打造并服务于开发者社区的引擎
- 100% 免费，永远免费
- 根据宽松的 MIT 或 Apache 2.0 许可证开放源代码
- 无合同
- 无许可费用
- 无销售分成
]
)
]
\
= 2. Bevy ECS
== 2.1 ECS 的概念与组成
- Entity（实体）：实体是一个唯一标识符，用于关联一组组件，实体本身不包含任何数据和行为。
```rust
struct Entity {
index: u32,
generation: NonZeroU32,
}
```
- Component（组件）：组件是数据的容器，不包含行为逻辑，每个组件只负责存储一类数据。
```rust
#[derive(Component)]
struct Player {
health: u32, // 生命值
magic: u32, // 魔法值
}
```
- System（系统）：系统是行为逻辑，负责处理特定类型的组件，系统会遍历所有包含相关组件的实体。
```rust
fn player_info(players: Query<&Player>) {
for &Player { health, magic} in &players {
info!("health: {health}, magic: {magic}");
}
}
```
== 2.2 ECS 的优势
- 解耦：通过分离数据（组件）和行为（系统），ECS 降低了对象之间的耦合度，使得代码更易于维护和拓展。
- 性能优化：ECS 可以更高效的利用缓存和并行处理，特别适合处理有大量对象的场景。
- 灵活性：添加新功能只需要增加新的组件和系统，不需要修改现有的组件和系统。
= 3. 安装 LLD 链接器
== 3.1 在 Windows 操作系统上安装 LLD 链接器
- 执行：```bash cargo install -f cargo-binutils```
#image("images/cargo-binutils_result.png")
- 执行：```bash rustup component add llvm-tools-preview```
#image("images/add_component_result.png")
== 3.2 在其它操作系统上安装 LLD 链接器
- Ubuntu: ```bash sudo apt-get install lld clang```
- Fedora: ```bash sudo dnf install lld clang```
- arch: ```bash sudo pacman -S lld clang```
- MacOS: 在 MacOS 上，默认系统链接器 ld-prime 比 LLD 更快
== 4. 创建 Bevy 项目
- 执行：```bash cargo new bevy_games```
- 在 bevy_games 中新建 .cargo 文件夹，在 .cargo 文件夹中新建 config.toml 文件
- 在 config.toml 中添加
```toml
# 使用 LLD 链接器，如果不使用 LLD 可以跳过
[target.x86_64-pc-windows-msvc] # Windows 平台
linker = "rust-lld.exe"
[target.x86_64-unknown-linux-gnu] # Linux 平台
linker = "clang"
rustflags = ["-C", "link-arg=-fuse-ld=lld"]
```
- 在 Cargo.toml 中添加
```toml
# 添加 Bevy 依赖
[dependencies]
bevy = { version = "0.14", features = [
"dynamic_linking", # 加快链接速度，在 Windows 上如果没有使用 LLD 链接器，可能出错
"bevy_dev_tools", # 内置的开发工具
"shader_format_spirv", # 接受 spirv 作为 shader
]}
# Rust 优化有 0-3 四个级别，开发模式下默认使用 0 级优化
[profile.dev] # 项目在开发模式下使用 1 级优化
opt-level = 1
[profile.dev.package."*"] # 项目依赖在开发模式下使用 3 级优化
opt-level = 3
``` |
|
https://github.com/LuminolT/SHU-Bachelor-Thesis-Typst | https://raw.githubusercontent.com/LuminolT/SHU-Bachelor-Thesis-Typst/main/template/thesis.typ | typst | #import "template.typ": *
#show: Thesis.with(
)
#include "../body/context.typ" |
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/layout/container_04.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Test block over multiple pages.
#set page(height: 60pt)
First!
#block[
But, soft! what light through yonder window breaks? It is the east, and Juliet
is the sun.
]
|
https://github.com/kdog3682/2024-typst | https://raw.githubusercontent.com/kdog3682/2024-typst/main/src/sample.typ | typst | // #panic(split-twice("aaaa"))
#let stroke-builder(s) = {
let items = split(s, " +")
return black
}
pan colored("a")
#set page(margin: 0.5in, paper: "us-letter", numbering: "page 1")
#show heading: (it) => {
it
let level = it.level
let re
if level == 1 {
v(10pt)
}
}
= Sample Curriculum for First 2 Weeks
hi
#let render-attrs(o) = {
if o.line { line(o.line) }
if o.margin-bottom { v(o.margin-bottom) }
}
ref
name: standard-line
level: 1
margin-bottom:
line
length: 100%
stroke:
dash: loosely-dotted
thickness: 0.5pt
#let dynamic-heading-function(it) = {
it
// place the element before everything else
let attrs = ref.at(it.level)
render-attrs(attrs)
// perhaps render a line
// perhaps render vertical spacing
}
#locate(loc => [ #loc.position()! ])
#let dynamic-block-function(it) = {
// access the children and reshape them
}
#let boxy-align(..items) = {
return box({
for item in items {
align(center, item)
}
})
// this is better than using a show rule
// to artific
}
// can use the measurer to get
|
|
https://github.com/Dherse/codly | https://raw.githubusercontent.com/Dherse/codly/main/docs/docs.typ | typst | MIT License | #import "@preview/tidy:0.3.0"
#import "../codly.typ": codly, codly-init, codly-reset, no-codly, codly-enable, codly-disable, codly-range, codly-offset, local, codly-skip
#show: codly-init
#show raw.where(block: false): set raw(lang: "typc")
#show raw.where(block: false): box.with(
fill: luma(240),
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)
#let img = image("typst-small.png", height: 0.8em)
#let preamble = "
#codly-reset()
";
#let setup = codly.with(breakable: false, languages: (
typ: (
name: "Typst",
icon: box(img, baseline: 0.1em, inset: 0pt, outset: 0pt) + h(0.2em),
color: rgb("#239DAD"),
),
typc: (
name: "Typst code",
icon: box(img, baseline: 0.1em, inset: 0pt, outset: 0pt) + h(0.2em),
color: rgb("#239DAD"),
)
))
#setup()
#let docs = tidy.parse-module(
read("../codly.typ"),
name: "Codly",
scope: (
codly: codly,
codly-reset: codly-reset,
no-codly: no-codly,
codly-enable: codly-enable,
codly-disable: codly-disable,
codly-range: codly-range,
codly-offset: codly-offset,
codly-skip: codly-skip,
local: local,
pre-example: () => {
codly-reset()
setup()
},
img: img
),
preamble: preamble,
)
#tidy.show-module(
docs,
show-outline: false,
style: tidy.styles.default,
) |
https://github.com/longlin10086/HITSZ-PhTyp | https://raw.githubusercontent.com/longlin10086/HITSZ-PhTyp/main/utils/tables.typ | typst | #import "@preview/tablex:0.0.8" : *
#import "../themes/theme.typ" : *
#let signature_table(
img
) = {
set align(right+bottom)
table(
columns: (auto, auto),
inset: (
x: 20pt,
y: 10pt
),
align: horizon + center,
table.header(
[
#set text(font: 字体.宋体, size: 字号.四号)
*教师*
],
[
#set text(font: 字体.宋体, size: 字号.四号)
*姓名*
]
),
[
#set text(font: 字体.楷体, size: 字号.三号)
签字
],
image(
img,
height: 28pt,
fit: "contain",
)
)
v(4em)
}
#let simple_table(
column-num: 1,
cap,
..table
) = {
set align(center)
set figure.caption(position: top)
figure(
caption: cap,
numbering: none,
tablex(
columns: (auto, ) * column-num,
rows: auto,
align: center + horizon,
inset: (
x: 10pt,
y: 7pt,
),
..table
)
)
}
|
|
https://github.com/janlauber/bachelor-thesis | https://raw.githubusercontent.com/janlauber/bachelor-thesis/main/chapters/customer_use_cases.typ | typst | Creative Commons Zero v1.0 Universal | = Customer Use Cases and Feedback
== Use Cases
=== Use Case 1: Streamlit Hosting for Data Science Projects
==== Description
<NAME>. is a data scientist at the Bern University of Applied Sciences (BUAS). She is working on a project in which she has developed a Streamlit application for getting data from the user by providing a user-friendly interface which uses a llm model to predict the branche of someones job. She is looking for a simple and efficient way to deploy her Streamlit application without worrying about the underlying infrastructure.
==== Feedback
Coralie found the One-Click Deployment system to be a perfect solution for deploying her Streamlit application. She was impressed by the simplicity of the deployment process and the ability to customize the deployment configuration based on her requirements. The system's integration with Kubernetes allowed her to deploy the application seamlessly, ensuring reliable performance and scalability. Coralie appreciated the user-friendly interface and the detailed documentation provided, which guided her through the deployment process. Overall, she was satisfied with the system's performance and ease of use, making it an ideal solution for deploying her data science projects.
It is also a great way to deploy Streamlit applications rather than using the hosted solution from Streamlit. The One-Click Deployment system provides more flexibility and control over the deployment process, allowing users to customize the deployment configuration based on their requirements.
#pagebreak()
=== Use Case 2: Vercel Alternative for Node Projects
==== Description
<NAME>. is a co-founder and full-stack developer for his web development agency unbrkn GmbH #footnote[https://www.unbrkn.ch/]. He is working on some Node.js projects and currently hosting them on Vercel. However, he is looking for an alternative Hosting partner in Switzerland to ensure data sovereignty and compliance with local regulations. So he is looking for a simple and efficient way to deploy his Node.js projects without worrying about the underlying infrastructure. Because at Natron Tech #footnote[https://natron.ch] we provide our customers managed Kubernetes clusters, he is looking for a solution that can be easily integrated with Kubernetes.
==== Feedback
Emanuel found the One-Click Deployment system to be an excellent alternative to Vercel for hosting his Node.js projects. He appreciated the system's seamless integration with Kubernetes, allowing him to deploy his applications with minimal effort. The ability to customize the deployment configuration based on his requirements was a significant advantage, enabling him to tailor the deployment process to suit his needs. Emanuel was impressed by the system's ease of use and features, ensuring that his applications ran smoothly and efficiently. He found the user interface intuitive and easy to navigate, making the deployment process straightforward and hassle-free. Overall, he was pleased with the system's capabilities and the support provided, making it an ideal solution for hosting his Node.js projects.
#pagebreak()
=== Use Case 3: Node-RED Deployment for IoT Projects
==== Description
At Natron Tech #footnote[https://natron.ch], we are working on simplifying the deployment of the Node-RED platform for IoT projects. The One-Click Deployment system offers a streamlined solution for deploying Node-RED instances on Kubernetes, enabling developers to create and manage IoT applications efficiently.
==== Feedback
The One-Click Deployment system has proven to be a valuable tool for simplifying the deployment of Node-RED instances for IoT projects. The system's user-friendly interface and customizable deployment configurations have made it easy for developers to deploy and manage Node-RED instances on Kubernetes. The seamless integration with Kubernetes has ensured reliable performance and scalability, allowing developers to focus on building innovative IoT applications without worrying about the underlying infrastructure. The detailed documentation and support provided have been instrumental in guiding developers through the deployment process, ensuring a smooth and hassle-free experience.
== Conclusion
The One-Click Deployment system has received positive feedback from customers across various domains, highlighting its efficiency, reliability, and ease of use. The system's seamless integration with Kubernetes, user-friendly interface, and customizable deployment configurations have made it an ideal choice for deploying a wide range of applications, from data science projects to IoT applications. Customers have appreciated the system's performance, scalability, and detailed documentation, which have guided them through the deployment process. The feedback from customers underscores the system's value in simplifying the deployment and management of applications, ensuring a seamless and efficient experience for users. By addressing the diverse needs of customers and providing a robust deployment solution, the One-Click Deployment system has proven to be a valuable tool for developers and organizations seeking a streamlined deployment experience. The positive feedback from customers reflects the system's success in delivering on its promise of simplifying the deployment process and empowering users to focus on building innovative applications. The system's continuous improvement and customer-centric approach will further enhance its capabilities and ensure its relevance in the rapidly evolving technology landscape.
|
https://github.com/kmitsutani/a_note_on_Hioki_I-1 | https://raw.githubusercontent.com/kmitsutani/a_note_on_Hioki_I-1/main/main.typ | typst | MIT No Attribution | // MIT No Attribution
// Copyright 2024 <NAME>
#import "jdocuments/jnote.typ": main, appendix, thebibliography
#show: main.with(
title: [象の卵は大きい象],
authors: [象山象太郎],
abstract: [古来より象の卵はもし存在するのならばとても大きいであろうと考えられてきた．
そこで我々は象の習性を研究し卵を発見を探し当てる戦略を立て実際に象の卵を発見した．
発見された卵は理論的に予測されていた大きさよりも大きかったということをを報告する．],
)
= はじめに
これはサンプルである．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
象の卵は大きいだけでなくおいしくオムライス１０食分である．
この原稿のソースコードは #link("https://github.com/kmitsutani/typst-jp-note-template") で公開しております．
== 象の習性と卵の観測計画
象は大きくとても体重が大きいため産卵期の象にうかつに近づくことは危険である．
そこで我々は象型のドローンを開発し象の群れに忍ばせることによって象の生態を bla bla bla
== 観測された卵のサイズ
%観測した卵のサイズ(N=3)をもとにN=100の分布を生成する．
== 理論のサーベイ
%WIP%
= 謝辞
本研究は一切の補助を受けておらず自費にて行った．
また本論は @zouyama2015theory @zouyama2017drone @zouyama2021AiL に依拠するものである．
著者は著者の幸福に寄与するすべての境界条件に感謝する．
// Appendix
#show: appendix
= Appendix 1
hogehoge
= Appendix 2
hugahuga
// Path の解決は仕様的に無理らしい https://github.com/typst/typst/issues/3394 のでここでbibliographyオブジェクトにして渡す
#show: thebibliography.with(bibliography("refs.yml"))
|
https://github.com/catppuccin/typst | https://raw.githubusercontent.com/catppuccin/typst/main/src/valkyrie/typst-schema.typ | typst | MIT License | #import "@preview/valkyrie:0.2.1" as z
#let rel-or-length(..args) = z.either(z.relative(), z.length(), ..args)
#let sides-schema = z.dictionary(
(
left: rel-or-length(optional: true),
right: rel-or-length(optional: true),
top: rel-or-length(optional: true),
bottom: rel-or-length(optional: true),
x: rel-or-length(optional: true),
y: rel-or-length(optional: true),
rest: rel-or-length(optional: true),
),
pre-transform: (ctx, it) => if type(it) != dictionary {
(rest: it)
} else {
it
},
post-transform: (ctx, it) => it.pairs().fold(
(:),
(acc, (k, v)) => (
acc + if v != none {
((k): v)
}
),
),
)
#let inset-schema(optional: false, default: (:)) = z.either(
rel-or-length(),
sides-schema,
default: default,
optional: optional,
)
#let outset-schema(optional: false, default: (:)) = inset-schema(optional: optional, default: default)
#let radius-schema(optional: false, default: (:)) = inset-schema(optional: optional, default: default)
|
https://github.com/erfan-khadem/resume | https://raw.githubusercontent.com/erfan-khadem/resume/main/modules_en/certificates.typ | typst | Apache License 2.0 | #import "../brilliant-CV/template.typ": *
#cvSection("Certificates")
#cvHonor(
date: [2021],
title: [Scientific Computing with Python],
issuer: [Free Code Camp],
location: [#link("https://www.freecodecamp.org/certification/fcc9e39ec8c-6530-4d05-acb1-786cb45b8f73/scientific-computing-with-python-v7", [view])]
)
#cvHonor(
date: [2021],
title: [Javascript Algorithms and Data Structures],
issuer: [Free Code Camp],
location: [#link("https://www.freecodecamp.org/certification/fcc9e39ec8c-6530-4d05-acb1-786cb45b8f73/javascript-algorithms-and-data-structures", [view])]
) |
https://github.com/mismorgano/UG-FunctionalAnalyisis-24 | https://raw.githubusercontent.com/mismorgano/UG-FunctionalAnalyisis-24/main/tareas/Tarea-07/Tarea-07.typ | typst | #import "../../config.typ": config, exercise, proof, cls, ip, conv
#show: doc => config([Tarea 7], doc)
1.57, 1.58, 1.59, 1.64 (checa el Teorema de la Categoría de Baire en el Munkres o en algún otro libro de topología), 2.4, 2.8 y 2.9.
#exercise[1.57][Sea $X$ un e.B y sea $C$ un conjunto compacto en $X$. ¿Se cumple que $conv(C)$ es compacto?]
#exercise[1.58][Sea $C$ un conjunto compacto en un e.B finito-dimensional $X$. Muestra que $conv(C)$ es compacto. ]
#exercise[1.59][Sea ${K_i}$ una familia finita de conjuntos convexos compactos en $RR^n$ tal que toda subfamilia de
$n+1$ elementos tiene intersección no vacía. El Teorema de Helly asegura que $sect K_i != emptyset$. Pruebalo para $n=1$.
Muestra un ejemplo para $n=2$ que $n+1$ es necesario.]
#exercise[1.64][Sea $X$ un e.B infinito-dimensional. Muestra que $X$ admite una base de Hammel (algebraica) no contable.
Por lo tanto $c_(00)$ no puede ser e.B.]
#exercise[2.4][Sea $f$ un f.l en un e.B $X$. Muestra que $f$ es continua ssi $f^(-1)(0)$ es cerrado.
#footnote[Podemos notar que $X$ es un espacio métrico, por lo cual ${0}$ es cerrado y por tanto ]
Muestra que si $f$ no es continua, entonces $f^(-1)(0)$ es denso en $X$. ]
#proof[
Primero veamos que $f$ es continua ssi $f^(-1)(0)$ es cerrado. Supongamos que $f$ es continua y sea
${x_n} subset f^(-1)(0)$ una sucesión tal que $x_n -> x in X$, por la continuidad de $f$ obtenemos que $f(x_n) -> f(x)$ y
ademas podemos notar que $f(x_n) = 0$ para todo $n in NN$, lo cual implica que $f(x_n) -> 0$, por
la unicidad del limite tenemos que $f(x) = 0$ y por tanto $x in f^(-1)(0)$. De lo anterior vemos que $f^(-1)(0)$ es cerrado.
Supongamos ahora que $f^(-1)(0)$ es cerrado y sea ${x_n} subset X$ una sucesión tal que $x_n -> x in X$, lo cual implica que
$x_n -x -> 0$.
Supongamos ahora que $f$ no es continua.
]
#exercise[2.8][Encuentra un mapeo lineal discontinuo $T$ de un e.B $X$ en si mismo tal que $"Ker"(T)$ es cerrado. ]
#exercise[2.9][Si $X$ es un e.B infinito-dimensional, muestra que existen conjuntos convexos $C_1, C_2$
tales que $C_1 union C_1 = X$, $C_1 sect C_2 = emptyset$ y tanto $C_1$ como $C_2$ son densos en $X$.]
|
|
https://github.com/MrToWy/hsh-thesis | https://raw.githubusercontent.com/MrToWy/hsh-thesis/main/template/customFunctions.typ | typst | MIT License | #import "@preview/gloss-awe:0.0.5": *
#import "abbreviations.typ": *
#import "@preview/treet:0.1.0": *
#import "@preview/big-todo:0.2.0": *
#import "@preview/gentle-clues:0.9.0": *
#import "@preview/wrap-it:0.1.0": wrap-content
#import "@preview/hydra:0.3.0": hydra
#import "@preview/codly:1.0.0": *
#let colorize = true
#let use-case-color = rgb("E28862")
#let use-case-color-light = rgb("EEC0AB")
#let requirement-color = silver
#if not colorize {
use-case-color = rgb("AAAAAA")
use-case-color-light = rgb("CCCCCC")
}
#let side-padding = 1em
#let top-bot-padding = 3em
#let small-line = line(length: 100%, stroke: 0.045em)
#let example-text(content: none) = {
if(content == none){
return
}
[
#linebreak()
#text(weight: "semibold")[Beispiel: ]
#content
]
}
#let track(title, padding: top-bot-padding/8, type: "E", example: none, label:none, content) = {
let c = counter(type)
c.step()
[
#box[
#context[
#pad(top: padding, bottom: padding)[
#text(weight: "semibold")[
#heading(outlined: false, depth: 9, numbering: (..nums) => {
let nums = nums.pos()
// the number to actually display
let num = nums.last()
// combine indent and formatted numbering
h(0em)
numbering(type + "1", num)
})[#smallcaps(title)]#label
] #linebreak()
#content
#example-text(content: example)
]]]]
}
#let narrow-track(title, type: "Info", label:none, content) = [
#track(title, padding: 0em, type: type, label:label, content)
]
#let use-case(nummer, name, kurzbeschreibung, akteur, vorbedingungen, hauptszenario) = [
#pad(left: 0em, right: 0em, rest: top-bot-padding/2)[
#figure()[
#block()[
#show table.cell.where(x: 0): set text(weight: "bold")
#table(
columns: (0.4fr, 1fr),
fill: (x, y) => if calc.even(x) { use-case-color } else { use-case-color-light },
stroke: (x: none, y: 2.5pt + rgb("FFFF")),
[Name], text([UC] + str(nummer) + " - " + name, weight: "semibold"),
[Kurzbeschreibung], kurzbeschreibung,
[Akteur], akteur,
[Vorbedingungen], vorbedingungen,
[Hauptszenario], hauptszenario,
// [Nachbedingung], nachbedingung
)
]]]
]
#let attributed-quote(label, body) = [
#pad(left: side-padding, right: side-padding, rest: top-bot-padding)[
// use a box to prevent the quote from beeing split on two pages
#box(
quote(
block: true, quotes: true, attribution: [#cite(label.target, form: "author") #label])[
#body
])
]
]
#let diagram-figure(caption, plabel, filename, rendered:true) = [
#pad(left: side-padding, right: side-padding, rest: top-bot-padding)[
#figure(
caption: caption,
kind: "diagram",
supplement: [Diagramm],
include "Diagrams/" + (if (rendered){"rendered/"} else {""}) + filename + ".typ"
) #plabel
]]
#let code-figure(caption, plabel, filename, annotations: none) = [
#pad(left: 0em, right: 0em, rest: top-bot-padding/4)[
#figure(
caption: caption,
kind: "code",
supplement: [Code],
include "Code/" + filename + ".typ"
) #plabel
]]
#let image-figure(plabel, filename, p-caption, height: auto, width: auto) = [
#align(center)[
#pad(left: side-padding, right: side-padding, rest: top-bot-padding)[
#figure(
image("Images/" + filename, height: height, width: width),
caption: p-caption
) #plabel
]]]
#let image-figure-no-pad(plabel, filename, p-caption, height: auto, width: auto) = [
#align(center)[
#figure(
image("Images/" + filename, height: height, width: width),
caption: p-caption
) #plabel
]]
#let tree-figure(p-label, p-caption, content) = [
#pad(left: side-padding, right: side-padding, rest: top-bot-padding)[
#par(leading: 0.5em)[
#figure(caption: p-caption)[
#align(left)[
#tree-list(content)]] #p-label ]]
]
#let get-current-heading-hydra(loc, top-level: false, top-margin) = {
if(top-level){
return hydra(1, top-margin:top-margin)
}
return hydra(2, top-margin:top-margin)
}
#let get-current-heading(loc, top-level: false, top-margin) = {
let chapter-number = counter(heading).display()
if(top-level){
chapter-number = str(counter(heading).get().at(0))
}
let top-level-elems = query(
selector(heading).before(loc),
loc,
)
if(top-level){
top-level-elems = query(
selector(heading.where(level: 1)).before(loc),
loc,
)
}
let current-top-level-elem = ""
if top-level-elems != () {
current-top-level-elem = top-level-elems.last().body
}
return chapter-number + " " + current-top-level-elem
} |
https://github.com/alliso/resume | https://raw.githubusercontent.com/alliso/resume/main/typ/cv_eng.typ | typst | #set page(
margin: 5%
)
#set text(font: "JetBrains Mono")
#grid(
columns: (80%, 20%),
rows: auto,
align(center + bottom, text(18pt)[
= <NAME>
#align(center, text(12pt)[== *FULL STACK DEVELOPER*])
]),
text(6pt)[#list(marker: [],
[+34 651 353 777],
[#text("<EMAIL>")],
[#underline[#link("www.linkedin.com/in/allico")]],
[#underline[#link("https://github.com/alliso")]],
[Calle Doctor Juan Peset n9 p4 Buñol, Valencia 46360 Spain],
)]
)
Developer with extensive experience in programming and system maintenance, and deep knowledge of languages such as Java, JavaScript, and TypeScript. I have participated in various application and system development projects and demonstrated my collaboration and teamwork skills in different professional contexts.
#align(center, line(length: 60%, stroke: 0.5pt + gray))
#align(center, [== #underline[Skills]])
#columns(5)[
#set list(marker: [‣])
- Java 11, 17, and 21
- Spring Boot
#colbreak()
- TypeScript
- Docker
#colbreak()
- Cucumber
- TypeScript
#colbreak()
- MongoDB
- Kafka
#colbreak()
- Git
- PostgreSQL
]
#align(center, line(length: 60%, stroke: 0.5pt + gray))
#align(center, [== #underline[Work Experience]])
=== Full Stack Developer at CTT Express - Remote (Feb 2023 - Present)
#text(10pt)[
- Creation and design of scalable and high-quality software solutions using technologies such as Java Spring Boot and Vue.
- Implementation of innovative methodologies such as TDD and Scrum, which streamline the development process and ensure software quality.
- Design of microservices and use of technologies such as Kafka and Grafana.
]
=== Full Stack Developer at IRTIC - Valencia (Jun 2022 - Feb 2023)
#text(10pt)[
- Creation of scalable and high-quality software solutions using technologies such as Java Spring Boot and Angular.
- Experience in creating and optimizing Docker containers for both the Frontend and Backend of applications, aiming to simplify and speed up the deployment process in production and development environments.
]
=== Full Stack Developer at Dialapplet - Valencia (Jan 2020 - Jun 2022)
#text(10pt)[
- Member of the company's R&D team, responsible for designing and implementing innovative and customized software solutions using cutting-edge technologies.
- Implementation of Docker containers to automate and optimize the company's processes, aiming to improve business efficiency and productivity.
- Maintenance and enhancement of existing applications by adding new features and solving technical problems.
- Application of agile methodologies such as SCRUM for software project management, using tools like Jira for task planning and tracking.
]
=== IT Support at F1-Connecting - Valencia (Oct 2019 - Jan 2020)
#text(10pt)[
- Maintenance of Linux operating systems, including process automation using programming languages such as Python.
]
=== Frontend Developer at WA works - Bergen, Norway (Sep 2018 - Dec 2018)
#text(10pt)[
- Experience in developing Front End applications using frameworks such as React and TypeScript, providing a fast and intuitive user experience.
]
#align(center, line(length: 60%, stroke: 0.5pt + gray))
#pagebreak()
#align(center, [== #underline[Education]])
#text(10pt)[
- Bachelor's Degree in Computer Engineering at Polytechnic University of Valencia (2015 - 2019)
]
|
|
https://github.com/yogurt-shadow/CV | https://raw.githubusercontent.com/yogurt-shadow/CV/master/cv.typ | typst | Creative Commons Zero v1.0 Universal | #show heading: set text(font: "Linux Biolinum")
#show link: underline
// Uncomment the following lines to adjust the size of text
// The recommend resume text size is from `10pt` to `12pt`
// #set text(
// size: 12pt,
// )
// Feel free to change the margin below to best fit your own CV
#set page(
margin: (x: 0.9cm, y: 1.3cm),
)
// For more customizable options, please refer to official reference: https://typst.app/docs/reference/
#set par(justify: true)
#let chiline() = {v(-3pt); line(length: 100%); v(-5pt)}
= <NAME>
<EMAIL> |
#link("https://github.com/yogurt-shadow")[github.com/yogurt-shadow] | #link("https://yogurt-shadow.github.io/")[https://yogurt-shadow.github.io/]
== Education
#chiline()
*Institute of Software, Chinese Academy of Sciences* #h(1fr) 2021/09 -- Present \
Master of Engineering in Computer Science (CS), GPA 3.7/4.0 #h(1fr) Beijing, China\
- Courses: Mathematical Logic and Theory of Programming, Formal Language and Automata Theory
- Second-class Academic Scholarship
*Nankai University* #h(1fr) 2017/08 -- 2021/06 \
Bachelor of Science in Electronic Engineering (EE) #h(1fr) Tianjin, China \
- GPA: 89.17/100, 3.71/4.0 (Rank: 6/45)
- Courses: Computer Principle, EDA Fundamental and Application, Analog Electronics Technology
== Publications
#chiline()
*Efficient Local Search for Nonlinear Real Arithmetic* #h(1fr) VMCAI 2024, London \
Code: https://github.com/yogurt-shadow/LS_NRA \
Video: https://www.youtube.com/watch?v=CKGDRTXvKjk\
- Introduce Local Search algorithm into all classes of SMT(NRA)
- Design boundary structure to compute Local Search operation incrementally
- Design Relaxation strategy for equalities constraints
- Implement based on Z3, beat all mainstream SMT Solvers on QF_NRA satisfiability instances of SMT_LIB.
== Projects
#chiline()
*Z3 Plus Plus: Gold medal in SMT-COMP* #h(1fr) SMT-COMP 2022 & 2023 \
WebPage: https://z3-plus-plus.github.io/ Code: https://github.com/shaowei-cai-group/z3pp\
- Implement sample-cell projection in Z3's Nlsat Solver
- Implement feasible region checker to shortcut unsat instances
*Dynamic Variable Order of Nlsat* #h(1fr) https://github.com/yogurt-shadow/z3-dnlsat\
- Introduce VSIDS dynamic branching heuristic into Nlsat Solver
- Fasten solving procedure both on satisfiable and unsatisfiable instances
*KeymaeraX: Verification of Hybrid Systems (CMU 15-424)* #h(1fr) https://github.com/yogurt-shadow/CMU-15-424\
- Self Solutions to practices in *Logical Foundations of Cyber Physical Systems*
- Use *KeymaeraX* to model and verify hybrid systems using dynamic differential logic (dℒ) interactively
== Work Experience
#chiline()
*Alibaba Group* #h(1fr) 2022/10 - 2023/08\
*Research Internship in Operations Research*
- Design Local Search Heuristic for advertising allocation problem
== Programming Skills
#chiline()
*Isabelle/HOL*\
Code: https://github.com/yogurt-shadow/Isar_Exercise
- Self Solutions to practices in *Concrete Semantics*
== Programming Languages
#chiline()
C/C++, Java, Python, VHDL, Verilog, Shell, HTML, Java, CSS, SQL, Matlab etc.
== English Level
#chiline()
*TOEFL:* Overall: 102 (Reading: 29, Listening: 25, Speaking: 22, Writing: 26)\
*GRE:* Verbal: 159 Quantitative: 170 Writing: 3.5
|
https://github.com/Drodt/clever-quotes | https://raw.githubusercontent.com/Drodt/clever-quotes/main/src/predefined.typ | typst | #import "util.typ": create-quote-style
#let default-quote-styles = (
// English
"en/US": create-quote-style("“", "”", "‘", "’", kern: 0.05em),
"en/GB": create-quote-style("‘", "’", "“", "”", kern: 0.05em),
// German
"de/DE": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
"de/DE|guillemets": create-quote-style("»", "«", "›", "‹", kern: 0.025em),
"de/CH": create-quote-style("«", "»", "‹", "›", kern: 0.025em),
"de/LI": create-quote-style("«", "»", "‹", "›", kern: 0.025em),
"de/AT": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
"de/AT|guillemets": create-quote-style("»", "«", "›", "‹", kern: 0.025em),
// Bosnian
"bs/BA": create-quote-style("”", "”", "’", "’"),
// Croation
"hr/HR": create-quote-style("„", "”", "‘", "’", kern: 0.05em),
"hr/HR|guillemets": create-quote-style("»", "«", "›", "‹", kern: 0.025em),
// Czech
"cs/CZ": create-quote-style("„", "“", "‚", "‘", kern: 0.025em),
"cs/CZ|guillemets": create-quote-style("»", "«", "›", "‹", kern: 0.025em),
// Danish
"da/DK": create-quote-style("„", "“", "’", "’", kern: 0.05em),
"da/DK|guillemets": create-quote-style("»", "«", "‘", "’", kern: 0.025em),
// Dutch
"nl/NL": create-quote-style("„", "”", "‚", "’", kern: 0.05em),
// Estionian
"et/EE": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
// Finnish
"fi/FI": create-quote-style("”", "”", "’", "’", kern: 0.05em),
// French
"fr/FR": create-quote-style("«\u{00A0}", "\u{00A0}»", "“", "”"),
"fr/FR|*": create-quote-style("«\u{00A0}", "\u{00A0}»", "“\u{00A0}", "\u{00A0}”"),
"fr/FR|guillemets": create-quote-style("«\u{00A0}", "\u{00A0}»", "«\u{00A0}", "\u{00A0}»"),
// Greek
"el/GR": create-quote-style("«", "»", "“", "”"),
// Hungarian
"hu/HU": create-quote-style("„", "”", "»", "«"),
// Icelandic
"is/IS": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
// Italian
"it/IT": create-quote-style("«", "»", "“", "”", kern: 0.025em),
"it/IT|quotes": create-quote-style("“", "”", "‘", "’", kern: 0.05em),
// Lithuanian
"lt/LT": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
// Latvian
"lv/LV": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
// Norsk
"no/NO": create-quote-style("«", "»", "‹", "›", kern: 0.05em),
"nb/NO": create-quote-style("„", "“", "«", "»"),
"nb/NO|quotes": create-quote-style("„", "“", "‚", "‘"),
"nn/NO": create-quote-style("„", "“", "«", "»"),
"nn/NO|quotes": create-quote-style("„", "“", "‚", "‘"),
// Polish
"pl/PL": create-quote-style("„", "”", "«", "»"),
"pl/PL|guillemets*": create-quote-style("„", "”", "»", "«"),
"pl/PL|quotes": create-quote-style("„", "”", "‚", "’"),
// Portuguese
"pt/PT": create-quote-style("«", "»", "“", "”", kern: 0.05em),
"pt/BR": create-quote-style("“", "”", "‘", "’", kern: 0.05em),
// Romanian
"ro/RO": create-quote-style("„", "”", "«", "»"),
// Russian
"ru/RU": create-quote-style("«", "»", "„", "“"),
// Serbian
"sr/RS": create-quote-style("„", "”", "’", "’", kern: 0.05em),
"sr/RS|guillemets": create-quote-style("»", "«", "’", "’", kern: 0.025em),
"sr/RS|german": create-quote-style("„", "“", "’", "’", kern: 0.05em),
// Slovak
"sk/SK": create-quote-style("„", "“", "‚", "‘", kern: 0.025em),
// Slovenian
"sl/SI": create-quote-style("»", "«", "›", "‹", kern: 0.025em),
"sl/SI|quotes": create-quote-style("„", "“", "‚", "‘", kern: 0.05em),
// Spanish
"es/ES": create-quote-style("«", "»", "“", "”", kern: 0.05em),
"es/MX": create-quote-style("“", "”", "‘", "’", kern: 0.05em),
// Swedish
"sv/SE": create-quote-style("”", "”", "’", "’", kern: 0.05em),
"sv/SE|guillemets": create-quote-style("»", "»", "›", "›", kern: 0.025em),
"sv/SE|guillemets*": create-quote-style("»", "«", "›", "‹", kern: 0.025em),
)
#let default-quote-aliases = (
// New aliases
"en": "en/US",
"de": "de/DE",
"de|guillemets": "de/DE|guillemets",
"bs": "bs/BA",
"hr": "hr/HR",
"hr|guillemets": "hr/HR|guillemets",
"cs": "cs/CZ",
"cs|guillemets": "cs/CZ|guillemets",
"da": "da/DK",
"da|guillemets": "da/DK|guillemets",
"nl": "nl/NL",
"et": "et/EE",
"fi": "fi/FI",
"fr": "fr/FR",
"fr|*": "fr/FR|*",
"fr|guillemets": "fr/FR|guillemets",
"el": "el/GR",
"hu": "hu/HU",
"is": "is/IS",
"it": "it/IT",
"it|quotes": "it/IT|quotes",
"lt": "lt/LT",
"lv": "lv/LV",
"no": "no/NO",
"nb": "nb/NO",
"nn": "nn/NO",
"pl": "pl/PL",
"pl|guillemets*": "pl/PL|guillemets*",
"pl|quotes": "pl/PL|quotes",
"pt": "pt/PT",
"ro": "ro/RO",
"ru": "ru/RU",
"sr": "sr/RS",
"sr|guillemets": "sr/RS|guillemets",
"sr|german": "sr/RS|german",
"sk": "sk/SK",
"sl": "sl/SI",
"sl|quotes": "sl/SI|quotes",
"es": "es/ES",
"sv": "sv/SE",
"sv|guillemets": "sv/SE|guillemets",
"sv|guillemets*": "sv/SE|guillemets*",
// Latin
"la": "it/IT",
"la|italianguillemets": "it/IT",
"la|germanquotes": "de/DE",
"la|germanguillemets": "de/DE|guillemets",
"la|britishquotes": "en/GB",
"la|americanquotes": "en/US",
)
#let get-default-style(name) = {
let style-alias = default-quote-aliases.at(name, default: none)
if style-alias != none {
name = style-alias
}
default-quote-styles.at(name, default: none)
} |
|
https://github.com/felsenhower/kbs-typst | https://raw.githubusercontent.com/felsenhower/kbs-typst/master/README.md | markdown | MIT License | # kbs-typst
Folien für das [KunterBunteSeminar (KBS)](https://mafiasi.de/KBS) über [Typst](https://github.com/typst/typst).
[](https://raw.githubusercontent.com/felsenhower/kbs-typst/master/presentation.pdf)
## Dependencies
* `typst`
* `make`
* `pdf2svg`
* Schriftarten:
* Latin Modern Sans (als Fallback wird DejaVu Sans benutzt, was built-in sein sollte, aber nicht so gut aussieht)
* Comic Sans MS (fragt nicht)
## Bauen:
```bash
$ git clone https://github.com/felsenhower/kbs-typst.git
$ cd kbs-typst
$ git submodule update --init
$ make
```
## Anmerkungen:
* Dieses Repo enthält ein paar Submodules (in [`typst-modules`](typst-modules)), die zum Bauen benötigt werden.
* In [`examples`](examples) befinden sich ein paar Typst-Beispiele, die vor dem Bauen der Präsentation erst zu PDF kompiliert und zu SVG konvertiert werden müssen (`make` macht das automatisch).
* Da sich Typst derzeit schnell weiterentwickelt, ist es möglich, dass der Inhalt dieses Repos nur mit bestimmten Versionen von Typst baut.
|
https://github.com/ammar-ahmed22/compile-typst-action | https://raw.githubusercontent.com/ammar-ahmed22/compile-typst-action/main/README.md | markdown | MIT License | <div align="center" >
🛠️ :page_facing_up:
</div>
<h1 align="center">
compile-typst
</h1>
<p align="center">
A GitHub Action for compiling Typst files to PDF's using the latest Typst release.
</p>
## ✨ Features
- **Compile Typst Code**: Automatically compiles .typ files into PDFs.
- **Customizable Paths**: Specify source and output paths for flexibility.
- **Font Support**: Optional custom font configuration for Typst rendering.
## 📥 Inputs
| Name | Type | Description | Required? |
| --------------- | ---------- | -------------------------------------------------------------------------------------------------------- | :-------: |
| `source_paths` | `String[]` | Space separated list of paths to the `.typ` files | ✅ |
| `output_paths` | `String[]` | Space separated list of output paths (must be `.pdf`) (defaults to the same name as the `source_paths`) | |
| `fonts_paths` | `String` | Path to the fonts directory used by the Typst compiler | |
> 💡 When providing `output_paths`, the number of `output_paths` should match exactly the number of `source_paths`. Each source file will be compiled to the output file in the given order.
## 🤸 Usage
To use this acton, create a workflow file (e.g. `.github/workflows/typst-compile.yml`) in your GitHub repository.
Here's a basic example:
```yaml
name: Compile Typst Documents
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Compile Typst Files
uses: ammar-ahmed22/compile-typst-action@v1
with:
source_paths: 'path/to/source/file1.typ path/to/source/file2.typ'
output_paths: 'path/to/output/file1.pdf path/to/output/file2.pdf'
fonts_path: 'path/to/fonts'
```
Here's a more complex example which does the following:
- Compiles the Typst files into PDF's
- Uploads artifacts of the PDF's
- If the action is run on a tag, creates a release with the PDF files
```yaml
name: Compile, Upload and Release Typst Documents
on:
workflow_dispatch:
push:
tags:
- '**'
permissions:
contents: write
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout Repository
uses: actions/checkout@v4
- name: Compile Typst Files
uses: ammar-ahmed22/compile-typst-action@v1
with:
source_paths: 'path/to/source/file1.typ path/to/source/file2.typ'
output_paths: 'path/to/output/file1.pdf path/to/output/file2.pdf'
fonts_path: 'path/to/fonts'
- name: Upload Artifacts
uses: actions/upload-artifact@v3
with:
name: PDF
path: '**/*.pdf'
- name: Release on tag
uses: softprops/action-gh-release@v1
if: github.ref_type = 'tag'
with:
name: "${{ github.ref_name }}"
files: |
path/to/output/file1.pdf
path/to/output/file2.pdf
```
I have created an example project where this action is used to compile and commit the generated/updated PDFs to the repo:
[compile-typst-example](https://github.com/ammar-ahmed22/compile-typst-example)
## 🙌 Contributing
Contributions to the Typst Compiler GitHub Action are welcome! It is far from perfect, I threw this together quickly to solve a personal problem. Please feel free to open a PR or issue with any changes!
For more information on Typst, visit [Typst Documentation](https://typst.app/docs/).
<NAME> (ammar-ahmed22) 2024 |
https://github.com/tiankaima/typst-notes | https://raw.githubusercontent.com/tiankaima/typst-notes/master/2bc0c8-2024_spring_TA/green.typ | typst | $
integral.double_(D) v laplace u - u laplace v dif x dif y = integral.cont_(diff D) v (diff u)/(diff bold(n)) - u (diff v)/(diff bold(n)) dif s
$
$
integral.double laplace u dif x dif y = integral.cont (diff u)/(diff bold(n)) dif s
$
$
nabla = bold(e)_r (diff)/(diff r) + bold(e)_theta 1/r (diff)/(diff theta) + 1/(r sin theta) bold(e)_phi (diff)/(diff phi)
$ |
|
https://github.com/Skimmeroni/Appunti | https://raw.githubusercontent.com/Skimmeroni/Appunti/main/Metodi%20Algebrici/Codici/Lineari.typ | typst | Creative Commons Zero v1.0 Universal | #import "../Metodi_defs.typ": *
Sia $ZZ_(p)^(n)$ lo spazio vettoriale delle $n$-uple di $ZZ_(p)$, con $p$
numero primo. La somma tra due vettori su tale spazio vettoriale é definita
come:
$ ([x_(1)]_(p), ..., [x_(n)]_(p)) + ([y_(1)]_(p), ..., [y_(n)]_(p)) =
([x_(1) + y_(1)]_(p), ..., [x_(n) + y_(n)]_(p)) $
Mentre il prodotto fra un vettore ed uno scalare come:
$ [lambda]_(p) ([x_(1)]_(p), ..., [x_(n)]_(p)) =
([lambda x_(1)]_(p), ..., [lambda x_(n)]_(p)) $
É infine possibile definire un prodotto scalare come:
$ ([x_(1)]_(p), ..., [x_(n)]_(p)) dot ([y_(1)]_(p), ..., [y_(n)]_(p)) =
sum_(i = 1)^(n) x_(i) y_(i) $
Se due vettori hanno nullo il loro prodotto scalare, si dicono *ortogonali*.
#lemma[
Siano $x, y, z in ZZ_(p)^(n)$ e $lambda in ZZ_(p)$. Si ha:
- $x dot y = y dot x$;
- $x dot (y + z) = x dot y + x dot z$;
- $(lambda x) dot y = lambda (x dot y)$.
]
La base canonica di tale spazio vettoriale viene definita come:
$ ([1]_(p), [0]_(p), dots, [0]_(p), [0]_(p)),
([0]_(p), [1]_(p), dots, [0]_(p), [0]_(p)),
dots,
([0]_(p), [0]_(p), dots, [1]_(p), [0]_(p)),
([0]_(p), [0]_(p), dots, [0]_(p), [1]_(p)) $
Per semplicitá, quando é desumibile dal contesto, una classe di resto
$[x]_(p)$ verrá semplicemente denotata con $x$.
#example[
Lo spazio vettoriale $ZZ_(2)^(5)$, é costituito da tutte e sole le
quintuple che hanno per elementi gli elementi di $ZZ_(2) = {0, 1}$
(si noti come con $0$ si intenda $[0]_(2)$, mentre con $1$ si intenda
$[1]_(2)$).
]
// #theorem[
// Lo spazio vettoriale $ZZ_(p)^(n)$ ha dimensione $n$.
// ]
Un qualsiasi sottospazio vettoriale di $ZZ_(p)^(n)$ viene detto
*codice lineare*.
#example[
A partire dallo spazio vettoriale $ZZ_(2)^(5)$ é possibile
definire il codice $C$ come il suo sottospazio avente base
$B = {b_(1) = 10111, b_(2) = 11110}$. I vettori che costituiscono
$C$ sono tutti e i soli vettori generati dalla combinazione lineare
$lambda_(1) b_(1) + lambda_(2) b_(2)$, con $lambda_(1), lambda_(2)
in ZZ_(2)$. Essendo $ZZ_(2)$ e $B$ due insiemi finiti, é possibile
enumerare $C$ esplicitamente:
#set math.mat(delim:none)
#grid(
columns: (0.5fr, 0.5fr),
[$ mat(
0(10111) + 0(11110) = (00000);
1(10111) + 0(11110) = (10111)
) $],
[$ mat(
0(10111) + 1(11110) = (11110);
1(10111) + 1(11110) = (01001)
) $]
)
] <Subspace>
#lemma[
Sia $C subset.eq ZZ_(p)^(n)$ un codice lineare di dimensione $k$.
Si ha $|C| = p^(k)$.
]
#proof[
Sia $B = {b_(1), b_(2), ..., b_(k)}$ una base di $C$. Ogni elemento
di $C$ puó essere generato a partire da una ed una sola combinazione
lineare dei vettori di $B$, ovvero
$ lambda_(1) b_(1) + lambda_(2) b_(2) + ··· + lambda_(k) b_(k)
space "con" space lambda_(i) in ZZ_(p), space i = {1, ..., k} $
Essendo i $lambda_(i)$ esattamente $p$ e dovendone scegliere $k$ per
generare ciascun vettore, anche ripetuti, il numero totale di vettori
di $C$ é $p^(k)$.
]
#example[
Il codice $C$ dell'@Subspace ha dimensione $abs(B) = 2$, ed é un
sottoinsieme di $ZZ_(2)^(5)$. Correttamente, $abs(C) = 2^(2) = 4$.
]
#lemma[
Ogni codice lineare $C$ contiene #footnote[É inoltre vero per
definizione, dato che $underline(0)$ é il vettore nullo di
$ZZ_(p)^(n)$ e qualsiasi sottospazio vettoriale deve contenerlo.]
la parola $underline(0) = 00...0$.
] <Null-word-always-in>
#proof[
Sia $B = {b_(1), b_(2), ..., b_(k)}$ una base di $C$ e sia $k$ la sua
dimensione. Per generare $00...0$ occorre costruire una combinazione
lineare dove tutti gli elementi sono nulli. Questo é sempre possibile
perché, per qualsiasi $p$, l'elemento $[0]_(p)$ appartiene a $ZZ_(p)$,
ed quindi é sempre possibile costruire una combinazione lineare del
tipo:
$ 0 b_(1) + 0 b_(2) + ··· + 0 b_(k) space "ovvero" space
lambda_(1) = lambda_(2) = ... = lambda_(k) = 0 $
]
Sia $x = (x_(1) x_(2) ... x_(n))$ un elemento di $ZZ_(p)^(n)$. Prende il
nome di *peso di Hamming* il numero di componenti $w(x)$ di $x$ diverse
da $0$, ovvero:
$ w(x) = {i | x_(i) != 0} $
Dato che in questo contesto verrá sempre usato il peso di Hamming come
nozione di peso, si sottointenderá con il solo termine "peso" il peso
di Hamming.
#lemma[
Sia $C$ un codice lineare, e siano $x, y$ due suoi elementi. Allora
$d(x, y) = w(x - y)$.
]
#proof[
Per il @Null-word-always-in, la parola $underline(0)$ appartiene
sempre a $C$. Pertanto, per qualsiasi $y in C$, vale $d(underline(0),
y) = w(y)$, perché di fatto le due definizioni coincidono. Poichè
$d(C)$ è la distanza minima di $C$ esistono certamente $x, y in C$
con $d(C) = d(x, y) = w(x − y)$.
]
#lemma[
Sia $C$ un codice lineare. La distanza minima $d(C)$ è pari al
peso della parola non nulla di $C$ avente, fra tutte, il peso
minimo. Ovvero:
$ d(C) = min{w(z) : z in C, z != underline(0)} $
]
#proof[
Si supponga per assurdo che $d(C) < min{w(z) : z in C, z !=
underline(0)}$. Se cosí fosse, potrebbe esisterebbe un $z_(0)
in C$ tale per cui $w(z_(0)) = d(z_(0), underline(0)) < d(C)$,
ma questo non é possibile, perché $d(C)$ é la minima distanza
fra tutte le parole di $C$.
]
Sia $C in ZZ_(p)^(n)$ un codice lineare di dimensione $k$. Siano
poi $cal(B)_(C) = {b_(1), b_(2), ..., b_(k)}$ una base di $C$ e
$cal(B) = {e_(1), e_(2), ..., e_(n)}$ una base di $ZZ_(p)^(n)$.
Dato che ogni parola in $cal(B)_(C)$ (e quindi in $C$) appartiene
a $ZZ_(p)$, ogni $b_(i) in cal(B)_(C)$ puó essere scritto come
combinazione lineare a coefficienti in $ZZ_(p)$ dei vettori di
$cal(B)$:
$ cases(
b_(1) = lambda_(1, 1) e_(1) + lambda_(1, 2) e_(2) + dots +
lambda_(1, n) e_(n),
b_(2) = lambda_(2, 1) e_(1) + lambda_(2, 2) e_(2) + dots +
lambda_(2, n) e_(n),
dots.v,
b_(k) = lambda_(k, 1) e_(1) + lambda_(k, 2) e_(2) + dots +
lambda_(k, n) e_(n)
) space "con" space lambda_(i, j) in ZZ_(p) space forall i, j = {1, ..., k} $
La matrice $G$ costituita dai coefficienti $lambda_(i, j)$ di tali
combinazioni lineari, ovvero:
$ G = mat(
lambda_(1, 1), lambda_(1, 2), dots, lambda_(1, n);
lambda_(2, 1), lambda_(2, 2), dots, lambda_(2, n);
dots.v, dots, dots.down, dots.v;
lambda_(k, 1), lambda_(k, 2), dots, lambda_(k, n);
) in "Mat"(k times n, ZZ_(p)) $
Viene detta *matrice generatrice* di $G$.
Naturalmente, preso un qualsiasi $m = (m_(1), m_(2), dots, m_(k))
in ZZ_(p)^(k)$, si avrá che il prodotto matriciale fra $m$ e $G$
appartiene a $C$:
$ m G = mat(m_(1), m_(2), dots, m_(k))
mat(
lambda_(1, 1), lambda_(1, 2), dots, lambda_(1, n);
lambda_(2, 1), lambda_(2, 2), dots, lambda_(2, n);
dots.v, dots, dots.down, dots.v;
lambda_(k, 1), lambda_(k, 2), dots, lambda_(k, n);
) in C
$
#example[
Si consideri il codice lineare $C subset.eq ZZ_(2)^(5)$ di dimensione
$3$. Sia $cal(B)_(C)$ la base di $C$ costituita dai vettori ${b_(1) =
10001, b_(2) = 11010, b_(3) = 11101}$. Sia poi $cal(B)$ la base canonica
di $ZZ_(2)^(5)$.
La matrice $G$ é cosí costruita:
$ cases(
10001 = lambda_(1, 1) 10000 + lambda_(1, 2) 01000 +
lambda_(1, 3) 00100 + lambda_(1, 4) 00010 + lambda_(1, 5) 00001,
11010 = lambda_(2, 1) 10000 + lambda_(2, 2) 01000 +
lambda_(2, 3) 00100 + lambda_(2, 4) 00010 + lambda_(2, 5) 00001,
11101 = lambda_(3, 1) 10000 + lambda_(3, 2) 01000 +
lambda_(3, 3) 00100 + lambda_(3, 4) 00010 + lambda_(3, 5) 00001
) space => G = mat(
1, 0, 0, 0, 1;
1, 1, 0, 1, 0;
1, 1, 1, 0, 1;
) $
Sia $m = (1, 0, 1) in ZZ_(2)^(3)$. Si osservi come:
$ m G =
mat(
1, 0, 1
)
mat(
1, 0, 0, 0, 1;
1, 1, 0, 1, 0;
1, 1, 1, 0, 1)
=
mat(
1 dot 1 + 0 dot 1 + 1 dot 1;
1 dot 0 + 0 dot 1 + 1 dot 1;
1 dot 0 + 0 dot 0 + 1 dot 1;
1 dot 0 + 0 dot 1 + 1 dot 0;
1 dot 1 + 0 dot 0 + 1 dot 1;
)^(t)
= mat(0, 1, 1, 0, 0) in C
$
É poi possibile ricavare il codice $C$ associato osservando come:
$ mat(x, y, z)
mat(1, 0, 0, 0, 1;
1, 1, 0, 1, 0;
1, 1, 1, 0, 1) =
mat(x dot 1 + y dot 1 + z dot 1;
x dot 0 + y dot 1 + z dot 1;
x dot 0 + y dot 0 + z dot 1;
x dot 0 + y dot 1 + z dot 0;
x dot 1 + y dot 0 + z dot 1)^(t) =
mat(x + y + z, y + z, z, y, x + z) $
Essendo $x, y, z in ZZ_(2)$, é possibile elencare gli elementi
di $C$ esplicitamente:
$ C = {00000, 10001, 11010, 11101, 01011, 01100, 00111, 10110} $
]
|
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/030_Amonkhet.typ | typst | #import "@local/mtgset:0.1.0": conf
#show: doc => conf("Amonkhet", doc)
#include "./030 - Amonkhet/001_Impact.typ"
#include "./030 - Amonkhet/002_Trust.typ"
#include "./030 - Amonkhet/003_The Writing on the Wall.typ"
#include "./030 - Amonkhet/004_Servants.typ"
#include "./030 - Amonkhet/005_The Hand That Moves.typ"
#include "./030 - Amonkhet/006_Brazen.typ"
#include "./030 - Amonkhet/007_Judgment.typ"
|
|
https://github.com/Area-53-Robotics/53B-Notebook-Over-Under-2023-2024 | https://raw.githubusercontent.com/Area-53-Robotics/53B-Notebook-Over-Under-2023-2024/master/templates/entries.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #let create_default_entry(title: [], date: [], design: [], witness: [], content: []) = {
page(
header: [
#grid(
columns: (2fr, 1fr),
align(left)[
#set text(
font: "Times New Roman",
18pt
)
= #title
],
align(right)[
#set text(
font: "Times New Roman",
16pt
)
#emph()[#date]
],
)
#align(center)[#line(length: 100%, stroke: 1.5pt)]
],
footer: [
#align(center)[#line(length: 100%, stroke: 1.5pt)]
#grid(
columns: (3fr,1fr),
align(left)[
#set text(
font: "Times New Roman",
12pt
)
Designed by: #emph()[#design] \
Witnessed by: #emph()[#witness]
],
align(right)[
#counter(page).display()
],
)
],
)[
#content
]
}
#let create_headerless_page(design: [], witness: [], content: []) = {
page(
footer: [
#align(center)[#line(length: 100%, stroke: 1.5pt)]
#grid(
columns: (3fr, 1fr),
align(left)[
#set text(
font: "Times New Roman",
12pt
)
Designed by: #emph()[#design] \
Witnessed by: #emph()[#witness]
],
align(right)[
#counter(page).display()
],
)
],
)[
#content
]
}
#let create_footerless_page(title: [], date: [], content: []) = {
page(
header: [
#grid(
columns: (2fr, 1fr),
align(left)[
#set text(
font: "Times New Roman",
18pt
)
= #title
],
align(right)[
#set text(
font: "Times New Roman",
16pt
)
#emph()[#date]
],
)
#align(center)[#line(length: 100%, stroke: 1.5pt)]
],
numbering: "1",
number-align: right
)[
#content
]
}
#let create_blank_page(content: []) = {
page(
numbering: "1",
number-align: right
)[
#content
]
} |
https://github.com/DanielOaks/tme | https://raw.githubusercontent.com/DanielOaks/tme/main/extra-sheet.typ | typst | #import "elements.typ": sheet, extraCharacterBox
#let title = "Talking Magic Equines 1e Extras Sheet"
#sheet(
title: title,
paper: "a4",
[
// top matter
#align(
end,
image(
"./tme_v2_-_light_bg.svg",
height: .9cm,
)
)
#v(3pt)
// character snippets
#grid(
columns: 3,
gutter: .65cm,
column-gutter: .65cm,
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
extraCharacterBox(lines: 4),
)
]
)
|
|
https://github.com/jijinbei/Lizard_Typst | https://raw.githubusercontent.com/jijinbei/Lizard_Typst/main/README.md | markdown | MIT License | # Lizard Typst
## Office Add-in React Vite Template
This is a template for developing an [Office.JS](https://learn.microsoft.com/en-us/office/dev/add-ins/) **PowerPoint** add-in with **Vite** and **React 18**. The main advantage of using this template is a much faster development cycle. The development server starts in just 2-3 seconds and hot-reloaded changes are near instant.
### Key differences
This template was generated using the [generator-office](https://www.npmjs.com/package/generator-office) generator which is based on the [Office-Addin-Taskpane-React](https://github.com/OfficeDev/Office-Addin-TaskPane-React) project.
These are the key differences between this template and the default generated template:
- Use Vite instead of Webpack.
- Use React 18.
- Remove polyfills and support for IE 11.
- Enabled typescript strict mode
### Usage
To start the development server, run:
```
npm run dev
```
To load the add-in in your Excel, use any of the `start` scripts. e.g:
```
npm run start
```
To create a production build, run:
```
npm run build
```
## Legacy Browsers
This template does not include support for IE11. If you need support, add [@vitejs/plugin-legacy](https://github.com/vitejs/vite/tree/main/packages/plugin-legacy).
|
https://github.com/mitex-rs/underleaf | https://raw.githubusercontent.com/mitex-rs/underleaf/main/fixtures/underleaf/ieee/main.typ | typst |
#import "@preview/mitex:0.2.0": *
#let res = mitex-convert(mode: "text", read("main.tex"))
#eval(res, mode: "markup", scope: mitex-scope)
|
|
https://github.com/jneug/typst-codetastic | https://raw.githubusercontent.com/jneug/typst-codetastic/main/bits.typ | typst | MIT License |
// TODO: This probably should be improved / optimized.
#let pow = calc.pow.with(2)
#let divmod(n) = (calc.quo(n, 2), calc.rem(n, 2))
#let new(pad:0) = (false,) * calc.max(1, pad)
/// >>> bits.to-int(()) == 0
/// >>> bits.to-int((true,)) == 1
/// >>> bits.to-int((true,false)) == 2
#let to-int(b) = b.rev().enumerate().fold(0, (d, bit) => d + if bit.at(1) {1} else {0} * pow(bit.at(0)))
#let display(b, format: (b) => b) = format(b.map((bit) => if bit {"1"} else {"0"}).join())
#let shift(b, n) = if n > 0 {
return b + (false,)*n
} else if n == 0 {
return b
} else {
return b.slice(0, n)
}
#let shift-to(b, n) = if b.len() < n {
b + (false,) * (n - b.len())
} else {
b
}
#let at(b, i) = b.at(i)
#let trim(b) = b.fold((), (b, bit) => {if b != () or bit {b.push(bit)}; b})
#let pad(b, pad) = if b.len() < pad { (false,) * (pad - b.len()) + b} else { b }
#let pad-same(a, b) = if a.len() < b.len() {
(pad(a, b.len()), b)
} else if b.len() < a.len() {
(a, pad(b, a.len()))
} else {
(a, b)
}
#let neg(b) = b.map((bit) => not bit)
#let inv = neg
#let band(a, b) = {
(a, b) = pad-same(a, b)
a.enumerate().map(((i, bit)) => bit and b.at(i))
}
#let bor(a, b) = {
(a, b) = pad-same(a, b)
a.enumerate().map(((i, bit)) => bit or b.at(i))
}
#let xor(a, b) = {
(a, b) = pad-same(a, b)
a.enumerate().map(((i, bit)) => bit != b.at(i))
}
#let is-zero(b) = b.all((bit) => not bit)
#let most-sig(b) = {
return b.len() - b.position((v) => v) - 1
}
#let most-sig-idx(b) = {
return b.position((v) => v)
}
#let bits-map = (
(),
(true,),
(true,false),
(true,true),
(true,false,false),
(true,false,true),
(true,true,false),
(true,true,true),
(true,false,false,false),
(true,false,false,true),
(true,false,true,false),
(true,false,true,true),
(true,true,false,false),
(true,true,false,true),
(true,true,true,false),
(true,true,true,true),
(true,false,false,false,false),
(true,false,false,false,true),
(true,false,false,true,false),
(true,false,false,true,true),
(true,false,true,false,false),
(true,false,true,false,true),
(true,false,true,true,false),
(true,false,true,true,true),
(true,true,false,false,false),
(true,true,false,false,true),
(true,true,false,true,false),
(true,true,false,true,true),
(true,true,true,false,false),
(true,true,true,false,true),
(true,true,true,true,false),
(true,true,true,true,true),
(true,false,false,false,false,false),
(true,false,false,false,false,true),
(true,false,false,false,true,false),
(true,false,false,false,true,true),
(true,false,false,true,false,false),
(true,false,false,true,false,true),
(true,false,false,true,true,false),
(true,false,false,true,true,true),
(true,false,true,false,false,false),
(true,false,true,false,false,true),
(true,false,true,false,true,false),
(true,false,true,false,true,true),
(true,false,true,true,false,false),
(true,false,true,true,false,true),
(true,false,true,true,true,false),
(true,false,true,true,true,true),
(true,true,false,false,false,false),
(true,true,false,false,false,true),
(true,true,false,false,true,false),
(true,true,false,false,true,true),
(true,true,false,true,false,false),
(true,true,false,true,false,true),
(true,true,false,true,true,false),
(true,true,false,true,true,true),
(true,true,true,false,false,false),
(true,true,true,false,false,true),
(true,true,true,false,true,false),
(true,true,true,false,true,true),
(true,true,true,true,false,false),
(true,true,true,true,false,true),
(true,true,true,true,true,false),
(true,true,true,true,true,true),
(true,false,false,false,false,false,false),
(true,false,false,false,false,false,true),
(true,false,false,false,false,true,false),
(true,false,false,false,false,true,true),
(true,false,false,false,true,false,false),
(true,false,false,false,true,false,true),
(true,false,false,false,true,true,false),
(true,false,false,false,true,true,true),
(true,false,false,true,false,false,false),
(true,false,false,true,false,false,true),
(true,false,false,true,false,true,false),
(true,false,false,true,false,true,true),
(true,false,false,true,true,false,false),
(true,false,false,true,true,false,true),
(true,false,false,true,true,true,false),
(true,false,false,true,true,true,true),
(true,false,true,false,false,false,false),
(true,false,true,false,false,false,true),
(true,false,true,false,false,true,false),
(true,false,true,false,false,true,true),
(true,false,true,false,true,false,false),
(true,false,true,false,true,false,true),
(true,false,true,false,true,true,false),
(true,false,true,false,true,true,true),
(true,false,true,true,false,false,false),
(true,false,true,true,false,false,true),
(true,false,true,true,false,true,false),
(true,false,true,true,false,true,true),
(true,false,true,true,true,false,false),
(true,false,true,true,true,false,true),
(true,false,true,true,true,true,false),
(true,false,true,true,true,true,true),
(true,true,false,false,false,false,false),
(true,true,false,false,false,false,true),
(true,true,false,false,false,true,false),
(true,true,false,false,false,true,true),
(true,true,false,false,true,false,false),
(true,true,false,false,true,false,true),
(true,true,false,false,true,true,false),
(true,true,false,false,true,true,true),
(true,true,false,true,false,false,false),
(true,true,false,true,false,false,true),
(true,true,false,true,false,true,false),
(true,true,false,true,false,true,true),
(true,true,false,true,true,false,false),
(true,true,false,true,true,false,true),
(true,true,false,true,true,true,false),
(true,true,false,true,true,true,true),
(true,true,true,false,false,false,false),
(true,true,true,false,false,false,true),
(true,true,true,false,false,true,false),
(true,true,true,false,false,true,true),
(true,true,true,false,true,false,false),
(true,true,true,false,true,false,true),
(true,true,true,false,true,true,false),
(true,true,true,false,true,true,true),
(true,true,true,true,false,false,false),
(true,true,true,true,false,false,true),
(true,true,true,true,false,true,false),
(true,true,true,true,false,true,true),
(true,true,true,true,true,false,false),
(true,true,true,true,true,false,true),
(true,true,true,true,true,true,false),
(true,true,true,true,true,true,true),
(true,false,false,false,false,false,false,false),
(true,false,false,false,false,false,false,true),
(true,false,false,false,false,false,true,false),
(true,false,false,false,false,false,true,true),
(true,false,false,false,false,true,false,false),
(true,false,false,false,false,true,false,true),
(true,false,false,false,false,true,true,false),
(true,false,false,false,false,true,true,true),
(true,false,false,false,true,false,false,false),
(true,false,false,false,true,false,false,true),
(true,false,false,false,true,false,true,false),
(true,false,false,false,true,false,true,true),
(true,false,false,false,true,true,false,false),
(true,false,false,false,true,true,false,true),
(true,false,false,false,true,true,true,false),
(true,false,false,false,true,true,true,true),
(true,false,false,true,false,false,false,false),
(true,false,false,true,false,false,false,true),
(true,false,false,true,false,false,true,false),
(true,false,false,true,false,false,true,true),
(true,false,false,true,false,true,false,false),
(true,false,false,true,false,true,false,true),
(true,false,false,true,false,true,true,false),
(true,false,false,true,false,true,true,true),
(true,false,false,true,true,false,false,false),
(true,false,false,true,true,false,false,true),
(true,false,false,true,true,false,true,false),
(true,false,false,true,true,false,true,true),
(true,false,false,true,true,true,false,false),
(true,false,false,true,true,true,false,true),
(true,false,false,true,true,true,true,false),
(true,false,false,true,true,true,true,true),
(true,false,true,false,false,false,false,false),
(true,false,true,false,false,false,false,true),
(true,false,true,false,false,false,true,false),
(true,false,true,false,false,false,true,true),
(true,false,true,false,false,true,false,false),
(true,false,true,false,false,true,false,true),
(true,false,true,false,false,true,true,false),
(true,false,true,false,false,true,true,true),
(true,false,true,false,true,false,false,false),
(true,false,true,false,true,false,false,true),
(true,false,true,false,true,false,true,false),
(true,false,true,false,true,false,true,true),
(true,false,true,false,true,true,false,false),
(true,false,true,false,true,true,false,true),
(true,false,true,false,true,true,true,false),
(true,false,true,false,true,true,true,true),
(true,false,true,true,false,false,false,false),
(true,false,true,true,false,false,false,true),
(true,false,true,true,false,false,true,false),
(true,false,true,true,false,false,true,true),
(true,false,true,true,false,true,false,false),
(true,false,true,true,false,true,false,true),
(true,false,true,true,false,true,true,false),
(true,false,true,true,false,true,true,true),
(true,false,true,true,true,false,false,false),
(true,false,true,true,true,false,false,true),
(true,false,true,true,true,false,true,false),
(true,false,true,true,true,false,true,true),
(true,false,true,true,true,true,false,false),
(true,false,true,true,true,true,false,true),
(true,false,true,true,true,true,true,false),
(true,false,true,true,true,true,true,true),
(true,true,false,false,false,false,false,false),
(true,true,false,false,false,false,false,true),
(true,true,false,false,false,false,true,false),
(true,true,false,false,false,false,true,true),
(true,true,false,false,false,true,false,false),
(true,true,false,false,false,true,false,true),
(true,true,false,false,false,true,true,false),
(true,true,false,false,false,true,true,true),
(true,true,false,false,true,false,false,false),
(true,true,false,false,true,false,false,true),
(true,true,false,false,true,false,true,false),
(true,true,false,false,true,false,true,true),
(true,true,false,false,true,true,false,false),
(true,true,false,false,true,true,false,true),
(true,true,false,false,true,true,true,false),
(true,true,false,false,true,true,true,true),
(true,true,false,true,false,false,false,false),
(true,true,false,true,false,false,false,true),
(true,true,false,true,false,false,true,false),
(true,true,false,true,false,false,true,true),
(true,true,false,true,false,true,false,false),
(true,true,false,true,false,true,false,true),
(true,true,false,true,false,true,true,false),
(true,true,false,true,false,true,true,true),
(true,true,false,true,true,false,false,false),
(true,true,false,true,true,false,false,true),
(true,true,false,true,true,false,true,false),
(true,true,false,true,true,false,true,true),
(true,true,false,true,true,true,false,false),
(true,true,false,true,true,true,false,true),
(true,true,false,true,true,true,true,false),
(true,true,false,true,true,true,true,true),
(true,true,true,false,false,false,false,false),
(true,true,true,false,false,false,false,true),
(true,true,true,false,false,false,true,false),
(true,true,true,false,false,false,true,true),
(true,true,true,false,false,true,false,false),
(true,true,true,false,false,true,false,true),
(true,true,true,false,false,true,true,false),
(true,true,true,false,false,true,true,true),
(true,true,true,false,true,false,false,false),
(true,true,true,false,true,false,false,true),
(true,true,true,false,true,false,true,false),
(true,true,true,false,true,false,true,true),
(true,true,true,false,true,true,false,false),
(true,true,true,false,true,true,false,true),
(true,true,true,false,true,true,true,false),
(true,true,true,false,true,true,true,true),
(true,true,true,true,false,false,false,false),
(true,true,true,true,false,false,false,true),
(true,true,true,true,false,false,true,false),
(true,true,true,true,false,false,true,true),
(true,true,true,true,false,true,false,false),
(true,true,true,true,false,true,false,true),
(true,true,true,true,false,true,true,false),
(true,true,true,true,false,true,true,true),
(true,true,true,true,true,false,false,false),
(true,true,true,true,true,false,false,true),
(true,true,true,true,true,false,true,false),
(true,true,true,true,true,false,true,true),
(true,true,true,true,true,true,false,false),
(true,true,true,true,true,true,false,true),
(true,true,true,true,true,true,true,false),
(true,true,true,true,true,true,true,true)
)
/// >>> bits.from-int(0) == ()
/// >>> bits.from-int(0, pad:8) == (false,) * 8
/// >>> bits.from-int(1) == (true,)
/// >>> bits.from-int(1, pad:8) == (false,) * 7 + (true,)
/// >>> bits.from-int(2) == (true, false)
/// >>> bits.from-int(254, pad:8) == (true,) * 7 + (false,)
/// >>> bits.from-int(255, pad:8) == (true,) * 8
#let from-int(n, pad:0) = {
let bin = ()
if n < 256 {
bin = bits-map.at(n)
} else {
let mod
while n > 0 {
(n, mod) = divmod(n)
bin.push(mod)
}
bin = bin.rev().map((bit) => (false, true).at(bit))
}
if bin.len() < pad {
bin = (false,) * (pad - bin.len()) + bin
}
return bin
}
/// >>> bits.from-str("0000") == (false,) * 4
/// >>> bits.from-str("101010") == (true, false) * 3
/// >>> bits.from-str("100000000") == (true,) + (false,) * 8
/// >>> bits.from-str("0011011101") == (false,false,true,true,false,true,true,true,false,true)
#let from-str(s, pad:0) = {
let bin = ()
for c in s {
bin.push(c == "1")
}
bin
}
#let from(n, pad:0) = if type(n) == "array" {
if n.len() < pad {
n = (false, ) * (pad - n.len()) + n
}
return n
} else if type(n) == "string" {
from-str(n, pad:pad)
} else {
from-int(n, pad:pad)
}
|
https://github.com/Myriad-Dreamin/tinymist | https://raw.githubusercontent.com/Myriad-Dreamin/tinymist/main/docs/tinymist/overview.typ | typst | Apache License 2.0 | #import "mod.typ": *
#show: book-page.with(title: "Overview of Service")
This document gives an overview of tinymist service, which provides a single integrated language service for Typst. This document doesn't dive in details unless necessary.
== Principles
Four principles are followed, as detailed in #cross-link("/principles.typ")[Principles].
- Multiple Actors
- Multi-level Analysis
- Optional Non-LSP Features
- Minimal Editor Frontends
== Command System
The extra features are exposed via LSP's #link("https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_executeCommand")[`workspace/executeCommand`] request, forming a command system. They are detailed in #cross-link("/commands.typ")[Command System].
== Additional Concepts for Typst Language
=== AST Matchers
Many analyzers don't check AST node relationships directly. The AST matchers provide some indirect structure for analyzers.
- Most code checks the syntax object matched by `get_deref_target` or `get_check_target`.
- The folding range analyzer and def-use analyzer check the source file on the structure named _lexical hierarchy_.
- The type checker checks constraint collected by a trivial node-to-type converter.
=== Type System
Check #cross-link("/type-system.typ")[Type System] for more details.
== Notes on Implementing Language Features
Five basic analysis like _lexical hierarchy_, _def use info_ and _type check info_ are implemented first. And all rest Language features are implemented based on basic analysis. Check #cross-link("/analyses.typ")[Analyses] for more details.
|
https://github.com/Lancern/resume-template | https://raw.githubusercontent.com/Lancern/resume-template/master/main-en.typ | typst | Creative Commons Zero v1.0 Universal | #import "resume.typ": *
#show: resume.with(
"<NAME>",
"123456789",
"<EMAIL>",
webpage: "https://hacker.me",
github-id: "Hacker",
)
= Education
#edu-item(
"Number One University",
"Bachelor",
"2016.08",
end-date: "2020.07",
major: "Software Engineering",
body: [
GPA: top 5%
]
)
#edu-item(
"Number Two University",
"Master",
"2020.08",
major: "Computer Science",
supervisor: "Old Hacker",
)
= Professional Skills
- *Programming Languages*: C / C++ / C\# / golang / Python / Rust / TypeScript / Zig
- *OS*: Linux / Windows
- *ISA*: x86_64 / ARMv8 / MIPS / CHERI / RISC-V
- *Others*: LLVM / CMake / git
= Awards
#award-item(
"ACM-ICPC 2018 EC-Final",
"2018.11",
"Gold Medal"
)
#award-item(
"ACM-ICPC 2018 World Final",
"2019.04",
"Gold Medal"
)
= Research Experiences
#resume-item(
"P != NP",
badge: "2020.12 - 2023.03",
subtitle: "Under peer review",
body: lorem(20),
)
= Work Experiences
#work-item(
"Google Corp.",
"Software Development Intern",
"2021.02",
end-date: "2022.03",
body: lorem(40),
)
#work-item(
"Microsoft Corp.",
"Software Development Intern",
"2022.03",
body: lorem(40),
)
= Hobby Projects
#develop-item(
"HackerA/ProjectA",
"Rust, C",
"Open-Source Contributor",
body: lorem(40),
)
#develop-item(
"HackerB/ProjectB",
"C++",
"Open-Source Contributor",
body: lorem(40),
)
#develop-item(
"Hacker/ProjectC",
"Agda",
"Owner",
body: lorem(40),
)
|
https://github.com/Walker-00/cs-eik | https://raw.githubusercontent.com/Walker-00/cs-eik/rust/pages/structure.typ | typst | Do What The F*ck You Want To Public License | #let text_style(contents) = [
#show link: underline
#set page(numbering: "1", number-align: center)
#set text(font: "Maple Mono", lang: "my")
#set heading(numbering: "1.1)")
#set par(justify: true)
#contents
] |
https://github.com/andreasKroepelin/lovelace | https://raw.githubusercontent.com/andreasKroepelin/lovelace/main/README.md | markdown | MIT License | # Lovelace
This is a package for writing pseudocode in [Typst](https://typst.app/).
It is named after the computer science pioneer
[Ada Lovelace](https://en.wikipedia.org/wiki/Ada_Lovelace) and inspired by the
[pseudo package](https://ctan.org/pkg/pseudo) for LaTeX.
Pseudocode is not a programming language, it doesn't have strict syntax, so
you should be able to write it however you need to in your specific situation.
Lovelace lets you do exactly that.
Main features include:
- arbitrary keywords and syntax structures
- optional line numbering
- line labels
- lots of customisation with sensible defaults
## Usage
- [Getting started](#getting-started)
- [Lower level interface](#lower-level-interface)
- [Line numbers](#line-numbers)
- [Referencing lines](#referencing-lines)
- [Indentation guides](#indentation-guides)
- [Spacing](#spacing)
- [Decorations](#decorations)
- [Algorithm as figure](#algorithm-as-figure)
- [Customisation overview](#customisation-overview)
- [Exported functions](#exported-functions)
### Getting started
Import the package using
```typ
#import "@preview/lovelace:0.3.0": *
```
The simplest usage is via `pseudocode-list` which transforms a nested list
into pseudocode:
```typ
#pseudocode-list[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
resulting in:
As you can see, every list item becomes one line of code and nested lists become
indented blocks.
There are no special commands for common keywords and control structures, you
just use whatever you like.
Maybe in your domain very uncommon structures make more sense?
No problem!
```typ
#pseudocode-list[
+ *in parallel for each* $i = 1, ..., n$ *do*
+ fetch chunk of data $i$
+ *with probability* $exp(-epsilon_i slash k T)$ *do*
+ perform update
+ *end*
+ *end*
]
```
### Lower level interface
If you feel uncomfortable with abusing Typst's lists like we do here, you can
also use the `pseudocode` function directly:
```typ
#pseudocode(
[do something],
[do something else],
[*while* still something to do],
indent(
[do even more],
[*if* not done yet *then*],
indent(
[wait a bit],
[resume working],
),
[*else*],
indent(
[go home],
),
[*end*],
),
[*end*],
)
```
This is equivalent to the first example.
Note that each line is given as one content argument and you indent a block by
using the `indent` function.
This approach has the advantage that you do not rely on significant whitespace
and code formatters can automatically correctly indent your Typst code.
### Line numbers
Lovelace puts a number in front of each line by default.
If you want no numbers at all, you can set the `line-numbering` option to
`none`.
The initial example then looks like this:
```typ
#pseudocode-list(line-numbering: none)[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
(You can also pass this keyword argument to `pseudocode`.)
If you do want line numbers in general but need to turn them off for specific
lines, you can use `-` items instead of `+` items in `pseudocode-list`:
```typ
#pseudocode-list[
+ normal line with a number
- this line has no number
+ this one has a number again
]
```
It's easy to remember:
`-` items usually produce unnumbered lists and `+` items produce numbered lists!
When using the `pseudocode` function, you can achieve the same using
`no-number`:
```typ
#pseudocode(
[normal line with a number],
no-number[this line has no number],
[this one has a number again],
)
```
#### More line number customisation
Other than `none`, you can assign anything listed
[here](https://typst.app/docs/reference/model/numbering/#parameters-numbering)
to `line-numbering`.
So maybe you happen to think about the Roman Empire a lot and want to reflect
that in your pseudocode?
```typ
#set text(font: "Cinzel")
#pseudocode-list(line-numbering: "I:")[
+ explore European tribes
+ *while* not all tribes conquered
+ *for each* tribe *in* unconquered tribes
+ try to conquer tribe
+ *end*
+ *end*
]
```
### Referencing lines
You can reference an inividual line of a pseudocode by giving it a label.
Inside `pseudocode-list`, you can use `line-label`:
```typ
#pseudocode-list[
+ #line-label(<start>) do something
+ #line-label(<important>) do something important
+ go back to @start
]
The relevance of the step in @important cannot be overstated.
```
When using `pseudocode`, you can use `with-line-label`:
```typ
#pseudocode(
with-line-label(<start>)[do something],
with-line-label(<important>)[do something important],
[go back to @start],
)
The relevance of the step in @important cannot be overstated.
```
This has the same effect as the previous example.
The number shown in the reference uses the numbering scheme defined in the
`line-numbering` option (see previous section).
By default, `"Line"` is used as the supplement for referencing lines.
You can change that using the `line-number-supplement` option to `pseudocode`
or `pseudocode-list`.
### Indentation guides
By default, Lovelace puts a thin gray (`gray + 1pt`) line to the left of each
indented block, which guides the reader in understanding the indentations, just
like a code editor would.
You can customise this using the `stroke` option which takes any value that is
a valid [Typst stroke](https://typst.app/docs/reference/visualize/stroke/).
You can especially set it to `none` to have no indentation guides.
The example from the beginning becomes:
```typ
#pseudocode-list(stroke: none)[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
#### End blocks with hooks
Some people prefer using the indentation guide to signal the end of a block
instead of writing something like "**end**" by having a small "hook" at the end.
To achieve that in Lovelace, you can make use of the `hook` option and specify
how far a line should extend to the right from the indentation guide:
```typ
#pseudocode-list(hooks: .5em)[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
]
```
### Spacing
You can control how far indented lines are shifted right by the `indentation`
option.
To change the space between lines, use the `line-gap` option.
```typ
#pseudocode-list(indentation: 3em, line-gap: 1.5em)[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
### Decorations
You can also add a title and/or a frame around your algorithm if you like:
#### Title
Using the `title` option, you can give your pseudocode a title (surprise!).
For example, to achieve
[CLRS style](https://en.wikipedia.org/wiki/Introduction_to_Algorithms),
you can do something like
```typ
#pseudocode-list(stroke: none, title: smallcaps[Fancy-Algorithm])[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
#### Booktabs
If you like wrapping your algorithm in elegant horizontal lines, you can do so
by setting the `booktabs` option to `true`.
```typ
#pseudocode-list(booktabs: true)[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
Together with the `title` option, you can produce
```typ
#pseudocode-list(booktabs: true, title: [My cool title])[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
```
By default, the outer booktab strokes are `black + 2pt`.
You can change that with the option `booktabs-stroke` to any valid
[Typst stroke](https://typst.app/docs/reference/visualize/stroke/).
The inner line will always have the same stroke as the outer ones, just with
half the thickness.
### Algorithm as figure
To make algorithms referencable and being able to float in the document,
you can use Typst's `figure` function with a custom `kind`.
```typ
#figure(
kind: "algorithm",
supplement: [Algorithm],
caption: [My cool algorithm],
pseudocode-list[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
)
```
If you want to have the algorithm counter inside the title instead (see previous
section), there is the option `numbered-title`:
```typ
#figure(
kind: "algorithm",
supplement: [Algorithm],
pseudocode-list(booktabs: true, numbered-title: [My cool algorithm])[
+ do something
+ do something else
+ *while* still something to do
+ do even more
+ *if* not done yet *then*
+ wait a bit
+ resume working
+ *else*
+ go home
+ *end*
+ *end*
]
) <cool>
See @cool for details on how to do something cool.
```
Note that the `numbered-title` option only makes sense when nesting your
pseudocode inside a figure with `kind: "algorithm"`, otherwise it produces
undefined results.
### Customisation overview
Both `pseudocode` and `pseudocode-list` accept the following configuration
arguments:
**option** | **type** | **default**
--- | --- | ---
[`line-numbering`](#line-numbers) | `none` or a [numbering](https://typst.app/docs/reference/model/numbering/#parameters-numbering) | `"1"`
[`line-number-supplement`](#more-line-number-customisation) | content | `"Line"`
[`stroke`](#indentation-guides) | stroke | `1pt + gray`
[`hooks`](#end-blocks-with-hooks) | length | `0pt`
[`indentation`](#spacing) | length | `1em`
[`line-gap`](#spacing) | length | `.8em`
[`booktabs`](#booktabs) | bool | `false`
[`booktabs-stroke`](#booktabs) | stroke | `2pt + black`
[`title`](#title) | content or `none` | `none`
[`numbered-title`](#algorithm-as-figure) | content or `none` | `none`
Until Typst supports user defined types, we can use the following trick when
wanting to set own default values for these options.
Say, you always want your algorithms to have colons after the line numbers,
no indentation guides and, if present, blue booktabs.
In this case, you would put the following at the top of your document:
```typ
#let my-lovelace-defaults = (
line-numbering: "1:",
stroke: none,
booktabs-stroke: 2pt + blue,
)
#let pseudocode = pseudocode.with(..my-lovelace-defaults)
#let pseudocode-list = pseudocode-list.with(..my-lovelace-defaults)
```
### Exported functions
Lovelace exports the following functions:
* `pseudocode`: Typeset pseudocode with each line as an individual content
argument, see [here](#lower-level-interface) for details.
Has [these](#customisation-overview) optional arguments.
* `pseudocode-list`: Takes a standard Typst list and transforms it into a
pseudocode.
Has [these](#customisation-overview) optional arguments.
* `indent`: Inside the argument list of `pseudocode`, use `indent` to specify
an indented block, see [here](#lower-level-interface) for details.
* `no-number`: Wrap an argument to `pseudocode` in this function to have the
corresponding line be unnumbered, see [here](#line-numbers) for details.
* `with-line-label`: Use this function in the `pseudocode` arguments to add
a label to a specific line, see [here](#referencing-lines) for details.
* `line-label`: When using `pseudocode-list`, you do *not* use `with-line-label`
but insert a call to `line-label` somewhere in a line to add a label, see
[here](#referencing-lines) for details.
|
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/011%20-%20Journey%20into%20Nyx/002_Desperate%20Stand.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"Desperate Stand",
set_name: "Journey into Nyx",
story_date: datetime(day: 16, month: 04, year: 2014),
author: "<NAME>",
doc
)
When I was caught stealing from the magister's study, I was given two choices. I could join the noble Akroan soldiers, or I could be executed. The magister must have been a wicked man, I thought, for he was sentencing me to death—I just got to choose the timetable.
It's true, I wouldn't have necessarily died in combat, but then the Nyxborn stabbed into my torso, its six sharp claws clenched into my body. My spear had been knocked from my hand and the strange creature that was centaur and kraken and spider threw me over my fellow soldiers into the sealed gates behind. I lay on the ground, my helmet turned and blocking some of my vision, unable to breathe. I might not have been destined to die in combat, but the Fates would be severing my thread just the same.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
Even as a young thief outside of the academies, you learned about the great heroes. How could you not? Their legends were always on the lips of travelers and soldiers eager to bask in the glory of great accomplishments, as if telling a story made them a part of it. All my life, I have heard of heroes like the brave Vinack, who felled a cyclops by reflecting the sun off his bracers into its massive eye, distracting it while he rammed a spear through its belly. I remember the exploits of Aesrias, the hero of Iroas, who knocked out the heads of a savage hydra so they would not multiply. Even today, there are whispers of great champions. Some speak of Solon, the man who braved a labyrinth to retrieve Dekella, the bident of Thassa, while others honor King <NAME> of Iretis, who ripped out his own eyes so he wouldn't see his wife and son murdered by treacherous leonin.
It wasn't difficult to see how these stories shaped the people, regardless of their truth. But they gave people something to believe in. They gave me, a poor orphan thief, something to strive for. As a thief, I pretended I was the king of the thieves, that my ordeal of liberating the coins of the evil merchant or braving the dangerous dungeon of the inn's storeroom would one day be the stories of my origins. The other orphans of the alleys laughed at me, but I didn't care. I knew I would one day be a living myth, a testament to the ages.
#figure(image("002_Desperate Stand/01.jpg", width: 100%), caption: [Gift of Immortality | Art by <NAME>], supplement: none, numbering: none)
Everyone knows the stories of Ky<NAME> and his irregulars, but no one remembers their names outside of their leader. These were the thoughts that would pass through my mind as I huddled for warmth under discarded cloth as it rained. It wasn't just the nobles who ignored me when they passed by, noses held high, but even the workers, or those who had little to spare, wouldn't dare look down on me. I resolved in my time on the streets that I wouldn't be ignored. I would be a legend and wouldn't give others the choice to ignore me. I would be greater than Kytheon.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
When I became a soldier I knew that my real story had begun. I was given the chance to improve my station and rise through the ranks to greatness. But I quickly learned I didn't know as much as I liked to believe. I was not yet an adult, although, having lived on my own, I considered myself one. But my instructors quickly remedied me of that delusion. Although I had only used a crude dagger to protect myself once or twice from the more violent alleyfolk, I had never used a sword. I was as surprised as they when I proved to be an excellent fighter, easily besting the others in my class and, once, the instructor. I got in a lucky strike, but the snickering of the class showed they didn't see it that way. As I improved, I saw the others stay behind. In a few months, I was to become an officer with a contingent of my own.
I found myself walking the streets and passing by those who were in my past position, starving in the shadows of an alley, but I almost instantly found myself not caring.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The Nyxborn were attacking. At least, this was the word from the wall. I was stationed in the city and, I'm ashamed to admit, I had yet to see real conflict. Although I could easily pass off as a hero to the locals, I was less convincing to my soldiers and unable to hide this from my superiors. I had ended several Returned and my company had outnumbered three minotaur a few months before, but that was the only legend I could claim. Then, as we rushed to the gate, I was excited, ready to enter the fray.
They were approaching from the north, which would place them on the bridge. We would meet them on the bridge and create a choke point, instructing the guards to close the doors behind us, echoing the tactics used by Kytheon Iora and his irregulars when they fought the cyclops at Akros. But even the most elaborate retellings didn't paint the cyclops as terrifying as the Nyxborn before us.
They were not just one monster. They were all sorts of creatures. Some looked human. Others like satyr. I could make out the heads of hydras and the claws of chimera. They were unified only in that they all had skin that shimmered of the night's sky, the trait we had come to know of the messengers of the gods. Why did the gods attack us now? Why did they send us their emissaries only to turn them against us? This was not an impassive act of negligence, nor a force of nature. These were agents of the gods sent to do their bidding.
It was then that I realized the error in my judgment. In my foolishness, I wanted someone to misremember the glory of my actions, to repeat my feats and try to pass them off as their own. I had rushed into a fight against an army of unknown size and strength with only seven other soldiers.
We held the line in a phalanx formation. We made a wall of shields, some kneeling while I and the remaining soldiers stood, all attacking the Nyxborn. The tactic worked beautifully. We held our ground. We did not need to kill the Nyxborn but simply knock them off the edge, sending them to their deaths.
#figure(image("002_Desperate Stand/02.jpg", width: 100%), caption: [Desperate Stand | Art by Raymond Swanland], supplement: none, numbering: none)
Yet, some men fell. Reinforcements arrived and the guards sealed the gates behind them, but my relief at the sight of new soldiers quickly faded when I saw the same inexperienced fighters I had passed up in training. These were the weakest of my class. My superiors had either run out of soldiers fighting other fronts or meant us all to die there. As I kept fighting, jabbing a Nyxborn minotaur over the side, I knew I had to survive. I did not want to be lost in a story, a nameless entity to be a background character in someone else's epic. I could not fall there, although if I did I needed to die last, spectacularly, so I would be the one remembered. My name needed to be spoken by those trying to pass off the weight of my legend as their own.
We kept fighting until there were no reinforcements left. It was then that I—an officer who had brought herself out of the gutter—was grabbed by the claw of a Nyxborn, stabbing me six times in the process, and thrown like a child's toy against the gates that didn't open.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
You never get a true sense of the hero from the poets. In the #emph[Theriad] ,the brave soldiers relish battle without giving death or dying a second thought. But in actual combat, outside of the perverse reverence of it, there is a moment of reality that sinks in when a soldier is faced with death. A poet never sees it. They write sitting on pillows, drinking wine. A soldier sees that moment and either dies or survives—and then must quickly forget, lest that true moment of death breaks her.
I saw that moment, unable to take in deep breaths due to the pain. I realized the pursuit of fame and fortune was pointless. I knew this because I did not even see Erebos, lording over the battle, having picked me out as his mortal nemesis. Athreos, the guide of the dead, was nowhere to be seen, my passing not even worth his attendance.
And then, as the last soldier fell, the Nyxborn retreated. What cruel joke was this? My soldiers' rent carcasses on the bridge and in the chasm below, and for what purpose? Moments passed, but possibly hours, but probably seconds, and the gates reopened, the swinging door pushing my body carelessly to the side. Two clerics ran out, a man and a woman, with two very shaky guards. They began to triage the wounded. I was unable to speak, prone on the ground, losing consciousness, as all faded into blackness.
I was turned over, my helmet removed. The man began to remove my armor and the woman took out a small dagger. Before I protested, not that I could, she stabbed me in the chest and guided a hollow reed into the wound. Suddenly, I could breathe again. The man used magic, his hands glowing white hot over my other wounds, and I could feel them healing. The woman coached me to breathe as she covered and uncovered the end of the reed as I did. Eventually, more clerics arrived and they placed me on a cart, the woman in the back still talking to me as they rushed me to a Pharikan temple.
#figure(image("002_Desperate Stand/03.jpg", width: 100%), caption: [Temple of Malady | Art by <NAME>], supplement: none, numbering: none)
She talked about how what I had done was heroic, but she didn't know I had led my soldiers into a slaughter, and that even if I had fought more intelligently, that battle was pointless in the end.
Maybe it was better not to be a hero, to be in the background, not trying to make myself into something I was not.
Maybe true heroes just let their names fade away.
#figure(image("002_Desperate Stand/04.jpg", height: 35%), caption: [], supplement: none, numbering: none)
|
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/grotesk-cv/0.1.0/metadata.typ | typst | Apache License 2.0 | #let first-name = "Miles"
#let last-name = "Dyson"
#let sub-title = ""
#let profile-image = "template/img/portrait.png"
#let language = "es"
#if language == "en" {
sub-title = "Software Engineer with a knack for human-friendly AI solutions"
} else if language == "es" {
sub-title = "Ingeniero de software con un talento para soluciones de IA centradas en el usuario"
}
#let info = (
address: "Los Angeles, CA",
telephone: "+1 (555) 123-4567",
email: "<EMAIL>",
linkedin: "linkedin.com/in/milesdyson",
github: "github.com/skynetguy",
)
|
https://github.com/typst-community/typst.js | https://raw.githubusercontent.com/typst-community/typst.js/main/test/example.typ | typst | Apache License 2.0 | = Introduction
In this report, we will explore the
various factors that influence _fluid
dynamics_ in glaciers and how they
contribute to the formation and
behavior of these natural structures.
#metadata("This is a note") <note> |
https://github.com/Error-418-SWE/Documenti | https://raw.githubusercontent.com/Error-418-SWE/Documenti/src/2%20-%20RTB/Documentazione%20interna/Verbali/23-11-26/23-11-26.typ | typst | #import "/template.typ":*
#show: project.with(
date: "26/11/23",
subTitle: "Meeting di retrospettiva e pianificazione",
docType: "verbale",
authors: (
"<NAME>",
),
missingMembers: (
"<NAME>", "<NAME>"
),
timeStart: "15:00",
timeEnd: "16:30",
);
= Ordine del giorno
- Retrospettiva sprint 3;
- Pianificazione sprint 4.
== Retrospettiva sprint 3 e pianificazione sprint 4
La valutazione dello sprint è in generale positiva. La riunione con il Proponente si è svolta in maniera rapida e precisa. La visione del progetto che è stata esposta tramite gli use case è stata utile al gruppo e al Proponente.
Sono stati considerati i punti critici della retrospettiva precedente, riuscendo così ad avere una maggiore interazione da parte di quasi tutti i membri del gruppo durante l'incontro con il Proponente.
Si è discussa la necessità di accorciare la durata dei meeting e di pianificare in maggior dettaglio lo sprint successivo. Inoltre, si è sottolineata la necessità di dettagliare i singoli ticket in modo da ottenere una visione coerente dei grafici di Gantt su Jira.
Il gruppo che si occupa di aggiornare il documento "Norme di Progetto" ha applicato modifiche sostanziali in modo da aderire ad uno standard più aggiornato (ISO/IEC 12207:2017 anziché ISO/IEC 12207:1995).
Il gruppo ha quindi provveduto a concludere il meeting con un veloce brainstorming mirato a fissare i principali obbiettivi dello sprint 4 in modo da permettere al responsabile di trasformare la board Miro in ticket Jira che rispettino le Norme di Progetto.
= Azioni da intraprendere
- Ultimare la prima versione dell'Analisi dei Requisiti;
- Scrivere il consuntivo dello sprint 3 e il preventivo per lo sprint 4;
- Continuare il lavoro sulle Norme di Progetto;
- Valutare un meeting con il professor Cardin per valutare la correttezza del lavoro svolto finora;
- Continuare il processo di studio del linguaggio Three.js per iniziare i lavori sul PoC. |
|
https://github.com/Tetragramm/flying-circus-typst-template | https://raw.githubusercontent.com/Tetragramm/flying-circus-typst-template/main/README.md | markdown | MIT License | # The `flyingcircus` Package
<div align="center">Version 3.2.0</div>
Do you want your homebrew to have the same fancy style as the Flying Circus book? Do you want a simple command to generate a whole aircraft stat page, vehicle, or even ship? I'll bet you do! Take a look at the Flying Circus Aircraft Catalog Template.
## Acknowledgments and Useful Links
Download the fonts from [HERE](https://github.com/Tetragramm/flying-circus-typst-template/archive/refs/heads/Fonts.zip). Install them on your computer, upload them to the Typst web-app (anywhere in the project is fine) or use the Typst command line option --font-path to include them.
Based on the style and work (with the permission of) <NAME> for the [Flying Circus RPG](https://opensketch.itch.io/flying-circus).
Integrates with the [Plane Builder](https://tetragramm.github.io/PlaneBuilder/index.html). Just click the Catalog JSON button at the bottom to save what you need for this template.
Same with the [Vehicle Builder](https://tetragramm.github.io/VehicleBuilder/).
Or check out the [Discord server](https://discord.gg/HKdyUuvmcb).
## Getting Started
These instructions will get you a copy of the project up and running on the typst web app.
```typ
#import "@preview/flyingcircus:3.2.0": *
#show: FlyingCircus.with(
Title: title,
Author: author,
CoverImg: image("images/cover.png"),
Dedication: [It's Alive!!! MUAHAHAHA!],
)
#FCPlane(read("My Plane_stats.json"), Nickname:"My First Plane")
```
## Usage
The first thing is the FlyingCircus style.
```typ
#import "@preview/flyingcircus:3.0.0": *
/// Defines the FlyingCircus template
///
/// - Title (str): Title of the document. Goes in metadata and on title page.
/// - Author (str): Author(s) of the document. Goes in metadata and on title page.
/// - CoverImg (image): Image to make the first page of the document.
/// - Description (str): Text to go with the title on the title page.
/// - Dedication (str): Dedication to go down below the title on the title page.
/// - body (content)
/// -> content
// Example
#show: FlyingCircus.with(
Title: title,
Author: author,
CoverImg: image("images/cover.png"),
Dedication: [It's Alive!!! MUAHAHAHA!],
)
```
Next is the FCPlane function for making plane pages.
```typ
/// Defines the FlyingCircus Plane page. Always on a new page. Image optional.
///
/// - Plane (str | dictionary): JSON string or dictionary representing the plane stats.
/// - Nickname (str): Nickname to go under the aircraft name.
/// - Img (image | none): Image to go at the top of the page. Set to none to remove.
/// - BoxText (dictionary): Pairs of values to go in the box over the image. Does nothing if no Img provided.
/// - BoxAnchor (str): Which anchor of the image to put the box in? Sample values are "north", "south-west", "center".
/// - DescriptiveText (content)
/// -> content
// Example
#FCPlane(
read("Basic Biplane_stats.json"),
Nickname: "Bring home the bacon!",
Img: image("images/Bergziegel_image.png"),
BoxText: ("Role": "Fast Bomber", "First Flight": "1601", "Strengths": "Fastest Bomber"),
BoxAnchor: "north-east",
)[
#lorem(100)
]
```
The FCVehicleSimple is for when you want to put multiple vehicles on a page.
```typ
/// Defines the FlyingCircus Simple Vehicle. Not always a full page. Image optional.
///
/// - Vehicle (str | dictionary): JSON string or dictionary representing the Vehicle stats.
/// - Img (image): Image to go above the vehicle. (optional)
/// - DescriptiveText (content)
/// -> content
#FCVehicleSimple(read("Sample Vehicle_stats.json"))[#lorem(120)]
```
FCVehicleFancy is a one or two page vehicle that looks nicer but takes up more space.
```typ
/// Defines the FlyingCircus Vehicle page. Always on a new page. Image optional.
/// If the Img is provided, it will take up two facing pages, otherwise only one, but a full page, unlike the Simple.
///
/// - Vehicle (str | dictionary): JSON string or dictionary representing the Vehicle stats.
/// - Img (image | none): Image to go at the top of the first page. Set to none to remove.
/// - TextVOffset (length): How far to push the text down the page. Want to do that inset text thing the book does? You can, the text can overlap with thte image. Does nothing if no Img provided.
/// - BoxText (dictionary): Pairs of values to go in the box over the image. Does nothing if no Img provided.
/// - BoxAnchor (str): Which anchor of the image to put the box in? Sample values are "north", "south-west", "center".
/// - FirstPageContent (content): Goes on the first page. If no image is provided, it is not present.
/// - AfterContent (content): Goes after the stat block. Always present.
/// -> content
// Example
#FCVehicleFancy(
read("Sample Vehicle_stats.json"),
Img: image("images/Wandelburg.png"),
TextVOffset: 6.2in,
BoxText: ("Role": "Fast Bomber", "First Flight": "1601", "Strengths": "Fastest Bomber"),
BoxAnchor: "north-east",
)[
#lorem(100)
][
#lorem(100)
]
```
Last of the vehicles, FCShip is for boats like Into the Drink.
```typ
/// Defines the FlyingCircus Ship page. Always on a new page. Image optional.
///
/// - Ship (str | dictionary): JSON string or dictionary representing the Ship stats.
/// - Img (image | none): Image to go at the top of the page. Set to none to remove.
/// - DescriptiveText (content): Goes below the name and above the stats table.
/// - notes (content): Goes in the notes section.
/// -> content
// Example: No builder for Ships, so you'll have to put it in your own JSON, or just a dict, like this.
#let ship_stats = (
Name: "<NAME>",
Speed: 5,
Handling: 15,
Hardness: 9,
Soak: 0,
Strengths: "-",
Weaknesses: "-",
Weapons: (
(Name: "x2 Light Howitzer", Fore: "x1", Left: "x2", Right: "x2", Rear: "x1"),
(Name: "x6 Pom-Pom Gun", Fore: "x2", Left: "x3", Right: "x3", Rear: "x2", Up: "x6"),
(Name: "x2 WMG", Left: "x1", Right: "x1"),
),
DamageStates: ("", "-1 Speed", "-3 Guns", "-1 Speed", "-3 Guns", "Sinking"),
)
#FCShip(
Img: image("images/Macchi Frigate.png"),
Ship: ship_stats,
)[
#lorem(100)
][
#lorem(5)
]
```
Additional functions include FCWeapon
```typ
/// Defines the FlyingCircus Weapon card. Image optional.
///
/// - Weapon (str | dictionary): JSON string or dictionary representing the Weapon stats.
/// - Img (image | none): Image to go above the card. Set to none to remove.
/// - DescriptiveText (content): Goes below the name and above the stats table.
/// -> content
//Example
#FCWeapon(
(Name: "Rifle/Carbine", Cells: (Hits: 1, Damage: 2, AP: 1, Range: "Extreme"), Price: "Scrip", Tags: "Manual"),
Img: image("images/Rifle.png"),
)[
Note that you can set the text in the cell boxes to whatever you want.
]
```
KochFont:
```typ
/// Sets the tex to the Koch Fette FC font for people who don't want to remember the font name.
///
/// - body (content)
/// - ..args: Any valid argument to the text function
/// -> content
// Example
#KochFont(size: 18pt)[Vehicles]
```
and HiddenHeading, which is for adding to the table of contents without actually putting words on the page.
```typ
//If we don't want all our planes at the top level of the table of contents. EX: if we want
// - Intro
// - Story
// - Planes
// - First Plane
// We break the page, and create a HiddenHeading, that doesn't show up in the document (Or a normal heading, if that's what you need)
//Then we set the heading offset to one so everything after that is indented one level in the table of contents.
#pagebreak()
#HiddenHeading[= Vehicles]
#set heading(offset: 1)
New in Version 3.2.0, the FCPlaybook (+utilities), FCNPCShort, and FCAirshipShort
//This creates pages like the playbook. Largely customizable, for say, chariots of steel versions.
// - Name (str) The name of the Playbook
// - Subhead (str) The text that goes with the name in the header
// - Character (content) This is the entire left column
// - Questions (content) This is the top section of the right column, for motivation and trust questions.
// - Starting (content) Middle section of the right column. Starting Assets, Burdens, Planes, Vices, ect
// - Stats (content) Bottom section of the right column. Just the four FCPStatTable calls (and a colbreak, probably)
// - StatNames () Define the stats to draw circles for on the top part of the 2nd page
// - Triggers (content) List of triggers, includes section, because not all playbooks use the same text there.
// - Vents (content) List of Vents, customizable like Triggers
// - Intimacy (content) Bottom section of the left column, for the intimacy move
// - Moves (content) The entire right column of the second page
//
// Utilities for use with FCPlaybook
// - FCPRule() The full-column horizontal line
// - FCPSection(name: str)[content] The section break
// - name (str) The fancy font name on the lft side of the section line, can be blank.
// - content The italicized text on the right side of the line, can be blank.
// - FCPStatTable(name, tagline, stats) For creating Stat tables
// - name (str) The name of the profile, to be rendered in smallcaps
// - tagline (str) The tagline of the profile, italicized
// - stats (dict) A dictionary of stats ex (Hard:"+2") Keys are first row, values are second row, no restrictions otherwise.
#FCPlaybook(
Name: str,
Subhead: str,
Character: content,
Questions: content,
Starting: content,
Stats: content,
StatNames: (),
Triggers: content,
Vents: content,
Intimacy: content,
Moves: content,
)
// This creates a short NPC profile like that in the back of the aircraft catalogue
// - plane (dict) Contains the keys
// - Name
// - Nickname
// - Price (optional)
// - Upkeep (optional)
// - Used (optional)
// - Speeds
// - Handling
// - Structure
// - img (image) Image to draw
// - img_scale (number) What scale to draw the image, relative to the column size
// - img_shift_dx (percent) How far to shift the image in the x direction
// - img_shift_dy (percent) How far to shift the image in the y direction
// - content The decriptive text to go above the stat block
#FCShortNPC(
plane,
img: none,
img_scale: 1.5,
img_shift_dx: -10%,
img_shift_dy: -10%,
content
)
// This creates a short airship profile like that in the back of the aircraft catalogue
// - airship (dict) Contains the keys
// - Name
// - Nickname
// - Price (optional)
// - Upkeep (optional)
// - Used (optional)
// - Speed
// - Lift
// - Handling
// - Toughness
// - img (image) Image to draw
// - img_scale (number) What scale to draw the image, relative to the column size
// - img_shift_dx (percent) How far to shift the image in the x direction
// - img_shift_dy (percent) How far to shift the image in the y direction
// - content The decriptive text to go above the stat block
#FCShortAirship(
airship,
img: none,
img_scale: 1.5,
img_shift_dx: -10%,
img_shift_dy: -10%,
content
)
```
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/github-pages/docs/readme-draft.typ | typst | Apache License 2.0 |
// #import "@preview/canvas:0.1.0": canvas
// #import "/contrib/typst/typst-canvas/lib.typ": canvas
#import "graphs.typ": data-flow-graph
// The project function defines how your document looks.
// It takes your content and some metadata and formats it.
// Go ahead and customize it to your liking!
#let project(title: "", authors: (), body) = {
// Set the document's basic properties.
let style_color = rgb("#ffffff")
set document(author: authors, title: title)
set page(
numbering: none,
number-align: center,
height: auto,
background: rect(fill: rgb("#343541"), height: 100%, width: 100%),
)
set text(font: "Linux Libertine", lang: "en", fill: style_color)
show link: underline
// math setting
// show math.equation: set text(weight: 400)
// code block setting
show raw: it => {
if it.block {
rect(
width: 100%,
inset: (x: 4pt, y: 5pt),
radius: 4pt,
fill: rgb(239, 241, 243),
[
#set text(fill: rgb("#000000"))
#it
],
)
} else {
it
}
}
// Main body.
set par(justify: true)
body
}
#show: project
Typst.ts is a project dedicated to bring the power of #link("https://github.com/typst/typst")[Typst] to the world of JavaScript. In short, it composes ways to compile and render your Typst document. In the scope of server-side rendering collaborated by #text(fill: rgb("#3c9123"), "server") and #text(fill: blue, "browser"), there would be a data flow like this:
#figure(
data-flow-graph(),
caption: [Browser-side module needed: $dagger$: compiler; $dagger.double$: renderer. ],
numbering: none,
)
Specifically, it provides several typical approaches:
- Compile Typst documents to browser-friendly SVG documents.
- Precompile Typst documents to a compressed artifact.
- Run the typst compiler directly in browser, like #link("https://typst.app")[typst.app].
// Typst.ts allows you to independently run the Typst compiler and exporter (renderer) in your browser.
// You can:
// - locally run the compilation via `typst-ts-cli` to get a precompiled document,
// - or use `reflexo-typst` to build your backend programmatically.
// - build your frontend using the lightweight TypeScript library `typst.ts`.
// - send the precompiled document to your readers' browsers and render it as HTML elements.
Visualized Feature:
- Artifact Streaming
- Incremental Rendering
- Incremental Font Transfer
== Application
- #link("https://myriad-dreamin.github.io/typst.ts/")[A Website built with Typst.ts]
- #link("https://github.com/Enter-tainer/typst-preview-vscode")[Instant VSCode Preview Plugin]
- #link("https://www.npmjs.com/package/hexo-renderer-typst")[Renderer Plugin for Hexo, a Blog-aware Static Site Generator]
- Renderer/Component Library for #link("https://www.npmjs.com/package/@myriaddreamin/typst.ts")[JavaScript], #link("https://www.npmjs.com/package/@myriaddreamin/typst.react")[React], and #link("https://www.npmjs.com/package/@myriaddreamin/typst.angular")[Angular]
== Installation
See https://github.com/Myriad-Dreamin/typst.ts/releases for precompiler and npm packages in Usage: Renderer section for renderer.
== Usage
== CLI (Precompiler)
Run Compiler Example:
```shell
typst-ts-cli compile --workspace "fuzzers/corpora/math" --entry "fuzzers/corpora/math/main.typ"
```
Help:
```shell
$ typst-ts-cli --help
The cli for typst.ts.
Usage: typst-ts-cli [OPTIONS] [COMMAND]
Commands:
compile Run compiler. [aliases: c]
completion Generate shell completion script
env Dump Client Environment.
font Commands about font for typst.
help Print this message or the help of the given subcommand(s)
package Commands about package for typst.
Options:
-V, --version Print Version
--VV <VV> Print Version in format [default: none] [possible values: none, short, full, json, json-plain]
-h, --help Print help
```
Compile Help:
```shell
$ typst-ts-cli compile --help
Run compiler.
Usage: typst-ts-cli compile [OPTIONS] --entry <ENTRY>
Compile options:
-w, --workspace <WORKSPACE> Path to typst workspace [default: .]
--watch Watch mode
--dynamic-layout Generate dynamic layout representation. Note: this is an experimental feature and will be merged as format `dyn-svg` in the future
--trace <TRACE> Enable tracing. Possible usage: --trace=verbosity={0..3} where verbosity: {0..3} -> {warning, info, debug, trace}
-e, --entry <ENTRY> Entry file
--format <FORMAT> Output formats, possible values: `json`, `pdf`, `svg`, `json_glyphs`, `ast`, `ir`, and `rmp`
-o, --output <OUTPUT> Output to directory, default in the same directory as the entry file [default: ]
--font-path <DIR> Add additional directories to search for fonts
```
Package Help:
```shell
$ typst-ts-cli package --help
Commands about package for typst.
Usage: typst-ts-cli package <COMMAND>
Commands:
doc Generate documentation for a package
help Print this message or the help of the given subcommand(s)
link Link a package to local data path
list List all discovered packages in data and cache paths
unlink Unlink a package from local data path
Options:
-h, --help Print help
```
==== Renderer <renderer-example>
The renderer accepts an input in artifact format and renders the document as HTML elements.
Import Typst.ts in your project:
- Using #link("https://www.npmjs.com/package/@myriaddreamin/typst.ts")[\@myriaddreamin/typst.ts]
```ts
import { createTypstRenderer } from '@myriaddreamin/typst.ts';
const renderer = createTypstRenderer();
```
- Using #link("https://www.npmjs.com/package/@myriaddreamin/typst.react")[\@myriaddreamin/typst.react]
```tsx
import { TypstDocument } from '@myriaddreamin/typst.react';
export const App = (artifact: string) => {
return (
<div>
<h1>Demo: Embed Your Typst Document in React</h1>
<TypstDocument fill="#343541" artifact={artifact} />
</div>
);
};
```
- Using #link("https://www.npmjs.com/package/@myriaddreamin/typst.angular")[\@myriaddreamin/typst.angular]
In the module file of your awesome component.
```ts
/// component.module.ts
import { TypstDocumentModule } from '@myriaddreamin/typst.angular';
```
Using directive `typst-document` in your template file.
```html
<typst-document fill="#343541" artifact="{{ artifact }}"></typst-document>
```
- Using #link("https://www.npmjs.com/package/@myriaddreamin/typst.vue3")[\@myriaddreamin/typst.vue3]
Coming soon.
== Development (Build from source)
=== Renderer Example
Note: you could build from source with/without wasm-pack.
Note: see [Troubleshooting WASM Build](docs/troubleshooting-wasm-build.md) for (especially) *Arch Linux* users.
Note: Since we use turborepo for `>=v0.4.0` development, if you are the earlier developer of `typst.ts`, please clean up all of your node_modules and dist folders before running the commands.
```shell
# Install and build the renderer
$ yarn install && yarn build:pkg
# Build the example artifacts
$ yarn corpus
# Run development server
$ yarn dev
```
And open `http://127.0.0.1:20810` in your browser.
You can also run `yarn run build:core` instead of `yarn run build:pkg` to build
core library (`@myriaddreamin/typst.ts`) and avoid building the WASM modules from source. |
https://github.com/flaribbit/indenta | https://raw.githubusercontent.com/flaribbit/indenta/master/demo.typ | typst | MIT License | #import "lib.typ": fix-indent
#set par(first-line-indent: 2em)
#show: fix-indent()
Indent
= Title 1
== Section 1
Indent
Indent
== Section 2
#figure(rect(),caption: lorem(2))
no indent
#figure(rect(),caption: lorem(2))
$"Indent"$
+ item
+ item
Indent
= Title 2
$ f(x) $
$ f(x) $
no indent
Indent
$ f(x) $
$ f(x) $
Indent
#table()[table]
Indent
```py
print("hello")
```
#raw("Indent") // https://github.com/flaribbit/indenta/issues/6
`Indent`
= Title 3
*Indent* // https://github.com/flaribbit/indenta/issues/9
#quote(block: true, attribution: [Test])[An apple a day keeps the doctor away.]
Indent
|
https://github.com/francois-rozet/postr | https://raw.githubusercontent.com/francois-rozet/postr/master/README.md | markdown | # Postr
A minimal research poster template in Typst.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.