repo
stringlengths 26
115
| file
stringlengths 54
212
| language
stringclasses 2
values | license
stringclasses 16
values | content
stringlengths 19
1.07M
|
|---|---|---|---|---|
https://github.com/BreakingLead/note | https://raw.githubusercontent.com/BreakingLead/note/main/Conlang/conlang.typ | typst | #import "@preview/ascii-ipa:2.0.0": *
#set page(flipped: true)
#show heading: set align(center)
#show table.cell.where(y:0): it => ([
*#it*
] , [ah])
= Language Reference
== Phonetics
#table(align: horizon, columns: (12),
table.header(
[],[Bilabial],[],[Labiodental],[],[Dental],[],[Alveolar],[],[Postalveolar],[],[Retroflex],[],[Palatal],[],[Velar],[],[Uvular],[Pharyngeal],[],[Glottal],[]),
[p],[b],[t],[d],[ʈ],[ɖ],[c],[ɟ],[k],[ɡ],[q],[ɢ],[ʔ]
) |
|
https://github.com/HarryLuoo/sp24 | https://raw.githubusercontent.com/HarryLuoo/sp24/main/math321/hw8.typ | typst | #set page(margin: (x: 0.5cm, y: 0.5cm),numbering: "1/1", columns: 1, flipped: false)
= HW8, <NAME> <EMAIL>
== 1 (a)
$ (diff (x,y))/(diff(u,v) )= det mat(1,1;1,-1) = #rect(inset: 8pt)[ $ display(-2)$ ] $
== (b)
$ dif x dif y = |(diff (x,y))/(diff(u,v) )|dif u dif v = #rect(inset: 8pt)[ $ display(2 dif u dif v )$ ] $
#line(length: 100%)
== 2.(a)
$ (diff (x,y))/(diff(u,v) )= det mat(v,u;1/v,-u/v^(2)) = #rect(inset: 8pt)[ $ display((-2u) / v)$ ] $
== (b)
$ dif x dif y = |(diff (x,y))/(diff(u,v) )|dif u dif v =#rect(inset: 8pt)[ $ display((2u) / v dif u dif v )$ ] $
#line(length: 100%)
== 3.
For $T(u,v) = (u^2-v^2,2 u v), u in [0,1], v in [0,1]$, we know:
$x= u^2-v^2, y= 2u v$, and the Jacobian is $(diff (x,y))/(diff(u,v) )= det mat(2u,-2v; 2v, 2u) = 4 u^2 + 4 v^2$
Thus, $ integral integral_(R)(x+y) dif x dif y &= integral_(0)^(1) integral_(0)^(1) (u^2-v^2+2u v) dot 4(u^2 + v^2)dif u dif v \ &= 4 integral_(0)^(1) integral_(0)^(1) u^4 - v^4 + 2u^(3) v + 2u v^(3) dif u dif v \
&=4integral_(0)^(1) 1/5+v/2+v^(3) -v^(4) dif v\
&= 4* 1/2 = #rect(inset: 8pt)[ $ display(2)$ ] $
#line(length: 100%)
== 4.
Considering the change of variables $x = a u, y = b v, z = c w$,\
The Jacobian is $(diff (x,y,z))/(diff(u,v,w) )= det mat(a,0,0;0,b,0;0,0,c) = a b c$
therefore, $ integral integral integral_E 1 dif V = integral integral integral_D a b c dif u dif v dif w &=^"from symmetry" 8integral_(0)^(pi/2) integral_(0)^(pi/2) integral_(0)^(1)a b c rho^2 sin phi dif rho dif phi dif theta \
&= 8 a b c integral_(0)^(pi/2) integral_(0)^(pi/2) lr(1/3 rho ^(3)sin phi|)_(rho=0)^(rho = 1) dif phi dif theta \
&= 8 a b c integral_(0)^(pi/2) lr((-1/3 cos phi) |)_0^(pi/2)dif theta\
&=8 a b c dot integral_(0)^(pi/2)1/3 dif theta \
&= 8 a b c dot 1/3 dot pi/2 = #rect(inset: 8pt)[ $ display(4pi/3 a b c )$ ] $ |
|
https://github.com/bionick7/kiergergaard-pillars | https://raw.githubusercontent.com/bionick7/kiergergaard-pillars/master/lcp2pdf.typ | typst |
// ================================== DATA ===================================
#let content_dir = "content_Buona_Sera_ONRYO"
#let frames = json(content_dir + "/frames.json").map(d => d + (file_source: "frames"))
#let weapons = json(content_dir + "/weapons.json").map(d => d + (file_source: "weapons"))
#let systems = json(content_dir + "/systems.json").map(d => d + (file_source: "systems"))
#let mods = json(content_dir + "/mods.json").map(d => d + (file_source: "weapon_mods"))
#let manufacturers = json(content_dir + "/manufacturers.json").map(d => d + (file_source: "manufacturers"))
#let tag_lib = (json("_manual_add_data/core_tags.json") + json("content/tags.json")).map(d => d + (file_source: "tags"))
#let core_bonuses = json(content_dir + "/core_bonuses.json").map(d => d + (file_source: "core_bonuses"))
#let pilot_gear = json(content_dir + "/pilot_gear.json").map(d => d + (file_source: "pilot_gear"))
#let talents = json(content_dir + "/talents.json").map(d => d + (file_source: "talents"))
#let equipment = weapons + systems + mods
#let LIGHT_RED = rgb("#f5253b")
#let DEFAULT_RED = rgb("c22026")
#let DARK_RED = rgb("#4e0000")
#let GLYPHS = (
// Range
Range: 0xe937,
Burst: 0xe938,
Cone: 0xe939,
Line: 0xe93a,
Blast: 0xe95b,
Threat: 0xe957,
// Dammage
Burn: 0xe93c,
Energy: 0xe93d,
Explosive: 0xe93e,
Heat: 0xe93f,
Kinetic: 0xe940,
Variable: 0xe941,
variable: 0xe941,
// Sizes
Size_half: 0xe954,
Size1: 0xe950,
Size2: 0xe951,
Size3: 0xe952,
// Sizes
Artillery: 0xe94b,
Controller: 0xe94c,
Striker: 0xe94d,
Support: 0xe94e,
Defender: 0x94f,
// Talents
Talent1: 0xe95c,
Talent2: 0xe95d,
Talent3: 0xe95e,
)
#let STAT_DISPLAY = (
size: "Size",
structure: "Structure",
stress: "Stress",
armor: "Armor",
edef: "E-Defense",
evasion: "Evasion",
heatcap: "Heat",
repcap: "Repair",
save: "Save Target",
sensor_range: "Sensors",
speed: "Speed",
hp: "HP",
tech_attack: "Tech Attack",
sp: "System Points",
)
#let MOUNT_NAMES = (
Aux: "AUXILIARY",
Main: "MAIN MOUNT",
Flex: "FLEX MOUNT",
Heavy: "HEAVY MOUNT",
"Aux/Aux": "AUX/AUX",
"Main/Aux": "MAIN/AUX",
)
#let COLOR_PALETTE = (
weapon: (rgb("#000000"), rgb("#f2f2f2")),
system: (rgb("#68bd45"), rgb("#e1f2da")),
mod: (rgb("#68bd45"), rgb("#e1f2da")),
tech: (rgb("#7e2477"), rgb("#f2e9f1")),
reaction: (rgb("#0b7675"), rgb("#e7f1f1")),
ai: (rgb("#d60000"), rgb("#fde8e7")),
protocol: (rgb("#d75000"), rgb("#fceee5")),
traits: (DEFAULT_RED, rgb("#f9e9e9")),
pilot_gear: (rgb("#471016"), rgb("#ede7e8")),
)
// ================================== STYLING ===================================
#let USE_A3 = false
#let on_left_page(loc) = {calc.even(loc.page())}
#let TRAINGLE_WIDTH = 5cm
#let TRAINGLE_HEIGHT = 3cm
#let style(doc) = [
#show heading.where(level: 1): it => (
align(center, text(
size: 24pt,
fill: DEFAULT_RED,
strong(it)
))
)
#set text(
font: "DM Sans",
overhang: true
)
#set par(
leading: 4pt,
)
#set page(
margin: (left: 2em, right: 4.5em, top: 2em, bottom: 2em),
background: locate(loc => {
let chapter = query(selector(heading).before(loc), loc)
if (on_left_page(loc)) {
place(left + bottom, polygon(
fill: DEFAULT_RED,
(TRAINGLE_WIDTH, 100%),
(0cm, 100% - TRAINGLE_HEIGHT),
(0cm, 100%),
))
place(left + bottom,
dy: 0.1cm,
line(
start: (TRAINGLE_WIDTH + 0.7cm, 100%),
angle: calc.atan(TRAINGLE_HEIGHT / TRAINGLE_WIDTH) + 180deg,
length: 10cm,
stroke: 0.2cm + DEFAULT_RED
))
} else {
place(right + bottom, polygon(
fill: DEFAULT_RED,
(100% - TRAINGLE_WIDTH, 100%),
(100%, 100% - TRAINGLE_HEIGHT),
(100%, 100%),
))
place(right + bottom,
dy: 0.1cm,
line(
start: (100% - TRAINGLE_WIDTH + 0.7cm, 100%),
angle: -calc.atan(TRAINGLE_HEIGHT / TRAINGLE_WIDTH),
length: 6.7cm,
stroke: 0.2cm + DEFAULT_RED
))
}}),
foreground: locate(loc => [
#let chapter = query(selector(heading.where(level: 1)).before(loc), loc).last()
#let chap_count = query(selector(heading.where(level: 1, outlined: true)).before(loc), loc).len()
#let section_query = query(selector(heading.where(level: 2)).before(loc), loc)
#set text(14pt, white, font: "Barlow")
#if(on_left_page(loc)) {
place(left + bottom,
dx: 2em, dy: -1em,
counter(page).display(
"[1]",
both: false,
))
} else {
place(right + bottom,
dx: -2em, dy: -1em,
counter(page).display(
"[1]",
both: false,
))
}
#set text(11pt, black, font: "DM Sans")
#if(on_left_page(loc)) {
place(left + bottom, dy: -2em, dx: TRAINGLE_WIDTH)[
#if (section_query.len() > 0) { [*Section \/\/ * #section_query.last().body] }
else { [*Chapter #chap_count \/\/ * #chapter.body] }
]
} else {
place(right + bottom, dy: -2em, dx: -TRAINGLE_WIDTH)[
#if (section_query.len() > 0) { [*Section \/\/ * #section_query.last().body] }
else { [*Chapter #chap_count \/\/ * #chapter.body] }
]
// Side content
set text(14pt, gray)
place(top + right, dx: -1cm, dy: 3.7cm,
rotate(-90deg, origin: top + right,
upper(strong(chapter.body))
))
set text(64pt, gray, font: "IBM Plex Mono")
place(right + top, dy: 0.7em, dx: 0.2em)[
*#chap_count*
]
}
])
)
#set table(
fill: (c, r) => if c == 0 and r != 0 {black} else if calc.odd(r) {rgb("#e6e6e6")} else {white},
stroke: none
)
#doc
]
// ================================== UTILITY ===================================
#let unescape_html(inp) = {
// TODO: properly handle lists etc
inp.replace("<br>", "\n").replace(regex("</?[^<>]+>"), "") // catches 90% of relevant stuff, not robust by any means
}
#let ensure_even_pagebreak() = {
pagebreak(weak: false)
let s_pagebreaks = state("pagebreaks", ())
let s_count1 = state("pageeven_count1", 0)
let s_count2 = state("pageeven_count2", 0)
let expected_count = frames.len() + manufacturers.len()
locate(loc => {
if s_count1.final(loc) < expected_count {
// First iteration: figure out where to put pagebreaks
s_pagebreaks.update(x => {
let prev = x.at(-1, default: (0, 0))
let expected_page = prev.at(1) + loc.page()
let skipped_pages = prev.at(1) + calc.rem(expected_page, 2)
(..x, (expected_page, skipped_pages))
})
s_count1.update(x => x+1)
} else {
// Consecutove iterations: put pagebreaks
// Latch all the states to not update anymore, this will enforce convergance, and we can put pagebreaks in peace
s_count1.update(9999)
s_count2.update(x => x+1)
let pbs = s_pagebreaks.final(loc)
s_pagebreaks.update(x => pbs)
let count = s_count2.at(loc)
if not calc.even(pbs.at(count).at(0)) {
pagebreak()
}
}
})
}
#let as_a3(body) = {
page(
paper: "a3",
flipped: true,
columns: 2,
body
)
}
#let lancer_glyph(key) = {
text(font: "compcon", fallback: false,
str.from-unicode(GLYPHS.at(key, default:0x0000))
)
}
#let box_display(name, header1, header2, body, color_tuple) = {
box(
stroke: 0pt,
inset: 0pt,
stack(dir: ttb,
rect(
text(fill: white,
heading(level: 4, bookmarked: false, upper(name)) +
if header1.len() > 0 {header1.join(h(10pt))} +
if header2.len() > 0 {linebreak() + header2.join(h(10pt))}
),
width: 100%, stroke: 0pt, fill: color_tuple.first()
),
rect(body, width: 100%, stroke: 0pt, fill: color_tuple.last())
)
)
}
#let compleate_tags(equipment) = {
let ACTIVATION_TAGS = (
"Quick": "tg_quick_action",
"Full": "tg_full_action",
"Quick Tech": "tg_quick_tech",
"Full Tech": "tg_full_tech",
"Invade": "tg_invade",
"Reaction": "tg_reaction",
"Free": "tg_free_action",
"Protocol": "tg_protocol",
)
let res = equipment.at("tags", default: ())
if "deployables" in equipment { res.insert(0, (id: "tg_deployable")) }
for action in equipment.at("actions", default:()) {
let tag = ACTIVATION_TAGS.at(action.at("activation", default: "Quick"))
if not res.any(x => x.id == tag) { res.insert(0, (id: tag)) }
}
res
}
#let translate_size_glyph(size_num) = {
if size_num == 0.5 { "Size_half" }
else if size_num == 2 { "Size2" }
else if size_num == 3 { "Size3" }
else { "Size1" }
}
#let translate_talent_glyph(talent_level) = ("Talent1", "Talent2", "Talent3").at(talent_level - 1, default: "Talent1")
#let format_tags(tags) = {
tags.map(tag => {
let name = tag_lib.find(x => x.id == tag.id).name
if "val" in tag and "{VAL}" in name {
name.replace("{VAL}", str(tag.val))
}
else {
name
}
})
}
#let format_range(range_data) = {
if "val" in range_data and "type" in range_data {
lancer_glyph(range_data.type) + h(5pt) + [#range_data.val] + h(8pt)
} else {
[INVALID]
}
}
#let format_dmg(dmg_data) = {
if "val" in dmg_data and "type" in dmg_data {
[#dmg_data.val] + h(5pt) + lancer_glyph(dmg_data.type) + h(8pt)
} else {
[INVALID]
}
}
// ================================== EQUIPMENT ===================================
#let display_reaction(reaction_data) = {
box(
stack(dir: ttb,
rect(
width: 100%, stroke: 0pt, fill: COLOR_PALETTE.reaction.first(),
text(fill: white, heading(level: 3, bookmarked: false, reaction_data.at("name", default:"")) + [Reaction] + h(10pt) + reaction_data.at("frequency", default:"Unlimited"))
),
rect(
width: 100%, stroke: 0pt, fill: white,
text(fill: black, [*Trigger:* ] + reaction_data.at("trigger", default:""))
),
rect(
width: 100%, stroke: 0pt, fill: COLOR_PALETTE.reaction.last(),
text(fill: black, [*Effect:* ] + reaction_data.at("detail", default:""))
)
))
}
#let display_weapon(weapon_data) = {
let body = unescape_html(weapon_data.at("effect_print", default: weapon_data.at("effect", default:"")))
if weapon_data.at("description", default:"") != "" {
body = body + line(length: 100%, stroke: (dash: "densely-dashed")) + emph(unescape_html(weapon_data.description))
}
let header1 = (weapon_data.mount, weapon_data.type, ..format_tags(compleate_tags(weapon_data)))
if "sp" in weapon_data {
header1 = (str(weapon_data.sp) + " SP", ..header1)
}
if "on_crit" in weapon_data {
body = [*On Critical hit:* ] + weapon_data.on_crit + linebreak() + body
}
if "on_hit" in weapon_data {
body = [*On Hit:* ] + weapon_data.on_hit + linebreak() + body
}
if "on_attack" in weapon_data {
body = [*On Attack:* ] + weapon_data.on_attack + linebreak() + body
}
let profile_data = if "profiles" in weapon_data {weapon_data.profiles.at(0)} else {weapon_data}
let header2 = (
profile_data.at("range", default: ()).map(format_range).join(),
profile_data.at("damage", default: ()).map(format_dmg).join()
)
box_display(weapon_data.name, header1, header2, body, COLOR_PALETTE.weapon)
}
#let display_tech_system(system_data) = {
let body = unescape_html(system_data.at("effect_print", default: system_data.at("effect", default:"No effect")))
for action in system_data.at("actions", default:()) {
body += rect(
stroke: (
"top": 2pt + COLOR_PALETTE.tech.first(),
"bottom": 2pt + COLOR_PALETTE.tech.first(),
"left": 0pt,
"right": 0pt
),
fill: white,
outset: 5pt,
width: 100%
)[*#action.at("name", default:"UNNAMED")*: #action.detail]
}
if system_data.at("description", default:"") != "" {
body = body + line(length: 100%, stroke: (dash: "densely-dashed")) + emph(unescape_html(system_data.description))
}
let header = (str(system_data.sp) + " SP", ..format_tags(compleate_tags(system_data)))
box_display(system_data.name, header, (), body, COLOR_PALETTE.tech)
}
#let display_nontech_system(system_data) = {
let body = unescape_html(system_data.at("effect_print", default: system_data.at("effect", default:"No effect")))
let colors = COLOR_PALETTE.system
if system_data.at("actions", default: ()).any(x => x.at("activation", default: "Quick") == "Protocol") {
colors = COLOR_PALETTE.protocol
}
if system_data.at("type", default: "System") == "AI" {
colors = COLOR_PALETTE.ai
}
if system_data.at("description", default:"") != "" {
body = body + line(length: 100%, stroke: (dash: "densely-dashed")) + emph(unescape_html(system_data.description))
}
let header = (str(system_data.sp) + " SP", ..format_tags(compleate_tags(system_data)))
box_display(system_data.name, header, (), body, colors)
}
#let display_system(system_data) = {
if system_data.at("type", default: "System") == "Tech" {
display_tech_system(system_data)
} else {
display_nontech_system(system_data)
}
}
#let display_weapon_mod(mod_data) = {
let body = unescape_html(mod_data.at("effect_print", default: mod_data.at("effect", default:"No effect")))
if mod_data.at("description", default:"") != "" {
body = body + line(length: 100%, stroke: (dash: "densely-dashed")) + unescape_html( mod_data.description)
}
box_display(mod_data.name, (), (), body, COLOR_PALETTE.mod)
}
// ================================== FRAME ===================================
#let display_stats(stat_dict) = {
let disp(stat_id) = {
STAT_DISPLAY.at(stat_id) + " :" + h(5pt) + str(stat_dict.at(stat_id))
}
let stat_heading(name) = text(fill: DEFAULT_RED, strong(name))
heading(level: 2, bookmarked: false)[STATS]
//grid(columns: 2, ..STAT_DISPLAY.pairs().map(
//p => p.last() + v(-7pt) + str(stat_dict.at(p.first()))
//))
grid(columns: 2, row-gutter: 8pt, column-gutter: 15pt,
disp("size"), disp("save"),
disp("armor"), disp("sensor_range"),
stat_heading("HULL"), stat_heading("SYSTEMS"),
h(15pt) + disp("hp"), h(15pt) + disp("edef"),
h(15pt) + disp("repcap"), h(15pt) + disp("tech_attack"),
stat_heading("AGILITY"), h(15pt) + disp("sp"),
h(15pt) + disp("evasion"), stat_heading("ENGINEERING"),
h(15pt) + disp("speed"), h(15pt) + disp("heatcap"),
)
linebreak()
}
#let display_traits(trait_list) = {
heading(level: 2, bookmarked: false)[TRAITS]
for trait in trait_list {
box_display(trait.name, (), (), trait.description, COLOR_PALETTE.traits)
}
}
#let display_mounts(mount_list) = {
heading(level: 2, bookmarked: false)[MOUNTS]
grid(columns: (33%, 33%, 33%), column-gutter: 10pt, ..mount_list.map(
x => box(
fill: DEFAULT_RED, width: 100%, inset: 10pt,
align(center, text(fill: white, size: 15pt, strong(MOUNT_NAMES.at(x))))
)
))
}
#let display_core_system(core) = {
heading(level: 2, bookmarked: false)[CORE SYSTEM]
heading(level: 3, core.name, bookmarked: false)
par(unescape_html(core.at("description", default:"")), justify: true)
for integrated_id in core.at("integrated", default:()){
display_weapon(weapons.find(d => d.id == integrated_id))
}
let colors = COLOR_PALETTE.system
if core.activation == "Protocol" { colors = COLOR_PALETTE.protocol }
box_display(core.active_name, ("Active (1 CP)", core.activation), (), par(unescape_html(core.active_effect)), colors)
for action in core.at("actions", default:()) {
if action.at("activation", default: "Quick") == "Reaction" {
display_reaction(action)
}
}
}
#let _frame_box(frame_data) = box({
// Title
hide(heading(level: 2, frame_data.name))
align(center, stack(dir: ttb,
text(font: "Barlow", fill: DEFAULT_RED, weight: "extralight", size: 24pt, frame_data.source) + v(1em),
text(fill: DEFAULT_RED, size: 24pt, frame_data.name) + v(1em),
text(fill: DEFAULT_RED, frame_data.mechtype.join("/")),
))
// Icons
place(
top + left,
stack(
text(fill: DEFAULT_RED, size: 32pt, lancer_glyph(translate_size_glyph(frame_data.stats.size))),
..frame_data.mechtype.map(x => text(fill: DEFAULT_RED, size: 32pt, lancer_glyph(x)))
)
)
// Flavor
grid(
columns:(3em, auto, 3em), // Hack to get variable page margins
[], par(unescape_html(frame_data.description), justify: true), []
)
// Mechanics
rect(stroke: DEFAULT_RED + 2pt,
rect(stroke: DEFAULT_RED + 2pt,
columns(2,
display_stats(frame_data.stats) +
display_traits(frame_data.traits) +
display_mounts(frame_data.mounts) +
colbreak() +
display_core_system(frame_data.core_system)
)
))
})
#let display_frame(frame_data) = {
//let manufacturer_data = manufacturers.find(x => x.id == frame_data.source)
//let bg_img = if manufacturer_data != none and "logo_path" in manufacturer_data {"artwork/blackbox.png"} else {none}
if USE_A3 {
as_a3({
_frame_box(frame_data)
colbreak()
if "img_path" in frame_data {
align(center, image(frame_data.img_path, height: 95%))
}
})
} else {
_frame_box(frame_data)
if "img_path" in frame_data {
pagebreak()
align(center, image(frame_data.img_path, height: 95%))
}
}
}
#let _license_box(frame_name, license_id) = {
let license_counter = counter("license")
counter("license").update(1)
let license_box(color, content) = {
set text(fill: white, size: 12pt)
box(fill: color, inset: 5pt, width: 100%, [License] + license_counter.display(" I: ") + content.map(
x => x.name
).join([, ])) + linebreak()
license_counter.step()
}
let lls = range(1, 4).map(x => equipment.filter(d => d.at("license_id", default:"") == license_id and d.at("license_level", default:-999) == x))
// Print licence structure
columns(2,
for i in range(3){
license_box((LIGHT_RED, DEFAULT_RED, DARK_RED).at(i), lls.at(i))
for equipment in lls.at(i){
if equipment.file_source == "weapons" { display_weapon(equipment) }
if equipment.file_source == "systems" { display_system(equipment) }
if equipment.file_source == "weapon_mods" { display_weapon_mod(equipment) }
for action in equipment.at("actions", default:()) {
if action.at("activation", default: "Quick") == "Reaction" {
display_reaction(action)
}
}
}
})
}
#let display_license(frame_name, license_id) = {
if USE_A3 {
as_a3(
_license_box(frame_name, license_id)
)}
else {_license_box(frame_name, license_id)}
}
// ================================== LICENSE-INDEPENDANT ===================================
#let display_manufacturer(manufacturer) = {
[= #manufacturer.name]
columns(2, {
emph(unescape_html(manufacturer.quote))
linebreak()
par(unescape_html(manufacturer.description), justify: true)
set heading(bookmarked: false)
[== #manufacturer.name Core Bonuses]
for bonus in core_bonuses.filter(x => x.source == manufacturer.id) {
box_display(bonus.name, (), (), {
par(emph(unescape_html(bonus.description)), justify: true)
par(unescape_html(bonus.effect), justify: true)
}, (DEFAULT_RED, white))
}
if "artwork_path" in manufacturer {
image(manufacturer.artwork_path, fit: "contain")
}
})
}
#let display_talets() = if talents.len() > 0 {
let TALENT_COLOR = rgb("#3a82c4")
pagebreak()
[= Talents]
let rnk_count = counter("TalentRank")
columns(2,
for talent in talents {
box_display(text(size: 16pt, strong(upper(talent.name))), (), (), {
par(emph(unescape_html(talent.description)), justify: true)
v(1em)
rnk_count.update(0)
talent.ranks.map(rank => {
line(length: 100%, stroke: 2pt + TALENT_COLOR)
rnk_count.step()
rnk_count.display(x => text(fill: TALENT_COLOR, size: 20pt, lancer_glyph(translate_talent_glyph(x))))
h(.5em) + text(size: 16pt, strong(upper(rank.name)))
par(unescape_html(rank.description), justify: true)
rank.at("actions", default:()).filter(x => x.activation == "Reaction").map(display_reaction).join()
}).join()
}, (TALENT_COLOR, white))
}
)
}
#let display_pilotgear() = if pilot_gear.len() > 0 {
pagebreak()
[= Gear]
let get_pilot_bonus(data, id, default: 0) = {
let f = data.find(x => x.id == id)
if f == none {default} else {f.at("val", default: default)}
}
let armor_table = pilot_gear.filter(x => x.type == "Armor").map(x => (
text(fill: white, upper(strong(x.name))),
smallcaps(format_tags(x.at("tags", default: ())).join()),
[#get_pilot_bonus(x.at("bonuses", default: ()), "pilot_armor")],
[#get_pilot_bonus(x.at("bonuses", default: ()), "pilot_evasion")],
[#get_pilot_bonus(x.at("bonuses", default: ()), "pilot_edef")],
[#get_pilot_bonus(x.at("bonuses", default: ()), "pilot_speed")],
)).flatten()
let weapon_table = pilot_gear.filter(x => x.type == "Weapon").map(x => (
text(fill: white, upper(strong(x.name))),
smallcaps(format_tags(x.at("tags", default: ())).join(", ")),
x.range.map(format_range).join(" "),
x.damage.map(format_dmg).join(" "),
)).flatten()
if armor_table.len() > 0 {table(
columns: 6,
..([], [Tags], [Armor], [Evasion], [E-Defense], [Speed]).map(strong),
..armor_table
)}
columns(2,{
if weapon_table.len() > 0 {table(
columns: 4,
..([], [Tags], [Range], [Damage]).map(strong),
..weapon_table
)}
for gear in pilot_gear.filter(x => x.type not in ("Weapon", "Armor")) {
box_display(
text(size: 16pt, strong(upper(gear.name))),
format_tags(gear.at("tags", default: ())), (), {
par(emph(gear.description), justify: true)
v(1em)
par(gear.at("effect_print", default: gear.at("effect", default: "NO EFFECT")), justify: true)
gear.at("actions", default: ()).filter(x => x.activation == "Reaction").map(display_reaction).join()
}, COLOR_PALETTE.pilot_gear)
}
})
}
#let display_gms_equipment() = {
let gms_equipment = equipment.filter(x => x.at("license", default:"") == "GMS")
if gms_equipment.len() > 0 {
[= GMS ADDENDUM]
let weapon_table = gms_equipment.filter(x => x.file_source == "weapons").map(x => (
text(fill: white, upper(strong(x.name))),
x.mount + " " + x.type,
smallcaps(format_tags(x.at("tags", default: ())).join()),
x.range.map(format_range).join(),
x.damage.map(format_dmg).join(),
)).flatten()
if weapon_table.len() > 0 {table(
columns: 5,
..([Name], [Size / Type], [Tags], [Range], [Damage]).map(strong),
..weapon_table
)}
}
columns(2, {
for sys in gms_equipment.filter(x => x.file_source == "systems") {
display_system(sys)
}
})
}
// ================================== FILE ===================================
#let display_whole() = {
display_talets()
display_pilotgear()
display_gms_equipment()
for manufacturer in manufacturers {
ensure_even_pagebreak()
display_manufacturer(manufacturer)
for frame_data in frames.filter(x => x.source == manufacturer.id) {
ensure_even_pagebreak()
display_frame(frame_data)
pagebreak()
display_license(frame_data.name, frame_data.license_id)
}
}
}
#par(leading: 8pt, outline(depth: 1))
//#grid(columns: 6, ..range(0xe900, 0xe96b).map(x => {
// [#str(x, base:16)] + text(font: "compcon", fallback: false, str(x, base:16) + str.from-unicode(x) + "\n")
//})) // Test font
#show: style
#display_whole() |
|
https://github.com/fediazizieln/infodev | https://raw.githubusercontent.com/fediazizieln/infodev/main/Lab-3.typ | typst | #import "Class.typ": *
#show: ieee.with(
title: [#text(smallcaps("Lab #3: Web Application with Genie"))],
/*
abstract: [
#lorem(10).
],
*/
authors:
(
(
name: "<NAME>",
department: [Senior-lecturer, Dept. of EE],
organization: [ISET Bizerte --- Tunisia],
profile: "",
),
)
// index-terms: (""),
// bibliography-file: "Biblio.bib",
)
= Exercise
In this lab, you will create a basic web application using *Genie* framework in Julia. The application will allow us to control the behaviour of a sine wave, given some adjustble parameters. You are required to carry out this lab using the REPL as in @fig:repl.
#figure(
image("Images/Genie-sinewave.png", width: 100%, fit: "contain"),
caption: "Julia REPL"
) <fig:repl>
#exo[Sine Wave Control][We provide the Julia and HTML codes to build and run a web app that allows us to control the amplitude and frequency of a sine wave. *Plotly* is used to plot the corresponding graph. We also added a slider to change the number of samples used to draw the figure. The latter setting permits to grasp the influence of sampling frequency on the look of our chart.]
#let code=read("../Codes/web-app/app.jl")
#raw(code, lang: "julia")
#let code=read("../Codes/web-app/app.jl.html")
#raw(code, lang: "html")
```zsh
julia --project
```
```julia
<div class="st-col col-12 col-sm st-module">
<p><b># phase</b></p>
<q-slider v-model="phi"
:min="-3.14" :max="3.14"
:step="0.03" :label="true">
</q-slider>
</div>
<div class="st-col col-12 col-sm st-module">
<p><b># offset</b></p>
<q-slider v-model="ofs"
:min="-0.5" :max="1"
:step="0.1" :label="true">
</q-slider>
</div>
```
```julia
julia> using GenieFramework
julia> Genie.loadapp() # Load app
julia> up() # Start server
```
We can now open the browser and navigate to the link #highlight[#link("localhost:8000")[localhost:8000]]. We will get the graphical interface as in @fig:genie-webapp.
#figure(
image("Images/1.png", width: 100%),
caption: "sine wave1",
) <fig:genie>
#figure(
image("Images/e6a34ecc-78b5-4e3d-9c29-e8e7c77b3371.jpg", width: 100%),
caption: "Genie -> Sine Wave2",
) <fig:genie-webapp>
|
|
https://github.com/derliemonne/differential-equations-lectures-fefu-5th-semester-chebotaryov | https://raw.githubusercontent.com/derliemonne/differential-equations-lectures-fefu-5th-semester-chebotaryov/main/src/utils.typ | typst | #import "@preview/showybox:2.0.1": showybox
#let der(x) = math.accent(x, sym.dot)
#let der2(x) = math.accent(x, sym.dot.double)
#let der3(x) = math.accent(x, sym.dot.triple)
#let der4(x) = math.accent(x, sym.dot.quad)
#let num(number) = place(
right,
"(" + str(number) + ")"
)
#let _box(content) = box(
stroke: 1pt,
radius: 5pt,
inset: (x: 1em, y: 0.65em),
content
)
#let lbox(content) = align(left, _box(content))
#let cbox(content) = {
content = align(left, content)
align(center, _box(content)
)
}
#let rbox(content) = {
content = align(left, content)
align(right, _box(content))
}
#let bbox(head, ..content) = showybox(title: head, ..content)
#let bbbox(head, ..content) = showybox(breakable: true, title: head, ..content)
#let note(..content) = bbox("Замечание", ..content)
#let def(..content) = bbox("Определение", ..content)
#let statement(..content) = bbox("Утверждение", .. content)
#let eg(..content) = bbox("Пример", .. content)
// for display math to align left
#let m(content) = box(content)
#let when = [$comma space$]
// when aligned
#let whena = [$comma &space$]
#let where = [$, " ""где "$]
// where aligned
#let wherea = [$, &" ""где "$]
#let matdet(..content) = math.mat(delim: "|", ..content)
#let matnorm(..content) = math.mat(delim: "||", ..content)
|
|
https://github.com/mawkler/cv | https://raw.githubusercontent.com/mawkler/cv/main/swedish.typ | typst | MIT License | #import "cv.typ": cv, experience, skill, list_interests
#import "@preview/fontawesome:0.1.0": *
#set text(lang: "se")
#cv(
name: "<NAME>",
links: (
(link: "mailto:<EMAIL>", icon: fa-at()),
(link: "https://github.com/mawkler", display: "mawkler", icon: fa-github()),
(link: "https://fosstodon.org/@mawkler", display: "fosstodon.org/@mawkler", icon: fa-mastodon()),
(link: "https://linkedin.com/in/melker-ulander/", display: "<NAME>", icon: fa-linkedin()),
),
occupation: "Mjukvaruutvecklare",
tagline: [Söker möjligheter att arbeta i Rust. Spana in vad jag har för mig på #link("https://github.com/mawkler", "min GitHub").],
compiled_date: [Kompilerad: #datetime.today().display()],
left_column: [
== Arbetslivserfarenhet
#experience("images/omegapoint.png")[Mjukvaruutvecklarkonsult][Omegapoint][2021 --- nuvarande][Stockholm]
De här konsultuppdragen har jag haft hittils:
- RESTfull back-end-utveckling i Go och Azure/Kubernetes för ett energiföretag. Bicep IaC, CI/CD.
- Java microservices i Kubernetes för en veterinärklinik. Fokus på DevOps och CI/CD, samt "funktionell Java".
- RESTfull back-end-utveckling med Azure Functions i TypeScript/Node för en värmepumpstillverkare. Primärt fokus på DDD, säkerhet och CI/CD.
#experience("images/ericsson.png")[Mjukvaruutvecklare][Ericsson][2016 --- 2017][Kista, Stockholm]
Under mitt jobb på Ericssons internship under sommar 2016 och 2017 byggde jag verktyg som förenklar hanteringen av databaser för radiomjukvara. Under den första sommaren arbetade jag primärt på en webb-klient skriven i Angular. Under den andra sommaren arbetade jag med text-parsning och byggde en webb-server i Python. Arbetet gjordes agilt i team på 2--5 personer.
#experience("images/hello-world.png")[Programmings- och CAD-lärare][Hello World!][2018][Stockholm]
Hello World! är en ideell förening som lär ut digitala färdigheter till barn och ungdomar. Jag lärde bland annat ut programmering av mikrokontrollers som exempelvis Arduinos i Python, programmering i språket Lua samt CAD och 3D-printing. Mitt jobb på Hello World! har stärkt både mina ledar- och pedagogiska färdigheter. Det har också bekräftat för mig hur mycket jag tycker om att lära ut.
#experience("images/uppsala.png")[Labbhandledare i datavetenskap][Uppsala Universitet][2017, 2019][Uppsala]
Jag assisterade studenter under laborationer i kursen Programkonstruktion och Datastrukturer. Labbarna bestod av många praktiska moment så som problemlösning i form av programmering i Haskell, beräkning av tidskomplexitet, induktionsbevis, mm. Som handledare har jag fått stärka min förmåga i pedagogik och undervisning.
== Utbildning
#experience("images/uppsala.png")[Civilingenjörsexamen i Informationsteknologi, 300 hp --- inriktning mjukvaruutveckling][Uppsala Universitet][2015-2021][Uppsala]
Programmering, matematik och människor är tre viktiga grundstenar i programmet. Jag har bland mycket annat lärt mig kring arbete i tvärfunktionella (cross-functional) teams, ta fram mjukvarukrav samt agil produktutveckling.
#experience("images/wik.png")[Musikprogrammet][Wiks Folkhögskola][2014-2015][Uppsala]
En musikutbildning med fokus på musikalisk bredd och övning i eget musikaliskt uttryck i låtskrivande såväl som framförande, samt musikteori.
== Intressen
#list_interests((
"Neovim",
"Open source",
"Rust",
"Verktyg/Tooling",
"Musik",
"Datorspel",
"Tangentbord",
"Brädspel",
"Klättring",
"Bågskytte",
"Snowboardåkning"
))
],
right_column_header: "Programmeringsfärdigheter",
languages_header: "Språk",
other_technologies_header: "Andra tekniker",
right_column: [
=== Metodologier
#skill("Domändriven Design", 4)
#skill("Agile", 4)
#skill("REST", 4)
#skill("DevOps", 4)
== Talade språk
#skill("Svenska", 5)
#skill("Engelska", 5)
#skill("Spanska", 1)
== Andra meriter
- AWS Certified Cloud Practitioner certificate
- B-körkort sedan 2015
],
footer_content: [Mitt CV är open-source. Om du är nyfiken så finns källkoden på #link("https://github.com/mawkler/cv").]
)
|
https://github.com/mohsu/cv-typst | https://raw.githubusercontent.com/mohsu/cv-typst/main/main.typ | typst | #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: 11.4pt,
font:"EB Garamond"
)
// Feel free to change the margin below to best fit your own CV
#set page(
paper: "us-letter",
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(-6pt)}
#align(center)[
== <NAME>
New York, NY | (646) 599-7498 | #link("<EMAIL>")[<EMAIL>] \
#link("https://github.com/mohsu")[github.com/mohsu] | #link("https://linkedin.com/in/maureen-hsu")[linkedin.com/in/maureen-hsu]
]
#let boldweight = 600
#let italac_(txt) = [
#set text(
style: "italic",
)
#txt
]
#let second_heading(txt) = [
#set text(
weight: 600
)
#txt
]
#show heading.where(
level: 2
): it => block(width: 100%)[
#set text(weight: 600, size: 12pt)
#upper(it.body)
]
#v(0.5em)
== EDUCATION
#chiline()
#block()[
#second_heading("Cornell University") #h(1fr) New York, NY\
#italac_("Master of Science, Information Science") #h(1fr) Aug 2022 – May 2024
- CS Coursework: Machine Learning Engineering, Security and Privacy in the Wild, Building Startup Systems, \ Blockchains & Cryptocurrencies, Algorithms for Applications
]
#block()[
#second_heading("National Taiwan University") #h(1fr) Taipei, Taiwan\
#italac_("Master of Science, Industrial Engineering") | GPA: 3.7 #h(1fr) Sep 2014 – Jan 2017
- CS Coursework: Linear Algebra, Machine Learning, Stochastic Process, Soft Computing Methods and Application, Data Mining
]
#v(0.5em)
== WORK EXPERIENCE
#chiline()
#block()[
#second_heading("Rubrik") #h(1fr) Palo Alto, CA\
#italac_("Software Engineer Intern") #h(1fr) May 2023 – Aug 2023
- Enhanced security of Cluster Cloud Elastic Storage by introducing key-less authentication using Azure Managed Identity, \ reducing potential access vulnerabilities
- Streamlined existing cluster workflows by integrating robust health checks, ensuring consistent uptime during the transition
- Automated authentication for every new Azure CC-ES cluster setup, guaranteeing secure connections from the outset and \ minimizing manual configuration
- Spearheaded the development of Golang and Scala backend solutions, which were integrated into 6 production APIs. Leveraged \ Kubernetes for efficient orchestration and resource utilization
]
#block()[
#second_heading("Houzz") #h(1fr) Taipei, Taiwan\
#italac_("Senior Software Engineer, Machine Learning") #h(1fr) Mar 2021 – Jul 2022
- Created syncing flows between chat messages on CRM messages and home professionals’ gmail with Google Cloud API, PHP, MySQL and Docker
- Employed BERT to classify semantic meaning of online chat between homeowners and professionals and generated proper response prompt based on the content detected; deployed models on AWS
- Doubled the amount of sales by building the data cleansing and scraping system for crawling home professionals from 30+ websites with Scrapy
]
#block()[
#second_heading("Neutec") #h(1fr) Taipei, Taiwan\
#italac_("Senior Machine Learning Engineer") #h(1fr) Jul 2017 – Mar 2021
- Employed cluster and CNN to provide real-time image recognition by using Tensorflow, Tensorflow-Serving, and FastAPI, and the service detected cards dealt on the table with 99.99% accuracy
- Created a backend management website to monitor results and adjust parameters by Django
- Ensured system’s reliability by adopting HA structure for load balance and prevent unscheduled downtime
- Led automatic dice fairness testing with programmers and statistics team; provided image recognition service (RESTful API)
]
#v(0.5em)
== TECHNICAL SKILLS
#chiline()
Programming Languages: Python, Scala, Go, R, C\#, Matlab, C++, Java, Javascript, PHP, React, Bash\
Database: MySQL, PostgreSQL, Oracle, Clickhouse, Redis, MongoDB, Hadoop, Cassandra\
Frameworks & Other Skills: Linux, Nginx, AWS, Azure, GCP, Docker, Git, Kubernetes, Jenkins, TensorFlow, Django, Scrapy |
|
https://github.com/saYmd-moe/note-for-statistical-mechanics | https://raw.githubusercontent.com/saYmd-moe/note-for-statistical-mechanics/main/contents/PartI/Chp01.typ | typst | #import "../../template.typ": *
== 热力学的基本规律
=== 平衡态及其描写
==== 平衡态
几个概念：
- *热力学系统*：热力学所研究的对象
- *绝热壁与导热壁*：绝热壁不允许两边的物体发生任何形式的热交换，反之称为导热壁
- *刚性壁*：不允许物体发生位移；刚性壁包裹的固体不可能发生形变
- *热接触*：刚性、导热壁分开的两个物体间只能发生热交换，而不互相做功与物质交换
- *热力学平衡*：没有外界影响的情况下一个系统的宏观性质长时间内不发生变化的状态
- *热学平衡*：两个或一个系统的不同部分的温度相等，是热力学平衡的一个条件。
#h(2em)根据与外界环境能发生的相互作用种类，热力学系统可以分为三种：
- *孤立系*：与外界不发生任何相互作用
- *闭系*：与外界只发生能量交换
- *开系*：与外界发生能量和物质交换
==== 平衡态的描写
热力学中会把物体看作连续介质，只需要少数几个宏观变量就可以表示出宏观平衡态，这些宏观变量被称为*#text(blue)[状态变量]*。可以归纳为以下几种状态变量：
- *几何变量*：$V, A, L$
- *力学变量*：$p, sigma, arrow(cal(F))$
- *电磁变量*：$arrow(cal(E)), arrow(cal(P)), arrow(cal(H)), arrow(cal(M))$
- *化学变量*：组元的摩尔数
#h(2em)除了这四类状态变量，还有热力学中特有的*#text(blue)[态函数]*，如温度、内能、焓、自由能、吉布斯函数等，这些态函数完全由上述状态变量确定。对于各部分性质完全相同的系统（*均匀系*），其状态变量和态函数可以分为与系统总质量成正比的*广延量*，包括摩尔数、体积、内能、熵等；与系统总质量无关的*强度量*，包括密度、温度、压强、内能密度、熵密度等。#highlight[广延量具有可加性，强度量不可加，并具有局域的性质。]
=== 物态方程
通过*热平衡定律*
#footnote([如果物体A分别与物体B和C处于热平衡，那么B与C也一定处于热平衡。热平衡定律也是热力学第零定律。])
我们可以引入第一个态函数——*温度*，我们将温度与独立状态变量之间的函数关系称为*#text(blue)[物态方程]*，对于一定质量的化学纯气体，温度、压强、体积均可作为状态变量：
$
g(p,V,T)=0
$<eq-of-stat>
或者更普遍的情况：
$
g(x_1,x_2,dots,x_n,T)=0
$
#h(2em)通过物态方程 @eq-of-stat 我们可以定义一些物理量：
+ *膨胀系数* $alpha$，表示压强不变的条件下体积随温度的相对变化率$ alpha equiv 1/V ((diff V)/(diff T))_p $
+ *压强系数* $beta$，表示体积不变的条件下压强随温度的相对变化率$ beta equiv 1/p ((diff p)/(diff T))_V $
+ *等温压缩系数* $kappa_T$，表示温度不变的条件下体积随压强的相对变化率$ kappa_T equiv -1/V ((diff V)/(diff p))_T $
#h(2em)两种常用物态方程：
- *理想气体状态方程*，假设分子间无相互作用：$ p V= N R T $<perfect-gas-equation>
- *范德瓦尔斯气体状态方程*，考虑了分子间相互作用引起的修正：#v(3.5em)$ (p+ (#pin(1)N^2 a#pin(2))/(V^2#pin(3)))(V-#pin(4)N b#pin(5))=N R T $ //TODO: 通过统计物理方法计算 a 和 b
#pinit-highlight-equation-from((1, 2, 3), 3, height: 2.5em, pos: bottom, fill: rgb(0, 180, 255))[
对分子间吸引力的修正
]
#pinit-highlight-equation-from((4, 5), 5, height: 2.5em, pos: top, fill: rgb(150, 90, 170))[
对分子间排斥力的修正
]
#v(3.5em)
=== 热力学第一定律
#colorbox(
title: [热力学第一定律],
color: "blue",
radius: 5pt,
width: auto
)[
#set list(indent: .5em)
- *能量守恒表述：*自然界一切物质都具有能量，能量有各种不同的形式，能够从一种形式转化为另一种形式，从一个物体传递给另一个物体，在转化和传递过程中能量的数量不变。
- *数学表述：*$Delta U=Q+W$，$Delta U、Q、W$分别为内能增量、系统吸收的能量和*外界对系统做的功*。
- 永动机是不可能造成的。
]
==== 热容和熵
热容用于表示物体吸收热量的能力，定义为$C_y equiv \u{0111} Q_y \/ d T$，如果考虑一个$p dash.en V dash.en T$系统，$y$ 可以分别取为$V、p$表示*定容热容*与*定压热容*：
系统体积不变时，外界对系统不做功（$\u{0111} W=0$），即$\u{0111}Q_V=d U$。则*#text(rgb("#FA7F6F"))[定容热容]*:
$
C_V = ((diff U)/(diff T))_V
$
#note[
如果已知理想气体热容$C_V (T)$，则可以得到任意两个状态间内能变化量的表达式：
$
Delta U &= integral_(T_1)^(T_2) C_V (T) dif T + integral_(V_1)^(V_2) ((diff U)/(diff V))_T dif V \
&=integral_(T_1)^(T_2) C_V (T) dif T
$<heat-capacity>
]
#h(2em)当系统的压强不变时，外界对系统做微功$\u{0111} W=-p d V$，则*#text(rgb("#FA7F6F"))[定压热容]*:
$
C_p &= ((diff U)/(diff T))_p + p((diff V)/(diff T))_p \
&= C_V + p((diff V)/(diff T))_p
$
#note[
由于两个式子的RHS均是内能和物态方程的微商，所以两个热容都是态函数。
]
#h(2em)现在可以引入一个新的态函数，*#text(rgb("#FA7F6F"))[焓]*：
$
H equiv U +p V
$
于是@heat-capacity 可以写成：
$
C_p = ((diff H)/(diff T))_p
$
在等压过程中，物体从外界吸收的热量等于物体焓的增加值。
==== 理想气体
理想气体不考虑分子间的相互作用，一般温度不太低、压强趋于零的极限状态下的气体可以看作理想气体。理想气体满足理想气体状态方程和内能只与温度有关：
$
&p V = N R T\
&U = U(T)
$
根据焓的定义，理想气体的焓也只是温度的函数
$
H equiv U + p V = U(T) + N R T = H(T)
$
于是可以写出理想气体的定容热容和定压热容：
$
C_V equiv ((diff U)/(diff T))_V = (dif U)/(dif T) = C_V (T)\
C_p equiv ((diff H)/(diff T))_p = (dif H)/(dif T) = C_p (T)
$
理想气体的热容均为 $T$ 的函数，现在可以得到两种热容满足如下式子：
$
C_V = (N R)/(gamma -1); quad C_p = gamma (N R)/(gamma -1)
$
其中 $gamma$ 定义为两种热容之比 $gamma equiv C_p\/C_V=gamma(T)$，已知热容可以通过积分得到理想气体的内能与焓：
$
U(T) = integral C_V (T) dif T + U_0\
H(T) = integral C_p (T) dif T + H_0
$
#h(2em)下面考虑理想气体的*绝热过程*（$\u{0111}Q=dif U+p dif V=0$），对于一个 $p dash V dash T$ 系统，以 $p V$ 为参量时有准静态绝热过程方程：
$
p V^gamma = C
$
利用理想气体状态方程可以进一步得到：
$
T V^(gamma-1) = C'\
T^(-gamma) p^(gamma-1) = C''
$<process-equation>
可以列出理想气体的常见热力学过程如下：
- *等容过程：*$V = op("const")$
- *等压过程：*$p = op("const")$
- *等温过程：*$p V = N R T = op("const")$
- *绝热过程：*$p V^gamma = op("const")$
- *#text(rgb("#FA7F6F"))[多方过程]：*$p V^n = op("const")$
#note[多方过程的多方指数 $n$ 可由下式测量：$n = ln(p_1\/p_2)\/ln(V_2\/V_1)$]
=== 热力学第二定律
==== 理想气体的卡诺循环
在建立热力学第二定律时需要借助卡诺循环进行推导，先考虑一种由理想气体作为工作物质的可逆卡诺循环过程。
#grid(
columns: 2,
gutter: 5pt,
box(width: 100%)[
#h(2em)该可逆卡诺循环由四步构成：
- *( I )#h(1em)等温膨胀：*$(T_1,V_1) arrow (T_1,V_2)$
- *( II )#h(.7em)绝热膨胀：*$(T_1,V_2) arrow (T_2,V_3)$
- *( III )#h(.4em)等温压缩：*$(T_2,V_3) arrow (T_2,V_4)$
- *( IV )#h(.4em)绝热压缩：*$(T_2,V_4) arrow (T_1,V_1)$
完成整个循环过程后温度没有发生改变，所以有$integral.cont dif U =0$，由热力学第一定律：
$
- integral.cont \u{0111}W = integral.cont \u{0111}Q
$
],
figure(
cetz.canvas(
{import cetz.draw: *
// 坐标轴
let x = (0,3)
let y = (0,3)
set-style(mark: (fill: none))
line((x.at(0),0),(x.at(1),0), mark: (end: ">"), stroke: (paint: luma(30%)))
content((x.at(1)-.1,-.3),[$V$])
line((0,y.at(0)),(0,y.at(1)), mark: (end: ">"), stroke: (paint: luma(30%)))
content((0,y.at(1)+.3),[$p$])
// 首先定义出四个状态的位置
let A = (.5,2.75)
let B = (2,2.5)
let C = (2.75,.75)
let D = (1.25,1.25)
// 绘制各过程的曲线
let p1 = (A.at(0)+.5*(B.at(0)-A.at(0)), B.at(1)+.1*(A.at(1)-B.at(1)))
let p2 = (B.at(0)+.1*(C.at(0)-B.at(0)), C.at(1)+.5*(B.at(1)-C.at(1)))
let p3 = (D.at(0)+.5*(C.at(0)-D.at(0)), C.at(1)+.1*(D.at(1)-C.at(1)))
let p4 = (A.at(0)+.1*(D.at(0)-A.at(0)), A.at(1)+.5*(D.at(1)-A.at(1)))
bezier(A, B, p1)
content((A.at(0),A.at(1)+.2),[$1$])
content((p1.at(0),p1.at(1)+.2),text(size: .5em)[( I )])
bezier(B, C, p2)
content((B.at(0),B.at(1)+.2),[$2$])
content((p2.at(0)+.3,p2.at(1)+.2),text(size: .5em)[( II )])
bezier(C, D, p3)
content((C.at(0)+.2,C.at(1)),[$3$])
content((p3.at(0),p3.at(1)-.1),text(size: .5em)[( III )])
bezier(D, A, p4)
content((D.at(0),D.at(1)-.2),[$4$])
content((p4.at(0)-.25,p4.at(1)),text(size: .5em)[( IV )])
}),
caption: [理想气体的可逆卡诺循环过程]
)
)
定义气体在循环过程中所做的净功$W'$：
$
W' equiv - integral.cont \u{0111}W = integral.cont \u{0111}Q = Q_1 + Q_2
$
其中 $Q_1, Q_2$ 分别为两个等温过程 ( I ) 与 ( III ) 中气体从外界吸收的热量
#footnote[
绝热过程中没有热量交换，等温过程可以看作分别与高温大热源（$T_1$）和低温大热源（$T_2$）进行热交换。
]
，可以通过积分得到：
$
Q_1 &= -W_1 = integral_(V_1)^(V_2) p dif V = N R T_1 ln V_2/V_1 \
Q_2 &= -W_2 = integral_(V_3)^(V_4) p dif V = - N R T_2 ln V_3/V_4
$
可以看到$Q_2 < 0$，也就是说过程 ( III ) 中理想气体是向外界放热的。下面我们来计算热机的效率 $eta$ ：
$
eta equiv W'/Q_1 = (Q_1 - abs(Q_2))/(Q_1) = 1 - abs(Q_2)/Q_1 = 1 - T_2/T_1 (ln(V_3\/V_4))/(ln(V_2\/V_1))
$<efficiency>
利用理想气体绝热方程的过程方程 @process-equation 作用与过程 ( II ) 和 ( IV ) 可以得到：
$
T_1 V_2^(gamma-1) = T_2 V_3^(gamma-1) \
T_1 V_1^(gamma-1) = T_2 V_4^(gamma-1)
$
相除得到：
$
V_2/V_1 = V_3/V_4
$
代入到 @efficiency 即可得到理想气体可逆卡诺循环的效率：
$
eta = 1- T_2/T_1
$
从该式可以看出理想气体的可逆卡诺循环效率只与高温热源和低温热源的温度有关，而与工作物质的质量、体积等无关。
#note[
如果是卡诺制冷机，其制冷系数定义为从低温热源吸收的热量 $abs(Q_2)$ 与外界对气体所作的净功 $W$ 之比：
$
epsilon equiv Q_2/W = T_2/(T_1 - T_2)
$
]
==== 热力学第二定律与两种表述的等价证明
#colorbox(
title: [热力学第二定律],
color: "blue",
radius: 5pt,
width: auto
)[
#set list(indent: .5em)
- *开尔文表述：*不可能从单一热源吸热使之完全变为有用功且不产生其他影响。
- *克劳修斯表述：*不可能把热从低温物体传到高温物体而不产生其他影响。
- *熵增原理：*孤立系统的熵永不减小。
- *实质：*所有与热有关的过程都是不可逆的；不可逆过程产生的后果不可能完全恢复原状而不引起其他变化。
]
下面来证明开尔文表述与克劳修斯表述的等价性，为了辅助证明我们采用热机模型，热机工作于高温热源（$T_1$）和低温热源（$T_2$）之间。
#figure(
grid(
columns: 2,
gutter: 5pt,
box(width: 30%)[
#cetz.canvas({
import cetz.draw: *
// 设置长度数值
let rect_len = 3
let rect_width = .75
let circ_r = .5
let circ_o1 = (-rect_len/4, 0)
let circ_o2 = (rect_len/4, 0)
let rect_pos1 = (
(-rect_len/2,1.75 * circ_r),
(rect_len/2,1.75 * circ_r + rect_width)
)
let rect_pos2 = (
(-rect_len/2,-1.75 * circ_r),
(rect_len/2,-(1.75 * circ_r + rect_width))
)
// 热源
rect(rect_pos1.at(0),rect_pos1.at(1))
content(
(0,rect_pos1.at(0).at(1)+ .5*rect_width),
[$T_1$]
)
rect(rect_pos2.at(0),rect_pos2.at(1))
content(
(0,rect_pos2.at(0).at(1)- .5*rect_width),
[$T_2$]
)
// 热机
circle(circ_o1, radius: circ_r, stroke: (dash: "dashed"))
circle(circ_o2, radius: circ_r)
// 热量与功
line(
(circ_o1.at(0),circ_r),
(circ_o1.at(0),1.75 * circ_r),
mark: (end: ">"),
)
content(
(circ_o1.at(0)+.3,circ_r + .2*rect_width),
text(size: .75em)[$Q_2$]
)
line(
(circ_o1.at(0),-1.75 * circ_r),
(circ_o1.at(0),-circ_r),
mark: (end: ">"),
)
content(
(circ_o1.at(0)+.3,-(circ_r + .2*rect_width)),
text(size: .75em)[$Q_2$]
)
line(
(circ_o2.at(0),1.75 * circ_r),
(circ_o2.at(0),circ_r),
mark: (end: ">"),
)
content(
(circ_o2.at(0)+.3,circ_r + .2*rect_width),
text(size: .75em)[$Q_1$]
)
line(
(circ_o2.at(0),-circ_r),
(circ_o2.at(0),-1.75 * circ_r),
mark: (end: ">"),
)
content(
(circ_o2.at(0)+.3,-(circ_r + .2*rect_width)),
text(size: .75em)[$Q_2$]
)
// 做功
line(
(circ_o2.at(0) + circ_r, 0),
(circ_o2.at(0) + 1.75 * circ_r, 0),
mark: (end: ">"),
)
content(
(circ_o2.at(0) + 1.75 * circ_r + 1, 0),
text(size: .75em)[$W=Q_1-Q_2$]
)
content((0,rect_pos2.at(1).at(1) - .2),[(a)])
})
],
box(width: 30%)[
#cetz.canvas({
import cetz.draw: *
// 设置长度数值
let rect_len = 3
let rect_width = .75
let circ_r = .5
let circ_o1 = (-rect_len/4, 0)
let circ_o2 = (rect_len/4, 0)
let rect_pos1 = (
(-rect_len/2,1.75 * circ_r),
(rect_len/2,1.75 * circ_r + rect_width)
)
let rect_pos2 = (
(-rect_len/2,-1.75 * circ_r),
(rect_len/2,-(1.75 * circ_r + rect_width))
)
// 热源
rect(rect_pos1.at(0),rect_pos1.at(1))
content(
(0,rect_pos1.at(0).at(1)+ .5*rect_width),
[$T_1$]
)
rect(rect_pos2.at(0),rect_pos2.at(1))
content(
(0,rect_pos2.at(0).at(1)- .5*rect_width),
[$T_2$]
)
// 热机
circle(circ_o1, radius: circ_r, stroke: (dash: "dashed"))
circle(circ_o2, radius: circ_r)
// 热量与功
line(
(circ_o1.at(0),1.75 * circ_r),
(circ_o1.at(0),circ_r),
mark: (end: ">"),
)
content(
(circ_o1.at(0)+.3,circ_r + .2*rect_width),
text(size: .75em)[$Q_1$]
)
line(
(circ_o2.at(0),circ_r),
(circ_o2.at(0),1.75 * circ_r),
mark: (end: ">"),
)
content(
(circ_o2.at(0)+.7,circ_r + .2*rect_width),
text(size: .75em)[$Q_1+Q_2$]
)
line(
(circ_o2.at(0),-1.75 * circ_r),
(circ_o2.at(0),-circ_r),
mark: (end: ">"),
)
content(
(circ_o2.at(0)+.3,-(circ_r + .2*rect_width)),
text(size: .75em)[$Q_2$]
)
// 做功
line(
(circ_o1.at(0) + circ_r, 0),
(circ_o2.at(0) - circ_r, 0),
mark: (end: ">"),
)
content(
(circ_o1.at(0) + 1.5 * circ_r , -circ_r),
text(size: .5em)[$W=Q_1$]
)
content((0,rect_pos2.at(1).at(1) - .2),[(b)])
})
]
),
caption: [证明开尔文表述和克劳修斯表述等价的假想实验]
)<second-law>
首先证明：如果开尔文表述成立则克劳修斯表述也必将成立。采用反证法，即假设开尔文表述成立而克劳修斯表述不成立。现在有一卡诺热机从高温热源（$T_1$）热源吸收热量 $Q_1$ 并传导热量 $Q_2$ 至低温热源（$T_2$）热源并对外界做功 $W = Q_1 - Q_2$ 。如果克劳修斯表述不成立，那么可以有另外一个卡诺热机（@second-law[图] 中的 (a) 图虚线热机）可以从低温热源 （$T_2$）吸收热量 $Q_2$ 并完全传递给高温热源 （$T_1$）且不产生其他影响。综合这两个热机的作用效果，复合热机相当于从单一热源（$T_1$）吸收热量 $Q_1-Q_2$ 并完全转化为功 $W=Q_1-Q_2$ ，这违反了开尔文表述。
其次证明：如果克劳修斯表述成立则开尔文表述也必将成立。同样使用反证法，假设克劳修斯表述成立而开尔文表述不成立。假设有一个违反开尔文表述的卡诺热机（@second-law[图] 中的 (b) 图虚线热机），它可以从单一热源（$T_1$）吸收热量 $Q_1$ 并完全转化为功 $W=Q_1$ 。那么我们让这个功驱动另外一个卡诺制冷机从低温热源（$T_2$）吸收热量 $Q_2$ 并传递给高温热源（$T_1$）$Q_1+Q_2$ 的热量，于是复合热机相当于从低温热源（$T_2$）吸收热量 $Q_2$ 并完全传递给高温热源（$T_1$）且不产生其他影响，这违反了克劳修斯表述。
==== 熵与熵增原理
热力学第二定律的实质是热过程的不可逆性，我们可以引入熵来表示这种不可逆性，为此先给出*卡诺定理*：
#colorbox(
title: [卡诺定理],
color: "blue",
radius: 5pt,
width: auto
)[
所有工作于两个恒温热源之间的热机中，可逆热机效率最高。
#footnote[卡诺定理的证明可通过热力学第二定律进行反证法得到，假设一个一般热机和一个可逆热机工作于相同的两热源之间。]
]
通过卡诺定理可以引出热力学温标，即*卡诺热机的效率是两个热源温度（$theta_1, theta_2$）的普适函数：*
$
eta = W/Q = 1 - Q_2/Q_1 = 1 - F(theta_1,theta_2)
$
可以证明：
$
F(theta_1, theta_2)=T_2/T_1
$
有了卡诺定理和热力学温标，我们就可以进一步引出*克劳修斯不等式*，假设一个系统在循环过程中与 $n$ 个热源接触，分别吸收热量 $Q_1, Q_2, dots.c, Q_n$ ，对外做功 $W$ ，则有：
$
sum_(i=1)^n Q_i/T_i lt.eq 0
$<clausius-theorem>
为了证明克劳修斯不等式，我们引入一个热源 $T_0$ ，和 $n$ 个可逆卡诺热机，使第 $i$ 个卡诺热机工作于热源 $T_i$ 与 $T_0$ 之间，分别从 $T_i, T_0$ 吸收热量 $-Q_i, Q_(0i)$，向外做功 $W_i$。于是这整个大系统对外做的总功为 $W_(op("total"))=W+sum_(i=1)^n W_i$，根据热力学第一定律，$W_(op("total"))=Q_0 equiv sum_(i=1)^n Q_(0 i)$，如果$Q_0 > 0$，那么 $W_(op("total")) > 0$，总系统从单一热源（$T_0$）吸收热量并完全转化为功，这违反了热力学第二定律的开尔文表述。所以 $Q_0 lt.eq 0$，即有 $sum_(i=1)^n Q_(0 i) lt.eq 0$，根据卡诺定理：
$
Q_(0 i)/T_0 + (- Q_i)/(T_i) = 0\
Q_0 = sum_(i=1)^n Q_(0 i) = T_0 sum_(i=1)^n Q_i/T_i lt.eq 0
$
这就证明了克劳修斯不等式( @clausius-theorem )成立，如果考虑 $n arrow infinity$ 的极限情况，则：
$
lim_(n arrow infinity) sum_(i=1)^n Q_i/T_i lt.eq 0 arrow integral.cont (\u{0111}Q)/T lt.eq 0
$<clausius-theorem-int>
对于可逆循环过程， @clausius-theorem-int 可以取等号。
有了克劳修斯不等式我们就可以引入熵了。现在考虑任意可逆循环过程：
$
integral.cont (\u{0111}Q_R)/T = 0
$
#grid(
columns: 2,
gutter: 5pt,
box(width: 100%)[
假设独立变量 $x_1, x_2, dots.c, x_k$ 描述该系统的平衡态，那么该系统的一个可逆过程就是处于这 $k$ 个独立变量构成的 $k$ 维状态空间中的一个闭合曲线。在这条封闭曲线上取两个点 $P_0, P$ ，这两个点对应于系统的两个平衡态。于是对封闭路径积分就有：$
integral.cont (\u{0111}Q_R)/T &= attach(
limits(integral),
b: C_1,
br: (P_0),
tr: (P),
) (\u{0111}Q_R)/T \
&+ attach(
limits(integral),
b: C_2,
br: (P),
tr: (P_0),
) (\u{0111}Q_R)/T = 0
$
],
box(width: 100%)[
#figure(
cetz.canvas(
{import cetz.draw: *
// 坐标轴
let x = (0,3)
let y = (0,3)
set-style(mark: (fill: none))
line((x.at(0),0),(x.at(1),0), mark: (end: ">"), stroke: (paint: luma(30%)))
content((x.at(1)-.1,-.3),[$x_1$])
line((0,y.at(0)),(0,y.at(1)), mark: (end: ">"), stroke: (paint: luma(30%)))
content((0,y.at(1)+.3),[$x_2$])
// 给出初终态的位置
let A = (2.25,2.5)
let B = (.5,.25)
// 绘制过程的曲线
let ctrl_point(x,y) = {
(B.at(0)+x*(A.at(0)-B.at(0)), B.at(1)+y*(A.at(1)-B.at(1)))
}
bezier(A, B, ctrl_point(.1,.7))
content((A.at(0),A.at(1)+.2),[$P$])
content(ctrl_point(.1,.7),[$C_1$])
bezier(B, A, ctrl_point(.8,.1))
content((B.at(0)-.25,B.at(1)+.1),[$P_0$])
content(ctrl_point(.8,.2),[$C_2$])
}),
caption: [可逆循环过程]
)
]
)
可以改写为：
$
attach(
limits(integral),
b: C_1,
br: (P_0),
tr: (P),
) (\u{0111}Q_R)/T
= - attach(
limits(integral),
b: C_2,
br: (P),
tr: (P_0),
) (\u{0111}Q_R)/T
= attach(
limits(integral),
b: C_2,
br: (P_0),
tr: (P),
) (\u{0111}Q_R)/T
$
即沿 $C_1$ 与沿 $C_2$ 的积分值相等，我们定义这个积分值就是两个平衡态 $P_0, P$ 之间的熵差：
$
Delta S = S - S_0 = integral_((P_0))^((P)) (\u{0111}Q_R)/T
$
#note[
对于理想气体，要计算熵变，对于等温、等压、等容过程分别有：
$
\u{0111}Q_T = p dif V, quad \u{0111}Q_p = C_P dif T, quad \u{0111}Q_V = C_V dif T
$
]
熵的几个性质：
- 没错，熵同样是状态函数，只和状态有关。
- 熵是广延量，这是因为系统从热源吸收的热量 $\u{0111}Q_R$ 与系统的总质量成正比，这使得熵具有可加性。
- 作为状态函数，熵变仅与初末状态有关，与过程无关。
#colorbox(
title: [熵增原理],
color: "blue",
radius: 5pt,
width: auto
)[
系统的熵在*绝热过程*中永不减少，可逆绝热过程中不变，不可逆绝热过程中增加。
$
Delta S gt.eq integral_1^2 (\u{0111}Q_R)/T
$
]
==== 绝热过程的进行方向
熵增原理给出了绝热过程的进行方向。考虑等温过程来引入两个态函数，*自由能*和*吉布斯函数*。
- *自由能：*考虑等温过程（$T_1=T_2=T$），有熵增原理$
&Delta S = integral_1^2 (\u{0111} Q)/T = 1/T integral_1^2 \u{0111}Q = Q/T gt.eq 0\
arrow.double& T Delta S gt.eq Q = Delta U - W arrow.double Delta U - T Delta S lt.eq W \
arrow.double& (U_2 - U_1) - T (S_2 - S_1) lt.eq W
$定义自由能 $F equiv U - T S$，则有 $F_2 - F_1 lt.eq W$，在仅有压缩功（$\u{0111} W = -p dif V$）并考虑等温等压过程，则有 $Delta F lt.eq 0$。也就是说#highlight[*等温等压过程向自由能减小的方向进行。*]$
dif F = dif (U - T S) = - S dif T - p dif V
$
- *吉布斯函数：*考虑等温等压过程（$T_1=T_2=T, p_1=p_2=p$）：$
&Delta F lt.eq W = W_1 - p Delta V arrow.double Delta F + p Delta V lt.eq W_1 \
arrow.double& (F_2 - F_1) + p (V_2 - V_1) lt.eq W_1
$定义吉布斯函数 $G equiv F + p V$ ，则有 $G_2 - G_1 lt.eq W_1$ ，如果不考虑非膨胀功，那么进一步有 $Delta G lt.eq 0$ ，#highlight[即等温等压过程向吉布斯函数减小的方向进行。]$
dif G = dif (F + p V) = - S dif T + V dif p
$
|
|
https://github.com/Shambuwu/stage-docs | https://raw.githubusercontent.com/Shambuwu/stage-docs/main/documenten/realisatierapport.typ | typst | #align(
center,
text(
size: 1.2em,
[
*Competentie: Realiseren* \
Implementatierapport en uitvoering \
],
)
)
#align(
center,
figure(
image("../bijlagen/realisatierapport/OIG.jpg",
width: 400pt
)
)
)
#let date = datetime(
year: 2023,
month: 6,
day: 30
)
#place(
bottom + left,
text[
*Student:* <NAME> \
*Studentnummer:* 405538 \
*Datum:* #date.display() \
*Onderwerp:* Competentie: Analyseren \
*Opleiding:* HBO-ICT \
*Studiejaar:* 3 \
]
)
#place(
bottom + right,
image("../bijlagen/logo.png", width: 175pt)
)
#pagebreak()
#set heading(numbering: "1.1")
#show heading: it => {
set block(below: 10pt)
set text(weight: "bold")
align(left, it)
}
#outline(
title: [
*Inhoudsopgave*
],
)
#set page(
numbering: "1 / 1",
number-align: right,
)
#pagebreak()
= Samenvatting
Tijdens de stage is een datavisualisatietool voor Tenwise ontwikkeld. Het project voorziet in een webinterface voor de analyse van voedselrecepten. De architectuur is gebaseerd op een React frontend en een Symfony backend, geïntegreerd in Docker containers voor eenvoudige schaalbaarheid en implementatie.
In de frontend wordt gebruik gemaakt van React voor herbruikbare en efficiënte componenten, wat een vloeiende gebruikerservaring oplevert. De Symfony-backend biedt een robuuste en flexibele oplossing voor webontwikkeling.
De stappen voor implementatie omvatten het vaststellen van doelen en problemen, verzamelen van requirements, ontwikkeling en advisering van het ontwerp en de daadwerkelijke realisatie. Implementatie is voltooid in Q2, 2023. De student heeft zich gefocust op het ontwikkelen van de backend en optimalisatie.
Voor succes zijn een stabiele API, een efficiënte database en een schaalbare architectuur vereist. Mogelijke risico's zijn een gebrek aan kennis van de gebruikte technologieën en een gebrek aan tijd voor implementatie. De student heeft zich ingezet om deze risico's te beperken door het volgen van cursussen en het opstellen van een planning.
Dit rapport beschrijft de implementatie van de applicatie en de stappen die zijn genomen om de applicatie te ontwikkelen. Het rapport is bedoeld voor de opdrachtgever, de begeleiders, de student en toekomstige ontwikkelaars van de applicatie.
#pagebreak()
= Inleiding
== Achtergrondonderzoek
Één van de belangrijkste onderdelen van het project is de dataoverdracht tussen de frontend en de backend. De student heeft onderzoek gedaan naar de verschillende methoden voor dataoverdracht en de voor- en nadelen van elke methode.
Er is gekeken naar de performance van het ophalen van nodes in Neo4j met een Object Graph Mapper (OGM) en de standaard Neo4j-driver. Via tijdsmetingen en statistische analyse is geconcludeerd dat de OGM, in dit geval, een betere performance biedt.
== Doel, resultaten en afbakening
Het doel van de implementatie is het vinden van de meest efficiënte manier om met de data om te gaan en het ontwikkelen van een stabiele en schaalbare architectuur. Het resultaat is een snellere en efficiëntere applicatie die eenvoudig kan worden uitgebreid. Dit implementatierapport is gelimitteerd tot de backend van de applicatie.
== Randvoorwaarden
De volgende randvoorwaarden zijn gesteld voor de implementatie:
- *Beschikbaarheid van vakkennis*: De organisatie heeft voldoende kennis van de gebruikte technologieën.
- *Beschikbaarheid van medewerkers*: De organisatie heeft voldoende medewerkers met kennis van de gebruikte database, backend en frontend technologieën.
- *Beschikbaarheid van middelen:* De organisatie heeft voldoende middelen om de applicatie te hosten en te onderhouden.
- *Commitment van het management:* Het management is bereid om de applicatie te onderhouden en uit te breiden.
== Overzicht van de structuur
#box(height: 225pt,
columns(2)[
#set par(justify: true)
+ *Samenvatting:* Dit deel biedt een beknopt overzicht van de belangrijkste punten van het rapport.
+ *Inleiding:* Hier wordt de context en het doel van het rapport uiteengezet.
+ *Implementatiestappen:* Dit hoofdstuk is opgedeeld in verschillende subsecties zoals voorbereiding, realisatie en de verschillende componenten van de applicatie zoals opstelling, configuratie, controllers, services en entiteiten.
+ *Communicatieplan:* Dit deel beschrijft hoe de communicatie tussen alle betrokken partijen wordt beheerd.
+ *Beheersplan:* Hier wordt het plan voor het effectief beheren van de applicatie gedurende haar levenscyclus uiteengezet.
+ *Conclusie:* Dit hoofdstuk biedt een samenvatting van de belangrijkste bevindingen en resultaten van het rapport.
+ *Bronnen:* Hier worden alle referenties en bronnen vermeld die zijn gebruikt tijdens het schrijven van het rapport.
]
)
#pagebreak()
= Implementatiestappen
== Voorbereiding
Voordat de implementatie kan beginnen zijn er een aantal stappen die moeten worden uitgevoerd. Er moet een serverruimte worden ingericht en de benodigde software moet worden geïnstalleerd. Testomgevingen moeten worden opgezet om de functionaliteit van de applicatie te testen. Tenslotte moet er een planning worden opgesteld om de voortgang van de implementatie te bewaken.
De stappenplan voor de realisatie is als volgt:
+ *SSH Verbinding maken met je VPS*
- Gebruik een SSH-client om verbinding te maken met je VPS.
+ *Docker, Docker Compose en Git Installeren*
- Update eerst je pakketlijst: `sudo apt update` (Debian-based distro's)
- Installeer Docker: `sudo apt install docker`
- Installeer Docker Compose: `sudo apt install docker-compose`
+ *Kopieer Bestanden van Github*
- Gebruik `git` of een andere methode om de bestanden naar de VPS te kopiëren.
+ *Composer en NPM Stages Bouwen*
- Voer `docker build --pull` uit om de containers te bouwen.
+ *Docker Compose Up*
- Ga naar de directory waar je `docker-compose.yml` staat.
- Voer `docker-compose up -d` uit om de containers te bouwen en te starten.
+ *Environment File*
- Zorg ervoor dat je een `.env` file hebt met de benodigde environment variabelen. Plaats deze in dezelfde directory als je `docker-compose.yml`.
+ *Frontend (Native)*
- De frontend draait op dit moment native. Dit zal in de toekomst worden gecontaineriseerd.
+ *Toegang*
- Nu zou de API toegankelijk moeten zijn via `http://<je-VPS-ip>:9000` en Neo4j via `http://<je-VPS-ip>:7474`.
+ *Logs & Debugging*
- Gebruik `docker logs <container_naam>` voor logs.
+ *Stop & Verwijder Containers*
- Gebruik `docker-compose down` als je de containers wilt stoppen en verwijderen.
De opzet van de test- en productieomgeving is hetzelfde, met uitzondering van de environment variabelen. De testomgeving gebruikt een andere Neo4j-database en de productieomgeving gebruikt een andere Neo4j-database en een andere API-URL.
#pagebreak()
== Realisatie
De realisatie van de applicatie bestaat uit het ontwikkelen van de backend en het optimalisatieproces.
=== Opstelling
De opstelling van de backend server maakt gebruik van Docker en docker-compose om een geïsoleerde omgeving te creëren waarin de Symfony-applicatie en Neo4j-database kunnen draaien. De `Dockerfile` bevat instructies om de Docker-image voor de Symfony-applicatie te bouwen. De `docker-compose.yml` bevat instructies om de containers te bouwen en bevat instructies hoe deze containers met andere services, zoals de Neo4j-database, samenwerken.
*Dockerfile*
- *Stages*:
- *Composer Stage*: Gebruikt het `composer:latest` image om de PHP-afhankelijkheden te installeren.
- *NPM Stage*: Gebruikt het `node:latest` image om de Node.js-afhankelijkheden te installeren.
- *PHP Stage* Gebruikt het `php:latest` image als het uiteindelijke image.
- *Commando's*:
- `composer install`: Installeert PHP-afhankelijkheden.
- `npm install`: Installeert Node.js-afhankelijkheden.
- `apt-get update`: Update de pakketlijst in het PHP-image.
*docker-compose.yml*
- *Services*:
- `app`: De Symfony-applicatie.
- Build: Vanuit de huidige directory.
- Ports: 9000:9000
- Command: Start de PHP-server en voert npm run watch uit.
- `db`: De Neo4j-database.
- Image: neo4j:latest
- Ports: 7474:7474, 7687:7687
- Volumes: Data en configuratiebestanden.
- *Volumes*:
- `db`: Gedefinieerd voor het bewaren van Neo4j-data. De container is `delegated`, wat betekent dat de host in read-only mode is en niet direct kan schrijven naar het volume. Dit is een veiligheidsmaatregel om te voorkomen dat de host de database beschadigt.
Deze Docker-configuratie maakt het gemakkelijk om de hele stack (Symfony-app en Neo4j-database) lokaal te draaien voor ontwikkeling. Het maakt gebruik van meerdere stages in de `Dockerfile` om de build te optimaliseren en omvat alle benodigde configuratie in de `docker-compose.yml`.
==== Waarom Docker en Docker Compose?
Docker biedt een manier om de applicatie de afhankelijkheden in een geïsoleerde container te draaien. Dit maakt het gemakkelijker om de applicatie te verspreiden en uit te voeren op verschillende systemen. Docker Compose gaat nog een stapje verder door meerdere containers te orkestreren en te verbinden. Dit faciliteert het gebruik van meerdere services, bijvoorbeeld een webserver en een database, in één applicatie.
==== Voordelen
+ *Isolatie*: Docker containers zijn geïsoleerd van elkaar en van het host systeem. Dit betekent dat de applicatie in een gecontroleerde omgeving draait en dat de applicatie niet kan worden beïnvloed door andere applicaties of het host systeem.
+ *Draagbaarheid*: Docker containers zijn draagbaar. Dit betekent dat de applicatie op verschillende systemen kan worden uitgevoerd zonder dat er wijzigingen nodig zijn.
+ *Schaalbaarheid*: Docker containers zijn schaalbaar. Dit betekent dat de applicatie kan worden geschaald door meer containers toe te voegen.
+ *Versiebeheer*: Docker maakt het gemakkelijk om verschillende versies van de applicatie of database te beheren, wat handig is voor het testen van nieuwe functies.
*Nadelen*
+ *Complexiteit*: Docker containers zijn complexer dan traditionele applicaties. Dit betekent dat er meer kennis nodig is om de applicatie te beheren.
+ *Resourcegebruik*: Containers kunnen meer resources gebruiken dan traditionele applicaties.
+ *Leercurve*: Docker heeft een steile leercurve. Dit betekent dat het meer tijd kost om te leren hoe Docker werkt.
==== Conclusie
De opstelling van Docker en Docker Compose biedt een robuuste en flexibele omgeving voor de Symfony- en Neo4j-gebaseerde applicatie. Hoewel er enige complexiteit en overhead is, worden deze nadelen gecompenseerd door de voordelen op het gebied van isolatie, draagbaarheid en schaalbaarheid.
#pagebreak()
=== Configuratie
==== Configuratie in Symfony
De volgende configuratiebestanden zijn cruciaal voor het functioneren van de Symfony-applicatie. Deze bestanden bieden een gecentraliseerde plek om verschillende aspecten van de applicatie te beheren.
- `Bundles.php`:
- Doel: Dit bestand bevat de lijst van alle Symfony-bundels die in de applicatie zijn geïnstalleerd.
- Inhoud: Het bevat bundels zoals `FrameworkBundle`, `MakerBundle`, `TwigComponentBundle`, etc.
- `Framework.yaml`:
- Doel: Basisconfiguratie voor de Symfony-applicatie.
- Inhoud: Bevat instellingen zoals `secret`, `session`, `php_errors`, etc.
- `Routing.yaml`:
- Doel: Configuratie voor de routering in de applicatie.
- Inhoud: Bevat instellingen zoals `utf8: true` en `strict_requirements: null` voor productie.
- `Twig.yaml`:
- Doel: Configuratie voor de Twig templating engine.
- Inhoud: Bevat het pad naar de templates en instellingen voor testomgevingen.
- `Validator.yaml`:
- Doel: Configuratie voor validatie van entiteiten in de applicatie.
- Inhoud: Bevat instellingen zoals `email_validation_mode: html5`.
- `Routes.yaml`:
- Doel: Definieert de routes voor de controllers.
- Inhoud: Bevat de `resource` en `namespace` voor de controllers.
- `Services.yaml`:
- Doel: Configuratie voor de services in de applicatie.
- Inhoud: Bevat instellingen zoals `autowire`, `autoconfigure`, en `bind`.
==== Configuratie in Neo4j
Het Neo4j-configuratiebestand is te vinden in `./conf/neo4j.conf`. Dit bestand bevat de belangrijkste instellingen voor de Neo4j-database en de verbinding met de Symfony-applicatie.
- *Algemene Instellingen*:
- `server.default_listen_address=0.0.0.0`: Hiermee kan de server verbindingen van elk IP-adres accepteren.
- `dbms.security.auth_enabled=false`: Authenticatie is uitgeschakeld voor eenvoudige toegang. Dit moet worden ingeschakeld voor productie.
- *Geheugenbeheer*:
- `server.memory.pagecache.size=1G`: Grootte van de pagina-cache.
- `dbms.memory.heap.max_size=1G`: Maximale grootte van de Java heap.
- *Netwerkconnectoren*:
- `server.bolt.enabled=true`: Bolt-connector is ingeschakeld.
- `server.http.enabled=true`: HTTP-connector is ingeschakeld.
- `server.https.enabled=false`: HTTPS is uitgeschakeld.
- *Logging*:
- `server.directories.logs=/logs`: Pad naar de logbestanden.
- *Overig*:
- `db.tx_log.rotation.retention_policy=100M size`: Retentiebeleid voor transactielogboeken.
Dit bestand biedt een basis voor de Neo4j-database en maakt het mogelijk om eenvoudig aanpassingen te doen voor specifieke behoeften.
#pagebreak()
=== Controllers
==== Algemene Architectuur
De Symfony Server maakt gebruik van het MVC (Model-View-Controller) model, wat een goede scheiding van verantwoordelijkheden biedt. De controllers zijn verantwoordelijk voor het ontvangen van de HTTP requests en het doorsturen van de requests naar de juiste services. De services zijn verantwoordelijk voor het verwerken van de requests en het terugsturen van de response.
==== Controllers en Endpoints
- *IndexController*: Deze controller is verantwoordelijk voor het renderen van de indexpagina. Het maakt gebruik van de `OGMClient` service om gegevens op te halen. \ *Endpoints*:
+ `GET /`: Deze route haalt alle entiteiten op uit de Neo4j-database en rendert ze op de hoofdpagina. Het maakt gebruik van de OGMClient service om deze taak uit te voeren.
- *QueryController*: Deze controller heeft meerdere routes en is verantwoordelijk voor het uitvoeren van CRUD-operaties op de Neo4j-database. Het maakt gebruik van Symfony's `ValidatorInterface` voor validatie en de `OGMClient` service voor database-injectie. \ *Endpoints*:
+ `GET /query`: Deze route haalt alle entiteiten op uit de Neo4j-database en rendert ze op de hoofdpagina. Het maakt gebruik van de OGMClient service om deze taak uit te voeren.
+ `POST /insert`: Deze route is verantwoordelijk voor het toevoegen van een nieuwe node aan de Neo4j-database. Het maakt gebruik van Symfony's ValidatorInterface om de nieuwe node te valideren voordat deze wordt toegevoegd.
+ `GET /api/nodes/{type}`: Deze route haalt alle nodes op van een bepaald type uit de Neo4j-database. Het retourneert een JSON-object met een lijst van nodes van het opgegeven type.
- *TestController*: Deze controller is meer een proof-of-concept en gebruikt de `Neo4jClient` service om alle entiteiten op te halen. \ *Endpoints*:
+ `GET /test`: Deze route is meer een proof-of-concept en haalt alle entiteiten op uit de Neo4j-database. Het maakt gebruik van de Neo4jClient service om deze taak uit te voeren.
==== Conclusie
De API-endpoints zijn ontworpen om een reeks CRUD-operaties op de Neo4j-database uit te voeren. Ze maken gebruik van verschillende services en validatiemechanismen om ervoor te zorgen dat de integriteit van de applicatie behouden blijft en een consistente gebruikerservaring wordt geboden.
#pagebreak()
=== Services
==== Neo4jClient
Deze service is de brug tussen de Symfony-applicatie en de Neo4j-database. Het is ontworpen om CRUD-operaties te beheren. Kernelementen van de service zijn:
- *Constructor*:
- Neemt parameters als `$alias`, `$url`, `$username` en `$password`. Deze parameters worden gebruikt om de gebruiker te authenticeren bij de Neo4j-database.
- Maakt gebruik van de `ClientBuilder` om een Neo4j-client te initialiseren.
- *Methodes*:
- `getClient()`:
- Doel: Geeft de huidige Neo4j-client terug.
- Return Type: ClientInterface
- `setClient(ClientInterface $client)`:
- Doel: Stelt een nieuwe Neo4j-client in.
- Parameters: Een object dat voldoet aan ClientInterface.
- Return Type: self
- `getAllEntities()`:
- Doel: Haalt alle entiteiten van het type Movie uit de database.
- Return Type: CypherList
- Cypher Query: MATCH (n: Movie) RETURN n
==== OGMClient
Deze service is bedoeld voor het beheren van entiteiten via Object-Graph Mapping (OGM), wat een meer abstracte manier is om met de Neo4j-database te werken.
- *Constructor*:
- Neemt de `$url` als parameter. Deze parameter wordt gebruikt om de gebruiker te authenticeren bij de Neo4j-database.
- Initialiseert `EntityManager` van `GraphAware\Neo4j\OGM`.
- *Methodes*:
- `getEntityManager()`:
- Doel: Geeft de huidige `EntityManager` terug.
- Return Type: `EntityManager`
- `getAllEntities()`:
- Doel: Haalt alle `Node` entiteiten uit de database.
- Return Type: `array`
- `getEntity(string $id)`:
- Doel: Haalt een specifieke `Node` entiteit op basis van de ID.
- Parameters: `id` van het type `string`.
- Return Type: `Node`
==== Conclusie
De twee belangrijkste services in de Symfony-applicatie zijn de `Neo4jClient` en de `OGMClient`. Deze dienen als ruggengraat voor alle interacties met de Neo4j-database. Ze bieden een goed gestructureerde en georganiseerde manier om de CRUD-operaties te beheren.
- `Neo4jClient`: Deze service is meer low-level en biedt de flexibiliteit om directe Cypher queries uit te voeren. Het is ideaal voor situaties waar je volledige controle wilt hebben over de database-interacties.
- `OGMClient`: Aan de andere kant biedt deze service een hoger niveau van abstractie via Object-Graph Mapping. Het is gebruiksvriendelijker en maakt het eenvoudiger om complexe relaties tussen entiteiten te beheren.
Kortom, de `Neo4jClient` en `OGMClient` bieden een goede balans tussen flexibiliteit en gebruiksvriendelijkheid. De `OGMClient` wordt voornamelijk gebruikt voor het ophalen van entiteiten voor de huidige frontend.
#pagebreak()
=== Entiteiten
==== Node
*Algemene Informatie*:
- Namespace: `App\Entity`
- Gebruikte Libraries: `GraphAware\Neo4j\OGM`, `Symfony\Component\Validator\Constraints`, `Doctrine\Common\Collections`
- Neo4j Label: `Node`
*Attributen*:
- `$id`:
- Type: `string`
- Annotaties: `@OGM\GraphId()`
- Beschrijving: Unieke identificatie voor de node in de Neo4j-database.
- `$type`:
- Type: `string`
- Annotaties: `@OGM\Property(type="string")`, `@Assert\NotBlank()`
- Beschrijving: Het type van de node. Kan niet leeg zijn.
- `$relatedNodes`:
- Type: `Collection|Node[]`
- Annotaties: `@OGM\Relationship(type="RELATES_TO", direction="OUTGOING", targetEntity="App\Entity\Node", collection=true)`
- Beschrijving: Een collectie van gerelateerde nodes.
*Methodes*:
- `__construct()`:
- Doel: Initialiseert de `$nodes` als een lege `ArrayCollection`.
- `addRelatedNode(Node $node): void`:
- Doel: Voegt een gerelateerde node toe aan `$relatedNodes`.
- Parameters: `Node $node`
- `removeRelatedNode(Node $node): void`:
- Doel: Verwijdert een gerelateerde node uit `$relatedNodes`.
- Parameters: `Node $node`
- `getRelatedNodes(): Collection|Node[]`:
- Doel: Haalt de gerelateerde nodes op.
- Return Type: `Collection|Node[]`
- `getId(): string` en `getType(): string`:
- Doel: Haalt de waarden van `$id` en `$type` op.
- Return Type: `string`
- `setType(string $type): self`:
- Doel: Stelt de waarde van `$type` in.
- Parameters: `string $type`
- Return Type: `self`
De `Node` entiteit is vrij gestroomlijnd en biedt een goede basis voor het modelleren van nodes in een Neo4j-database. Het maakt gebruik van Symfony's validatie en Neo4j's OGM om een robuuste en flexibele entiteit te creëren.
== Communicatieplan
Het is van groot belang dat alle betrokkenen bij de implementatie op de hoogte is van wat hij of zij moet doen, weet waarom de implementatie plaatsvindt en wanneer bepaalde activiteiten moeten worden uitgevoerd. De student heeft een communicatieplan opgesteld om ervoor te zorgen dat alle betrokkenen op de hoogte zijn van de implementatie.
Hiervoor is het volgende communicatieplan opgesteld:
#table(
columns: (0.6fr, 1fr, 1fr, 1fr),
inset: 10pt,
align: center,
[*Doelgroep*], [*Doel*], [*Boodschap*], [*Communicatiemiddel*],
"Collega",
"Collega's zijn op de hoogte van de voortgang van het product, openstaande taken, retrospective en planning.",
"De voortgang van het product en openstaande taken worden gedeeld via Jira en dagelijkse stand-ups. Retrospective en planning om de week",
"Dagelijkse stand-up met collega's en Jira.",
"Opdrachtgever",
"De opdrachtgever is op de hoogte van de voortgang van het product en kan feedback geven waar nodig.",
"De voortgang van het product en de mogelijkheid tot feedback.",
"Wekelijkse online meeting met de opdrachtgever.",
"Begeleiders",
"Begeleiders zijn op de hoogte van de voortgang van het product en kunnen feedback geven waar nodig.",
"De voortgang van het product en de mogelijkheid tot feedback.",
"E-mail, fysiek overleg of online meeting."
)
#pagebreak()
= Beheersplan
== Doel
Het volgende beheersplan is bedoeld om de levenscyclus van de applicatie te stroomlijnen, van ontwikkeling tot productie en onderhoud. Dit plan is bedoeld voor de opdrachtgever, de begeleiders en de toekomstige ontwikkelaars van de applicatie.
== Ontwikkelingsfase
- *Versiebeheer*: Gebruik Git voor versiebeheer. Het hosten van de repository kan op Github.
- *Code Reviews*: Voer regelmatig code reviews uit om de codekwaliteit te waarborgen.
== Testfase
- *Unit Tests*: Schrijf unit tests voor de belangrijkste functionaliteiten van de applicatie.
- *Testomgeving*: Gebruik een testomgeving om de applicatie te testen voordat deze in productie gaat.
== Deploymentfase:
- *Deployment*: Gebruik een CI/CD pipeline om de applicatie te deployen. Dit kan bijvoorbeeld met Github Actions, GitLab CI of Jenkins.
- *Docker*: Gebruik Docker om de applicatie te containeriseren. Dit maakt het gemakkelijker om de applicatie te deployen en te schalen.
== Onderhoudsfase:
- *Monitoring*: Gebruik een monitoring tool om de applicatie te monitoren. Dit kan bijvoorbeeld met Prometheus, Grafana of Zabbix.
- *Back-ups*: Maak regelmatig back-ups van de applicatie en database.
== Toegangsbeheer: (Wanneer nodig)
- *Authenticatie*: Implementeer sterke authenticatiemechanismen.
- *Autorisatie*: Definieer rollen en toegangsrechten.
#pagebreak()
= Conclusie
In dit rapport is een uitgebreide analyse uitgevoerd van de Symfony-Neo4j applicatie. De implementatie is gedetailleerd beschreven, van kerncomponenten en configuratie tot Docker-setup, om een volledig beeld te geven van de applicatiearchitectuur. Het communicatieplan heeft een cruciale rol gespeeld in het project, en het beheersplan biedt een raamwerk voor toekomstig beheer en onderhoud.
De documentatie in dit rapport dient als een uitgebreide handleiding voor het begrijpen van de huidige implementatie en biedt een solide basis voor toekomstige ontwikkeling en schaalbaarheid. Door de nadruk te leggen op best practices, is de applicatie ontworpen met onderhoudbaarheid en uitbreidbaarheid als kernprincipes.
Samenvattend, dit rapport toont aan dat de Symfony-Neo4j applicatie een robuust en flexibel systeem is, goed gepositioneerd voor toekomstige groei en het voldoen aan de behoeften van een uitbreidend gebruikersbestand.
#pagebreak()
= Bronnen
#align(left,
table(
columns: (auto, auto, auto),
rows: (auto, auto, auto),
align: left,
inset: 10pt,
stroke: none,
[*Bijlagen*], [], [],
[Hanzehogeschool Groningen logo], [Hanzehogeschool Groningen], [https://freebiesupply.com/logos/hanzehogeschool-groningen-logo/],
[Titelpagina figuur], [DALL-E-3, OpenAI], [bijlagen -> realisatierapport -> OIG.jpg],
[Symfony Server Source Code], [<NAME>], [https://github.com/Shambuwu/neo4j-symfony-app]
)
)
|
|
https://github.com/tingerrr/anti-matter | https://raw.githubusercontent.com/tingerrr/anti-matter/main/src/lib.typ | typst | MIT License | #import "core.typ"
#import "rules.typ"
/// Mark the end of a part of your document, place this on the last page of your current part. This
/// must be put into the document exactly twice.
///
/// - label (label): the label to use for the fences
/// -> content
#let fence(label: <anti-matter:fence>) = [#metadata("anti-matter-fence") #label]
/// Set the numbering for the current part.
///
/// - numbering (str, function, none): the new numbering for the current part
/// -> content
#let set-numbering(numbering) = locate(loc => {
import "util.typ"
util.assert-pattern(numbering)
let key = core.part(loc)
let (_, idx) = core.select(key)
core.numbering-state().update(value => {
value.numbering.at(idx) = numbering
value
})
})
/// Returns and formats the page number for the given location.
///
/// If `passthrough` is `true` and `loc` is not `none`, then a dictionary is returned which contains
/// the current and last number, as well as whether the numbering was `none` at this location. If
/// the numbering was `none`, then the current number is from the last page with numbering.
///
/// - passthrough (bool): if `false` the page number is not formatted and instead the numbers are
/// returned directly
/// - loc (location, none): the location at which to get the numbers for
/// -> (content, array, none)
#let page-number(
passthrough: false,
loc: none,
) = {
import "util.typ"
util.maybe-locate(loc, loc => {
let key = core.part(loc)
let (counter, idx) = core.select(key)
let at = counter.at(loc).last()
let last = counter.final(loc).last()
let num = core.numbering-state().at(loc).numbering.at(idx)
if passthrough {
(current: at, last: last, at-none: num == none)
} else {
if type(num) == function or (type(num) == str and util.cardinality(num) == 2) {
numbering(num, at, last)
} else if type(num) == str {
numbering(num, at)
}
}
})
}
/// Step the anti-matter counter for the current part.
///
/// -> content
#let step() = locate(loc => {
let key = core.part(loc)
let (counter, idx) = core.select(key)
let num = core.numbering-state().at(loc).numbering.at(idx)
if num != none { counter.step() }
})
/// A template function which applies the page numbering and a show rule for `outline.entry` to fix
/// its page numbering. If you need more granular control over outline entries and page headers see
/// the library documentation. This should be used as a show rule.
///
/// - header (content, none): the page header to display
/// - numbering (array): an array of numberings describing the numberings for each part of your
/// document, the numberings can be a `str`, `function` or `none`, functions receive the current
/// and final amount as arguments
/// - label (label): the label to use for document fences
/// - body (content): the content to render with anti-matter numbering
/// -> content
#let anti-matter(
header: none,
numbering: ("I", "1", "I"),
label: <anti-matter:fence>,
body,
) = {
import "util.typ"
assert.eq(numbering.len(), 3, message: util.oxifmt.strfmt(
"Must have exactly 3 numberings, got {}",
numbering.len(),
))
for n in numbering {
util.assert-pattern(n)
}
set page(
header: step() + header,
numbering: (..args) => page-number(),
)
show outline.entry: rules.outline-entry.with(func: loc => page-number(loc: loc))
locate(loc => {
let fences = query(label, loc)
assert.eq(fences.len(), 2, message: util.oxifmt.strfmt(
"Must have exactly 2 fences, found {}, did you use `fence()` (`<{}>`) more than twice?",
fences.len(),
label,
))
})
// NOTE: for some reason the state needs a default even when it is set here,
// before any page is rendered
core.numbering-state(label: label, numbering: numbering).update((
label: label,
numbering: numbering,
))
body
}
|
https://github.com/miliog/typst-penreport | https://raw.githubusercontent.com/miliog/typst-penreport/master/intro.typ | typst | MIT No Attribution | #import "./typst-penreport/content/title_page.typ": *
#import "./typst-penreport/content/document_properties.typ": *
#import "./typst-penreport/content/version_table.typ": *
#import "./typst-penreport/content/target_table.typ": *
#import "./typst-penreport/content/summary_of_findings.typ": *
#let intro(
title: "",
subtitle: "Penetration Test Report #1",
date: datetime.today(),
versions: (),
targets: (),
client: "",
authors: (),
) = [
#titlePage(title, subtitle, date)
#documentProperties("Document Properties", client, subtitle, targets)
#versionTable("Version Control", versions)
#outline(
title: "Table of Contents",
indent: true,
depth: 2,
fill: none,
)
= Executive Summary
== Introduction
== Scope
== Objectives
== Summary of Findings
#summaryOfFindings()
= Methodology
== Planning
== Risk Classification
== CWE
The Common Weakness Enumeration (CWE) data, including titles, descriptions, and related content referenced in this report, are owned by The MITRE Corporation (MITRE). For detailed terms of use and further information, please refer to MITRE's CWE Terms of Use which can be found at https://cwe.mitre.org/about/termsofuse.html.
#pagebreak()
= Findings
] |
https://github.com/GeorgeHoneywood/alta-typst | https://raw.githubusercontent.com/GeorgeHoneywood/alta-typst/master/example.typ | typst | MIT License | #import "alta-typst.typ": alta, term, skill, styled-link
#alta(
name: "<NAME>",
links: (
(name: "email", link: "mailto:<EMAIL>"),
(name: "website", link: "https://example.com/", display: "example.com"),
(name: "github", link: "https://github.com/example", display: "@example"),
(name: "linkedin", link: "https://linkedin.com/in/example", display: "<NAME>"),
),
tagline: [Software Engineer. #lorem(10)],
[
== Experience
=== Junior Software Engineer \
_Company Two_\
#term[Jul 2021 --- Jul 2022][London, UK]
- #lorem(15)
- #lorem(10)
- #lorem(24)
=== Junior Systems Administrator \
_Company 1_\
#term[Oct 2019 --- Jul 2021][Bournemouth, UK]
- #lorem(20)
- #lorem(10)
References available on request
== Education
=== Higher \
_University Name_\
#term[Sep 2019 --- Jul 2023][Location, UK]
B.Sc. Computer Science with Year in Industry. #lorem(10)
=== A-Levels \
_Place Grammar School_\
#term[Sep 2017 --- Aug 2019][Place, UK]
#lorem(10)
== Interests
- Walks on the beach
- #lorem(8)
- #lorem(6)
- #lorem(4)
- #lorem(12)
#colbreak()
== Projects
==== #link("https://example.com")[Some project]
#lorem(30)
#styled-link("https://example.com")[Example page]
==== Project with a longer name
#lorem(20)
==== Employee Appraisal System
- #lorem(15)
- #lorem(10)
- #lorem(20)
==== Hackathons
/ Hack1: #lorem(20)
/ TwoHackTwo: #lorem(15)
==== Project 4
- #lorem(30)
- #lorem(10)
==== Project Five
- #lorem(23)
== Skills
#skill("Go", 5)
#skill("TypeScript", 3)
#skill("Git", 1)
#skill("Typst", 1)
],
)
|
https://github.com/aurghya-0/Project-Report-Typst | https://raw.githubusercontent.com/aurghya-0/Project-Report-Typst/main/README.md | markdown | # Project Report Template in Typst
This is a simple project report template for college and university level project and can be easily customized to suit your needs.
I will keep adding more functionalities to the template but as typst is rapidly evolving, I do not guarantee any backwords compatibility.
Thank you for using the template. Feel free to fork, modify and PR. |
|
https://github.com/titaneric/typst-mixed-resume | https://raw.githubusercontent.com/titaneric/typst-mixed-resume/main/README.md | markdown | MIT License | # typst-mixed-resume
This typst resume is inspired from [Harkunwar/attractive-typst-resume](https://github.com/Harkunwar/attractive-typst-resume), [giovanniberti/moderncv.typst](https://github.com/giovanniberti/moderncv.typst), and [alta-typst](https://github.com/GeorgeHoneywood/alta-typst), which extract the personal preference and include into one template.
This template allow writing summary or objective in the resume, which will be shown below the name.
You can clone this repo and mutate `resume.typ` to meet your need.
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/genealotree/0.1.0/calc-functions.typ | typst | Apache License 2.0 | #let get-person-by-name(geneal, name) = {
geneal.persons.filter(el => {el.name == name}).at(0)
}
#let get-generation(geneal, name, level: 0) = {
// Default : if no generation set and no parent found for person neither for its partners : 1
let person = get-person-by-name(geneal, name)
if person.generation != none {person.generation + level}
else {
if person.parents-names != none {
let parent-name = person.parents-names.at(0)
level = level + 1
get-generation(geneal, parent-name, level: level)
} else if person.partners-names == () {1 + level} else {
let partners = person.partners-names.map(
el => {get-person-by-name(geneal, el)}
)
if partners.any(el => {el.generation != none}) {
let partners-with-generation = partners.filter(
el => {el.generation != none}
)
return partners-with-generation.at(0).generation
}
let partners-with-parents = partners.filter(
el => {el.parents-names != none}
)
if partners-with-parents == () {1 + level} else {
get-generation(
geneal, partners-with-parents.at(0).name, level: level
)
}
}
}
}
#let set-generations(geneal) = {
geneal.persons = geneal.persons.map(
el => {if el.generation != none {
el
} else {
el.insert("generation", get-generation(geneal, el.name))
el
}}
)
geneal.unions = geneal.unions.map(
el => {
let parent = get-person-by-name(
geneal,
el.parents-names.at(0),
)
let generation = parent.generation
el.insert("parents-generation", generation)
el
}
)
return geneal
}
// On centre toujours les descendants. On rapproche frères et soeurs au plus proche sans clash.
// A chaque génération, on note les coordonnées minimales (= à gauche) et maximales (= à droite) par rapport aux parents. On crée un array de dict(l: , r: ) nommé size, et un dict(nom: spacing) d'espacement après chaque enfant, nommé spacings.
// Si aucun enfant n'a d'enfant : gauche = -nb-enfants*4/2 et droite = nb-enfants*4/2.
// taille-fratrie = nb-enfants*4
// espacements : 4 pour chaque
// Ensuite s'il y a un seul enfant qui a des enfants :
// taille-fratrie = (nb-enfants + 1)*4
// A la génération -1, g--1 = -taille-fratrie/2, d--1 = taille-fratrie/2
// pos-union-enfant = -taille-fratrie/2 + (index(enfant) + 1)*4
// Pour les générations suivantes on join à (l: g--1, r: d--1) l'array de l'enfant, en mettant à jour les entrées en leur ajoutant pos-union-enfant
// gauche = pos-union-enfant + gauche de l'enfant
// droite = pos-union-enfant + droite de l'enfant
// espacements : 4 pour chaque et 8 pour celui qui a des enfants.
// Si deux enfants au moins ont des enfants :
// On regarde s'il a fallu les décaler, c'est à dire s'il y a eu clash.
// On parcourt la liste des enfants qui ont des enfants pour trouver leur espacement les uns par rapport au suivant :
// On parcourt les enfant qui ont des enfants depuis la fin. Pour chacun, on regarde l'espacement aux suivants :
// On somme le droite du 1er et le gauche du second à chaque génération, on prend le max.
// Si ce max est inférieur à leur espacement, on compte leur espacement.
// S'il est supérieur à leur espacement, on compte ce max.
// On rentre les espacements dans un dict (nom: espacement)
// On calcule la taille de la fratrie : somme des espacements.
// pos-union-enfant = espacement + 4 - taille-fratrie/2
// A la génération -1, g--1 = -taille-fratrie/2, d--1 = taille-fratrie/2.
// A la génération -2, g--2 = pos-union-enfant-1er + gauche-enfant-1er, d--2 = pos-union-enfant-dernier + droite-enfant-dernier.
// Pour les générations suivantes on join à (l: g--1, r: d--1) l'array des enfants, en mettant à jour les entrées en leur ajoutant pos-union-enfant. Le 1er enfant donne les l: et le dernier les r:
// gauche = pos-union-enfant-1er + gauche du 1er enfant
// droite = pos-union-enfant-dernier + droite du dernier enfant
// On retourne l'array de dicts (l: , r: ) et le dict de spacings.
#let set-subtree-unions(geneal) = {
for union in geneal.unions {
let union-index = geneal.unions.position(el => {
el.parents-names == union.parents-names
})
let parent0 = get-person-by-name(geneal, union.parents-names.at(0))
let parent1 = get-person-by-name(geneal, union.parents-names.at(1))
if parent0.parents-names != none and parent1.parents-names != none {
geneal.unions.at(union-index).insert("subtree", true)
} else {
geneal.unions.at(union-index).insert("subtree", false)
}
}
geneal
}
#let get-descendants(geneal, union) = {
let descs-names = ()
let children = union.children-names.map(el => {
get-person-by-name(geneal, el)
})
for child in children {
descs-names.push(child.name)
if child.partners-names != none {
for partner-name in child.partners-names {
let child-union = geneal.unions.filter(el => {
child.name in el.parents-names and partner-name in el.parents-names
}).at(0)
descs-names += get-descendants(geneal, child-union)
}
}
}
descs-names
}
#let get-unions-spacing(geneal, union1, union2) = {
// union 1 is at the left of union2
// Extract first union rights and second union lefts at corresponding generations, and get the max distance. Unions must have overlapping generations.
let union1-gens = range(
union1.parents-generation + 1,
union1.parents-generation + union1.size.len() + 1
)
let union2-gens = range(
union2.parents-generation + 1,
union2.parents-generation + union2.size.len() + 1
)
let unions-gens = union1-gens.filter(el => {el in union2-gens})
let union1-rights = union1.size.map(el => {el.r})
let union2-lefts = union2.size.map(el => {- el.l})
// First check if the two unions have married descendants
let unions1-descs = get-descendants(geneal, union1)
let unions2-descs = get-descendants(geneal, union2)
let subtree-unions = geneal.unions.filter(el => {
el.subtree and (
(
el.parents-names.at(0) in unions1-descs and el.parents-names.at(1) in unions2-descs
) or (
el.parents-names.at(1) in unions1-descs and el.parents-names.at(0) in unions2-descs
)
)
})
if subtree-unions != () {
// if the two unions have subtrees, distance between them is the max between the necessary distance outside of the subtree and the position of the subtree union. -> prevents calculating double subtree size. Parents of the subtree must be at the right of the first union and at the left of the second.
for sub-union in subtree-unions {
let sub-union-gens = range(
sub-union.parents-generation,
sub-union.parents-generation + sub-union.size.len() + 1
)
for gen in sub-union-gens {
union1-rights.at(
gen - union1.parents-generation - 1
) = union1-rights.at(
gen - union1.parents-generation - 1
) - sub-union.size.at(
gen - sub-union.parents-generation - 1,
default: geneal.config.siblings-dist
).r - geneal.config.siblings-dist/2
union2-lefts.at(
gen - union2.parents-generation - 1
) = union2-lefts.at(
gen - union2.parents-generation - 1
) - sub-union.size.at(
gen - sub-union.parents-generation - 1,
default: geneal.config.siblings-dist
).l - geneal.config.siblings-dist/2
}
}
}
let union1-rights = union1-rights.slice(
unions-gens.at(0) - union1.parents-generation - 1,
unions-gens.at(-1) - union1.parents-generation
)
let union2-lefts = union2-lefts.slice(
unions-gens.at(0) - union2.parents-generation - 1,
unions-gens.at(-1) - union2.parents-generation
)
let spacing = calc.max(
..union1-rights.zip(union2-lefts).map(el => {
el.sum()
})
)
return spacing
}
#let get-union-sizes-compact(geneal, union) = {
let children = union.children-names.map(el => {
get-person-by-name(geneal, el)
})
let with-childs = children.filter(el => {el.partners-names != ()})
let spacings = children.map(el => {
if el in with-childs {(el.name, geneal.config.siblings-dist*2)} else {(el.name, geneal.config.siblings-dist)}
}).fold(
(:),
(dict, el) => {
dict.insert(el.at(0), el.at(1))
dict
}
)
if with-childs.len() == 0 {
// if no child is a parent
(
size: (
(
l: -spacings.values().sum()/2,
r: spacings.values().sum()/2
),
),
spacings: spacings
)
} else if with-childs.len() == 1 {
// if only one child is a parent
let sib-size = spacings.values().sum()
let g1 = ((l: -sib-size/2, r: sib-size/2),)
let child-index = union.children-names.position(el => {
el == with-childs.at(0).name
})
let child-union-pos = -sib-size/2 + (child-index + 1)*geneal.config.siblings-dist // position relative to parents union center
let union-sizes = geneal.unions.filter(el => {
with-childs.at(0).name in el.parents-names
}).at(0).size.map(el => {
(l: el.l + child-union-pos, r: el.r + child-union-pos)
})
(size: g1 + union-sizes, spacings: spacings)
} else {
// if more than one child is a parent
// calculate spacings between siblings
for child in with-childs.slice(0, -1).rev() {
// First we check if there is a clash at lower generation,
let child-pos = with-childs.position(el => {el == child})
let child-spacings = ()
for next-child in with-childs.slice(child-pos + 1) {
let child-union = geneal.unions.filter(el => {
child.name in el.parents-names
}).at(0)
let next-child-union = geneal.unions.filter(el => {
next-child.name in el.parents-names
}).at(0)
// Calculate distance between the two unions centers.
let min-nescess-dist = get-unions-spacing(
geneal,
child-union,
next-child-union
)
// calculate distance between unions center if no clash
let child-pos-sibs = children.position(el => {el == child})
let next-child-pos-sibs = children.position(el => {el == next-child})
let between-dist = spacings.values().slice(
child-pos-sibs, next-child-pos-sibs
).sum(default: 0)
// Keep the max between the two distances
let spacing = calc.max(between-dist, min-nescess-dist) - (between-dist - geneal.config.siblings-dist*2)
child-spacings.push(spacing)
}
let child-spacing = calc.max(..child-spacings)
spacings.insert(child.name, child-spacing)
}
// calculate unions siblings size
let siblings-size = spacings.values().sum()
let g1 = ((l: -siblings-size/2, r: siblings-size/2),)
// Calculate sizes relative to the parents
let relsizes = ()
for child in with-childs {
let child-union = geneal.unions.filter(el => {
child.name in el.parents-names
}).at(0)
let child-pos = union.children-names.position(el => {
el == child.name
})
let relpos = spacings.values().slice(0, child-pos).sum(default: 0) - siblings-size/2 + geneal.config.siblings-dist // + siblings-dist to be in the middle of the union
let relsize = child-union.size.map(el => {
(l: el.l + relpos, r: el.r + relpos)
})
relsizes.push(relsize)
}
// Make all sizes array the same length
let max-depth = calc.max(..relsizes.map(el => {el.len()}))
let relsizes = relsizes.map(el => {
if el.len() < max-depth {
el + ((l: none, r: none),)*(max-depth - el.len())
} else {el}
})
// Calculate union size : left as the min and right as the max of the sizes relative to the parents between generations.
let union-sizes = ()
for depth in range(max-depth) {
let min-left = calc.min(
..relsizes.map(el => {
el.at(depth).l
}).filter(el => {el != none})
)
let max-right = calc.max(
..relsizes.map(el => {
el.at(depth).r
}).filter(el => {el != none})
)
union-sizes.push((l: min-left, r: max-right))
}
(size: g1 + union-sizes, spacings: spacings)
}
}
#let set-unions-sizes-compact(geneal) = {
// On parcourt les unions à partir de la plus haute génération, on calcule les tailles et on les set
for union in geneal.unions.sorted(key: el => {
-el.parents-generation
}) {
let size = get-union-sizes-compact(geneal, union).size
let spacings = get-union-sizes-compact(geneal, union).spacings
let union-index = geneal.unions.position(el => {
el.parents-names == union.parents-names
})
geneal.unions.at(union-index).insert("size", size)
geneal.unions.at(union-index).insert("spacings", spacings)
}
geneal
}
#let get-union-size-wide(geneal, union) = {
// Attention, à appliquer à une union dont toutes les tailles des unions des enfants sont connues
// minimum 7 cm. Un enfant sans partner vaut 4. Avec partner : on prend la taille de l'union.
// on crée un array avec les tailles alouées à chaque enfant, on somme les tailles, et on prend le maximum entre la valeur obtenue et 7.
let children-size = union.children-names.map(child-name => {
let child = get-person-by-name(geneal, child-name)
if child.partners-names == () {
geneal.config.siblings-dist
} else {
geneal.unions.filter(union => {
child-name in union.parents-names
}).map(union => {
union.size
}).sum()
}
}).sum()
return calc.max(geneal.config.siblings-dist*2, children-size)
}
#let set-unions-sizes-wide(geneal) = {
// On parcourt les unions à partir de la plus haute génération, on calcule les tailles et on les set
for union in geneal.unions.sorted(key: el => {
-el.parents-generation
}) {
let size = get-union-size-wide(geneal, union)
let union-index = geneal.unions.position(el => {
el.parents-names == union.parents-names
})
geneal.unions.at(union-index).insert("size", size)
}
geneal
}
#let get-root-couples(geneal) = {
let root-names = geneal.persons.filter(el => {
el.parents-names == none
}).map(el => {
el.name
})
let parent-names = geneal.unions.map(el => {
el.parents-names
})
return parent-names.filter(el => {
el.at(0) in root-names and el.at(1) in root-names
})
}
#let get-root-spacings(geneal) = {
// Returns a dict of root-couple.join(): spacing to add after the couple
let root-couples = get-root-couples(geneal)
let spacings = (:)
if root-couples.len() > 1 {
for root-couple in root-couples.slice(0, -1).rev() {
let couple-spacings = ()
let couple-index = root-couples.position(el => {el == root-couple})
let root-union = geneal.unions.filter(el => {
root-couple == el.parents-names
}).at(0)
for next-root-couple in root-couples.slice(couple-index + 1) {
let next-couple-index = root-couples.position(el => {
el == next-root-couple
})
let next-root-union = geneal.unions.filter(el => {
next-root-couple == el.parents-names
}).at(0)
// Calculate distance between the two unions centers.
let min-nescess-dist = get-unions-spacing(
geneal,
root-union,
next-root-union
)
// enter couple spacing in spacings if no clash : distance with next
if next-couple-index - couple-index == 1 {
spacings.insert(root-couple.join(), min-nescess-dist)
}
// calculate distance between couples
let roots-between = root-couples.slice(
couple-index,
next-couple-index
)
let between-dist = roots-between.map(el => {
spacings.at(el.join())
}).sum(default: 0)
// Keep the max between the two distances
let couple-spacing = calc.max(between-dist, min-nescess-dist) - between-dist + spacings.at(root-couple.join())
couple-spacings.push(couple-spacing)
}
let max-couple-spacing = calc.max(..couple-spacings)
spacings.insert(root-couple.join(), max-couple-spacing)
}
}
spacings
}
|
https://github.com/RubixDev/typst-tabley | https://raw.githubusercontent.com/RubixDev/typst-tabley/main/tabley.typ | typst | MIT License | #import "@preview/cetz:0.1.2"
#let tabley(pos, columns: 3, name: none, vlines: auto, hlines: auto, ..items) = cetz.draw.group(name: name, ctx => {
import cetz.draw: *
let items = items.pos().map(it => box(inset: 5pt, it))
let table = ()
let row = 0
while true {
if row * columns + columns > items.len() { break }
table.push(items.slice(row * columns, count: columns))
row += 1
}
let item-sizes = table.map(row => row.map(item => measure(item, ctx)))
let row-heights = item-sizes.map(row => calc.max(..row.map(size => size.at(1))))
let column-widths = range(item-sizes.at(0).len()).map(col-idx => calc.max(..item-sizes.map(row => row.at(col-idx).at(0))))
set-origin(pos)
let y-pos = 0
for (y, row) in table.enumerate() {
let x-pos = 0
let row-height = row-heights.at(y)
for (x, item) in row.enumerate() {
let column-width = column-widths.at(x)
let top-left = (x-pos, y-pos)
let bottom-right = (x-pos + column-width, y-pos - row-height)
let top = (x-pos + column-width / 2, y-pos)
let left = (x-pos, y-pos - row-height / 2)
let prefix = str(x) + "-" + str(y)
anchor(prefix + "-top-left", top-left)
anchor(prefix + "-top-right", (bottom-right.at(0), top-left.at(1)))
anchor(prefix + "-bottom-right", bottom-right)
anchor(prefix + "-bottom-left", (top-left.at(0), bottom-right.at(1)))
anchor(prefix + "-top", top)
anchor(prefix + "-right", (bottom-right.at(0), left.at(1)))
anchor(prefix + "-left", left)
anchor(prefix + "-bottom", (top.at(0), bottom-right.at(1)))
anchor(prefix + "-center", (top.at(0), left.at(1)))
content(prefix + "-center", item)
x-pos += column-width
}
y-pos -= row-height
}
if hlines == auto {
line("0-0-top-left", str(column-widths.len() - 1) + "-0-top-right")
for row in range(row-heights.len()) {
line("0-" + str(row) + "-bottom-left", str(column-widths.len() - 1) + "-" + str(row) + "-bottom-right")
}
}
if vlines == auto {
line("0-0-top-left", "0-" + str(row-heights.len() - 1) + "-bottom-left")
for col in range(column-widths.len()) {
line(str(col) + "-0-top-right", str(col) + "-" + str(row-heights.len() - 1) + "-bottom-right")
}
}
})
|
https://github.com/mkpoli/roremu | https://raw.githubusercontent.com/mkpoli/roremu/master/test/test.typ | typst | The Unlicense | #set text(font: "Noto Serif CJK JP")
#show raw: set text(font: "Noto Sans Mono CJK JP")
#import "../src/lib.typ": roremu
#show raw.where(block: true): it => {
box(fill: luma(240), inset: 10pt, radius: 4pt, it)
}
```typst
#roremu(8)
```
#roremu(8)
#v(1em)
```typst
#roremu(8, offset: 8)
```
#roremu(8, offset: 8)
#v(1em)
```typst
#roremu(38, offset: 16)
```
#roremu(38, offset: 16)
#v(1em)
```typst
#roremu(100, custom-text: "私はその人を常に先生と呼んでいた。")
```
#roremu(100, custom-text: "私はその人を常に先生と呼んでいた。")
#v(1em)
```typst
#roremu(125)
#roremu(107, offset: 125)
```
#roremu(125)
#roremu(107, offset: 125)
|
https://github.com/Yzx7/public_study_files | https://raw.githubusercontent.com/Yzx7/public_study_files/main/Monografía FIEE/chapters/questionnaires.typ | typst | = Discusión
Los resultados experimentales confirman plenamente el *comportamiento predicho por la ley de reflexión*. En todos los ángulos de incidencia medidos, se observó que el *ángulo de reflexión* era exactamente igual, lo que concuerda con lo predicho por la teoría. La precisión de las mediciones de ángulos estuvo sujeta a una incertidumbre de ±0,5°, pero incluso dentro de ese margen, no se detectaron discrepancias significativas.
En cuanto a la *distancia objeto-imagen*, las mediciones mostraron que para todas las distancias seleccionadas, la *imagen reflejada* estaba exactamente a la misma distancia del espejo que el objeto real, validando la relación s₀ = si.
Las posibles discrepancias, aunque mínimas, pudieron haber surgido por pequeñas imprecisiones al alinear el lápiz con su imagen reflejada. Sin embargo, estas no alteraron los resultados principales del experimento.
= Conclusiones
En resumen, el experimento *verificó con éxito* la *ley de reflexión* en un espejo plano, confirmando que:
1. El *ángulo de incidencia* es igual al *ángulo de reflexión*.
2. La *distancia del objeto al espejo* es igual a la *distancia de la imagen* al espejo.
Estos resultados refuerzan la validez de la ley de reflexión, un principio fundamental en óptica, y la capacidad de un espejo plano para formar imágenes virtuales de tamaño y distancia equivalentes a los del objeto real. |
|
https://github.com/hitszosa/universal-hit-thesis | https://raw.githubusercontent.com/hitszosa/universal-hit-thesis/main/templates/universal-bachelor.typ | typst | MIT License | #import "@preview/universal-hit-thesis:0.2.1": universal-bachelor
#import universal-bachelor: *
// 参考 本科毕业论文（设计）书写范例（理工类）.doc 进行编写
// 编译命令 typst compile ./templates/universal-bachelor.typ --root ./
// 实时预览 typst watch ./templates/universal-bachelor.typ --root ./
#show: doc.with(
thesis-info: (
// 论文标题，可使用 \n 进行换行
title-cn: "局部多孔质气体静压轴承关键技术的研究",
title-en: "RESEARCH ON KEY TECHNOLOGIES OF PARTIAL POROUS EXTERNALLY PRESSURIZED GAS BEARING",
author: "▢▢▢",
student-id: "▢▢▢▢▢▢▢▢▢▢",
supervisor: "▢▢▢ 教授",
profession: "机械制造及其自动化",
collage: "机电工程学院",
institute: "哈尔滨工业大学",
// year: 2024,
// month: 5,
// day: 1,
),
// 图表选项
figure-options: (
// extra-kinds, extra-prefixes 表示需要执行计数器重置和引用的图表类型
// 参考 https://github.com/RubixDev/typst-i-figured/blob/main/examples/basic.typ
// 示例：extra-kinds: ("atom",), extra-prefixes: (atom: "atom:")，即新建一个 atom 类型，并使用 @atom: 来引用
extra-kinds: (), extra-prefixes: (:),
),
// 参考文献配置
bibliography: bibliography.with("universal-bachelor-ref.bib", full: true, style: "gb-t-7714-2015-numeric-hit.csl"),
abstract-cn: [
气体静压轴承由于具有运动精度高、摩擦损耗小、发热变形小、寿命长、无污染等特点，在航空航天工业、半导体工业、纺织工业和测量仪器中得到广泛应用。本文在分析国内外气体静压轴承的基础上，以改善气体静压轴承的静态特性和稳定性为目的，通过理论分析、仿真计算和实验研究对局部多孔质气体静压止推轴承进行了研究，同时分析轴承的结构参数和工作参数对局部多孔质气体静压止推轴承工作特性的影响，为局部多孔质气体静压轴承的设计和工程应用奠定理论基础。
建立基于分形几何理论的多孔质石墨渗透率与分形维数之间关系的数学模型，该模型可预测多孔质石墨的渗透率，并可直观描述孔隙的大小对渗透率的影响。
本文在理论分析的基础上，建立局部多孔质气体静压止推轴承静态特性的数学模型，在此基础上，通过工程方法和有限元方法对所建立的模型进行求解。在采用有限元方法时，首先通过加权余量法，将二阶偏微分方程降为一阶，从而，降低了对插值函数连续度的要求，同时，方便采用有限元方法进行求解。
……
],
keywords-cn: ("多孔质石墨", "……", "稳定性"),
abstract-en: [
Externally pressurized gas bearing has been widely used in the field of aviation, semiconductor, weave, and measurement apparatus because of its advantage of high accuracy, little friction, low heat distortion, long life-span, and no pollution. In this thesis, based on the domestic and overseas researching development about externally pressurized gas bearing, the author investigated the partial porous externally pressurized gas thrust bearing by theoretical analysis, computer simulation, and experiments to improve its static charaterictics and stability. The effects of structure and operating parameters on partial porous externally pressurized gas bearing has been studied. Therefore, a theoretical foundation for the designing and application for the partial porous externally pressurized gas bearing has been presented.
Based on the fractal theory, a model was established to demonstrate the relationship between the porous graphite permeability and the fractal dimension. It can predict the permeability of porous graphite and show the effects of the pore size on the permeability.
In this thesis, the author established a model about the static characteristics of partial porous externally pressurized gas thrust bearing, and it was analyzed by engineering solution and Finite Element Method (FEM). While using FEM, the second-order partial differential equation was reduced to one-order by adopting Galerkin weighted residual method, for decreasing the continuity degree requirement of the interpolation function and facilitating to the calculation.
],
keywords-en: ("porous graphite", "…", "Stability"),
)
= #[绪#h(1em)论]
== 课题背景、研究目的和意义
发展国防工业、微电子工业等尖端技术需要精密和超精密的仪器设备，精密仪器设备要求高速、……
……
== 气体润滑轴承及其相关理论的发展概况
气体轴承是利用气膜支撑负荷或减少摩擦的机械构件。……
……
=== 气体润滑轴承的发展
1828年，*R.R.Willis* @林来兴1992空间控制技术 发表了一篇关于小孔节流平板中压力分布的文章，这是有记载的研究气体润滑的最早文献。……
根据间隙内气膜压力的产生原理，气体轴承可以分为四种基本形式：
（1）*气体静压轴承* 加压气体经过节流器进入间隙，在间隙内产生压力气膜使物体浮起的气体轴承，……
=== 气体润滑轴承的分类
根据间隙内气膜压力的产生原理，气体轴承可以分为四种基本形式，其结构如图1-1所示。
（1）*气体静压轴承* 加压气体经过节流器进入间隙，在间隙内产生压力气膜使物体浮起的气体轴承，结构如 @fig:气体润滑轴承的分类1 (a) 所示。……
#figure(
grid(
columns: (auto, auto),
rows: (auto, auto),
row-gutter: 1em,
column-gutter: 1em,
[ #align(left)[(a)]
#square(size: 8em, stroke: 2pt)
// 可替换为实际的图片
// image("path/to/image.png", width: 50%)
],
[ #align(left)[(b)] #square(size: 8em, stroke: 2pt) ],
[ #align(left)[(c)] #square(size: 8em, stroke: 2pt) ], [ #align(left)[(d)] #square(size: 8em, stroke: 2pt) ],
),
caption: [气体润滑轴承的分类],
supplement: [图],
)<气体润滑轴承的分类1>
#align(center)[(a) 气体静压轴承; (b) 气体动压轴承; (c) 气体动静压轴承; (d) 气体压膜轴承]
（也可以按照下图范例书写）
#figure(
grid(
columns: (auto, auto),
rows: (auto, auto),
row-gutter: 1em,
column-gutter: 1em,
[ #square(size: 8em, stroke: 2pt) #text()[ (a) 气体静压轴承 ]],
[ #square(size: 8em, stroke: 2pt) #text()[ (b) 气体动压轴承 ]],
[ #square(size: 8em, stroke: 2pt) #text()[ (c) 气体动静压轴承 ]],
[ #square(size: 8em, stroke: 2pt) #text()[ (d) 气体压膜轴承 ]],
),
// image("path/to/image.png", width: 50%),
caption: [气体润滑轴承的分类],
supplement: [图],
)<气体润滑轴承的分类2>
=== 多孔质气体静压轴承的研究
由于气体的压力低和可压缩性，……。
==== 多孔质静压轴承的分类
轴承工作面的整体或……。
==== 多孔质材料特性的研究
材料的主要特点是具有一定的……。
（1）孔隙特性 多孔质材料是由……。
……
== 本文主要研究内容
本课题的研究内容主要是针对局部多孔质止推轴承的多孔质材料的渗透
率、静压轴承的静态特性、稳定性及其影响因素进行展开，……。
#pagebreak()
= 基于FLUENT软件的轴承静态特性研究
== 引言
利用现成的商用软件来研究流场，可以免去对N-S方程求解程序的……
== 问题的提出
本文采用……，则每一个方向上的……由公式 @eqt:formula-1 @eqt:formula-2 求得：
$ phi = D^2_p / 150 psi^3 / (1 - psi)^2 $ <formula-1>
$ C_2 = 3.5 / D_p ((1 - psi)) / psi^3 $ <formula-2>
式中 $D_p$ —— 多孔质材料的平均粒子直径（m）；
#h(1em) $psi$ —— 孔隙度（孔隙体积占总体积的百分比）；
#h(1em) $phi$ —— 特征渗透性或固有渗透性（m2）。
……
== 本章小结
……
#pagebreak()
= 局部多孔质静压轴承的试验研究
== 引言
在前面几章中，分别对局部多孔质材料的渗透率……
== 多孔质石墨渗透率测试试验
……
1号试样的试验数据见 @tbl:1号试样的实验数据。
#figure(
table(
columns: (1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
stroke: none,
align: center + horizon,
table.hline(),
[供气压力 #linebreak() $P_s ("MPa")$],
[流量测量 #linebreak() $M prime (m^3\/h)$ ],
[#v(.5em) 流量修正值 #linebreak() #v(.5em)
$M (m_3\/s) \ times 10^(-4)$ #v(.25em)],
[压力差 #linebreak() $Delta P ("Pa")$ ],
[$lg Delta P$],
[$lg M$],
table.hline(stroke: .5pt),
// ---
[0.15],
[0.009],
[0.023 12],
[46 900],
[4.671 17],
[-5.636 01],
// ---
[0.2],
[0.021],
[0.045 84],
[96 900],
[4.986 32],
[-5.338 76],
table.hline(),
),
caption: [1号试样渗透率测试数据(温度：T=16 ℃ 高度：H=5.31 mm)],
supplement: [表],
)<1号试样的实验数据>
#linebreak()
#figure(
table(
columns: (1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
stroke: none,
align: center + horizon,
table.hline(),
[供气压力 #linebreak() $P_s ("MPa")$],
[流量测量 #linebreak()$M prime (m^3\/h)$ ],
[#v(.5em) 流量修正值 #linebreak() #v(.5em)
$M (m_3\/s) \ times 10^(-4)$ #v(.25em) ],
[压力差 #linebreak() $Delta P ("Pa")$ ],
[$lg Delta P$],
[$lg M$],
table.hline(stroke: .5pt),
// ---
[0.15],
[0.009],
[0.023 12],
[46 900],
[4.671 17],
[-5.636 01],
// ---
[0.2],
[0.021],
[0.045 84],
[96 900],
[4.986 32],
[-5.338 76],
table.hline(),
),
caption: [试样渗透率测试数据],
supplement: [表],
)<试样渗透率测试数据>
== 本章小结
……
#pagebreak()
= 其他 Typst 使用示例
== 图表
使用`@fig:`来引用图片： @fig:square
#figure(
square(size: 8em, stroke: 2pt),
caption: [A curious figure.],
supplement: [图],
) <square>
#indent 图表之后默认不缩进，如需缩进，可以手动调用`#indent`实现缩进。
#figure(
table(
columns: 4,
[t], [1], [2], [3],
[y], [0.3s], [0.4s], [0.8s],
),
caption: [Timing results],
supplement: [表],
) <time-results>
#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 results（三线表）],
supplement: [表],
) <time-results-three-line-table>
使用`@tbl:`来引用表格： @tbl:time-results @tbl:time-results-three-line-table
== 伪代码
#[
#import "@preview/algorithmic:0.1.0"
#import algorithmic: algorithm
使用`@algo:`来引用伪代码， 支持`algorithmic`和`lovelace`包，如#[@algo:XXX算法]和#[@algo:lovelace-algo]所示
#algorithm-figure(
algorithm({
import algorithmic: *
Function(
"Binary-Search",
args: ("A", "n", "v"),
{
Cmt[Initialize the search range]
Assign[$l$][$1$]
Assign[$r$][$n$]
State[]
While(
cond: $l <= r$,
{
Assign([mid], FnI[floor][$(l + r) / 2$])
If(
cond: $A ["mid"] < v$,
{
Assign[$l$][$m + 1$]
},
)
ElsIf(
cond: [$A ["mid"] > v$],
{
Assign[$r$][$m - 1$]
},
)
Else({
Return[$m$]
})
},
)
Return[*null*]
},
)
}),
caption: [二分查找],
supplement: [算法],
label-name: "XXX算法",
)
#import "@preview/lovelace:0.2.0": *
#algorithm-figure(
pseudocode(
no-number,
[#h(-1.25em) *input:* integers $a$ and $b$],
no-number,
[#h(-1.25em) *output:* greatest common divisor of $a$ and $b$],
[*while* $a != b$ *do*],
ind,
[*if* $a > b$ *then*],
ind,
$a <- a - b$,
ded,
[*else*],
ind,
$b <- b - a$,
ded,
[*end*],
ded,
[*end*],
[*return* $a$],
),
caption: [The Euclidean algorithm],
label-name: "lovelace-algo",
)
]
== 代码块
#[
#code-figure(
```rs
fn main() {
println!("Hello, World!");
}
```,
caption: [XXX代码],
supplement: [代码],
label-name: "XXX代码",
)
#indent 与 Markdown 类似，代码可以高亮显示，使用`@lst:`来引用代码块： @lst:XXX代码
]
#pagebreak()
#show: ending.with(
// 结论
conclusion: [
本文对局部多孔质气体静压止推轴承的静态特性和稳定性进行了理论研究，对于局部多孔质气体静压径向轴承、圆锥轴承和球轴承仅需对止推轴承压力分布的数学模型进行适当的坐标变换即可对其特性进行求解。同时，本文对局部多孔质气体静压止推轴承进行了实验研究并与整体多孔质和小孔节流止推轴承的静态特性和稳定性进行了实验对比。
本论文的主要创造性工作归纳如下：
1. 建立了基于分形几何理论的多孔质石墨渗透率与分形维数之间关系的数学模型，该模型可预测多孔质石墨的渗透率，并可直观描述各种孔隙的大小对渗透率的影响。通过实验验证了该模型的正确性。
2. 分别建立了基于气体连续性方程、Navier-Stokes 方程、Darcy 定律以及气体状态方程的局部多孔质气体静压轴承的承载能力、静态刚度和质量流量的数学模型，利用有限元法进行求解，给出了局部多孔质气体静压轴承的承载能力、静态刚度和质量流量特性曲线。
……
今后还应在以下几个方面继续深入研究：
1. 本文仅是采用了局部多孔质圆柱塞这种节流方式，在以后的研究中，可以通过改变局部多孔质材料的形状来改变节流方式，从而通过性能对比，获得最优的节流效果。
……
],
// 创新性成果，若没有则可以移除或设置为 none
achievement: [
#par(first-line-indent: 0em)[
*一、发表的学术论文*
]
[1] ×××，×××. Static Oxidation Model of Al-Mg/C Dissipation Thermal Protection Materials［J］. Rare Metal Materials and Engineering, 2010, 39(Suppl. 1): 520-524.（SCI收录，IDS号为669JS）
[2] ×××，×××. 精密超声振动切削单晶铜的计算机仿真研究［J］. 系统仿真学报，2007，19（4）：738-741，753.（EI收录号：20071310514841）
[3] ×××，×××. 局部多孔质气体静压轴向轴承静态特性的数值求解［J］. 摩擦学学报，2007（1）：68-72.（EI收录号：20071510544816）
[4] ×××，×××. 硬脆光学晶体材料超精密切削理论研究综述［J］. 机械工程学报，2003，39（8）：15-22.（EI收录号：2004088028875）
[5] ×××，×××. 基于遗传算法的超精密切削加工表面粗糙度预测模型的参数辨识以及切削参数优化［J］. 机械工程学报，2005，41（11）：158-162.（EI收录号：2006039650087）
[6] ×××，×××. Discrete Sliding Mode Cintrok with Fuzzy Adaptive Reaching Law on 6-PEES Parallel Robot［C］. Intelligent System Design and Applications, Jinan, 2006: 649-652.（EI收录号：20073210746529）
#par(first-line-indent: 0em)[
*二、申请及已获得的专利（无专利时此项不必列出）*
]
[1] ×××，×××. 一种温热外敷药制备方案：中国，88105607.3［P］. 1989-07-26.
#par(first-line-indent: 0em)[
*三、参与的科研项目及获奖情况*
]
[1] ×××，×××. ××气体静压轴承技术研究, ××省自然科学基金项目.课题编号：××××.
[2] ×××，×××. ××静载下预应力混凝土房屋结构设计统一理论. 黑江省科学技术二等奖, 2007.
],
// 致谢
acknowledgement: [
衷心感谢导师×××教授对本人的精心指导。他的言传身教将使我终身受益。
感谢×××教授，以及实验室全体老师和同窗们的热情帮助和支持！
本课题承蒙××××基金资助，特此致谢。
……
],
) |
https://github.com/Pegacraft/typst-plotting | https://raw.githubusercontent.com/Pegacraft/typst-plotting/master/plotst/util/util.typ | typst | MIT License |
// Calculates step size for an axis
// full_dist: the distance of the axis while drawing (most likely width or height)
// axis: the axis
// returns: the step size
#let calc_step_size(full_dist, axis) = {
return full_dist / axis.values.len() / axis.step
}
// transforms a data list ((amount, value),..) to a list only containing values
#let transform_data_full(data_count) = {
if not type(data_count.at(0)) == "array" {
return data_count
}
let new_data = ()
for (amount, value) in data_count {
for _ in range(amount) {
new_data.push(value)
}
}
return new_data
}
// transforms a data list (val1, val2, ...) to a list looking like this ((amount, val1),...)
#let transform_data_count(data_full) = {
if type(data_full.at(0)) == "array" {
return data_full
}
// count class occurances
let new_data = ()
for data in data_full {
let found = false
for (idx, entry) in new_data.enumerate() {
if data == entry.at(1) {
new_data.at(idx).at(0) += 1
found = true
break
}
}
if not found {
new_data.push((1, data)) //?
}
}
return new_data
}
// converts an integer or 2-long array to a width, height dictionary
#let convert_size(size) = {
if type(size) == "int" { return (width: size, height: size) }
if size.len() == 2 { return (width: size.at(0), height: size.at(1)) }
}
#let draw_marking(data, markings) = {
if markings == none { return }
if markings == "square" {
markings = square(size: 2pt, fill: black, stroke: none)
} else if markings == "circle" {
markings = circle(radius: 1pt, fill: black, stroke: none)
} else if markings == "cross" {
markings = {
place(line(angle: 45deg, length: 1pt))
place(line(angle: -45deg, length: 1pt))
place(line(angle: 135deg, length: 1pt))
place(line(angle: -135deg, length: 1pt))
}
}
style(s => {
let (width, height) = measure(markings, s)
place(dx: data.at(0) - width/2, dy: data.at(1) - height/2, markings)
})
}
// range that supports float parameters
#let float_range(min, max, step: 1) = {
if type(min) == "float" or type(max) == "float" or type(step) == "float" {
let it = ()
it.push(min)
if step < 0 {
while it.last() + step > max {
assert(it.last() + step < it.last(), message: "step size too small to decrease float")
it.push(it.last() + step)
}
} else {
while it.last() + step < max {
assert(it.last() + step > it.last(), message: "step size too small to increase float")
it.push(it.last() + step)
}
}
it
} else {
range(min, max, step: step)
}
}
/// This function generates `(x, y)` data based on a function to use in other equations.
/// - equation (function): A function that accepts the `x` value of the data and returns the proper `y` value.
/// - start (integer, float): The first `x` value that should be generated.
/// - end (integer, float): The last `x` value that should be generated.
/// - precision (integer): How many lines should be plotted between the `start` and `end` value. The higher the value, the more precise the data will get.
#let function_plotter(equation, start, end, precision: 100) = {
let points = ()
for step in float_range(start, end, step: (end - start) / precision) {
points.push((step, equation(step)))
}
points.push((end, equation(end)))
return points
} |
https://github.com/rem3-1415926/Typst_Thesis_Template | https://raw.githubusercontent.com/rem3-1415926/Typst_Thesis_Template/main/sec/sec1.typ | typst | MIT License | = 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.
Gorgonzola is edible.
+ The climate
- Temperature
- Precipitation
+ The topography
+ The geology
Gorgonzola as the one shown in @fig:gorgonzola will continue to exist regardless of climate change.
#figure(
image("../img/gorgonzola.png", width: 50%),
caption: [
This is _not_ Gorgonzola.
],
) <fig:gorgonzola>
The equation $ Q = rho A v + "time offset" $ defines the glacial flow rate.
Total displaced soil by glacial flow:
$ 7.32 beta +
sum_(i=0)^nabla Q_i / 2 $
// https://typst.app/docs/reference/math/
Resistance is $77 m Omega "/" square.stroked$.
// https://typst.app/docs/reference/symbols/sym/
== subheading
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.
Gorgonzola is edible, but #cite(<harry>) does not prove that.
Integrated Microelectronics are not edible either.
This is not outlined in #cite(<PE_Allen_CMOS>), but should be implicitely clear.
Hayagriva#cite(<hayagriva>) is apparently a YAML based bibliography management, although its advantages over biblatex elude me. (Didn't care to change that, tho).
In unrelated news, @app:one does not provide any insights at all.
#lorem(60) |
https://github.com/gomazarashi/typst_slydst | https://raw.githubusercontent.com/gomazarashi/typst_slydst/main/Typstで静的でシンプルなスライドを作成する【slydstパッケージ】.md | markdown | # はじめに
この記事では、Typstのパッケージであるslydstを使って、静的でシンプルなスライドを作成する方法について解説します。
このパッケージでは、Typstの見出しを利用してスライドのセクションやスライドを作成します。
公式のREADMEによると、アニメーション等はサポートされていないようですが、シンプルなスライドを作成するのには十分な機能が揃っているようです。
# 環境
2024年9月18日時点の最新版を使用しています。
- Typst: 0.11.1
- slydst:0.1.1
# 導入
パッケージの導入は、Typst Universeのページに存在する他のパッケージと同様に行えます。
```typst
#import "@preview/slydst:0.1.1": *
```
# 使い方
## タイトル等の設定
まず、Typstファイルを作成し次のようなプリアンブルを記述します。
```typst
#import "@preview/slydst:0.1.1": *
#show: slides.with(
title: "ここにタイトルを挿入", // 必須
subtitle: none,
date: none,
authors: (),
layout: "medium",
ratio: 4/3,
title-color: none,
)
ここにコンテンツを挿入
```
このプリアンブルでは以下の項目を設定できます。
- title: スライドのタイトル
- subtitle: スライドのサブタイトル
- date: スライドの日付
- authors: スライドの著者
- layout: スライドのレイアウト
- ratio: スライドの幅と高さの比率
- title-color: タイトルの色
タイトルは必須ですが、他の項目は省略可能です。
それでは個人的に設定してみたものを以下に示します。
```typst
#set text(lang: "ja") // 言語を日本語に設定
#set text(font: ("Yu Gothic")) // フォントを設定
#set heading( numbering: "1.1.")
#import "@preview/slydst:0.1.1": * // slydstの導入
#show: slides.with(
title: "Typstでスライドを作成する ", // 必須
subtitle: "slydstで手軽に静的スライドを作ろう",
date: [#datetime.today().display()],
authors: ("ごま"),
layout: "medium",
ratio: 4/3,
title-color: none,
)
```
大体の設定の解説は必要なさそうですが、いくつか補足しておくと、`date`の項目は`#datetime.today().display()`で現在の日付を取得し、表示しています。詳しくは[datetime](https://typst.app/docs/reference/foundations/datetime/)を参照してください。また、`ratio`はスライドの幅と高さの比率を指定します。形式は`幅/高さ`なので、今回は`幅:4, 高さ:3`の比率に設定しています。`title-color`はタイトルの色を指定しますが、デフォルトの色が気に入っているので今回は指定していません。
## スライドの作成
次に、スライドの作成を行います。ここではTypstの見出しを利用してスライドのセクションやスライドを作成します。以下のように記述します。
```typst
= レベル1の見出し→セクション
== レベル2の見出し→スライド
```
このように、Typstの見出しを利用してスライドのセクションやスライドを作成することができます。スライドの内容は、見出しの下に記述します。
## 画像の挿入
画像を挿入する場合は、通常のTypstの画像挿入と同様に記述します。
```typst
== 図を挿入する
これは花です。
#figure(image("flower.jpg", width: 60%))
```
## コードの挿入
raw形式でコードを挿入することもできます。
```typst
== コードを挿入する
```java
class Hello {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```
```
# 他のパッケージとの併用
slydstを他のパッケージと併用してみます。これが可能であれば、LT会や講義等のための資料作成にかなり役立ちそうです。
## codelstでコードを挿入する
codelstパッケージはTypstでコードを挿入するためのパッケージです。以下のように記述します。詳しくは[私の記事](https://qiita.com/gomazarashi/items/ddef3d0db22a9f1e08ba)や[公式のマニュアル](https://github.com/jneug/typst-codelst/blob/main/manual.pdf)を確認していただくとして、今回は簡単な例を示します。
```typst
== codelstを使ってみる
#import "@preview/codelst:2.0.1":*
#sourcecode[```c
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
```]
```
どうやら適切に挿入できているようです。もしサイズなどが気になる場合は`#figure`としてサイズを調整できそうですが、今回は割愛します。
## showyboxで装飾したboxを挿入する
showyboxパッケージはTypstで装飾したboxを挿入するためのパッケージです。こちらも申し訳ないですが、[私の記事](https://qiita.com/gomazarashi/items/2e83759fe6755b14b2bb)や[公式のマニュアル](https://github.com/Pablo-Gonzalez-Calderon/showybox-package/blob/main/Showybox's%20Manual.pdf)を参照してください。
それでは簡単な例を示します。
```typst
== showyboxを使ってみる
#v(10%)
#showybox(title: "Green's Theorem", frame: (
border-color: olive,
title-color: olive.lighten(10%),
body-color: olive.lighten(95%),
footer-color: olive.lighten(80%),
), footer: "証明は省略する。")[
閉曲線$C$で囲まれた領域$D$において、$C^1$級関数$P(x,y)$と$Q(x,y)$に対して、以下が成り立つ。
$ integral.cont_C (P dif x + Q dif y ) = integral.double_D ((diff Q)/(diff x)-(diff P)/(diff y)) dif x dif y $
]
```
数式も含め、適切に挿入できているようです。
# まとめ
今回はTypstのパッケージであるslydstを使って、静的でシンプルなスライドを作成する方法について解説し、他のパッケージとの併用も可能であることが確認できました。今回説明した以外のパッケージとも併用ができそうなので、機会があれば試してみたいと思います。
# 参考
- [slydst0.1.1](https://typst.app/universe/package/slydst)
- [glambrechts/slydst](https://github.com/glambrechts/slydst)
- [Typstでコードを埋め込むには【codelstパッケージ】](https://qiita.com/gomazarashi/items/ddef3d0db22a9f1e08ba)
- [Typstで式やテキストを装飾する【showyboxパッケージ】](https://qiita.com/gomazarashi/items/2e83759fe6755b14b2bb)
|
|
https://github.com/sthenic/technogram | https://raw.githubusercontent.com/sthenic/technogram/main/src/lib.typ | typst | MIT License | #import "descriptions.typ": *
#import "admonitions.typ": *
#import "tree.typ": *
#import "cpp.typ" as cpp
#import "registers.typ" as reg
#import "presentation.typ": presentation
#import "document.typ": document, changelog, changelog-section, backmatter, appendix
#import "palette.typ": DEFAULT-PALETTE, update-palette, get-palette
#import "metadata.typ": get-metadata
#import "requirements.typ": requirements, req, reqcomment
#let fixme(body) = block(text(fill: red, [*FIXME:* ] + body))
|
https://github.com/dogezen/badgery | https://raw.githubusercontent.com/dogezen/badgery/main/README.md | markdown | MIT License | # Badgery
This package defines some colourful badges and boxes around text that represent user interface actions such as a click or following a menu.
For examples have a look at the example [main.typ](./example/main.typ), [main.pdf](./example/main.pdf).
## Badges
```typ
#badge-gray("Gray badge"),
#badge-red("Red badge"),
#badge-yellow("Yellow badge"),
#badge-green("Green badge"),
#badge-blue("Blue badge"),
#badge-purple("Purple badge")
```
## User interface actions
This is a user interface action (ie. a click):
```typ
#ui-action("Click X")
```
This is an action to follow a user interface menu (2 steps):
```typ
#menu(("File", "New File..."))
```
This is a menu action with multiple steps:
```typ
#menu(("Menu", "Sub-menu", "Sub-sub menu", "Action"))
```
|
https://github.com/NyxAlexandra/ib-internal-asessment | https://raw.githubusercontent.com/NyxAlexandra/ib-internal-asessment/main/src/final-copy/paper.typ | typst |
#set page(numbering: "1.", number-align: right)
#set text(size: 12pt)
#set table(align: left)
#let mod = "mod"
// ---
#align(horizon)[
#heading(outlined: false)[Hashing: How do servers store passwords?]
/ Topic: Cryptography
/ Stimulus: Computer Science
#pagebreak()
#outline(depth: 3, indent: 1em)
]
#pagebreak()
= Introduction
How do servers store passwords?
The natural answer is a structure like this:
#figure(
table(
columns: (auto, auto),
[`username`], [`password`],
[`<EMAIL>`], [`sorry-bob-321`],
),
)
When a user attempts to log in, they transmit their credentials. If the provided
password matches the password for the requested username, authentication
succeeds.
While this works, there are glaring security issues with this model. Consider
the consequences of a data leak: anyone with the data can now access every
leaked user's accounts and the user's accounts on other servers, given how
common non-unique passwords are.
To solve this conundrum, break the question into it's parts:
- Authentication involves the user inputting their username and password
- The server checks whether the received password is correct for the requested
user
We know that we can compare the value of the sent password and the password in
the database, but that involves the server knowing the password.
What if the value of the password could be stored without knowing the original
password? To avoid the security problems, this encoded version would have to be
non-reversible. A function like this would have a very useful property:
#figure(
[
if $f(a) = f(b)$, then $a = b$ and vice versa
],
)
where $f$ is the encoding function.
#pagebreak()
= Introduction to hashing
A _Hash Function_ is a function that maps inputs of any size to a fixed-size
value. This output is called the _Digest_. This value has the property of
being unique #footnote[To a degree. Depends on the particular algorithm and if
it is designed for security or not. See the following Section for the distinction.]
for any given input. This value can be compared in place of the original input.
Using the popular hashing algorithm SHA-256, the above database can instead
store the digest in the password field:
#figure(
table(
columns: (auto, auto),
[`username`], [`password`],
[`<EMAIL>`], [`<PASSWORD>2<PASSWORD>`],
),
)
Via hashing, the server never receives raw passwords from users. When the user
inputs their password, the password is hashed with the same algorithm used by
the server and is only then transmitted.
A _Cryptographic Hash Function_ is a hash function which has additional security
properties. For any length $n$, these include:
- The probability of any one digest being output by the function decreases
exponentially as $n$ increases (at least $2^(-n)$)
- It is unfeasible to derive the input string given a digest
- It is unfeasible to find 2 inputs that produce the same digest
Non-cryptographic hash functions are widely used for non-security-critical
infrastructure. Common use cases include unique identifiers in a "hash map", a
datastructure that maps hashes of keys to values.
Cryptographic hash functions are widely used for digital security. Besides
passwords, they are used to verify integrity. When a server sends a request to
another computer, the response usually contains the hash of the response. If the
hashed response does not match the provided hash, there is an issue with the
integrity of the message. @cryptographic-hash-function
#pagebreak()
= Hashing in detail
The "shape" of the input $x$ of a hash function $f(x)$ is not the kind familiar
to most mathematicians, numbers. The same hash function can be used on both text,
images, and arbitrary datatypes in a computer program. This variety of uses is
due to all of the listed uses being made of the same thing: _bytes_.
A bit can be thought of as an on/off switch or a boolean true/false. At the base
level, computers are entirely built on such simple logic. Operations on bits are
called _bitwise operations_.
=== Bitwise operations and syntax
In mathematical notation, the base of a number is expressed as a subscript. For
example, the number $123$ in base 2 is $1111011_2$. In programming contexts,
it is more often to logic around bitwise operations using hexadecimal (base 16).
For this paper, only binary will be used. Numbers expressed without a base are
considered to be base 10 (decimal).
#figure(
table(
columns: (auto, auto, auto, auto),
[Operation], [Description], [Symbol], [Example],
[AND], [Logical and], $and$, $110_2 and 011_2 = 010_2$,
[OR], [Inclusive or], $or$, $1100_2 or 1001_2 = 1101_2$,
[XOR], [Exclusive or], $xor$, $1100_2 xor 1001_2 = 0101_2$,
[NOT], [Logical not], $not$, $not 1100_2 = 0011_2$,
[SHL], [Shift bits left], $<<$, $010_2 << 1 = 100_2$,
[SHR], [Shift bits right], $>>$, $010_2 >> 1 = 001_2$,
[ROTL], [Rotate bits left], $<<<$, $101_2 <<< 1 = 011_2$,
[ROTR], [Rotate bits right], $>>>$, $101_2 >>> 1 = 110_2$,
),
caption: [A table of common bitwise operations],
)
Leading zeros are significant for some operations. For example, $not 1_2 = 0$, but
$not 01_2 = 10_2 = 2$. This is becase bitwise operations are (almost) always applied
to a set of bits, not just individual ones. The NOT operation will flip all the
leading zeros to ones, resulting in a different number.
The amount of digits can be considered the "size" of the set of bits. In a computing
context, bits are usually addressed in terms of _bytes_.
== What is a "byte"?
A _byte_ is the fundamental unit of computer memory. For all modern architectures,
a byte is 8 bits in size.
Most computers only allow adressing bytes, not bits. Any operations to read or write
to bits are done as operations on a particular bit of a particular byte.
Bytes are how all computer data is stored. This is the encoding for all text, images,
archives, documents, etc. that hash algorithms take as input. Because of this, it is
the least-common denominator for all computer memory. As such, it is the input to
the hash function.
== How do hash functions actually work?
The kind of operations to perform on bytes to achieve good hashes are ones that:
- Will vary in value/bits after application
- Is hard to undo
Usually, mathematical operations are less optimal in that they usually have an
inverse operation ($+$ and $-$, $times$ and $div$, $\x^n$ and $log _x (n)$, etc.).
The modulus operator (expressed as $"mod"$ or $%$) is the remainder after integer
division. It is useful for adding randomness to the hash while being difficult
to undo, as there is no inverse to modulus.
Some example operations:
#figure(
table(
columns: (auto, auto, auto, auto),
[Operation], [Input], [Output], [Comment],
$<< 3$, $011001001_2$, $110010010_2$, [Useful for mixing up the hash.
Usually used in conjunction with
other operations for more
randomness],
$>>> 3$, $011001001_2$, $001101001_2$, [Similar to SHR in purpose, except
ROTR doesn't lose data when exceeding
the size of the set of bits.],
$mod 7$, $011001001_2$, $000000101_2$, [Introduces a lot of small variations
when combined with other operations
(like bit shifts).],
),
)
After any combination of mixing operations are performed on the hash for each
byte, it is common to do a final bit shift or union to create the final digest.
#pagebreak()
= Example hash function: Adler-32
Adler-32 is a hash function used for checksumming. It finds use in the compression
library Zlib @adler32-wiki. It can be expressed mathematically:
#figure(
$
f(x) &= a_n or (b_n << 16) \
"where" \
a_0 &= 1 \
b_0 &= 0 \
a_i &= (a_(i - 1) + x_i) mod 65521 \
b_i &= (b_(i - 1) + a_i) mod 65521
$
)
where $n$ is the length of the sequence of bytes $x$ and $a$ and $b$ are 32-bit
unsigned integers.
== Time complexity
In the domain of mathematics, there is no aspect of "execution time", only values.
In a computing context, this algorithm is very inefficient. #footnote[_This_ is
inefficient. Other implementations can be much better time-wise.] Every time that
$a_i$ is calculated, $a_(i - 1)$ must also be calculated, and the same for $b$.
The calculations for $f(x)$ for $n = 2$ and $n = 3$:
#let tree(body) = {
set list(marker: [...], body-indent: 3pt)
pad(2pt)[#body]
}
#figure(
[
#let tree(body) = {
set list(marker: [...], body-indent: 3pt)
pad(2pt)[#body]
}
#table(
columns: (auto, auto, auto),
$n$, $2$, $3$,
[Calcs.], tree[
- $a_2 or (b_2 << 16)$
- $a_2 = (a_1 + x_2) mod 65521$
- $a_1 = (a_0 + x_1) mod 65521$
- $b_2 = (b_1 + a_2) mod 65521$
- $a_2 = (a_1 + x_2) mod 65521$
- $a_1 = (a_0 + x_1) mod 65521$
- $b_1 = (b_0 + a_1) mod 65521$
- $a_1 = (a_0 + x_1) mod 65521$
], tree[
- $a_3 or (b_3 << 16)$
- $a_3 = (a_2 + x_3) mod 65521$
- $a_2 = (a_1 + x_2) mod 65521$
- $a_1 = a_0 + x_1) mod 65521$
- $b_3 = (b_2 + a_3) mod 65521$
- $a_3 = (a_2 + x_3) mod 65521$
- $a_2 = (a_1 + x_2) mod 65521$
- $a_1 = a_0 + x_1) mod 65521$
- $b_2 = (b_1 + a_2) mod 65521$
- $a_2 = (a_1 + x_2) mod 65521$
- $a_1 = (a_0 + x_1) mod 65521$
- $b_1 = (b_0 + a_1) mod 65521$
- $a_1 = (a_0 + x_1) mod 65521$
],
[\#], $8$, $13$,
)
],
)
The cost of this implementation is clear: not only does every computation of $a_i$
require computing every previous one, every evaluation of $b_i$ requires computing
$a_(i - 1)$ for every $b_i$. Without state, the same $a_i$ values are calculated
multiple times.
_Big-O Notation_ is a method for describing time complexity of algorithms in terms
of a function $O$ in terms of $n$. For example, the notation for constant time is
$O(1)$ and logarithmic time is $O(log(n))$. @time-complexity-wiki
Big-O notation disregards the actual time each calculation takes, instead representing
the overall complexity. In the above example, the calculation $a_1 = (a_0 + x_i) mod 65521$
equals $1$ calculation. Thus, Big-O notation is the amount of individual units of work (calculations) required to compute an algorithm for any size $n$.
The Big-O notation for the above function $f(x)$:
- $a_i$ executes once for each $i$. This makes it $O(n)$.
- $b_i$ executes $a_i$ $n$ times and itself $n$ times.
- The overall $a_n or (b_n << 16)$ is a single calculation, so $O(1)$.
In total, $O(5(n - 1) + 3)$. Refactoring that, $f(x)$ has a time complexity of
$O(5x - 2)$, or $cases(O(1) "if" n = 0, O(5x - 2) "else")$ if including the base case
where no recursion is needed.
In practice, Big-O notation doesn't usually use this much precision in expressing
complexity. This algorithm's complexity would be more likely to be expressed as
being $O(n)$. #footnote[For the purpose of this paper, I treat the notation as
a function.]
#pagebreak()
= Reflection
I had expected writing this paper to be easier, a confidence mistake I make often. I
have existing knowledge of most of the topics covered here, so i assumed that it would
be easy to figure out how to form a mathematical connection.
I originally planned on writing the math section on collision attacks on MD-5 (an
algorithm that used to be used for cryptographic hashes that has since been proven
unsafe), but in the process of writing I realized that was unfeasible. While there
is a lot of existing literature on the topic, such as initial paper that described
the attack @colision-attacks-md5, but it is much too long to integrate into a paper
like this, and it is less connected to the kind of math that would be well-suited
for this assignment.
For the future, I will attempt more research and testing before I start writing my
paper so as to avoid this struggle.
In addition to what's mentioned above:
- I'd like to write in a way that flows better.
- I thought my function would be be non-linearly complex, turns out it's just
linear. This led to my point about efficiency of algorithms to be less
impactful.
- I could have connected time complexity to derivatives/integrals.
Overall, I am happy with my deepened understanding of the complexities of the software
that backs every, even trivial, online interaction.
#pagebreak()
= Bibliography
Sources not directly cited were used in the research of this paper.
#bibliography("sources.yml", title: none, full: true)
|
|
https://github.com/3w36zj6/textlint-plugin-typst | https://raw.githubusercontent.com/3w36zj6/textlint-plugin-typst/main/test/fixtures/Break/input.typ | typst | MIT License | *Date:* 26.12.2022 \
*Topic:* Infrastructure Test \
*Severity:* High \
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/layout/place_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
#set page("a8")
#place(bottom + center)[© Typst]
= Placement
#place(right, image("/assets/files/tiger.jpg", width: 1.8cm))
Hi there. This is \
a placed element. \
Unfortunately, \
the line breaks still had to be inserted manually.
#stack(
rect(fill: eastern, height: 10pt, width: 100%),
place(right, dy: 1.5pt)[ABC],
rect(fill: conifer, height: 10pt, width: 80%),
rect(fill: forest, height: 10pt, width: 100%),
10pt,
block[
#place(center, dx: -7pt, dy: -5pt)[Hello]
#place(center, dx: 7pt, dy: 5pt)[Hello]
Hello #h(1fr) Hello
]
)
|
https://github.com/SWATEngineering/Docs | https://raw.githubusercontent.com/SWATEngineering/Docs/main/src/2_RTB/PianoDiProgetto/sections/PreventivoSprint/NonoSprint.typ | typst | MIT License | #import "../../const.typ": Re_cost, Am_cost, An_cost, Ve_cost, Pr_cost, Pt_cost
#import "../../functions.typ": prospettoOrario, prospettoEconomico, glossary
== Nono #glossary[sprint]
*Inizio*: Venerdì 09/02/2024
*Fine*: Giovedì 15/02/2024
#prospettoOrario(sprintNumber: "9")
#prospettoEconomico(sprintNumber: "9") |
https://github.com/Gekkio/gb-ctr | https://raw.githubusercontent.com/Gekkio/gb-ctr/main/preface.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #import "common.typ": *
== Preface
#v(2em)
#caveat[
#text(17pt)[
IMPORTANT: This document focuses at the moment on 1st and 2nd generation
devices (models before the Game Boy Color), and some hardware details are
very different in later generations.
Be very careful if you make assumptions about later generation devices based
on this document!
]
]
#pagebreak()
== How to read this document
#counter(heading).update((0, 0))
#v(2em)
#speculation[
This is something that hasn't been verified, but would make a lot of sense.
]
#caveat[
This explains some caveat about this documentation that you should know.
]
#warning[
This is a warning about something.
]
=== Formatting of numbers
When a single bit is discussed in isolation, the value looks like this: #bit("0"), #bit("1").
Binary numbers are prefixed with #bin("") like this: #bin("0101101"), #bin("11011"), #bin("00000000"). Values are prefixed with zeroes when necessary, so the total number of digits always matches the number of digits in the value.
Hexadecimal numbers are prefixed with #hex("") like this: #hex("1234"), #hex("DEADBEEF"), #hex("FF04"). Values are prefixed with zeroes when necessary, so the total number of characters always matches the number of nibbles in the value.
Examples:
#v(1em)
#table(
columns: 4,
stroke: none,
[], [4-bit], [8-bit], [16-bit],
[Binary], bin("0101"), bin("10100101"), bin("0000101010100101"),
[Hexadecimal], hex("5"), hex("A5"), hex("0AA5")
)
#pagebreak()
=== Register definitions
#reg-figure(
caption: [#hex("1234") - This is a hardware register definition]
)[
#reg-table(
[R/W-0], [R/W-1], [U-1], [R-0], [R-1], [R-x], [W-1], [U-0],
table.cell(colspan: 2)[VALUE\<1:0\>], unimpl-bit(), table.cell(colspan: 3)[BIGVAL\<7:5\>], [FLAG], unimpl-bit(),
[bit 7], [6], [5], [4], [3], [2], [1], [bit 0]
)
#set align(left)
#v(1em)
*Top row legend:*
#grid(
columns: (1cm, 1fr),
gutter: 1em,
[*R*], [Bit can be read.],
[*W*], [Bit can be written. If the bit cannot be read, reading returns a constant value defined in the bit list of the register in question.],
[*U*], [Unimplemented bit. Writing has no effect, and reading returns a constant value defined in the bit list of the register in question.],
[*-n*], [Value after system reset: #bit("0"), #bit("1"), or x.],
[*#bit("1")*], [Bit is set.],
[*#bit("0")*], [Bit is cleared.],
[*x*], [Bit is unknown (e.g. depends on external things such as user input)]
)
#v(1em)
*Middle row legend:*
#table(
columns: 2,
align: center + horizon,
`VALUE<1:0>`, [Bits 1 and 0 of VALUE],
unimpl-bit(), [Unimplemented bit],
`BIGVAL<7:5>`, [Bits 7, 6, 5 of BIGVAL],
`FLAG`, [Single-bit value FLAG]
)
#v(1em)
*In this example:*
- After system reset, VALUE is #bin("01"), BIGVAL is either #bin("010") or #bin("011"), FLAG is #bin("1").
- Bits 5 and 0 are unimplemented. Bit 5 always returns #bit("1"), and bit 0 always returns #bit("0").
- Both bits of VALUE can be read and written. When this register is written, bit 7 of the written value goes to bit 1 of VALUE.
- FLAG can only be written to, so reads return a value that is defined elsewhere.
- BIGVAL cannot be written to. Only bits 5-7 of BIGVAL are defined here, so look elsewhere for the low bits 0-4.
]
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/crates/conversion/vec2svg/README.md | markdown | Apache License 2.0 | # reflexo-vec2svg
Export a frame of Typst document into svg element.
See [Typst.ts](https://github.com/Myriad-Dreamin/typst.ts)
|
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/036%20-%20Guilds%20of%20Ravnica/005_Bound%20and%20Bonded.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"Bound and Bonded",
set_name: "Guilds of Ravnica",
story_date: datetime(day: 14, month: 11, year: 2018),
author: "<NAME>",
doc
)
"You're going to visit her again, aren't you?" Ambrellin says, standing in the doorway to my room. Technically, it's her room, but she's been letting me crash here the past few months, since the accident. Her voice is calm, but her eyes crinkle at the edges, deepening toward her temples where the smoothness of her skin turns to rough bark. It's an obvious tell for the frustration she's harboring, a tell she's had since we were kids.
"I'm just going to drop off a little money for the orphanage," I say. It's the least I can do.
"That's good, Terrik. It really is. But at some point, we're going to have to talk about what's healthy grieving and what's obsession. Eventually, you'll have to forgive yourself and move on, and it'll be a lot easier if your emotions aren't tied up with the fate of an orphan."
"Of course, you're right," I say, the words coming out like a reflex. Twenty-eight years of Selesnyan training has taught me to maintain harmony with my friends and community above all else, but how can I forgive myself for causing a building to collapse, killing two dozen people? I force a smile, then pull my cap down over the points of my elven ears, and pull my scarf up, obscuring most of my face. I'll need the anonymity where I'm going. "This is the last time I'll see her, I promise."
"Thank you. Oh, there's one more thing. I'm afraid the neighbors have been complaining again." Ambrellin cocks her head, the sudden movement making the finches nesting in the branches of her hair ruffle their feathers. "Are you sure you haven't heard any strange sounds?"
"More 'wurm noises'?" I roll my eyes.
"I know, I know. It's just that they're my neighbors, and if there's any kind of issue, I'd like to resolve it." Her fingers trace over the lacquered wood of the chariot cab I'd converted into a wardrobe. She opens the doors and kicks my old wurmcaller boots lined up across the bottom. A layer of dust has already accumulated on the worn black leather. She peeks behind the armored uniforms as well, remnants from my old life as a lead wurm trainer for the Selesnyan army, before I'd made the mistake that had changed everything. "They say they've seen the wurm, too, peeking through the stone ceiling. Said it had teeth the size of a butcher's knife!"
"I'm not trying to cause any discord, Ambrellin, but do you think it might be possible that your neighbors are over-meditating? Shamans have been calling the faithful to gather more and more often. Maybe your neighbors are seeing and hearing things in that heightened state."
She considers this for a moment, then she stoops over and lifts the edge of my bedspread.
"Ambrellin," I say, my voice tipping right up to the threshold of politeness and into aggravation. "I appreciate your generosity of taking me into your home, but do you really think I'd be able to fit a half-grown wurm under my bed?"
#figure(image("005_Bound and Bonded/01.png", width: 100%), caption: [Art by: <NAME>], supplement: none, numbering: none)
Ambrellin drops the bedspread and sighs. "You're right. I'm being ridiculous. What kind of person would be delusional enough to keep a dangerous animal in a residential cooperative?"
I nod. What kind of person, indeed.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The tall, dark spires of Orzhov cathedrals loom above, seeding tension throughout my body. The entire skyline looks as if it's been smudged by soot, with arched stained-glass windows glinting orange as the sun starts its descent. The flavor of oppression changes from one cartel's territory to the next, but I keep my head high, my eyes focused straight ahead, my fists clenched. I'd be better off taking the main thoroughfare a few streets over, where the streetlights are plentiful—as are the witnesses—but then I'd pass the site where the Basilica of the Opportune had once stood, one of the oldest churches in the Orzhov Syndicate. Well, it was until I'd ridden my wurm underneath it, compromising its structural support, and sending the whole thing crashing down into a pile of rubble. It was being remodeled at the time, nearly fifty construction workers refitting broken stained glass, refacing pitted stone, and regrading the surrounding grounds so the spring floods wouldn't pool up against the building and drip down into the catacombs. Sometimes, when I close my eyes, I can still hear the screams of the people caught in the debris. I'd rather take my risks with a few ruffians than relive that day again.
"Oy!" says a voice. I look back and see a guy dressed in black leather with several strands of silver coins hanging around his neck. "I see you walking this way quite a bit," he says like he's chewing each word as it comes out. "Maybe you'd be interested in purchasing some insurance? You know, so you can be assured that you'll get to wherever you need to get in one piece."
"No, thanks," I say, using my least confrontational voice. "It's a short walk."
"Maybe. But still, ya never know when something might happen." He grinds his fist into his open palm. "I've got some really reasonable rates."
Suddenly, the weight of the coins in my pocket feels like a liability. He's already eyeing the bulge there.
"I'm good," I say, "I brought my own protection." I open my jacket, revealing the hilt on my hip.
The thug shrugs. "A little knife like that won't get you far in a place like this."
"It's not a knife," I say. I pop open the leather strap and pull out metal shears. "These will cut through the densest, most enchanted bramble. Do you know the kind of damage enchanted bramble does to flesh?"
But he's too focused on my pocket to reply. I turn and walk quickly, crossing the street, but he follows. I slip my hand into my vest, pull a leather satchel full of bramble seeds out, and drop a handful at my feet. When the thug steps over them seconds later, I call upon the magic infused through all things, force the spell behind me, and turn to watch as thorny vines erupt from the sidewalk, entangling my pursuer in their scratchy embrace.
#figure(image("005_Bound and Bonded/02.jpg", width: 100%), caption: [Portcullis Vine | Art by: <NAME>], supplement: none, numbering: none)
I leave him there, screaming, and double my pace until I reach the orphanage. It's an awful place—a crumbling, oppressive building that would better be served as a place to melt down old coinage than provide refuge to children. But bit by bit, I've been donating my meager earnings to help improve their infrastructure.
There's a small gap between buildings where the rubble of the basilica is visible. I try hard not to look at it, but as usual, I fail. Jagged spires jut up through tremendous hills of blackened debris, like the remains of a long-dead campfire. Anything of value had been scavenged. Seems cruel that Bazda has to live here, within a stone's throw of where both her parents had died. I bite my lip and walk up the gray, dusty stairs and enter the front door. One day, I'll find the courage to talk to her, to apologize to her, but today is not that day. My mind's so preoccupied, I run right into one of the children, smacking him so hard that my scarf falls from my face. I try to hastily put it back, but it's too late. He's recognized me. He jumps up and plucks the cap from my head, and the points of my ears poke out. If there was any doubt of my identity, there isn't anymore.
"It's that wurmcaller!" the kid says, tossing my cap to one of his friends. "The thrull's ass who destroyed the basilica! No wonder, he still can't pay attention to where he's going!"
And just my luck, Bazda is standing within earshot, small for her age, nearly drowning in the gray institutional smock she'd been issued. Her black hair sits upon her head in two buns. She turns, sees me. I turn away, searching for a caretaker so I can drop the money off and get on my way, but as usual, there are none to be found.
"Your name is mud around here," the punk kid tells me. "Money's never going to pay off the debt you owe!" He spits on my boot.
"Hey," Bazda says, grabbing my cap from his friend and making her way toward us. "Leave him alone."
"And who's going to make me?" he asks.
Bazda pulls a six-inch hairpin from her right bun and jabs it at the punk, coming less than an inch away from his throat.
"Forget both of you," the punk says, sulking off.
Bazda looks at me, handing me my cap, then styling her hair back into a perfect bun. "I've seen you around before," she says. "You drop off a bag of zibs every week, then stand around watching me. It's creepy. Are you a creeper?"
"No! I'm not a creeper," I say. "Just a regular guy. You can ask anyone back home."
Bazda purses her lips. "Sounds like something a creeper would say."
"Look, I caused a terrible accident. I'm just doing my best to make it right."
"Can you give me my parents back?" she asks.
"No, but I'm sure they're in a better—"
"They're not 'in a better place' if that's what you were going to say. They're in the same place, but worse, because they're spirits now. They're so busy working off their debts they don't have time to visit me." She crosses her arms over her chest.
"Oh."
"Seems to me you'd be better off trying to fix yourself rather than coming here, stinking the place up with your gloomy attitude. What's wrong with you?"
"Nothing," I stammer.
"No job, no life, no friends. That about sum it up?"
"I've got friends," I say. I prickle all over. It's strange being interrogated by a twelve-year-old, but she's got a lot of reason for her anger. Still, I feel the need to defend my own honor. "#emph[Great] friends! Savaryn, he's a loxodon, brawny as they come and isn't afraid of anything. Kellim is an architect who designs the most tranquil sanctuaries. He's human, but we don't hold that against him. And Ambrellin, she's a dryad who's an artifact broker specializing in antiquities. We meet up once a week to—"
"Wait~she knows about artifacts? Like really old ones?"
"Yes~"
Bazda sizes me up, then takes folded cloth from her pocket. She unwraps it and shows me a crescent-shaped piece of carved stone with a hole in the center and golden symbols etched all over. Even I can tell it's ancient. "My father gave me this a couple days before he died. He found it during construction at the basilica. I want to know what it is."
"I could show it to Ambrellin, if you'd like. I'm sure she'd be willing to help." Even under the weight of the gloom of this building, of the gloom in my heart, I feel my chance for redemption. I can only imagine how much this artifact means to Bazda, probably the last thing her father had given her.
She raises an eyebrow. "Can I trust you to bring it back?"
"You have my word that I will return it to you undamaged," I say. "I swear it upon the roots of Vitu-Ghazi."
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The Selesnyan forests welcome me home, and as the peaceful sounds of nature penetrate my mind, the heaviness of the Orzhov Syndicate eases out of my muscles. My shoulders relax, my fists unclench. Evening services are already in full swing, and I pass several shamans calling upon the power of faithful congregants to enchant a series of stone signets etched with the blessed symbol of the Conclave.
#figure(image("005_Bound and Bonded/03.jpg", width: 100%), caption: [Temple Garden | Art by: <NAME>], supplement: none, numbering: none)
I'm nearly home when I get a sinking feeling I'm being followed. Could be any one of the Orzhov street thugs who'd tried to shake me down for insurance money on my way back from the orphanage. I toss another handful of seeds, then round a corner. I cast the spell, but I guess the assailant has avoided the brambles, because the footsteps keep coming. I go to pull out my shears as a backup weapon, but the leather sleeve is empty. I glance up as my assailant turns the corner, then sigh in relief. It's Bazda.
"Looking for these?" she asks, holding up my shears.
"You little thief!" I say, snatching them back. "How did you get those?"
"You thought I'd trust the word of a creeper? You have something valuable of mine. It's only fair I hold something valuable of yours."
"Here. Then take your artifact and go home. I'm not contributing to the delinquency of a kid!"
"Home? Nobody will even notice I'm missing, much less care. And besides, you'd have me traveling the streets at this hour? By myself?"
"I've seen you work a pair of hair pins. You'll be fine."
Bazda crosses her arms. "Probably. But I still want to know about the artifact. This is where you live?" she asks, looking up at our residential cooperative, a combination of polished white stone and tiered gardens, the topmost designed by Sadruna, the woodworker of the famed topiary grove. "Kind of a lot of branches and leaves."
"It's a Selesnyan thing," I mumble. "Come on up, I guess."
We cross through the gardens, up the stone stairs, through two atriums, passing the open doorways of other residents. Our downstairs neighbor waves. I wave back and hurry past, so they don't have a chance to talk to me about the wurm noises again.
"Why aren't there any doors in your building?" Bazda asks.
"Why would we need doors?"
"To keep people out."
"All are welcome in our home."
"Yeah," Bazda says, her eyes shifting, "but what if someone tries to #emph[steal] something?"
"That's just not something we worry over," I say as we climb the final sets of stairs. It's easy to forget that much of Ravnica is focused on individual wants and gains.
The breezeway opens onto a spectacular view of the rolling vista. The sun's dipped just below the horizon, the last remnants of day creating silhouettes of the loping risen sanctuaries roaming in the distance. To the right, where darkness has already settled, the branches of Vitu-Ghazi are aglow with firefly light. I'm eager to show the artifact to Ambrellin, but I stay a little longer, just so Bazda has a chance to absorb it all. Finally, she's speechless.
"Come on," I say, tugging her through the archway of twisted branches that serves as the threshold into our home. "Ambrellin," I shout. "I've got something to show you!"
Ambrellin greets me with a wide smile. "Terrik! You'll never guess who's come—" She stops, looks at Bazda. "Oh, hello, dear. Welcome to our home. I'm Ambrellin." She curtseys, her branches nearly touching the ground. Her finches flutter around Bazda in greeting, chirping happily.
"I'm Bazda," Bazda says, with a cute curtsy of her own.
Ambrellin's eyes flick to mine, searching for explanation without appearing rude in front of her guest.
"It's fine," I tell her. "She's got this artifact she wants to show you. Maybe you can tell her more about it?"
Ambrellin takes the cloth-wrapped artifact from Bazda and gently unfolds each corner until it's exposed. She gasps.
"My father found it digging at the basilica," Bazda says. "Is it old?"
"Very. These golden symbols, I've seen them before on ancient Izzet machinery, technology from thousands of years ago, when they were still working heavily with stone and mana-infused circuits. Rare enough as it is, but it's a mystery how it would have ended up buried under an Orzhovian basilica."
"Valuable?" Bazda asks.
"Priceless," Ambrellin says with a heavy breath.
Bazda shakes her head. "Everything has a price."
"I'll speak with the brokerage magistrate tomorrow to see which guild holds the proper claim to this," Ambrellin says. "This is only a small piece to something much bigger."
"Maybe someone's already found the rest of it," I say.
"I doubt it. Word travels fast among antiquity brokers. I would have heard #emph[something] ."
"Terrik!" comes a voice from the dining room. Out steps Savaryn, his trunk raised in excitement. He hustles over to us, arms outstretched. "Peace and tranquility to you, my friend."
"Peace and tranquility to you, as well," I say, carefully angling myself between his tusks, and falling into a warm embrace. "How are you? It's been nearly a week!"
"Kellim and I have just come to share a bit of blessed news. I've been granted a promotion. The Kasarna training grounds have reached maximum capacity, so they're planning a new facility on the other side of the North Ridge Forest. I'll be the director, and Kellim has been hired to design it."
"Congratulations," I say. "North Ridge? That'll be a huge commute! You'll spend an hour easy trying to get across the concourse."
Savaryn exchanges an anxious look with Ambrellin. After a long, thoughtful moment, she nods.
"We're not commuting," Savaryn says. "We're moving to be closer to—"
"Moving!" I shout. I bite my tongue and try to be a good Selesnyan, ignoring the pain tearing through my heart, and instead, nurturing the tranquility within me. "I mean, moving. Of course. That would definitely be more convenient for you." I smile so hard, I feel like my teeth are about to shatter. Finally, I just can't take anymore, and I storm off to my room.
#figure(image("005_Bound and Bonded/04.jpg", width: 100%), caption: [Pause for Reflection | Art by: <NAME>], supplement: none, numbering: none)
"Terrik," Ambrellin says, easing her way in as the others crowd in the doorway. "It's going to be fine. We can visit any time."
"I know. But it won't be the same." Our group is dissolving. This news hits me harder than losing my job and my reputation had. I can't let this be it for our friendship.
"What if we could have one last adventure together?" I ask them. "Before everyone is spread all over Ravnica."
"That's a great idea," says Ambrellin. "We can visit the topiary gardens next week. We'll pack a lunch and—"
"That's just an outing. I want to do something we'll never forget. I think we should go find out what else is hiding under that basilica. Why can't we be the ones to discover it?"
Ambrellin shakes her head, then takes a seat on the edge of my bed. "Something that old is likely buried very deep. It'd be impossible to dig for without the whole of the Orzhov Syndicate converging on us."
"What about a wurm?" I ask. "We can dive as deeply into the ground as we want. No digging." I channel a calling spell, something like a whistle to our ears, but like a bright homing beacon to a wurm. The mattress shifts under Ambrellin, and she jumps up, watching as my bed becomes a lumpy mess.
"You #emph[were] hiding a wurm under your bed!" she says.
I shake my head. "Not quite. The wurm #emph[is] the bed." The bedspread is tossed off, and so is a thick layer of quilting covering a wooden palette. "Everybody stay calm," I say as the wurm uncoils from the tangle of sheets. Her beady eyes are trained on me, and her mouth hangs open, saliva dripping from row upon row of razer-sharp teeth. "Good girl," I say, tossing a stick of raktusk jerky into her open maw. She's young, just over a year old and already one ton of pure muscle.
"Amazing~" Bazda says, daring to step near. "Can I pet her?"
"Sure," I say.
"Absolutely not!" Ambrellin says, snatching her back.
"She's harmless," I say. "To friends, anyway. I raised her from a hatchling."
"I can't believe you've been hiding that thing in my home!" Ambrellin says, real irritation in her voice. "And now you want us to follow you into one of the most corrupt areas of Ravnica, looking for treasure with a runaway orphan."
"I'll go," Savaryn says. "Terrik's right. A major bonding event in the form of an adventure would provide a positive transitional structure to a long-distance friendship."
"I'll go, too," says Kellim. "I've got to admit, I'm curious about what lies beneath that building. Come on, Ambrellin. You know Izzet will scrap it to make some bigger and better invention, and Orzhov will just sell it to the highest bidder."
Ambrellin holds up the artifact, a gleam in her eyes. "Okay, we'll go take a look. #emph[Just] a look. If anything feels wrong, we're leaving immediately."
I grin. "First sign of trouble and we're out of there, I promise."
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The wurm cuts a path through solid rock, subsonic frequencies temporarily rendering stone into a state of liquid, allowing us to avoid the evening traffic and any shakedowns by Orzhov gangs. I'm armored to the teeth in my old wurmcaller's uniform, my plating shielding me from the burn of the melted rock that surrounds us. The others are crammed into the fortified chariot cab that had previously served as my wardrobe.
We're nearing the site of the collapsed basilica, but the wurm is drifting back up toward the surface. I pull her reigns, bidding her to dive deeper, but she's resisting. I scratch her on the side, right behind her ear divot. She purrs and calms some, though from the tense way she's holding herself, I can tell she's still hesitant. It doesn't matter in the end, because she delivers us to a long, rectangular catacomb chamber beneath the collapsed basilica.
"What's wrong, girl? Did something spook you?" I pet my wurm's snout and give her a treat as the others disembark. Savaryn is shaking off the motion sickness, and if you've never seen a loxodon dry heaving, well, be thankful. Kellim is mesmerized by the stone sculptures of giants, their backs hunched up against the curved ceiling as if they're keeping the whole place from caving in on us. Stress fractures meander through the stone, probably from the collapse above, but Kellim doesn't seem too concerned with their structural integrity. Ambrellin is taken with the thousands of ceramic urns that are shelved on either side of the sculptures, each decorated with gold coins.
"The Basilica of the Opportune dates back thousands of years, and the catacombs are even older," she says, looking around, lost in awe. "Some of these urns could be nearly—" Her eyes catch on something at the far end of the chamber. She starts walking toward it, then hastens her step. We follow.
#figure(image("005_Bound and Bonded/05.png", width: 100%), caption: [Swamp | Art by: <NAME>], supplement: none, numbering: none)
It's another stone statue, a thrull this time, sitting back on its haunches, head bowed in servitude, arms outstretched and holding a chalice. The chalice is covered in layers of dust, but I can feel the mana streaming off it. It's an artifact. Ambrellin blows the dust away, revealing finely etched pictographs with emeralds lining the cup's rim. Carefully, she tries to dislodge the artifact from the statue's grip, twisting it to each side. Without notice, the entire statue tilts backward, receding into the wall, taking Ambrellin with it.
Kellim is the closest, and he reaches after Ambrellin, grabbing onto her leg, but he's being pulled into the pitch-black opening, too. Savaryn gets a good grip with his meaty hands, and Bazda and I help to steady him. Working together, we heave, heave, heave, and Ambrellin is nearly out, but the vigor of our rescue has caused the stone around the statue to fracture. The floor has started to crumble, as well. I look back at my wurm and conjure a quick spell to call her forward. She's strong enough to pull us all out.
I hope.
But she's not responding. I whistle again, and she bristles, shaking her head like she's trying to rid herself of her harness. "Come on, girl! I've got some jerky for you."
She inches forward, eyes wide and crazed, but right before she makes it within arm's reach, she reels back and makes a jump for the ceiling. Stone goes liquid, and then she's gone, tail whipping through and stone solidifying again a half second later. I call for her twice more, but something has frightened her, and she's not coming back.
Then the entire floor gives out, and there's nowhere for us to go but down.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
We're coughing rubble for a full five minutes, but the only casualties are some bruised ribs, a chipped tusk, and our pride. We've fallen fifteen feet, maybe twenty, into some kind of corridor. I feel awful and cast an area healing spell to help with the scrapes and cuts. I'd promised we'd be gone at the first sign of danger, and now look at us. Stuck.
"It'll take a while, but if we stack the broken stone, we can make a set of stairs leading back up," Savaryn says, lifting a boulder like it's filled with air.
I lift a smaller, less impressive rock and stack it next to his. "Sounds like a solid plan."
Ambrellin cuts her eyes at me, an unmistakable "I told you so" forming on her lips. But even completely out of her element, she clings to the harmonious tenets of the Conclave. "Yes," she says, straining to keep her smile from turning to bared teeth. "It sounds like a good plan."
"You're mad at me," I say to her. "I get it. You've been nothing but kind, and I've been nothing but a disappointment."
The bark near her temples is crinkling so hard, it's coming up at the edges. "I'm not mad."
"Not even a little bit? I know we value serenity and the sacredness of friendship, but if you're bothered, you have to say something. I've spent the past three months in your home, eating your food, secretly kept a wurm that harassed your neighbors, maybe kind of almost kidnapped a child, and got you stuck under a collapsed building in the middle of the Orzhov Syndicate—"
"Okay I'm angry with you, are you happy?" Ambrellin walks up to me, pounding her finger right into my chest plate. "We've been patiently waiting for you to hit rock bottom, so we could help build you back up, but instead, you've managed to drag us down with you! Our get togethers are all about tiptoeing around your feelings, and you've thrown off our chemistry, and now Savaryn and Kellim are leaving because you've been so insufferable to be around!" She stops, looks up at me, relief on her face for just an instant before the remorse sets in.
"They're leaving because of me?" I say.
Ambrellin shakes her head, leaves rustling. "I'm so sorry, Terrik, I didn't mean—"
"No, #emph[I'm] sorry," I say. I thought I could lean on them for support, but I guess in times like these, you learn who your true friends are. "Take care of Bazda. Get her back to the orphanage. You don't have to worry about me dragging you down ever again."
I head away down the hallway, alone, except for the dozens of gargoyles perched in notches on either side, eyes cast up, mouths open wide. They've been sleeping for centuries, maybe millennia, but I don't dare risk waking them. Guilt pecks at my brain. I'd gotten my friends into this mess, and I should be helping to find a way out, but at this point, I can't trust myself not to make it a hundred times worse. So I keep putting distance between us, until I come to a stairwell that leads deeper into the depths of the catacombs.
I take one timid step down, another, and suddenly I'm overwhelmed with the familiar scent of wurm castings, the most highly prized fertilizer among Selesnyan gardeners. For a moment, I am swept away by thoughts of my old life, traipsing through the forests in late autumn, digging through rich, black earth in search of wurm cocoons. The translucent cocoons were about the size of a loxodon's fist, and inside you could see five or six little wurmlings squiggling around. I'd trained hundreds of wurms over the course of my career, growing them into tremendous lethal weapons to protect our way of life, but that moment in the woods was always the best part of my job, holding in the palms of my hands all that potential power, their futures unwritten.
The good feelings slam to the recesses of my mind when I get to the bottom of the stairs, peek around the corner, and see three adult wurms blasting the walls of the chamber with their subsonic emanations. Spirits, impervious to the vibrations, wipe away the liquified rock before it can solidify.
At the center of the chamber sits a circular stone machine with a large lever protruding out at chest height, something like an antiquated mill, with similar markings as Bazda's artifact. Definitely the Izzet technology Ambrellin was talking about. Copper coins lay in piles around the machine. A stout man with the undeniable look of desperation in his eyes orchestrates the workers. He's dressed in white robes with black cording, though the dust has rendered his outfit into shades of gray. An Orzhov pontiff, if I remember their rankings right. There's an old leather-bound tome hanging from a worn strap slung over his shoulder, and an impish thrull follows him around, practically his shadow.
#figure(image("005_Bound and Bonded/06.jpg", width: 100%), caption: [High Priest of Penance | Art by: <NAME>], supplement: none, numbering: none)
"Faster! It's got to be buried around here somewhere," the pontiff says, jabbing one of the wurms with his staff, the business end a sunburst of jeweled amber. The wurm wails out in pain, a deep cry I feel in my chest. Cries like that can travel over half a mile. No wonder my wurm had been spooked.
Savaryn's big hand comes down on my shoulder, tugging me back. "He doesn't look like the kind of guy who takes kindly to uninvited guests," he whispers. "Come on. Ambrellin wants to apologize, then we can work on getting out of here."
Another thump hits my other shoulder. It's not Savaryn's reassuring hand this time though. I don't dare twist my head. From the look in Savaryn's eyes, I can't even imagine the half-dead Orzhov creature that's got a hold of me.
"It's~it's~it's~" Savaryn is saying, definitely not whispering anymore. My eyes dart to the gargoyle perched behind him. I think it shifted ever so slightly. "It's~"
#emph[Squeak] , comes a tiny voice in my ear. I turn and exhale sharply. "It's just a rat."
I pull it off my shoulder and show Savaryn. His hands are clasped over his mouth, stifling a scream, but a little trumpet of fright escapes his trunk. Now the gargoyle behind him is opening an eye. It sees us, intruders, and starts shrieking. Then all the gargoyles are emitting ear-piercing sirens that echo throughout the catacombs. Before we know it, spirits have surrounded us. The pontiff elbows his way through them.
"Blessed spirits, what do we have here?" says the pontiff.
"Looks like trespassers, Master," says his thrull, lurching forward to crouch at the pontiff's side. Its voice is a hollow wet rasp, exactly what I'd expect from a creature molded from dead flesh.
"And who knows the fine for trespassing in these sacred catacombs?"
"Twenty-thousand zibs, Master," says one of the spirits, eyes cast downward. "Or ten thousand labor hours."
"I'm guessing you don't have twenty-thousand zibs on you," the pontiff says, and as he points his staff at me, the amber stone lights up, and all my valuables rip out of my pockets. My enchanted bramble seeds, my shears, and a few coins.
"Those are mine," I say to him.
"Ah, but the Orzhov Syndicate considers possession ninety-nine hundredths of the law. And now #emph[I] possess them." He hands the staff and my belongings to his thrull, then opens his leather-bound book and flips through dozens of signed contracts until he comes to a blank page. He taps his finger on the pristine parchment, and words bleed through, dictating the terms of my indentured servitude and a spot for my signature and the date. "Sign it or become wurm food."
Wurm food seems like the easier choice, but I sign a fake name and hope for the best, knowing the others had heard the siren, alerting them to the danger. I know Ambrellin's mad at me, but our friendship has deep roots, and she'll stop at nothing to find a way to free us.
Once Savaryn has signed, too, the pontiff hands us each a bucket and commands us to get to work.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The spirits seem to forget that living people need breaks, and they pile up buckets of gravel faster than we can haul them off. I carry one in each arm as I walk down a short hallway that opens into another catacomb chamber, this one shelved with neatly stacked bones and skulls with coins inset into their eyes, burial practices from an even earlier era. Statues line the circular room as well, some human, some thrull, even a vampire with her fangs bared. At the center of the chamber is where we dump the crushed stone, an ominous hole that leads further down into the forgotten histories of Ravnica. I dare to peek into the darkness, wondering how deep it goes, and if the fall would kill me or just leave me with broken bones and regrets.
"You shouldn't linger," says the spirit who's come up behind me. She dumps the contents of her bucket into the hole—wurm saliva, sickly dark with yellow foam. A sure sign of a distressed wurm.
"Sorry," I say, hustling back ahead of her. "So, what does that machine do, anyway?"
She looks around, then speaks with a voice so soft and scratchy, it turns my skin to gooseflesh. "It mints gold coins out of copper, some Izzet invention that was stolen by Master's great-grandfather twelve generations back. He used it to amass a great wealth that launched him into a position with the elite, the family's dirty little secret."
#figure(image("005_Bound and Bonded/07.jpg", width: 100%), caption: [Izzet Locket | Art by: <NAME>], supplement: none, numbering: none)
"But it's missing a piece," I say, and immediately regret it. But instead of the spirit looking suspicious about how I know that, she seems racked with guilt. Somehow, despite being an apparition, she manages to go pale. "You know where it is, don't you?" I ask her.
She shakes her head quickly, but then I notice~the resemblance is there. Same mousy face and slight build, dark gray hair that had probably been black in life. "You're Bazda's mother?"
"Please, we've already lingered too long!" She runs off ahead of me, and I sprint after her.
"She misses you. She's here, in the chamber just above. Let's sneak out of here when the pontiff isn't looking."
"We can't. We are bound by contract. The law magic would pull us right back here if we dared to run away."
"Kadin! Zavora! You're late!" the pontiff says when we arrive back. He passes his staff to his thrull attendant, then cracks open his tome. "One day added to your debts." Zavora makes a tiny scratch onto a long row of marks. The pontiff then flips to my page. I feel the strain of the law magic, forcing my hand to make the mark.
"There will be plenty more of those to come!" the pontiff laughs.
I tense, and suddenly the weight of the contract sinks in. I'm going to be indebted to him forever, and not even death, especially not even death, will free me, unless I make a move right now. I grab the book, then run over to Savaryn, who's carrying three full buckets in each hand. He drops them as I toss the book at him. "Rip it up!" I say. "Rip it all up, and we'll all be free."
Savaryn obeys, and his big hands crack the binding of the book while I hold the pontiff back. Pages rip next, and the book is nothing but shreds. I think I can feel the contract's bonds weakening already.
"Who are you, anyway 'Kadin'?" the pontiff says to me, looking searchingly into my eyes, like maybe he's recognized me. "And what were you doing down here?"
"Nobody and nothing," I say.
"Hmm. We'll see about that." He snatches the staff back from his attendant, then scrapes the amber tip along the stone floor as he draws a circle around my feet. Suddenly, I'm standing as straight as a board and my tongue feels like it's been transformed into a weapon. "I'll ask again. Who are you and what are you doing here?"
"My name is Terrik, and my friends have come down here looking for treasure to bond our relationship after I ruined everything by steering a wurm under this very basilica and causing it to collapse!" I hadn't meant to say any of that, but he's put me under the influence of a verity spell, a strong one, and my own words betray me. But there's one thing I cling to with all my might, our only piece of leverage, that Bazda has the missing piece of the machine. I meditate, surrounding that thought with mental armor.
"I thought you looked familiar," the pontiff says. "You can ease your conscience, Terrik. You and your wurm were just in the wrong place at the wrong time. Seems I got a little too ambitious with the digging down here and knocked out some support structures I shouldn't have. But it's good to know you have more friends around. I'll use every set of hands I can get."
The pontiff sends a group of spirits to retrieve my friends, then waves his staff in the air, leaving wisps of gray smoke trailing behind it. The smoke sinks down to the ground, covering the scraps of parchment and ripped binding in an eerily glowing fog. Then the pontiff reaches down into the mist and pulls back a perfectly bound book, pages all intact.
He looks at me and smiles. "Oh, you're going to be in debt to my family for generations."
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
My stomach pitches when the spirits come back, pushing Ambrellin, Kellim, and Bazda ahead. Their eyes go wide when they see the wurms and the machine. Bazda breaks from the spirit's grip, barreling right into me with a tight embrace.
"It's okay," I tell her. "We're going to find a way out of this."
"Get over here," the pontiff says, ripping her away from me. "Let's see what we've got." He waves his staff over Ambrellin first, but she keeps nothing the pontiff would find of value on her, her only adornments the branches winding down her arms and a necklace made of autumnal leaves. He gets a dagger from Kellim, and then he turns to Bazda. I close my eyes. He's going to find her artifact, and his machine will be complete, and our usefulness here will have run its course, and there's no way he'd let us go, knowing what we know.
"Sign, or become wurm food," the pontiff says to my friends.
I open my eyes, and he's passed his staff to the thrull, who's only holding the dagger and Bazda's hair pins. Where did they hide the artifact? Bazda nods at me, then I look down, noticing a bump under my armor that wasn't there a moment ago. I discreetly feel along its edges, the shape of a crescent with a hole in the middle. Her quick thieving hands had planted it on me without me even noticing.
"Master!" one of the spirits shouts. "This wurm has stopped moving."
The pontiff grabs his staff and stomps over to the wurm, body gone slack against the cold stone floor. He jabs the pointed end into the wurm's flesh, and the amber sunburst lights up, delivering a jolt of pain magic to the animal. It shudders for a moment, a black web radiating out across the skin. He shocks the wurm again, but this time there's no response.
"What are you all standing around looking at?" the pontiff screams. "We've still got two wurms. Find that missing piece by the end of the day, or I'm adding another year to everyone's debt!"
As soon as the pontiff has gone, I run over to the wurm. I put my hands on the pulse behind his jaw, feeling the faintest of beats. The eye turns to me, and I'm struck by the look of recognition he gives me, a dark, thick tear running down his face. He's one of mine, I know it. The others could be, too. But it wouldn't matter either way, because the pontiff is going to pay dearly for this.
"Don't linger," comes Bazda's mother's voice again. She's got her bucket filled with wurm saliva. I pick up two filled with gravel and walk quickly ahead of her until we reach the catacomb chamber, far enough from prying ears.
"Ma'am. I could really use your help," I plead. "I've got a plan to free me and you and everyone else the pontiff's got bound by contract. All I ask of you is to do these two simple things~"
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
Bazda's mother stands at the hole in the center of the chamber, looking down into its depths. The pontiff stands next to her, looking down as well.
"He just jumped," she says. "I guess the work was too rough for him. You know how elves are."
"Pity," the pontiff says. "At least I've still got the loxodon. Definitely the better worker of the two." He hands his staff to the thrull as he always does before opening his contract book, then he flips to the page I'd signed. The pontiff raises his hands, and as he casts the spell, I'm close enough to see where the expiry date bleeds into the paper, and yet the pontiff doesn't notice me.
The first thing I'd asked of Bazda's mother was that she fetch the pontiff and tell him that I'd jumped. There was no other entry or exit to the room, so it was obvious that's the way I had to go.
The second thing I'd asked was to borrow her bucket of wurm saliva. I'd rubbed it upon my entire body. The experience, I can't say that it was a positive one, but it gave me a nice tacky coating for gravel to stick to. After two applications, I looked as much like a stone statue as any of the others lining the walls. I struck a pose, then waited.
#figure(image("005_Bound and Bonded/08.jpg", width: 100%), caption: [Overgrown Tomb | Art by: Yeong-Hao Han], supplement: none, numbering: none)
And now is my chance to strike. I barrel toward the pontiff at full speed, then swipe the contract book with one hand. I catch him by surprise, and it goes flying. I grab onto him, wrestling him toward the hole. He's scrappy, but I've spent my whole life atop the backs of beasts a thousand times his size, and with two hard flips, I pitch him into the hole. Four seconds pass before I hear flesh impact and bones snap. I wince, then race for the book, tearing up contract after contract. I look back at the thrull who's still standing there, holding the staff.
"Come on," I say. "Help me with this, and we can all go free. Including you! He won't be able to put the book back together without his staff."
The thrull slowly turns to face me. From the hole, we hear the pontiff moaning. There's a flash on the thrull's face, and before I can plead with him to stop, he's jumped in after the pontiff. Moments later, I hear the ripping of muscles and ligament. Amber light flickers down deep as the pontiff wields his flesh magic.
"Change of plans," I say to Bazda's mother, then I'm running back toward the others. I pull the artifact from beneath my armor and give it to Ambrellin. "Do you think you can get that machine working?" I ask her.
"I think so," she says. "The magic is strong, but the mechanics are simple. I'll just need someone to push."
"I can do it," Savaryn says, flexing his muscles. Ten minutes later, the piece is in place, Kellim and Bazda are dropping copper coins into the feeder, Savaryn is pushing the lever around and around, and as the top stone grinds against the bottom one, purple sparks fly and the hairs on my arms stand on end. I keep checking over my shoulder, looking for the pontiff, but the hallway stays silent. The first gold coin tumbles out the chute, and I catch it in my hands. I bite it. Looks like the real thing. A dozen more tumble out, then fifty. The spirits count them out into buckets of five hundred zinos each.
I ask each of them how much they have left of their debts, and divide the money between them, ready to buy their freedom. Everything stops when we hear a #emph[click, click, click] coming toward us. Moments later, the pontiff emerges into the room, one arm hanging lower than the other and his jaw sitting too far forward. Blue-gray flesh peeks out from beneath his robes with each step, and it takes me a moment to realize that he's fused the thrull to his leg, its head now where the pontiff's foot had been, the thrull's golden faceplate hitting the stone tile with each step.
"It's over," I tell him, setting a bucket of zinos before his feet. "I'm paying off all of our debts. We are no longer bound to your contracts." And with my words, I feel the law magic loosening its grip.
"No!" he says, his scream like a gargle in his throat. "The machine is mine. Those coins belong to me! You have no claim!"
"But we do. You said it yourself. Possession is ninety-nine hundredths of the law." I grin.
Bazda waves at him, sitting atop the coin mill.
"I will make more money," the pontiff says. "Money to feed into the Syndicate. Money to fund wars. All other guilds will fall, starting with Selesnya."
"We'll be leaving, now," I say, tipping my head. "It was nice doing business with you."
And with that, the spirits stretch up, their ethereal bodies suddenly lighter, and they disappear through the rock. My friends and I make our way back up the stairs, toward the chamber and half-finished set of stairs.
I whistle, calling the wurms below, hoping they remember their training. They show up moments later. I strip out of my armor and hand it to Bazda. "Here, put these on. It's about to get a little hot."
Ambrellin looks at me. "You expect us to ride a wurm out of here? Without protection? We'll melt!"
"It's not far to the surface. Five, ten seconds, max."
"Five seconds of molten lava in our faces."
"Or, ten," I remind her. "Alone, we couldn't make it, but if we work together. Sticking close, casting healing spells, and weaving them together into something greater than the sum of its parts, I think we'll make it."
"I believe in Terrik," Savaryn says. "I think it's a good plan."
"I agree," says Kellim.
"I do, too!" Bazda says, the bulk of my armor nearly swallowing her.
"It's a good plan," Ambrellin agrees.
We all climb upon the wurm and hold on tightly. I pat the wurm and speak softly to her, hoping the abuse she's endured hasn't nullified all her training. I've still got a few jerky crumbs in my pocket. I toss one into her mouth. "Come on, girl, let's do this."
I lean forward, taking my time like I'm training a hatchling, even though time is the one thing I'm short on. She moves forward, gains some confidence, and trust starts to build. She wurms her way up the gap to the catacomb where we'd entered, and by the time we've reached the other end of the chamber, she's moving at a steady clip. "It's time. Start your spells," I say and pull back, directing the wurm to jump toward the ceiling. Healing spells encompass the five of us, the others meditating with all their might as I steer. The heat hits my face, burns, but I hold steady, and finally, the curtain of molten lava parts, and the cool of the night soothes away our wounds. Never in my life would I have thought to be so glad to be breathing the sooty air of the Orzhov Syndicate.
#figure(image("005_Bound and Bonded/09.jpg", width: 100%), caption: [Flower \/\/ Flourish | Art by: <NAME>], supplement: none, numbering: none)
Two of the spirits are sitting there, waiting for us. It takes Bazda a long moment, but she finally puts it together. "Mama? Papa?" she asks them. The strong little girl I thought incapable of softness breaks down into tears. There was a little money left over after all the debts had been paid. I hand it to Bazda.
"Here's something for you to restart your lives together," I say.
"Thank you," Bazda says. "But that man. Won't he keep using the machine? Won't he make war?"
"Not any time soon," Ambrellin says. She hands Bazda's artifact back to her.
"I told you you'd get it back," I say. "I always keep a promise."
We part ways with Bazda's family, the four of us dragging ourselves back to Ambrellin's cooperative, but when we hear screaming coming from her downstairs neighbors' apartment, we hasten our steps. We enter their home to find my little wurm girl curled up on their bed, slobbering through to the mattress. Looks like she found her way back home, give or take a floor. We all start laughing. Well, minus the neighbors.
"This feels good," I say, "all of us together like this." I don't know what the future holds, if I'll be able to clear my name and get my job back, or if Savaryn and Kellim will still decide to leave. I do know that the future is full of possibilities, and our bond is something that will never be broken.
|
|
https://github.com/li3zhen1/Typst-Templates | https://raw.githubusercontent.com/li3zhen1/Typst-Templates/main/homework.typ | typst |
#let conf(
homework-index: 1,
homework-title: "", // "Data Exploration and Analysis",
class-id: [],
author: "<NAME>",
doc,
) = {
set text(font: "SF Pro Text", size: 10.5pt)
set strong(delta: 200)
set enum(
numbering: it => text(features: ("tnum",), weight: 600)[#(str(it)+".")]
)
show heading.where(
level: 1
): it => box(inset: (bottom: 20pt, top: 48pt))[
#text(font:"SF Pro Display", weight: 600, size: 20pt)[#it.body]
]
show heading.where(
level: 2
): it => box(inset: (bottom: 2pt, top: 24pt))[
#text(font:"SF Pro Display", weight: 600, size: 15pt)[#it.body]
]
set page(
numbering: "1"
)
show figure: it => align(center)[
#block(
stroke: 1pt+rgb(80,80,81)
)[#it.body]
#v(6pt, weak: true)
#text(size: 7pt, fill: rgb(80,80,81))[Figure #it.counter.display(it.numbering) - #it.caption]
]
grid(
columns: (1fr, 1fr),
[#author],
datetime.today().display("[month repr:short] [day padding:none], [year]")
)
[= #class-id - HW#homework-index#if type(homework-title)=="string" and homework-title.len() > 0 {
[\ #homework-title]
}]
doc
}
|
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/visualize/image_11.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Test format auto detect
#image.decode(read("/assets/files/tiger.jpg", encoding: none), width: 80%)
|
https://github.com/UntimelyCreation/typst-neat-cv | https://raw.githubusercontent.com/UntimelyCreation/typst-neat-cv/main/src/content/fr/education.typ | typst | MIT License | #import "../../template.typ": *
#cvSection("Formation")
#cvEntry(
title: [Master en informatique],
organisation: [La même université],
logo: "",
date: [2016 - 2018],
location: [France],
description: list(
[#lorem(20)],
),
tags: ("Systèmes de bases de données", "Réseaux informatiques", "Cybersécurité")
)
#divider()
#cvEntry(
title: [Licence en informatique],
organisation: [Une certaine université],
logo: "",
date: [2014 - 2016],
location: [France],
description: list(
[#lorem(20)],
),
)
|
https://github.com/dyc3/ssw-555-agile-methods | https://raw.githubusercontent.com/dyc3/ssw-555-agile-methods/main/main.typ | typst | #import "ieee.typ": *
#import "apa.typ": *
#show: apa.with(
title: "Impact of Agile Methodologies on Open Source Software Development: A Comparative Analysis",
running-head: "Agile Methods in Open Source",
authors: (
(
name: "<NAME>",
email: "<EMAIL>",
department: [School of Systems and Enterprises],
organization: [Stevens Institute of Technology],
location: [Hoboken, NJ],
),
(
name: "<NAME>",
email: "<EMAIL>",
department: [School of Systems and Enterprises],
organization: [Stevens Institute of Technology],
location: [Hoboken, NJ],
),
(
name: "<NAME>",
email: "<EMAIL>",
department: [School of Systems and Enterprises],
organization: [Stevens Institute of Technology],
location: [Hoboken, NJ],
),
(
name: "<NAME>",
email: "<EMAIL>",
department: [School of Systems and Enterprises],
organization: [Stevens Institute of Technology],
location: [Hoboken, NJ],
),
(
name: "<NAME>",
email: "<EMAIL>",
department: [School of Systems and Enterprises],
organization: [Stevens Institute of Technology],
location: [Hoboken, NJ],
)
),
bibliography-file: "bibfile.bib",
course: "SSW 555: Agile Methods for Software Development",
instructor: "<NAME>",
abstract: [
This paper delves into the intricate relationship between agile methodologies and open-source software development, recognizing the paramount role that open-source software plays in contemporary computing. The exploration begins with a comprehensive overview of agile methods, elucidating their principles and practices. Subsequently, the paper delineates the conventional open-source development process, setting the stage for a meticulous comparison of the management styles inherent in agile and open-source development. Noteworthy open-source projects that incorporate agile methods are scrutinized, providing concrete examples for analysis. The study culminates in a thorough examination of the discernible impact of agile methodologies on the overarching landscape of open-source development. This research contributes to the evolving discourse surrounding software development methodologies, shedding light on the synergies and disparities between agile practices and the collaborative ethos intrinsic to open-source software development.
]
)
== Introduction
Open-source software (OSS) constitutes a pivotal component of contemporary computing, prompting considerable scholarly interest in the methodologies governing its development and maintenance. This paper aims to expound upon the ramifications of agile methodologies on open-source software development. The discourse commences with an exploration of agile methods, followed by an examination of the conventional open-source development process. Subsequently, an analysis comparing the management styles inherent in agile and open-source development is presented. Additionally, the paper scrutinizes selected open-source projects that incorporate agile methods. Ultimately, a comprehensive assessment is undertaken to elucidate the profound impact of agile methodologies on the realm of open-source development.
We sourced literature from various academic databases searching for key words ("Agile Methods", "Agile", "Open Source", "Software Project Management"), and found projects using agile methods through GitHub. We then analyzed the projects to determine how agile methods were used, and how they impacted the project.
== What is Agile?
Agile Methodologies, while there are a multitude of strategies to follow, primarly have a shared goal of increasing the rate of development for development teams. @Coram_2005 Software projects have many frequent changes throughout the life cycle as a result of changing user requirements. Developers needed a way to better handle these changes, which resulted in the creation of the Manifesto for Agile Software Development. The Manifesto emphasizes the value of the individual and interactions over tools and processes, and collaboration with the stakeholders over a negotiation. Functional software is also desired over solid documentation, as well as responsiveness and adaption to a situation rather than following a plan. @Eckstein_2004 To put it simply, the quality and efficiency of development is the goal of agile methods. Methods like Extreme Programming, SCRUM, Dynamic System Development Method (DSDM), and Test-Driven Development are popular in today's technology sector, all techniques designed for rapid development to deliver a product. One of the largest and longest-running surveys, State of Agile (2018), reports that 97% of organizations that responded to the survey use agile methods in their development practices. @Hoda_2018 The pulse of software development is to use agile methods for adaptive, reactive, and effective teams.
=== Extreme Programming
The objective of Extreme Programming (XP) is to get the project done in a straightforward manner. Compared to the highly decorative process of the waterfall model, XP relies on communication, feedback and simplicity. XP is comprised of 5 phases: Exploration, Planning, Iterations to Release, Productionizing, Maintanence and Death. @Beck_2000 Exploration is the time period where requirements are defined with the customer. Teams prioritize requirements during the planning phase, and then developed in iterations to the first release. Further development and testing is completed during Productionizing to ensure that the release meets customer requirements. Finally, new iterations are executed to correct, perfect and adapt the code with changes for the customer, and the Death phase produces all documentation until the system is no longer needed. @Coram_2005 XP works best for small, localized teams so the use of XP would not be benefical due to the nature of open source development. @Turnu_2006
=== Test-Driven Development
Test-Driven Development (TDD) requires tests to be written before the code itself is written. The design of the software changes through the tests as the rapid cycle of adding new tests, passing those tests and cleaning the code by refactoring is executed ("test-code-refactor"). @Turnu_2006 It is imperative that the tests are automated to ensure that there is no technical debt from manually running tests. If they are automated, minimal effort is required to be run over and over again. The debugging process in TDD is simplified because bugs can be found earlier with the tests, making it easier and quicker to develop a full project. @Turnu_2006
=== SCRUM
The next agile method commonly used in agile development is Scrum. Scrum is an agile framework that is a series of steps designed to manage and control the process of software and product development. There are specific roles defined in Scrum to delegate work and leadership, as well as to make sure the team evolves with the changing requirements. There is a Product owner, Scrum master, Scrum team, all working cross functionally with developers and testers. @Srivastava_2017 All requirements for the project are documented in the product backlog. Work is divided into Sprints, which is a block of time (usually 1-3 weeks) where developers work on defined requirements from the product backlog. @Coram_2005 The goal of each sprint is to deliver a potentially shippable product. At the end of each sprint, there is a sprint review to demonstrate the increment (work completed) and reflect on the way work was completed. @Srivastava_2017
=== Dynamic System Development Method
The Dynamic System Development Method (DSDM) is different from other methods in that resources and time are prioritized, and functionally is adjusted around those parameters. Phases of DSDM are still iterative (similar to Scrum and XP) with pre-defined periods of time. DSDM begins with assessing the project and building a development plan, followed by outlining a prototyping plan and system architecture. During the functional model iteration phase, the requirements, functions and risk analysis are created for the project. Finally, the project is designed and built to meet the minimum set of requirements through iterative sessions, and then finally the software is delivered to the customer. @Coram_2005
== Typical Open Source Development
Open-source software development entails a collaborative endeavor involving both developers and users. Users possess the capability to actively contribute to the software's advancement by identifying and reporting bugs, proposing features, and even submitting code. Developers, in turn, leverage this feedback to enhance the software. Notably, open-source software development diverges from conventional software development in two pivotal aspects. Firstly, users have the opportunity to participate directly in the software's development, including but not limited to contributing code. Secondly, the majority of developer collaboration occurs asynchronously through online platforms.
Over the course of time, the genesis of open-source software has undergone notable evolution. @Fitzgerald_2006 The initiation of an open-source project diverges markedly from that of a conventional software undertaking. In the latter, the project lifecycle encompasses four overarching phases: planning, analysis, design, and implementation. Conversely, certain open-source projects commence with a solitary developer or a small group who identify a personally compelling problem to address. @Bonaccorsi_Rossi_2003 The planning phase is often condensed, and requirements analysis is frequently nominal or absent. @Fitzgerald_2006 Notably, contemporary open-source projects have experienced increased financial backing, leading to a proliferation of startups embracing open-source development practices.
A distinctive characteristic of open-source software development is the frequent anonymity of contributors. This anonymity arises from the absence of a requirement for contributors to disclose personal information during the contribution process. This stands in stark contrast to traditional software development, wherein developers typically operate in close proximity, facilitating face-to-face communication and engendering a disparate project management dynamic.
=== Project Management in Open Source Software
In numerous smaller open-source projects, a singular figure, often referred to as the "Benevolent Dictator For Life," assumes the roles of project manager and lead developer simultaneously. @Schneider_2022 @Reagle_2007 This individual delineates the project's objectives and priorities and retains sole authority in making conclusive decisions regarding feature additions. The person in question assumes complete ownership of the code and bears absolute responsibility for its oversight. While this approach offers a straightforward method of project management, its scalability diminishes with project growth. In mid-sized open-source projects, a small cadre of individuals may collectively manage the project, adhering to the foundational principles of the "Benevolent Dictator For Life."
It is noteworthy, however, that not all open-source projects adhere to this management paradigm. Certain open-source initiatives are overseen by corporate entities, wherein the company assumes responsibility for project development, and developers are entrusted with the task of actualizing the project. While reminiscent of traditional software development models, developers in this context still retain the capacity to contribute to the project. Importantly, developers in such management structures typically wield an equitable influence in determining the code integrated into the project.
Despite these alternative management models, numerous expansive and widely utilized open-source projects persist under the ultimate guidance of a Benevolent Dictator. A prime illustration of this is the Linux kernel, where <NAME> assumes the role of the Benevolent Dictator For Life. However, beneath his purview exists a hierarchical structure comprising maintainers tasked with overseeing distinct facets of the kernel. These maintainers assume the responsibility of scrutinizing and endorsing the quality of submitted code as it ascends the chain of command, ultimately reaching <NAME>. @How-Linux-is-Built
== Comparing Agile and Open Source Management Styles
Agile and Open Source management styles are quite similar in a few different aspects. Regarding the process of developing software, while agile methods have predefined processes and sequences, numerous open source projects also have structured processes. Agile is built on individual capability and the motivation of those individuals, each person equally invested and contributing to the project. Open source differs from this in that there are a large number individuals participating in development, but a few Chief Programmers who contribute the majority of the source code. @Eckstein_2004
The way agile and open source teams function are quite similar. Self-organization is a shared trait among agile and open source teams. In Agile, self-organized teams are important to adapt and adjust to changing requirements. In open source, there is a common focus so all contributing individuals join and follow the goals, organizing in a way that results in maxium productivity. Close collaboration is required within the team (in methods of pair programming, review, etc), whereas open source teams are scattered in different parts of the world, working asyncronously. This makes the nature of collaborative development different but effective for the tasks at hand. @Eckstein_2004
Agile projects typically involve frequent customer/stakeholder interactions, with feedback being gathered throughout the development process. This allows for early identification and correction of any issues, and helps to ensure that the final product meets the needs of the customer. Open source projects, on the other hand, typically have a less formal approach to customer interactions. This is due to the fact that open source projects are often volunteer-driven, and it can be difficult to coordinate stakeholder meetings with a global community of contributors. @hunt_adapting_2010
Additionally, Agile projects are designed to deliver working software in short increments, which allows for early feedback from customers and stakeholders. This feedback can then be used to improve the product before it is fully released. Open source projects also release software frequently, but the feedback loop is typically less direct. This is because open source projects often have a large community of users, and it can be difficult to track down and gather feedback from everyone. @hunt_adapting_2010
Despite these differences, Agile and Open Source management styles share some important similarities. Both approaches value flexibility, adaptability, and iteration. They also both emphasize the importance of collaboration and communication. As a result, these two management styles can be complementary, and they can be used together to achieve great success.
== The Impact of Agile Methods on Open Source Development
As Agile Methodologies integrate into mainstream development due to the positive effects on code quality and quick response time, aspects of agile are emerging into open source development. A trend in open source projects appear to be the adoption of Testing and Continuous Integration. The implementation of automated tests establishes trust among the developers involved with the open source project because passing tests demonstrates that their code works, and that the code does not have to be rewritten by other developers. @Turnu_2006
In addition to Testing and CI, other Agile practices are also making their way into open source development. Iterative development models are becoming more common, allowing features to be developed, tested, and released in small increments. This approach aligns with the Agile principle of responding quickly to changes and adapting to user feedback. @Hron_2022
User-centric design is another Agile practice that open source projects are increasingly focusing on. By prioritizing user feedback and requirements, these projects ensure that their software meets the needs and expectations of end-users. Furthermore, Agile's flexible and adaptive planning approach is particularly beneficial for open source projects, which often need to pivot based on contributor availability, community interest, and technological shifts. @Muhammad_2021
However, applying Agile methodologies in open source contexts is not without its challenges. Coordinating distributed teams, managing contributions from developers with varying expertise, and ensuring consistent communication are significant hurdles. To overcome these challenges, open source projects often tailor Agile practices to their specific environments, such as using asynchronous communication tools and flexible scheduling to accommodate contributors across different time zones. Establishing clear guidelines and documentation also plays a crucial role in effectively onboarding new contributors and maintaining project continuity.
Agile Methods also require strong developers who communicate well. @Coram_2005 The nature of an open source project might change to adapt more forms of communication between developers to adapt to changing requirements of the project. The level of skill that a developer has might also be checked before an individual is allowed to contribute to source code. Developers that require "hand-holding" could struggle in an agile environment, negatively impacting the rate of development. @Cohn_2003
Interactions with customers during open source development using agile methods will have to be more frequent and with more influence. Agile Methods require the customer to partake in a role on the development team throughout the entire development process to ensure the end product meets the user requirements. Communicating through documentation will also be less important using Agile Methods since the priority is development over documentation (especially in DSDM), but still necessary in open source development. Compared to the easy coversation in a traditional development team, the asynchronous development of open source requires some kind of documentation to catch new members up to speed. @Coram_2005
=== Case Study: Visual Studio Code
The Visual Studio Code project, commonly referred to as VSCode, stands as a open source integrated development environment (IDE) crafted by Microsoft. @Visual_Studio_Code In alignment with agile methodologies, the project adopts a transparent approach by publicly disclosing its roadmap and monthly iteration plans on GitHub. This transparent sharing of insights and plans enables not only an open view of forthcoming developments but also encourages community engagement and feedback. The iterative nature of VSCode's development, facilitated by these public iterations, allows for rapid adjustments, enhancements, and the integration of user suggestions or reported issues within short time frames. This agile method empowers continuous improvement and iterative development, fostering a more responsive and user-oriented evolution of the software.
The substantial proportion of VSCode users being developers not only delineates a unique demographic but significantly bolsters the agile attributes of the project. This amalgamation of users as potential contributors streamlines the feedback collection process, expediting its integration into the project. The inherent capability of community members to directly contribute to the project materializes as an efficient mechanism for rapidly incorporating user feedback, ultimately fortifying the project's agile nature.
=== Case Study: Keptn
Keptn, an open-source Kubernetes observability tool initially conceived by <NAME> and presently overseen by Dynatrace, strategically employs agile methodologies in its project management. To harmonize the open-source framework with agile practices, Keptn segregates its developer cohort into distinct groups: the "core" team, comprising Dynatrace employees, and a "contributor team." The core team rigorously engages in biweekly sprints, orchestrating their progress from a comprehensive product backlog accessible through their GitHub repository. Given the transient nature of contributor involvement, contributors operate independently from the sprints, leveraging a Kanban board that grants them flexibility in their task selection. @Bräuer_2021
This structural dichotomy is deliberately crafted to enhance organizational efficiency in release planning. The sprints meticulously define the assured components of each release, while contributions from the contributor team serve as supplementary enhancements, augmenting the final release composition. @Bräuer_2021
== Conclusion
Agile methodologies, characterized by their emphasis on flexibility, adaptability, and collaboration, have forged a symbiotic relationship with open-source software development, a paradigm driven by community participation and shared ownership. This convergence has ushered in a new era of software development, one that prioritizes responsiveness to user needs, continuous improvement, and an unwavering commitment to quality.
Open-source software projects, by their very nature, demand a high degree of flexibility and adaptability. As a distributed community of developers, contributors from around the globe come together to build and maintain software, often under unpredictable circumstances. Agile methodologies, with their emphasis on incremental development and iterative releases, provide a well-suited framework for managing this dynamic environment.
The collaborative nature of open-source software development aligns perfectly with the core values of agile methodologies. Frequent interactions between developers, testers, and users foster a sense of shared ownership and responsibility, ensuring that the software evolves in the right direction. Agile practices, such as pair programming and code reviews, promote knowledge sharing and collective problem-solving, further strengthening the collaborative spirit of open-source projects.
Agile methodologies have also had a positive impact on the quality of open-source software. The emphasis on testing and continuous integration, hallmarks of agile development, has led to a more rigorous approach to software quality assurance. This has resulted in a significant improvement in the overall quality and stability of open-source software, making it more attractive to a wider range of users.
The interactions between agile methodologies and open-source software development is a testament to the power of collaboration and adaptability in the modern software development landscape. By embracing these principles, open-source projects have not only produced high-quality software but have also fostered a community of passionate developers who are constantly pushing the boundaries of innovation.
As the software development landscape continues to evolve, understanding and navigating the interactions between agile methods and open-source development will become increasingly crucial for fostering innovation, responsiveness, and sustained growth in the ever-dynamic world of technology. |
|
https://github.com/8LWXpg/typst-ansi-render | https://raw.githubusercontent.com/8LWXpg/typst-ansi-render/master/test/typst.typ | typst | MIT License | #import "../ansi-render.typ": *
#set page(width: auto, height: auto, margin: 0pt)
#ansi-render(read("typst.txt"), size: 4pt) |
https://github.com/Zeng-WCh/SYSU-Typst-Internship-report-template | https://raw.githubusercontent.com/Zeng-WCh/SYSU-Typst-Internship-report-template/main/template.typ | typst | MIT License | // Font Settings, change it if you need
#let song = "FZShuSong-Z01"
#let xbsong = "FZXiaoBiaoSong-B05"
#let code = "Monaspace Neon Var"
#let report(
title: "本科生实习报告书",
banner: none + "",
school: "摸鱼学院摸鱼专业",
grade: "xxxx 级 x 班",
name: "张三",
stu_id: "22223333",
company: "某某公司",
start_time: "2077 年 7 月 1 日",
end_time: "2077 年 8 月 31 日",
teacher: "李四",
year: "2077",
month: "12",
day: "25",
body,
) = {
// set document(title: title)
set page(paper: "a4")
show raw.where(block: true): block.with(
fill: rgb(248, 248, 248),
inset: (x: 1.25em, y: 1em),
width: 100%,
radius: 4pt,
)
show raw.where(block: true): par.with(first-line-indent: 0em, justify: true, leading: 8pt)
show raw.where(block: false): box.with(
fill: rgb(248, 248, 248),
inset: (x: 5pt, y: 0pt),
outset: (y: 4pt),
radius: 3pt,
)
show raw: text.with(font: code, size: 1em)
show heading: it => [
// Cancel indentation for headings of level 2 or above
#set par(first-line-indent: 0em)
#let sized_heading(it, size, weight, mt, mb) = [
#set text(size, weight: weight)
#v(mt)
#if it.numbering != none {
counter(heading).display()
h(0.1em)
}
#text(size, weight: weight, it.body)
#v(mb)
]
#if it.level == 1 {
sized_heading(it, 20pt, "semibold", 1em, 0.3em)
} else if it.level == 2 {
sized_heading(it, 16pt, "semibold", 0.7em, 0.2em)
} else if it.level == 3 {
sized_heading(it, 14pt, "medium", 0.5em, 0.2em)
} else {
sized_heading(it, 12pt, "medium", 0.3em, 0.1em)
}
]
show link: underline
let fieldname(name, font) = [
#set align(right + top)
#text(name, font: font)
#h(0.25em)
]
let fieldvalue(value, font) = [
#set align(center + horizon)
#set text(font: font)
#grid(
rows: (auto, auto),
row-gutter: 0.2em,
value,
line(length: 100%)
)
]
align(center)[
\
\
#if banner != none {
image(banner, width: 64%)
}
\
\
\
#set text(font: xbsong, lang: "zh", size: 25pt)
#title
\
\
\
\
#set text(font: xbsong, lang: "zh", size: 16pt)
#grid(
columns: (80pt, 280pt),
row-gutter: 1em,
fieldname("院系专业", song),
fieldvalue(school, song),
fieldname("年级班级", song),
fieldvalue(grade, song),
fieldname(text("姓") + h(2em) + text("名"), song),
fieldvalue(name, song),
fieldname(text("学") + h(2em) + text("号"), song),
fieldvalue(stu_id, song),
fieldname("实习单位", song),
fieldvalue(company, song),
fieldname("实习时间", song),
fieldvalue(start_time + "至" + end_time, song),
fieldname("指导教师", song),
fieldvalue(teacher, song),
)
#set text(font: xbsong, lang: "zh", size: 12pt)
#v(140pt)
#text(year)年 #h(2em) #(month)月 #h(2em) #(day)日
]
let content(body) = {
pagebreak(weak: true)
table(
columns: (2fr, 19fr),
[
#set align(center + horizon)
#set text(font: xbsong, lang: "zh", size: 16pt)
实习\
报告
],
[
#set text(font: song, lang: "zh", size: 11pt)
#body
]
)
}
content(body)
pagebreak(weak: true)
table(
columns: (2fr, 19fr),
[
#set align(center + horizon)
#set text(font: xbsong, lang: "zh", size: 16pt)
实习\
单位\
意见
],
[
#set text(font: song, lang: "zh", size: 14pt)
#v(250pt)
#align(right)[
（盖章） #h(5em)
#h(2em)
年
#h(2em)
月
#h(2em)
日
]
#v(15pt)
],
[
#set align(center + horizon)
#set text(font: xbsong, lang: "zh", size: 16pt)
指导\
老师\
评语
],
[
#set text(font: song, lang: "zh", size: 14pt)
#v(100pt)
#align(right)[
成绩评定： #h(70pt)
\
指导老师（签名）： #h(5em)
\
#h(2em)
年
#h(2em)
月
#h(2em)
日
]
#v(15pt)
],
[
#set align(center + horizon)
#set text(font: xbsong, lang: "zh", size: 16pt)
院系\
意见
],
[
#set text(font: song, lang: "zh", size: 14pt)
#v(100pt)
#align(right)[
主管教学领导签名（盖章）： #h(5em)
\
#h(2em)
年
#h(2em)
月
#h(2em)
日
]
#v(15pt)
],
)
}
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/unichar/0.1.0/ucd/block-10E60.typ | typst | Apache License 2.0 | #let data = (
("RUMI DIGIT ONE", "No", 0),
("RUMI DIGIT TWO", "No", 0),
("RUMI DIGIT THREE", "No", 0),
("RUMI DIGIT FOUR", "No", 0),
("RUMI DIGIT FIVE", "No", 0),
("RUMI DIGIT SIX", "No", 0),
("RUMI DIGIT SEVEN", "No", 0),
("RUMI DIGIT EIGHT", "No", 0),
("RUMI DIGIT NINE", "No", 0),
("RUMI NUMBER TEN", "No", 0),
("RUMI NUMBER TWENTY", "No", 0),
("RUMI NUMBER THIRTY", "No", 0),
("RUMI NUMBER FORTY", "No", 0),
("RUMI NUMBER FIFTY", "No", 0),
("RUMI NUMBER SIXTY", "No", 0),
("RUMI NUMBER SEVENTY", "No", 0),
("RUMI NUMBER EIGHTY", "No", 0),
("RUMI NUMBER NINETY", "No", 0),
("RUMI NUMBER ONE HUNDRED", "No", 0),
("RUMI NUMBER TWO HUNDRED", "No", 0),
("RUMI NUMBER THREE HUNDRED", "No", 0),
("RUMI NUMBER FOUR HUNDRED", "No", 0),
("RUMI NUMBER FIVE HUNDRED", "No", 0),
("RUMI NUMBER SIX HUNDRED", "No", 0),
("RUMI NUMBER SEVEN HUNDRED", "No", 0),
("RUMI NUMBER EIGHT HUNDRED", "No", 0),
("RUMI NUMBER NINE HUNDRED", "No", 0),
("RUMI FRACTION ONE HALF", "No", 0),
("RUMI FRACTION ONE QUARTER", "No", 0),
("RUMI FRACTION ONE THIRD", "No", 0),
("RUMI FRACTION TWO THIRDS", "No", 0),
)
|
https://github.com/Ad4u/ad4u.github.io | https://raw.githubusercontent.com/Ad4u/ad4u.github.io/main/dinner_cn.typ | typst | #let WIDTH = 90mm
#let HEIGHT = 160mm
#let MARGIN = 6mm
#let FRONT_TOP_MARGIN = 35mm
#let BACKGROUND = image("assets/background.jpg", width: WIDTH, height: HEIGHT)
#let FRONT = image("assets/front.jpg", width: WIDTH, height: HEIGHT)
#let BACK = image("assets/back.jpg", width: WIDTH, height: HEIGHT)
#set document(title: "Betty and Romain's wedding dinner")
#show heading: item => [
#pagebreak()
#set align(center)
#set text(font: "Better Smile", size: 44pt)
#item
#v(-20mm)
#image("assets/separator.png", width: 60%)
#v(-8mm)
]
// Page setup
#set par(leading: 0.55em, justify: true)
#set page(width: WIDTH, height: HEIGHT, margin: MARGIN)
// Front page
#set text(font: "Better Smile", size: 44pt, weight: "medium")
#set page(background: FRONT)
#set page(margin: (top: FRONT_TOP_MARGIN))
#align(center)[Betty \ and \ Romain's \ wedding \ dinner]
// Body
#set page(background: BACKGROUND, margin: MARGIN)
#set text(font: "TT Chocolates Trl", size: 16pt, weight: "medium")
= Thank you
#read("speeches/ThankYou_CN.txt")
= Speech 4
#read("speeches/4_CN.txt")
= Speech 5
#read("speeches/5_CN.txt")
= Speech 6
#read("speeches/6_CN.txt")
= Speech 7
#read("speeches/7_CN.txt")
= Speech 8
#read("speeches/8_CN.txt")
= Speech 9
#read("speeches/9_CN.txt")
// Back page
#set page(background: BACK)
#pagebreak()
|
|
https://github.com/tsubakichan-289/Yang-Baxter-equation | https://raw.githubusercontent.com/tsubakichan-289/Yang-Baxter-equation/main/main.typ | typst | #import "@preview/fletcher:0.5.1" as fletcher: diagram, node, edge
#import "@preview/polylux:0.3.1": *
#set page(paper: "presentation-16-9", fill: black)
#set text(fill: white)
#polylux-slide[
#diagram(
let V1 = node("V"),
let V2 = node("V'"),
let V3 = node("V"),
let V4 = node("V'"),
$
V1 edge("rr",->, stroke: #white, f) edge("dd",->, stroke: #white, pi(a)) & & V2 #edge("->", "dd", $pi'(a)$, label-side: left, stroke: white) \
& arrow.cw & \
V3 edge("rr", ->, stroke: #white, f) & & V4 \
$
)
]
$
pi(X^+) = mat(0,1;0,0), quad pi(X^-) = mat(0,0;1,0), quad pi(K) = mat(q,0;0,q^(-1))
$
$K=q^H$とすれば，$pi(H)=mat(1,0;0,-1)$となる．
$
K = q^H = e^(epsilon H) = E + epsilon H + 1/2 epsilon^2 H^2 + ...
$
$
pi(K) =& pi(E) + epsilon pi(H) + 1/2 epsilon^2 pi(H^2) + ...\
lim_(epsilon -> 0) d/(d epsilon) pi(K) =& lim_(epsilon -> 0) (pi(H) + epsilon pi(H^2) + ...)\
=& pi(H)
$
$
d/(d epsilon) pi(K) =& lim_(h -> 0) (mat(e^epsilon,0;0,e^(-epsilon)) - mat(e^(epsilon - h),0;0,q^(epsilon - h)))/h \
=& lim_(h -> 0) mat((e^epsilon - e^(epsilon - h))/h,0;0,(e^(-epsilon) - q^(epsilon - h))/h) \
=& mat(e^epsilon,0;0,-e^(-epsilon))
$
つまり，
$
pi(H) = lim_(epsilon -> 0) d/(d epsilon) pi(K) = mat(1,0;0,-1)
$
$
pi(X^+) + pi(X^-) = mat(0,1;0,0) + mat(0,0;1,0) = mat(0,1;1,0)\
pi(X^+ + X^-)
$ |
|
https://github.com/egorsmkv/pdf-generator-gradio | https://raw.githubusercontent.com/egorsmkv/pdf-generator-gradio/master/README.md | markdown | # Generate PDF documents using Gradio and Typst
- Jinja2 to template a Typst document
- Typst to generate a PDF document
- ImageMagick to get a preview image
- Gradio to provide a web interface with user parameters (via Components)
- Docker to run the app
## Demo
<img src="./demo.jpeg" width="800">
## Development
Install Python packages:
```
uv venv --python 3.12
source .venv/bin/activate
uv pip install -r requirements.txt
uv pip install -r requirements-dev.txt
```
## Run
Run Gradio app locally:
```
python app.py
```
## Production
Build the Docker image:
```
docker build -t pdf-generator-gradio .
```
Run:
```
docker run --rm -p 7860:7860 -it pdf-generator-gradio
```
|
|
https://github.com/sses7757/sustech-graduated-thesis | https://raw.githubusercontent.com/sses7757/sustech-graduated-thesis/main/sustech-graduated-thesis/utils/page-break.typ | typst | Apache License 2.0 | #let _page-break() = {
set page(header: none, footer: none)
[~]
pagebreak(weak: true, to: "odd")
}
#let page-break(twoside: true) = {
if twoside {
locate(loc => {
let pn = counter(page).at(loc).at(0)
if calc.rem(pn, 2) == 1 {
_page-break()
}
})
}
} |
https://github.com/ChHecker/diverential | https://raw.githubusercontent.com/ChHecker/diverential/main/lib.typ | typst | MIT License | #let _add-eval(expression, eval, evalsym: "|", space: none) = {
/// Add evalutation brackets.
/// - `expression`: Expression to wrap the brackets around.
/// - `eval`: Point of evalutation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
if space != none {
expression += space
}
let left = ""
let right = ""
if evalsym == "(" or evalsym == ")" {
left = "("
right = ")"
} else if evalsym == "[" or evalsym == "]" {
left = "["
right = "]"
} else if evalsym == "{" or evalsym == "}" {
left = "{"
right = "}"
} else if evalsym == "|" {
left = ""
right = "|"
if space == none {
expression += h(0.1em)
}
} else {
panic("invalid eval symbol: " + evalsym)
}
return math.attach(math.lr([#left #expression #right]), b: eval)
}
#let _degree(array) = {
/// Calculate the degree of an array taking the value in tuples into account.
let acc = 0
let cont = []
for x in array {
if type(x) == "array" and x.len() > 1 {
if type(x.at(1)) == "integer" {
acc += x.at(1)
} else if type(x.at(1)) == "content" {
if cont == [] {
cont += x.at(1)
} else {
cont += [$+ #x.at(1)$]
}
} else {
panic("invalid degree: " + x.at(1))
}
} else {
acc += 1
}
}
if cont == [] {
acc
} else {
[#cont + #acc]
}
}
#let dv(f, x, deg: none, eval: none, evalsym: "|", space: none) = {
/// Normal differential.
/// `f`: Function to take the derivative of.
/// `x`: Variable with respect to which to take the derivative of.
/// `deg`: Degree of the derivative.
/// `eval`: Point of evaluation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
let frac = math.frac([
#if deg != none {
math.attach(math.dif, t: deg)
} else {
math.dif
}
#f
],
[
#math.dif
#if deg != none {
math.attach(x, t: deg)
} else {
x
}
]
)
if eval == none {
frac
} else {
_add-eval(frac, eval, evalsym: evalsym, space: space)
}
}
#let dvc(f, x, deg: none, eval: none, evalsym: "|", space: none) = {
/// Compact differential.
/// `f`: Function to take the derivative of.
/// `x`: Variable with respect to which to take the derivative of.
/// `deg`: Degree of the derivative.
/// `eval`: Point of evaluation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
let expression = [
#if deg != none {
math.attach(math.dif, t: deg, b: x)
} else {
math.attach(math.dif, b: x)
}
#f
]
if eval == none {
expression
} else {
_add-eval(expression, eval, evalsym: evalsym)
}
}
#let dvs(f, x, deg: none, eval: none, evalsym: "|", space: none) = {
/// Separate differential.
/// `f`: Function to take the derivative of.
/// `x`: Variable with respect to which to take the derivative of.
/// `deg`: Degree of the derivative.
/// `eval`: Point of evaluation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
let frac = [
#math.frac(if deg != none {
math.attach(math.dif, t: deg)
} else {
math.dif
},
[
#math.dif
#if deg != none {
math.attach(x, t: deg)
} else {
x
}
]
)
#f
]
if eval == none {
frac
} else {
_add-eval(frac, eval, evalsym: evalsym, space: space)
}
}
#let dvp(f, ..x, deg: none, eval: none, evalsym: "|", space: none) = {
/// Partial differential.
/// `f`: Function to take the derivative of.
/// `x`: Variable(s) with respect to which to take the derivative of. Multiple variables can be supplied and a higher-order degree derivative with respect to one variable with a pair of variable and degree (e.g. `[x], ([y], 2)`). If the degree is an integer, the total degree will be the sum of the numbers. If it's content, the variables are added up. Specifying `deg` manually is always possible and might be required in more complicated cases.
/// `deg`: Degree of the derivative.
/// `eval`: Point of evaluation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
if x.named() != (:) {
panic("invalid named argument: " + str(x.named().keys().at(0)))
}
x = x.pos()
let degree = deg
if deg == none {
degree = _degree(x)
}
let frac = math.frac([
#if deg != none or (type(degree) == "integer" and degree > 1) or type(degree) == "content" {
math.attach(math.diff, t: [#degree])
} else {
math.diff
}
#f
],
for (i, term) in x.enumerate() {
if i != 0 {
[#space]
}
if type(term) == "array" and ((type(term.at(1)) == "integer" and term.at(1) > 1) or type(term.at(1)) == "content") {
[#math.diff #math.attach(term.at(0), t: [#term.at(1)])]
} else if x.len() == 1 and deg != none {
[#math.diff #math.attach(term, t: deg)]
} else {
[#math.diff #term]
}
}
)
if eval == none {
frac
} else {
_add-eval(frac, eval, evalsym: evalsym, space: space)
}
}
#let pdv(f, ..x, deg: none, eval: none, evalsym: "|", space: none) = dvp(f, ..x, deg: deg, eval: eval, evalsym: evalsym)
#let dvpc(f, ..x, deg: none, eval: none, evalsym: "|", space: none) = {
/// Compact partial differential.
/// `f`: Function to take the derivative of.
/// `x`: Variable(s) with respect to which to take the derivative of. Multiple variables can be supplied and a higher-order degree derivative with respect to one variable with a pair of variable and degree (e.g. `[x], ([y], 2)`). In this case, `deg` is ignored.
/// `deg`: Degree of the derivative.
/// `eval`: Point of evaluation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
if x.named() != (:) {
panic("invalid named argument: " + str(x.named().keys().at(0)))
}
x = x.pos()
let expression = for (i, term) in x.enumerate() {
if i != 0 {
[#space]
}
if type(term) == "array" and ((type(term.at(1)) == "integer" and term.at(1) > 1) or type(term.at(1)) == "content") {
[#math.attach(math.diff, b: term.at(0), t: [#term.at(1)])]
} else if x.len() == 1 and deg != none {
[#math.attach(math.diff, b: term, t: deg)]
} else {
[#math.attach(math.diff, b: term)]
}
}
expression += [#f]
if eval == none {
expression
} else {
_add-eval(expression, eval, evalsym: evalsym)
}
}
#let dvcp(f, x, deg: none, eval: none, evalsym: "|", space: none) = dvpc(f, x, deg: deg, eval: eval, evalsym: evalsym, space: space)
#let pdvc(f, x, deg: none, eval: none, evalsym: "|", space: none) = dvpc(f, x, deg: deg, eval: eval, evalsym: evalsym, space: space)
#let dvps(f, ..x, deg: none, eval: none, evalsym: "|", space: none) = {
/// Separate partial differential.
/// `f`: Function to take the derivative of.
/// `x`: Variable(s) with respect to which to take the derivative of. Multiple variables can be supplied and a higher-order degree derivative with respect to one variable with a pair of variable and degree (e.g. `[x], ([y], 2)`). If the degree is an integer, the total degree will be the sum of the numbers. If it's content, the variables are added up. Specifying `deg` manually is always possible and might be required in more complicated cases.
/// `deg`: Degree of the derivative.
/// `eval`: Point of evaluation.
/// - `evalsym`: Brackets of evalutation. This must be in `(`, `[`, `{`, `|`.
if x.named() != (:) {
panic("invalid named argument: " + str(x.named().keys().at(0)))
}
x = x.pos()
let degree = deg
if deg == none {
degree = _degree(x)
}
let frac = [
#math.frac([
#if deg != none or (type(degree) == "integer" and degree > 1) or type(degree) == "content" {
math.attach(math.diff, t: [#degree])
} else {
math.diff
}
],
for (i, term) in x.enumerate() {
if i != 0 {
[#space]
}
if type(term) == "array" and ((type(term.at(1)) == "integer" and term.at(1) > 1) or type(term.at(1)) == "content") {
[#math.diff #math.attach(term.at(0), t: [#term.at(1)])]
} else if x.len() == 1 and deg != none {
[#math.diff #math.attach(term, t: deg)]
} else {
[#math.diff #term]
}
}
)
#f
]
if eval == none {
frac
} else {
_add-eval(frac, eval, evalsym: evalsym, space: space)
}
}
#let dvsp(f, x, deg: none, eval: none, evalsym: "|", space: none) = dvps(f, x, deg: deg, eval: eval, evalsym: evalsym, space: space)
#let pdvs(f, x, deg: none, eval: none, evalsym: "|", space: none) = dvps(f, x, deg: deg, eval: eval, evalsym: evalsym, space: space) |
https://github.com/Myriad-Dreamin/tinymist | https://raw.githubusercontent.com/Myriad-Dreamin/tinymist/main/crates/tinymist-query/src/fixtures/docs/multiple_line.typ | typst | Apache License 2.0 | // This is X.
// Note: this is not Y.
#let x /* ident */ = 1;
|
https://github.com/hrutvikyadav/typst | https://raw.githubusercontent.com/hrutvikyadav/typst/main/README.md | markdown | # Getting started with typst
## Installation
Using `nix`
```sh
nix-shell -p typst
```
with home-manager - add to `home.packages` in `home.nix`
```nix
pkgs.typst
```
run latest development version
```sh
nix run github:typst/typst -- --version
```
## Editor integration
`Neovim`
References:
[Tinymist server configuration example](https://github.com/Myriad-Dreamin/tinymist/blob/main/editors/neovim)
[Lspconfig server configuration example](https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#tinymist)
[My lspconfig](https://github.com/hrutvikyadav/nt4/blob/main/lua/riaari/lspconfig.lua)
### Patches
1. Install `tinymist` language server with `Mason`
2. Create autocommand to set correct filetype for `.typ` files
```lua
vim.api.nvim_create_autocmd(
{
"BufNewFile",
"BufRead",
},
{
pattern = "*.typ",
callback = function()
local buf = vim.api.nvim_get_current_buf()
-- vim.api.nvim_buf_set_option(buf, "filetype", "typst") -- WARN: deprecated
vim.bo[buf].filetype = "typst"
end
})
```
This is different from the example in the `tinymist` repository, because the example is deprecated.
```diff
- vim.api.nvim_buf_set_option(buf, "filetype", "typst")
+ vim.bo[buf].filetype = "typst"
```
3. Add `tinymist` language server configuration to `lspconfig`
```lua
return {
--- todo: these configuration from lspconfig maybe broken
single_file_support = true,
root_dir = function()
return vim.fn.getcwd()
end,
--- See [Tinymist Server Configuration](https://github.com/Myriad-Dreamin/tinymist/blob/main/Configuration.md) for references.
settings = {}
}
```
## Additional tooling
### Hot reloading
Install with `rust`
```sh
cargo install typst-live
```
**OR**
Run directly with `nix`
```sh
nix run github:ItsEthra/typst-live ./testfile.typ
```
|
|
https://github.com/tinnamchoi/resumes | https://raw.githubusercontent.com/tinnamchoi/resumes/master/src/letter.typ | typst | #import "preamble.typ": *
#show: doc => template(
doc,
)
#header(name: name, links: links)
#letter()
|
|
https://github.com/maxds-lyon/lokiprint | https://raw.githubusercontent.com/maxds-lyon/lokiprint/main/templates/typst/.template/shared/sizes.typ | typst | #let size-scale(base: 12pt, ratio: 1.1) = (
small: base * calc.pow(ratio, -1),
p: base * calc.pow(ratio, 0),
h6: base * calc.pow(ratio, 1),
h5: base * calc.pow(ratio, 2),
h4: base * calc.pow(ratio, 3),
h3: base * calc.pow(ratio, 4),
h2: base * calc.pow(ratio, 5),
h1: base * calc.pow(ratio, 6),
)
#let minor-second-scale = size-scale.with(ratio: 1.067)
#let major-second-scale = size-scale.with(ratio: 1.125)
#let minor-third-scale = size-scale.with(ratio: 1.200)
#let major-third-scale = size-scale.with(ratio: 1.250)
#let perfect-fourth-scale = size-scale.with(ratio: 1.333)
#let scale = major-second-scale(base: 12pt) |
|
https://github.com/SkytAsul/INSA-Typst-Template | https://raw.githubusercontent.com/SkytAsul/INSA-Typst-Template/main/packages/silky-letter-insa/README.md | markdown | MIT License | # INSA - Typst Template
Typst Template for short documents and letters for the french engineering school INSA.
## Example
By default, the template initializes with the `insa-letter` show rule, with parameters that you must fill in by yourself.
Here is an example of filled template:
````typst
#import "@preview/silky-letter-insa:{{VERSION}}": *
#show: doc => insa-letter(
author: "<NAME>, <NAME>",
insa: "rennes"
doc)
#v(15pt)
#align(center, text(size: 22pt, weight: "bold", smallcaps("Probabilités - Annale 2022 (V1)")))
#v(5pt)
#set heading(numbering: "1.")
#show heading.where(level: 2): it => [
#counter(heading).display()
#text(weight: "medium", style: "italic", size: 13pt, it.body)
]
= Intervalle de confiance
== Calculer sur l’échantillon une estimation de la moyenne.
$ overline(x_n) = 1/n sum_(i=1)^n x_i = 1885 $
== Calculer sur l’échantillon une estimation de la variance.
$
"Variance biaisée :" s^2 &= 1/n sum_(i=1)^n (x_i - overline(x_n))^2 = 218^2\
"Variance corrigée :" s'^2 &= n/(n-1) s^2 = 231^2
$
Le bon estimateur est le second.
== Écrire le code R permettant d’évaluer les deux bornes de l’intervalle de confiance du temps d’exécution avec une confiance de 92%.
Nous sommes dans le cas d'une recherche de moyenne avec variance inconnue, l'intervalle sera donc
$ [overline(X) + t_(n-1)(alpha/2) S'/sqrt(n), quad overline(X) + t_(n-1)(1 - alpha/2) S'/sqrt(n)] $
En R, avec l'échantillon nommé `data`, ça donne
```R
data = c(1653, 2059, 2281, 1813, 2180, 1721, 1857, 1677, 1728)
moyenne = mean(data)
s_prime = sqrt(var(data)) # car la variance de R est déjà corrigée
n = 9
alpha = 0.08
IC_min = moyenne + qt(alpha / 2, df = n - 1) * s_prime / sqrt(n)
IC_max = moyenne + qt(1 - alpha / 2, df = n - 1) * s_prime / sqrt(n)
```
Ici on a $[1730, 2040]$.
````
## Fonts
The graphic charter recommends the fonts **League Spartan** for headings and **Source Serif** for regular text. To have the best look, you should install those fonts.
To behave correctly on computers without those specific fonts installed, this template will automatically fallback to other similar fonts:
- **League Spartan** -> **Arial** (approved by INSA's graphic charter, by default in Windows) -> **Liberation Sans** (by default in most Linux)
- **Source Serif** -> **Source Serif 4** (downloadable for free) -> **Georgia** (approved by the graphic charter) -> **Linux Libertine** (default Typst font)
### Note on variable fonts
If you want to install those fonts on your computer, Typst might not recognize them if you install their _Variable_ versions. You should install the static versions (**League Spartan Bold** and most versions of **Source Serif**).
Keep an eye on [the issue in Typst bug tracker](https://github.com/typst/typst/issues/185) to see when variable fonts will be used!
## Notes
This template is being developed by <NAME>EUNE from the INSA de Rennes in [this repository](https://github.com/SkytAsul/INSA-Typst-Template).
For now it includes assets from the INSA de Rennes graphic charter, but users from other INSAs can open an issue on the repository with the correct assets for their INSA.
If you have any other feature request, open an issue on the repository as well.
## License
The typst template is licensed under the [MIT license](https://github.com/SkytAsul/INSA-Typst-Template/blob/main/LICENSE). This does *not* apply to the image assets. Those image files are property of Groupe INSA and INSA Rennes.
## Changelog
### 0.2.1
- Added `insa` option
- Added INSA HdF assets |
https://github.com/kamack38/cram-snap | https://raw.githubusercontent.com/kamack38/cram-snap/main/README.md | markdown | MIT License | # cram-snap
Simple cheatsheet template for [Typst](https://typst.app/) that allows you to
snap a quick picture of essential information and cram it into a useful
cheatsheet format.
## Usage
You can use this template in the Typst web app by clicking "Start from template"
on the dashboard and searching for `cram-snap`.
Alternatively, you can use the CLI to kick this project off using the command
```
typst init @preview/cram-snap
```
Typst will create a new directory with all the files needed to get you started.
## Configuration
This template exports the `cram-snap` function with the following named
arguments:
- `title`: Title of the document
- `subtitle`: Subtitle of the document
- `icon`: Image that appears next to the title
- `column-number`: Number of columns
The `theader` function is a wrapper around the `table.header` function that
creates a header and takes `colspan` as argument to span the header across
multiple table columns (by default it spans across two)
If you want to change an existing project to use this template, you can add a
show rule like this at the top of your file:
```typst
#import "@preview/cram-snap:0.2.0": *
#set page(paper: "a4", flipped: true, margin: 1cm)
#set text(font: "Arial", size: 11pt)
#show: cram-snap.with(
title: [Cheatsheet],
subtitle: [Cheatsheet for an amazing program],
icon: image("icon.png"),
column-number: 3,
)
// Use it if you want different table columns (the default are: (2fr, 3fr))
#set table(columns: (2fr, 3fr, 3fr))
#table(
theader(colspan: 3)[Great heading that is really looooong],
[Closing the program], [Type `:q`], [You can also type `QQ`]
)
```
|
https://github.com/Ttajika/typst_template_tajika | https://raw.githubusercontent.com/Ttajika/typst_template_tajika/main/readme.md | markdown | # Typst template for myself
* 自分用のtypstの（非公式）テンプレートです．経済学の論文を書く用途に使えると思います．
* 公式テンプレートはこちら https://typst.app/universe/search?kind=templates
* 詳しい機能はexample.typを見てください．
ウェブアプリで確かめたい方は以下
https://typst.app/project/r3GVChhUil4_mwHCstXr6C
|
|
https://github.com/sardorml/vantage-typst | https://raw.githubusercontent.com/sardorml/vantage-typst/main/vantage-typst.typ | typst | MIT License | #let primary_colour = rgb("#3730a3")
#let link_colour = rgb("#12348e")
#let icon(name, shift: 1.5pt) = {
box(
baseline: shift,
height: 10pt,
image("icons/" + name + ".svg")
)
h(3pt)
}
#let findMe(services) = {
set text(8pt)
let icon = icon.with(shift: 2.5pt)
services.map(service => {
icon(service.name)
if "display" in service.keys() {
link(service.link)[#{service.display}]
} else {
link(service.link)
}
}).join(h(10pt))
[
]
}
#let term(period, location) = {
text(9pt)[#icon("calendar") #period #h(1fr) #icon("location") #location]
}
#let max_rating = 5
#let skill(name, rating) = {
let done = false
let i = 1
name
h(1fr)
while (not done){
let colour = rgb("#c0c0c0")
let strokeColor = rgb("#c0c0c0")
let radiusValue = (left: 0em, right: 0em)
if (i <= rating){
colour = primary_colour
strokeColor = primary_colour
}
// Add rounded corners for the first and last boxes
if (i == 1) {
radiusValue = (left: 2em, right: 0em)
} else if (i == max_rating) {
radiusValue = (left: 0em, right: 2em)
}
box(rect(
height: 0.3em,
width: 1.5em,
stroke: strokeColor,
fill: colour,
radius: radiusValue
))
if (max_rating == i){
done = true
}
i += 1
}
[\ ]
}
#let styled-link(dest, content) = emph(text(
fill: link_colour,
link(dest, content)
))
#let vantage(
name: "",
position: "",
links: (),
tagline: [],
leftSide,
rightSide
) = {
set document(
title: name + "'s CV",
author: name,
)
set text(9.8pt, font: "PT Sans")
set page(
margin: (x: 1.2cm, y: 1.2cm),
)
show heading.where(level: 1) : it => text(16pt,[#{it.body} #v(1pt)])
show heading.where(
level: 2,
): it => text(
fill: primary_colour,
[
#{it.body}
#v(-7pt)
#line(length: 100%, stroke: 0.5pt + primary_colour)
]
)
show heading.where(
level: 3
): it => text(it.body)
show heading.where(
level: 4
): it => text(
fill: primary_colour,
it.body
)
[= #name]
text(12pt, weight: "medium",[#position])
v(0pt)
findMe(links)
tagline
grid(
columns: (7fr, 4fr),
column-gutter: 2em,
leftSide,
rightSide,
)
}
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/text/raw_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// No extra space.
`A``B`
|
https://github.com/huyufeifei/grad | https://raw.githubusercontent.com/huyufeifei/grad/master/docs/paper/src/misc.typ | typst | #let cabs = [
驱动程序漏洞与故障的频发为操作系统安全带来了重大威胁。本文探讨了一种新的安全驱动实现方案。通过使用基于Rust语言的内存隔离与保障机制，设计了可用于驱动程序与内核、设备交互的接口，进而使用纯粹的safe Rust实现了一系列驱动程序。这种安全设计能够有效地减少由开发者引入的漏洞。同时，考虑到模块化与复用性需求，驱动以Rust包的形式发布，能够在多种操作系统中简单引入，以提高系统整体的安全性。
为测试其实用性，在Alien系统中以隔离域的形式加入该驱动。在操作系统的支持下，驱动能够满足故障隔离，防止硬件故障导致整个系统停止功能；同时，还支持在驱动崩溃发生时自动重新加载，在用户没有感知的情况下恢复正常功能。
为测试其效率，在同样环境下将安全驱动与现有不安全驱动进行测试。结果表明驱动的安全化对性能几乎无负面影响。这证明了使用安全Rust代码编写的驱动在功能上可以替换原有驱动，在提升安全性的同时，不会带来性能降低的副作用。
]
#let ckw = ("Rust", "隔离", "驱动", "操作系统", "安全")
#let eabs = [The frequent occurrence of driver vulnerabilities and failures poses a major threat to operating system security. In this paper, we explore a new secure driver implementation scheme. By using a memory isolation and safeguard mechanism based on the Rust language, we design interfaces that can be used for drivers to interact with the kernel and devices, and then implement a series of drivers using pure safe Rust. This safe design can effectively reduce the vulnerabilities introduced by developers. At the same time, considering the modularity and reusability requirements, the driver is released in the form of Rust packages, which can be simply introduced in a variety of operating systems to improve the overall security of the system.
In order to test its practicality, the driver is added to the Alien system in the form of an isolated domain. With the support of the operating system, the driver is able to meet the fault isolation to prevent hardware failure from causing the whole system to stop functioning; at the same time, it also supports automatic reloading when the driver crash occurs, restoring the normal functioning without the user's perception.
To test its efficiency, the secured driver is tested against the existing insecure driver in the same environment. The results show that the securitization of the driver has almost no negative impact on performance. This proves that the driver written with secure Rust code can functionally replace the original driver and improve security without the side effect of performance degradation.]
#let ekw = ("Rust", "isolation", "driver", "OS", "safety")
#let ack = [
值此论文完成之际，首先向我的导师陆慧梅老师、向勇老师、吴竞邦老师致以最尊敬的谢意。没有他们长期对我的指点、督促及实验环境上的帮助，就没有本文中的成果。
其次我要感谢陈林峰学长对我的帮助。他是Alien系统的主要开发者，为我的毕业设计提供了工作的方向，并且在我的研究过程中为我提供了环境配置、Alien系统相关等多方面的帮助。
我还要感谢北京理工大学的众多教师和同学、同一实验室的同学和校外的众多好友。经过和他们的学习、答疑和讨论，我才能够达到现在的水平。
最后也要感谢我的父母养育我长大并供我上学，感谢北京理工大学为我提供学习的平台。感谢Rust编程语言、qemu模拟器、VirtIO虚拟设备以及许许多多的开发者，他们的工作是本项目的基础。感谢VSCode编辑器、Typst排版系统为我的开发、论文撰写过程带来了极大的便利。
] |
|
https://github.com/typst-doc-cn/tutorial | https://raw.githubusercontent.com/typst-doc-cn/tutorial/main/src/basic/reference-bibliography.typ | typst | Apache License 2.0 | #import "mod.typ": *
#show: book.ref-page.with(title: [参考：导入和使用参考文献])
|
https://github.com/linxuanm/math-notes | https://raw.githubusercontent.com/linxuanm/math-notes/master/setup.typ | typst | #import "@preview/curryst:0.2.0": rule, proof-tree
#import "@preview/ctheorems:1.1.2": *
#let lecenv(txt) = [
#show: thmrules
#set heading(numbering: "1.1.")
#txt
]
#show: thmrules
#set heading(numbering: "1.1.")
#let theorem = thmbox("theorem", "Theorem", fill: rgb("#eeffee"), inset: (x: 0em))
#let corollary = thmplain(
"corollary",
"Corollary",
base: "theorem",
titlefmt: strong,
inset: (x: 0em)
)
#let definition = thmbox("definition", "Definition", inset: (x: 0em))
#let example = thmplain("example", "Example", inset: (x: 0em)).with(numbering: none)
#let proof = thmproof("proof", "Proof", inset: (x: 0em))
#let bR = $bb(R)$
#let bN = $bb(N)$
#let bold(txt) = text(weight: "bold", txt)
|
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/bugs/emoji-linebreak_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
#set page(width: 50pt, height: auto)
#h(99%) 🏳️🌈
🏳️🌈
|
https://github.com/isaacholt100/isaacholt100.github.io | https://raw.githubusercontent.com/isaacholt100/isaacholt100.github.io/master/maths-notes/2-durham%3A-year-2/algebra/algebra.typ | typst | #import "../../template.typ": template
#show: template
= Rings, subrings and fields
- *Ring $R$*: set with binary operations addition and subtraction, where $(R, +)$ is an abelian group and:
- *Identity*: exists $1 in R$ such that $forall x in R, 1 dot.op x = x dot.op 1 = x$
- *Associativity*: for every $x, y, z in R, x(y z) = (x y)z$
- *Distributivity*: for every $x, y, z in R, x(y + z) = x y + x z$ and $(y + z)x = y x + z x$
- *Set of remainders modulo $n$* (*residue classes*): $ZZ \/ n = {overline(0), overline(1), ..., overline(n - 1)}$
- $ZZ \/ n$ is a ring: $overline(a) + overline(b) = overline(a + b), overline(a) - overline(b) = overline(a - b), overline(a) dot.op overline(b) = overline(a dot.op b)$
- *Subring $S$* of ring $R$: a set $S subset.eq R$ that contains $0$ and $1$ and is closed under addition, multiplication and negation:
- $0 in S$, $1 in S$
- $forall a, b in S, a + b in S$
- $forall a, b in S, a b in S$
- $forall a in S, -a in S$
- *Field $F$* is a ring with:
- $F$ is commutative
- $0 != 1 in F$ ($F$ has at least two elements)
- $forall 0 != a in R$, $exists b in R$, $a b = 1$. $b$ is the *inverse* of $a$
- $a$ is a *zero divisor* if $a b = 0$ for some $b != 0$
= Integral domains
- *Integral domain $R$*: ring which is commutative, has at least two elements ($0 != 1$), and has no zero divisors apart from $0$
- Any subring of a field is an integral domain
- If $R$ is an integral domain, then $R[x] = {a_0 + a_1 x + ... + a_n x^n : a_i in R}$ is also an integral domain.
- $a$ is a *unit* if $a b = b a = 1$ for some $b in R$. $b = a^(-1)$ is the *inverse* of $a$
- Inverses are unique
- $R^times$, set of all units in $R$, is a group under multiplication of $R$
- For field $F$, $F^times = F - {0}$
- $a in ZZ \/ n$ is a unit iff $gcd(a, n) = 1$
- $ZZ \/ p$ is a field iff $p$ is prime
- $ZZ \/ n$ is an integral domain iff $n$ is prime (iff $ZZ \/ n$ is a field)
= Polynomials over a field
- *Degree* of $f(x) = a_0 + a_1 x + ... + a_n x^n$:
$ deg(f) = cases(
max{i: a_i != 0} & "if" f != 0,
-oo & "if" f = 0
) $
- $deg(f g) = deg(f) + deg(g)$
- $deg(f + g) <= max{deg(f), deg(g)}$
- If $deg(f) != deg(g)$ then $deg(f + g) = max{deg(f), deg(g)}$
- Let $f(x), g(x) in F[x]$, $g(x) != 0$, then $exists q(x), r(x) in F[x]$ with $deg(r) < deg(g)$ such that $f(x) = q(x) g(x) + r(x)$
= Divisibility and greatest common divisor in a ring
- $a$ *divides* $b$, $a | b$, if $exists r in R$ such that $b = r a$
- $d$ is a *greatest common divisor* of $a$ and $b$, $gcd(a, b)$, if:
- $d | a$ and $d | b$ and
- If $e | a$ and $e | b$ then $e | d$
- $gcd(0, 0) = 0$
- *Euclidean algorithm example*: find $gcd$ of $f(x) = x^2 + 7x + 6$ and $g(x) = x^2 - 5x - 6$ in $QQ[x]$: $ f(x) & = g(x) + 12(x + 1) \ g(x) & = 1/12 x dot.op 12(x + 1) - 6(x + 1) \ 12(x + 1) & = -2 dot.op -6(x + 1) + 0 $ Remainder is now zero so stop. A $gcd$ is given by the last non-zero remainder, $-6(x + 1)$. We can write $-6(x + 1)$ as a combination of $f(x)$ and $g(x)$: $ -6(x + 1) & = g(x) - 1/12 x dot.op 12(x + 1) \ & = g(x) - 1/12 x dot.op (f(x) - g(x)) \ & = (1 + 1/12 x) g(x) - 1/12 x f(x) $
- Let $R$ be integral domain, $a, b in R$ and $d = gcd(a, b)$. Then $forall u in R^times$, $u d$ is also a $gcd(a, b)$. Also, for $d$ and $d'$ $gcd$s of $a$ and $b$, $exists u in R^times$ such that $d = u d'$ (so $gcd$ is unique up to units).
- Polynomial is *monic* if leading coefficient is $1$
- There always exists a unique monic $gcd$ of two polynomials in $F[x]$
- Let $R = ZZ "or" F[x]$, $a, b in R$. Then
- A $gcd(a, b)$ always exists
- $a != 0 "or" b != 0$ then a $gcd(a, b)$ can be computed by Euclidean algorithm
- If $d$ is a $gcd(a, b)$ then $exists x, y in R$ such that $a x + b y = d$
= Factorisations in rings
- $r in R$ *irreducible* if:
- $r in.not R^times$ and
- If $r = a b$ then $a in R^times$ or $b in R^times$
- $a in F$ is *root* of $f(x) in F[x]$ if $f(a) = 0$
- Let $f(x) in F[x]$.
- If $deg(f) = 1$, $f$ is irreducible.
- If $deg(f) = 2 "or" 3$ then $f$ is irreducible iff it has no roots in $F$.
- If $deg(f) = 4$ then $f$ is irreducible iff it has no roots in $F$ and it is not the product of two quadratic polynomials.
- Let $f(x) = a_0 + a_1 x + ... + a_n x^n in ZZ[x]$, $deg(f) >= 1$. If $f(p \/ q) = 0$, $gcd(p, q) = 1$, then $p | a_0$ and $q | a_n$.
- *Gauss's lemma*: let $f(x) = a_0 + a_1 x + ... + a_n x^n in ZZ[x]$, $deg(f) >= 1$. Then $f(x)$ is irreducible in $ZZ[x]$ iff it is irreducible in $QQ[x]$ and $gcd(a_0, a_1, ..., a_n) = 1$.
- If monic polynomial in $ZZ[x]$ factors in $QQ[x]$ then it factors into integer monic polynomials.
- Let $R$ be commutative, $x in R$ be irreducible and $u in R^times$. Then $u x$ is also irreducible.
- *Eisenstein's criterion*: let $f(x) = a_0 + a_1 x + ... + a_n x^n in ZZ[x]$, $p$ be prime with $p divides a_0$, $p divides a_1, ..., p divides a_(n - 1)$, $p divides.not a_n$, $p^2 divides.not a_0$. Then $f(x)$ is irreducible in $QQ[x]$
- Let $f(x) in F[x]$, then $f$ can be uniquely factorised into a product of irreducible elements, up to order of factors and multiplication by units.
- Let $R$ be commutative. $x in R$ is *prime* if:
- $x != 0$ and $x in.not R^times$ and
- If $x divides a b$ then $x divides a$ or $x divides b$
- If $R = ZZ "or" F[x]$ then $a in R$ is prime iff it is irreducible.
- Let $R$ be an integral domain and $x in R$ prime. Then $x$ is irreducible.
- Integral domain $R$ is *unique factorisation domain (UFD)* if every non-zero non-unit element in $R$ can be written as a unique product of irreducible elements, up to order of factors and multiplication by units.
= Ring homomorphisms
- For $R, S$ rings, $f: R -> S$ is *homomorphism* if:
- $f(1) = 1$ and
- $f(a + b) = f(a) + f(b)$ and
- $f(a b) = f(a) f(b)$
- Let $f: R -> S$ homomorphism, then
- $f(0) = 0$ and
- $f(-a) = -f(a)$
- *Kernel*: $ ker(f) := {a in R: f(a) = 0} $
- *Image*: $ "Im"(f) := {f(a): a in R} $
- *Isomorphism*: bijective homomorphism.
- $R$ and $S$ *isomorphic*, $R tilde.eqq S$ if there exists isomorphism between them.
- Homomorphism $f$ injective iff $ker(f) = {0}$.
- *Direct product* of $R$ and $S$, $R times S$:
- $(r, s) + (r', s') = (r + r', s + s')$.
- $(r, s) (r', s') = (r r', s s')$.
- Identity is $(1, 1)$.
- For $p_1(r, s) = r$ and $p_2(r, s) = s$, $ker(p_1) = {(0, s): s in S}$ and $ker(p_2) = {(r, 0): r in R}$. These are both rings, with $ker(p_1) tilde.eqq S$ (via $(0, s) -> s$) and $ker(p_2) tilde.eqq R$ (via $(r, 0) -> r$). ($ker(p_1)$ and $ker(p_2)$ are not subrings of $R times S$ though). So $ ker(p_1) times ker(p_2) tilde.eqq R times S $
= Ideals and quotient rings
- $I subset.eq R$ is an *ideal* if $I$ closed under addition and if $x in I$, $r in R$ then $r x in I$ and $x r in I$.
- *Left ideal*: $I$ closed under addition and if $x in I$, $r in R$ then $r x in I$.
- *Right ideal*: $I$ closed under addition and if $x in I$, $r in R$ then $x r in I$.
- If $x in I$, then $(-1)x = x(-1) = -x in I$ so $I$ closed under negation.
- For $f: R -> S$ homomorphism, $ker(f)$ is ideal of $R$.
- For $R$ commutative ring and $a in R$, *principal ideal generated by $a$* is $ (a) := {r a: r in R} $
- For $R$ commutative and $a_1, ... a_n in R$, $ (a_1, ..., a_n) := {r_1 a_1 + dots.h.c + r_n a_n: r_1, ..., r_n in R} $ is an ideal. $(a_1, ..., a_n)$ is *generated* by $a_1, ..., a_n$. $a_i in (a_1, ..., a_n)$ for all $i$.
- If ideal $I$ contains unit $u$, then $u^(-1) u = 1 in I$ so $forall r in R, r dot.op 1 = r in I$. So $R subset.eq I$ so $R = I$.
- For field $F$, any ideal is either ${0}$ or $F$.
- Let $I_1 = (a_1, ..., a_m)$, $I_2 = (b_1, ..., b_n)$ then $I_1 = I_2$ iff $a_1, ..., a_m in I_2$ and $b_1, ..., b_n in I_1$.
- $a, b in R$ *equivalent modulo $I$* if $a - b in I$. Write $overline(a) = overline(b)$ or $a ident b quad (mod I)$.
- Let $a(x) in QQ[x]$, then $p(x) = q(x) a(x) + r(x)$ with $deg(r) < deg(a)$. $p(x) - r(x) = q(x) a(x) in (a(x))$ so $overline(p(x)) = overline(r(x))$. $r(x)$ is *representative* of the class $overline(p(x))$.
- Let $I subset.eq R$ ideal. *Coset* of $I$ generated by $x in I$ is $ overline(x) := x + I = {x + r: r in I} subset.eq R $ $x$ is a *representative* of $x + I$.
- For $x, y in R$, $ x + I = y + I <==> x + I sect y + I != nothing <==> x - y in I $
- If $x$ is a representative of $x + I$, so is $x + r$ for every $r in I$.
- *Quotient* of $R$ by $I$ ("$R mod I$"): set of all cosets of $R$ by $I$: $ R \/ I := {overline(x): x in R} = {x + I: x in R} $ with
- $(x + I) + (y + I) = (x + y) + I$.
- $(x + I) (y + I) = x y + I$.
- $R \/ I$ is a ring, with zero element $0 + I = I$ and identity $1 + I in R \/ I$.
- *Quotient map (canonical map/homomorphism)*: $R -> R \/ I$, $r -> overline(r) = r + I$.
- Kernel of quotient map is $I$ and image is $R \/ I$. Hence every ideal is a kernel.
- *First isomorphism theorem (FIT)*: Let $phi: R -> S$ be homomorphism. Then $ overline(phi): R \/ ker(phi) -> "Im"(phi), overline(phi)(overline(x)) = phi(x) $ is an isomorphism: $R \/ ker(phi) tilde.eqq "Im"(phi)$.
= Prime and maximal ideals
- Ideal $I subset.eq R$ *prime ideal* if $I != R$ and $a b in I ==> a in I$ or $b in I$.
- $I subset.eq R$ *maximal* if only ideals containing $I$ are $I$ and $R$ (so no ideals strictly between $I$ and $R$).
- $x in R$ is prime iff $(x)$ is prime ideal.
- To contain is to divide: $ a in (x) <==> (a) subset.eq (x) <==> x | a $
- For $R$ commutative and $I$ ideal:
- $I$ prime iff $R \/ I$ integral domain.
- $I$ maximal iff $R \/ I$ field.
- $(I, x)$ is ideal generated by $I$ and $x$: $ (I, x): {r x + x': r in R, x' in I} $
- If $I$ is maximal ideal, then it is prime.
= Principal ideal domains
- *Principal ideal domain (PID)*: integral domain where every ideal is principal.
- $ZZ$, $F[x]$, $ZZ[i]$ and $ZZ[sqrt(plus.minus 2)]$ are PIDs.
- Every PID is a UFD.
- Let $R$ be PID and $a, b in R$. Then $d = gcd(a, b)$ exists and $(d) = (a, b)$.
= Fields as quotients
- Let $R$ be PID, $a in R$ irreducible. Then $(a)$ is maximal.
- Let $f(x) in F[x]$ irreducible. Then $F[x] \/ (f(x))$ is field and $F[x] \/ (f(x))$ is a vector space over $F$ with basis ${overline(1), overline(x), ..., overline(x)^(n - 1)}$ where $n = deg(f)$. So every element in $F[x] \/ f(x)$ can be uniquely written as $overline(a_0 + a_1x + dots.h.c + a_(n - 1) x^(n - 1))$, $a_i in F$.
- Let $p$ prime and $n in NN$, then there exists irreducible $f(x) in (ZZ \/ p)[x]$ with $deg(f) = n$ and $(ZZ \/ p)[x] \/ (f(x))$ is a field with $p^n$ elements. Any two such fields are isomorphic so unique (up to isomorphism) field with $p^n$ elements is written $FF_(p^n)$.
= The Chinese remainder theorem
- $a, b in R$ *coprime* if no irreducible element divides $a$ and $b$.
- Let $R$ be PID, $a, b in R$ coprime. Then $(a, b) = (1) = R$ so $a x + b y = 1$ for some $x, y in R$. So any $gcd(a, b)$ is a unit.
- *Chinese remainder theorem (CRT)*: Let $R$ be PID, $a_1, ..., a_k$ pairwise coprime. Then $ phi: R \/ (a_1 dots.h.c a_k) -> R \/ (a_1) times dots.h.c times R \/ (a_k) \ phi(r + (a_1 dots.h.c a_k)) = (r + (a_1), ..., r + (a_k)) $ is an isomorphism.
= Basics of groups
- *Group* $(G, compose)$: set $G$ with binary operation $compose: G times G -> G$ satisfying:
- *Closure*: $g compose h in G, h compose g in G$.
- *Associativity*: $a compose (b compose c) = (a compose b) compose c$.
- *Identity*: $g compose e = g$ and $e compose g = g$ for some $e in G$.
- *Inverse*: $g compose h = h compose g = e$ for some $h = g^(-1) in G$.
- Group *abelian* if $compose$ commutative: $g compose h = h compose g$.
- $H subset.eq G$ is *subgroup* of $(G, compose)$, $H < G$ if $H$ is group under same operation.
- Subgroup $H$ *proper* if $H != {e}$ and $H != G$.
- *Subgroup criterion*: $H < G$ iff:
- $H$ non-empty.
- $h_1, h_2 in H ==> h_1 compose h_2 in H$.
- $h in H ==> h^(-1) in H$.
- *Order* of group $G$ is number of elements in it, $|G|$.
- *Lagrange's theorem*: Let $G$ finite, $H < G$, then $ \#H divides \#G $
- Let $H < G$, $g in G$. *Left coset* of $g$ with respect to $H$ in $G$: $ g compose H := {g compose h: h in H} $
- All left cosets with respect to $H$ have same cardinality as cardinality of $H$.
- *Right coset* of $g in G$ with respect to $H < G$ in $G$: $ H compose g := {h compose g: h in H} $
- $H < G$ *normal*, $H triangle.stroked.small.l G$, if $forall g in G, g H = H g$.
- $H$ is normal iff $forall g in G$, $ forall h in H, g h g^(-1) in H <==> g H g^(-1) subset H $ where $g H g^(-1) = {g h g^(-1): h in H}$.
- Every subgroup of abelian group is normal.
- *Subgroup of $G$ generated by $g$*: $ angle.l g angle.r := {g^n: n in ZZ} $
- *Subgroup of $G$ generated by $S subset.eq G$*: $ angle.l S angle.r := {"all finite products of elements in" S "and their inverses"} $ so if $G$ abelian (doesn't hold for non-abelian), for $S = {g_1, ..., g_n}$, $ angle.l S angle.r = {g_1^(a_1) dots.h.c g_n^(a_n): a_i in ZZ} $
- If $G$ not abelian, $ angle.l g, h angle.r = {g^(a_1) h^(b_1) dots.h.c g^(a_m) h^(a_m)} $
- *Order* of $g in G$, $"ord"_G(g)$ is smallest $r > 0$ such that $g^r = e$. If $r$ doesn't exist, order is $oo$.
- Order of $overline(m) in ZZ \/ n$ is $n \/ gcd(m, n)$.
= Specific families of groups
- Quaternion group: $ Q_8 = {plus.minus 1 plus.minus i, plus.minus j, plus.minus k}, quad i^2 = j^2 = k^2 = -1, i j = k = -j i $
- *Cyclic group*: can be generated by single element.
- *Example of cyclic group*: $ C_n = {e^((2 pi i) / n k): 0 <= k < n} $
- Cyclic groups are abelian.
- If $|G|$ is prime, $G$ is cyclic and is generated by any $e != g in G$.
- *Permutation* of $X != nothing$: bijection $X -> X$.
- $S_X := {"bijection" X -> X}$.
- *Notation*: $S_n := S_{1, ..., n}$.
- $(S_X, compose)$ is group where $compose$ is composition of permutations.
- $(S_n, compose)$ is *symmetric group of degree $n$* (or *symmetric group on $n$ letters*).
- *Notation*: write $sigma in S_n$ as $ mat(1, 2, ..., n; sigma(1), sigma(2), ..., sigma(n)) $
- $|S_n| = n!$.
- *Cycle of length $k$ (or $k$-cycle)*: permutation $sigma$ in $S_n$, with $ sigma(i_1) = i_2, quad sigma(i_2) = i_3, ..., sigma(i_(k - 1)) = i_k, quad sigma(i_k) = i_1 $ and leaves all other elements fixed. Write as $(i_1 space i_2 space ... space i_k)$ or $ mat(i_1, i_2, ..., i_k; i_2, i_3, ..., i_1) $
- $2$-cycles are *transpositions* (or *inversions*).
- $k$-cycle has order $k$.
- There are $k$ ways of writing $k$ cycle.
- Cycles are *disjoint* if they don't have any common elements.
- Disjoint cycles commute.
- Every permutation is product of disjoint cycles, unique up to swapping cycles and $k$ ways of writing a $k$-cycle.
- $k$-cycle can be written as product of transpositions: $ (i_1 space i_2 space ... space i_k) = (i_1 space i_2) (i_2 space i_3) dots.h.c (i_(k - 1) space i_k) $
- When composing cycles, *work right to left*.
- $g, g' in G$ *conjugate* in $G$ to each other if for some $h in G$, $h g h^(-1) = g'$.
- Any conjugate of transposition in $S_n$ is transposition.
- Every $sigma in S_n$ can be factored into product of transpositions.
- *Parity* of number of transpositions needed in any factorisation of $sigma$ is the same. So remainder of this number modulo $2$ is well-defined.
- Element made of disjoint cycles of lengths $k_1, ..., k_m$ has order $"lcm"(k_1, ..., k_m)$.
- *Sign of permutation $sigma$*: $ "sgn"(sigma) := (-1)^t = cases(
1 & "if" t "is even",
-1 & "if" t "is odd"
) $ where $t$ is number of transpositions needed in factorisation of $sigma$. If $t$ even, $sigma$ is *even*, else $sigma$ is *odd*.
- *Alternating group*, $A_n$: subgroup of even permutations of $S_n$.
- $|A_n| = (n!) / 2$.
- $A_n$ normal in $S_n$.
- $A_n$ generated by $3$-cycles.
- *Isometry*: map from plane to itself which preserves distances between points.
- For $n >= 3$, there are $2n$ isometries of the plane which preserve regular $n$-gon.
- Group of isometries of regular $n$-gon form group, the *dihedral group*, $D_n$.
- $D_n$ *alternative definition*: group with two generators $r$ (rotation) and $s$ (reflection), with $s r s^(-1) = r^(-1)$, $r^n = e$ and $s^2 = e$. So $D_n = angle.l r, s angle.r$.
- Every element in $D_n$ can be written $r^j s^k$, $0 <= j < n$, $0 <= k <= 1$.
- $|D_n| = 2n$.
- Rotations of plane which preserve regular $n$-gon form cyclic subgroup of $D_n$, which is normal in $D_n$.
= Relating, identifying and distinguishing groups
- *Group homomorphism*: map $phi: G -> G'$ between groups, with $ phi(g_1 g_2) = phi(g_1) phi(g_2) $
- *Group isomorphism*: bijective group homomorphism.
- $G$ and $G'$ *isomorphic*, $G tilde.eqq G'$ if exists isomorphism between them.
- *Kernel* of group homomorphism: $ ker(phi) := {g in G: phi(g) = e} $
- *Image* of group homomorphism: $ "im"(phi) := {phi(g): g in G} $
- $ker(phi)$ is normal subgroup of $G$.
- $"im"(phi)$ is subgroup of $G'$.
- Let $N$ normal subgroup of $G$. *Quotient group (factor group)* of $G$ with respect to $N$, is $G \/ N := {g N: g in G}$, with group multiplication $ (g_1 N) (g_2 N) = (g_1 g_2) N $ and inverse $ (g N)^(-1) = (g^(-1)) N $
- *First isomorphism theorem for groups (FIT)*: let $phi: G -> G'$ homomorphism, then $ G \/ ker(phi) tilde.eqq "im"(phi) $
- Let $p$ prime, then every group of order $p$ is isomorphic to $(ZZ \/ p, +)$.
- Each cyclic group of order $n$ isomorphic to $(ZZ \/ n, +)$.
- Each infinite cyclic group isomorphic to $(ZZ, +)$.
- For groups $G, H$, $G times H$ also a group, with $e = (e_G, e_H)$, $(g, h) compose (g', h') = (g compose_G g', h compose_H h')$, inverse $(g, h)^(-1) = (g^(-1), h^(-1))$.
- $ZZ \/ 2 times ZZ \/ 3 tilde.eqq ZZ \/ 6$.
- $ZZ \/ (m n) tilde.eqq ZZ \/ m times ZZ \/ n <==> gcd(m, n) = 1$.
- Group isomorphism preserves:
- Order of group.
- Set of orders of elements (with multiplicity - i.e. count repeated occurences of an order).
- Size of its centre.
- Property of being abelian/non-abelian.
- Property of having proper (normal) subgroups and their sizes.
- *Notation*: for $E_1, E_2 subset.eq G$, $ E_1 compose E_2 := {e_1 compose e_2: e_1 in E_1, e_2 in E_2} $
- Let $H, K$ subgroups of $G$ with:
- $H compose K = G$,
- $H sect K = {e}$,
- $forall h in H, k in K, h k = k h$.
Then $G tilde.eqq H times K$.
- Group of symmetries of unit cube in $RR^3$ isomorphic to $S_4$.
- *Cayley's theorem*: Every group $(G, dot.op)$ is isomorphic to a subgroup of $(S_G, compose)$ where $S_G$ is set of bijections of $G$ by the isomorphism $psi(g) = L_g$, where $L_g(h) = g h$.
= Group actions
- *Action of group $G$ on non-empty set $X$*: homomorphism $ phi: G -> S_X $ $G$ acts on $X$.
- Let $phi: G -> S_X$ group action, $x in X$. *Orbit* of $x$ inside $X$ is $ G(x) := cal(O)(x) := {phi(g)(x): g in G} $
- Let $phi: G -> S_X$ group action, $x in X$. *Stabiliser* of $x$ in $G$ is $ G_x := "Stab"_G(x) := {g in G: phi(g)(x)= x} $
- For every $x in X$, $"Stab"_G(x)$ is subgroup of $G$.
- *Notation*: can write $g(x)$ instead of $phi(g)(x)$.
- Let $phi: G -> S_X$ group action. Then all orbits $cal(O)(x)$ partition $X$ so:
- Every orbit non-empty subset of $X$.
- Union of all orbits is $X$.
- Two orbits either disjoint or equal.
- Action of group on itself:
- By left translation: $g(h) = g h$.
- By conjugation: $g(h) = g h g^(-1)$.
- *Conjugacy class* of $g in G$ is set of all elements conjugate to $g$: $ "ccl"_G(g) := {h g h^(-1): h in G} $
- Conjugacy class of $g$ is orbit of conjugation action of $g$.
- Conjugacy classes of $G$ all of size $1$ iff $G$ abelian.
- *Orbit-stabiliser theorem*: Let $G$ act on $X$. Then $forall x in X$, exists bijection $ beta: cal(O)(x) -> {"left cosets of" "Stab"_G(x) "in" G} \ beta(g(x)) = g "Stab"_G(x) $
- *Consequence of Orbit-Stabiliser theorem*: if finite $G$ acts on finite $X$, then $forall x in X$, $ |cal(O)(x)| dot.op |"Stab"_G(x)| = |G| $
- So size of each conjugacy class in $G$ divides $|G|$.
- If $x in cal(O)(y)$, then $"Stab"_G(x)$ and $"Stab"_G(y)$ conjugate to each other: $ exists h in G, quad "Stab"_G(x) = h "Stab"_G(y) h^(-1) $ (here $h(y) = x$).
= Cauchy's theorem and classification of groups of order $2p$
- *Cauchy's theorem*: let $G$ finite group, $p$ prime, $p divides |G|$. Then exists subgroup of $G$ of order $p$.
- Let $p$ odd prime, then any group of order $2p$ is either cyclic or dihedral.
= Classification of groups of order $p^2$
- *Centre* of group $G$: $ Z(G) := {g in G: forall h in G, g h = h g} $
- $Z(G)$ is normal subgroup of $G$.
- $Z(G)$ is union of all conjugacy classes of size $1$. So every $z in Z(G)$ has $|"ccl"_G(z)| = 1$.
- $Z(G) = G$ iff $G$ abelian.
- If $G$ acts on itself via conjugation then for every $h in G$, $Z(G) subset "Stab"_G(h)$.
- Let $p$ prime, $|G| = p^r$, $r >= 0$. Then $Z(G)$ non-trivial ($Z(G) != {e}$).
- If $|G| = p^2$, $p$ prime, then $G$ abelian.
- Let $p$ prime, $|G| = p^2$. Then $G tilde.eqq ZZ \/ p^2$ or $G tilde.eqq ZZ \/ p times ZZ \/ p$.
- *Sylow's theorem*: let $G$ group, $|G| = p^r m$, $gcd(p, m) = 1$. Then $G$ has subgroup of order $p^r$ (and subgroup of order $p^i$ for all $1 <= i <= r$).
= Classification of finitely generated abelian groups
- $G$ *finitely generated* if exists set ${g_1, ..., g_r}$ such that $G = angle.l g_1, ..., g_r angle.r$.
- Any finitely generated abelian group can be written as $ G tilde.eqq ZZ^n \/ K $ for some $n >= 0$, $K$ is subgroup of $ZZ^n$, $K = {underline(a) in ZZ^n: a_1 g_1 + dots.h.c + a_n g_n = 0}$. $underline(a) in K$ is *relation* and $K$ is *relation subgroup* of $G$.
- $G$ is *free abelian group of rank $n$* if no non-trivial solutions in $K$, i.e. $a_1 g_1 + dots.h.c + a_r g_r = 0 ==> a_1 = dots.h.c = a_r = 0$. Here, $K = {underline(0)}$.
- Every subgroup of $ZZ^n$ is free abelian group generated by $r <= n$ elements, so rank $<= n$.
- *Fundamental theorem of finitely generated abelian groups*: let $G$ be finitely generated abelian group. Then $ G tilde.eqq ZZ \/ d_1 times dots.h.c times ZZ \/ d_k times ZZ^r $ where $r >= 0$, $k >= 0$, $d_j >= 1$. If $d_1 divides d_2 divides dots.h.c divides d_k$ and $d_1 > 1$, then this form is unique.
- $r$ is *rank* of $G$, $d_1, ..., d_k$ are *torsion invariants (torsion coefficients)*. Torsion coefficients are given with repetitions (multiplicities).
- To classify all groups of order $n$, use that $d_1 dots.h.c d_k = n$ and $1 < d_1 divides d_2 divides dots.h.c divides d_k$.
- Let $e != x in S_n$ be written as product of disjoint cycles: $ x = (a_1 space a_2 space ... space a_(k_1)) (b_1 space b_2 space ... space b_(k_2)) dots.h.c (t_1 space t_2 space ... space t_(k_r)) $ where $r >= 1$, $2 <= k_1 <= k_2 <= dots.h.c <= k_r$, $n >= k_1 + dots.h.c + k_r$. Then $x$ has *cycle shape* $[k_1, k_2, ..., k_r]$.
- Let $x = (i_1 space i_2 space ... space i_k) in S_n$, $g in S_n$. Then action of $g$ on $x$ by conjugation is $ g x g^(-1) = (g(i_1) space g(i_2) space ... space g(i_k)) $
- Let $x in S_n$, then $"ccl"_(S_n)(x)$ consists of all permutations with same cycle shape as $x$.
- Conjugacy classes of $S_n$ have cycle shapes given by non-decreasing partitions of $n$, without $1$ (except for cycle shape $[1]$).
- Let $x = (a_1 space a_2 space ... space a_m) in S_n$, then $ gamma(n\; m) := |"ccl"_(S_n)(x)| = (n(n - 1) dots.h.c (n - m + 1)) / m $
- Let $x in S_n$ have cycle shape $[m_1, ..., m_r]$, $m_1 < m_2 < dots.h.c < m_r$. Then $ gamma(n\; m_1, ..., m_r) := |"ccl"_(S_n)(x)| = product_(k = 1)^r gamma(n - sum_(i = 1)^(k - 1) m_i\; m_k) $
- Let $x in S_n$ has cycle shape $[m_1, ..., m_1, m_2, ..., m_2, ..., m_r, ..., m_r]$, $m_1 < m_2 < dots.h.c < m_r$, $m_i$ repeated $s_i$ times, then number of elements of that cycle shape is $ |"ccl"_(S_n)(x)| = (gamma(n\; m_1, ..., m_1, m_2, ..., m_2, ..., m_r, ..., m_r)) / (s_1! s_2! dots.h.c s_r!) $
- Let $H$ subgroup of $G$. Then $H$ normal in $G$ iff $H$ is union of conjugacy classes of $G$.
- So if $H$ normal then sum of sizes of its conjugacy classes divides $|G|$. But converse doesn't imply $H$ is subgroup.
- To find all normal subgroups $H$ of $S_n$, use that size of $H$ is sum of sizes of conjugacy classes of $S_n$. Use formula above to work out all possible sizes of conjugacy classes, and fact that $H$ must contain identity so must include $1$ in its sum (size of conjugacy class of $1$ is $1$). Then use Lagrange's theorem to restrict the possible sums of the sizes. Then check that each set formed by the union is a group. |
|
https://github.com/xhalo32/math-camp | https://raw.githubusercontent.com/xhalo32/math-camp/main/README.md | markdown | MIT License | # Aalto Math Camp
This repository provides a simple [Typst](https://typst.app/) document to create adventure maps for math camps. Also an example exercise for the treasure hunt is provided in [equal-sets](./equal-sets/).
## Setting up typst
The typst CLI can be installed from [its GitHub repository](https://github.com/typst/typst?tab=readme-ov-file#installation).
> [!NOTE]
> If you have issues installing typst, please ask me [via email](mailto:<EMAIL>).
## Adventure Map Template
The template is located at [`./map/map.typ`](./map/map.typ). It has some comments explaining the different bits.
### Compiling
To recompile on changes to `map.typ`, run the following inside the `map` directory:
```bash
$ typst watch map.typ
```
## More references on typst
- The [official documentation](https://typst.app/docs)
- The [CeTZ documentation](https://cetz-package.github.io/docs/) and [manual (latest stable)](https://raw.githubusercontent.com/cetz-package/cetz/refs/tags/stable/manual.pdf) |
https://github.com/ymgyt/techbook | https://raw.githubusercontent.com/ymgyt/techbook/master/cloud/aws/cdk/stack.md | markdown | # Stack
* unit of deployment
* appに複数のstackを渡せる
```typescript
const app = new App();
new MyFirstStack(app, 'stack1');
new MySecondStack(app, 'stack2');
```
## 環境の表現
```typescript
import { App, Stack } from 'aws-cdk-lib';
import { Construct } from 'constructs';
interface EnvProps {
prod: boolean;
}
// imagine these stacks declare a bunch of related resources
class ControlPlane extends Stack {}
class DataPlane extends Stack {}
class Monitoring extends Stack {}
class MyService extends Construct {
constructor(scope: Construct, id: string, props?: EnvProps) {
super(scope, id);
// we might use the prod argument to change how the service is configured
new ControlPlane(this, "cp");
new DataPlane(this, "data");
new Monitoring(this, "mon"); }
}
const app = new App();
new MyService(app, "beta");
new MyService(app, "prod", { prod: true });
```
こうすると都合6のstackが作成される
```shell
$ cdk ls
betacpDA8372D3
betadataE23DB2BA
betamon632BD457
prodcp187264CE
proddataF7378CE5
prodmon631A1083
```
## AWS AccountとRegionの指定
```typescript
const envEU = { account: '2383838383', region: 'eu-west-1' };
const envUSA = { account: '8373873873', region: 'us-west-2' };
new MyFirstStack(app, 'first-stack-us', { env: envUSA });
new MyFirstStack(app, 'first-stack-eu', { env: envEU });
```
* StackとEnvironmentの関係は3つに分類できる
* env指定なし
* environment-agnostic stackになり一部の機能が制限される
* `env: { account: process.env.CDK_DEFAULT_ACCOUNT }`の指定
* synth時にcli command実行時の情報が渡される
* hard code
* これが推奨というか安全と思われる
## Stack名の指定
```typescript
// こうするとstackNameを指定できる
new MyStack(this, 'not:a:stack:name', { stackName: 'this-is-stack-name' });
```
## Cross Stack Reference
stack間で値を参照する方法
### exportする側(被参照)
```typescript
import { CfnOutput, Stack, StackProps } from "aws-cdk-lib";
export interface ExportStackProps extends StackProps {}
export class EcrRepositoryStack extends Stack {
constructor(scope: Construct, id: string, props: ExportStackProps) {
super(scope, id, props);
new CfnOutput(this, "cfnExportValueA", {
// 大抵作成したresourceのarnや名前
value: "exportResourceArn",
// 参照時の識別子
exportName: "exportValueA",
});
}
}
```
### exportされた値を利用する側(参照)
```typescript
import {Stack, StackProps, Fn } from "aws-cdk-lib";
export interface AppRunnerStackProps extends StackProps {}
export class AppRunnerStack extends Stack {
constructor(scope: Construct, id: string, props: AppRunnerStackProps) {
super(scope, id, props);
const resourceArn = Fn.importValue("exportValueA")
}
}
```
### app
```typescript
const app = new cdk.App();
const ecrRepoStack = new EcrRepositoryStack(app, "EcrRepoStack", {});
const appRunnerStack = new AppRunnerStack(app, "AppRunnerStack", {});
appRunnerStack.addDependency(ecrRepoStack);
```
* `addDependency()`で依存性を表現する。
|
|
https://github.com/pawarherschel/typst | https://raw.githubusercontent.com/pawarherschel/typst/main/modules/skills.typ | typst | Apache License 2.0 | #import "../template/template.typ": *
#import "../helpers/helpers.typ": *
#let SOT = yaml("../SOT.yaml")
#let skills = ()
#if SOT.keys().contains("skills") {
skills = SOT.skills
}
#if skills.len() != 0 {
cvSection("Skills")
for skill in skills {
let type = skill.type
let info = join-with-hBar(skill.info)
cvSkill(
type: type,
info: info
)
}
} |
https://github.com/Area-53-Robotics/53E-Notebook-Over-Under-2023-2024 | https://raw.githubusercontent.com/Area-53-Robotics/53E-Notebook-Over-Under-2023-2024/giga-notebook/entries/robot-rebuild/identify.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #import "/packages.typ": notebookinator
#import notebookinator: *
#import themes.radial.components: *
#import "/utils.typ": grid
#show: create-body-entry.with(
title: "Identify: Robot Rebuild",
type: "identify",
date: datetime(year: 2024, month: 3, day: 5),
author: "<NAME>",
witness: "Alan Morales",
)
= Current Problems
We haven't had enough time between competitions to be able to make major changes
to our bot, but we have an approximately two month timeline before worlds, so we
decided a total rebuild was in order.
We broke down the issues on our current robot that we'd like to address in our
rebuild.
== Robot Weight
#grid(
columns: (1fr, 2fr),
[
One of the things we foolishly didn't take into account from the beginning of
the season is the weight of the robot.
At this moment in time we don't know the exact weight of our robot, but we
estimate it to be around 18 pounds.
This is extremely heavy for a vex robot, and has caused a lot of problems for
us. It limits how fast we can accelerate, puts more stress on the motors, and
makes the lift very inconsistent.
],
figure(image("./full-iso.png"), caption: "Full robot CAD"),
)
== Drivetrain Towers
The motors on our drivetrain are mounted above the main drivetrain c-channel, on
towers constructed of standoffs and smaller c-channel. While this may not seem
like a massive issue, it has been the source of numerous problems for us.
Not only do they increase weight, but they also make it extremely difficult to
find easy mount points on top of the drivetrain. This has massively increased
the development and build time of every single one of our subsystems.
#figure(
image("./towers-side.png", width: 50%),
caption: "Drivetrain: Side View",
)
== Lift
#grid(
[
While the lift is mostly working, its nowhere near perfect. The flywheel mounted
to the end of it greatly increases its weight, and it dramatically limits
movement of the robot when extended.
In addition, the lift isn't powerful enough to pull our robot above A tier. We
haven't seen very many teams be able to achieve higher than that without a motor
lift, so we're not sure if a pneumatic lift is the way forward.
], //
figure(image("./lift-side.png"), caption: "Lift: Side View"),
)
== Flywheel
#grid(
figure(image("./flywheel-front.png"), caption: "Flywheel: Front View"),
[
The flywheel was an essential part of our strategy earlier in the season, but is
no longer as useful. Now that field starvation strategies are more prevalent,
shooting during matches is almost completely unnecessary.
This makes our flywheel only useful during skills, where its very low accuracy
is a very large weakness.
Our decision to mount it to the end of the lift was also a major mistake. Almost
no team is running blockers anymore, so having a lifted shooter is basically
useless.
],
)
= Goals
Originally we were unsure whether we wanted to build a bot that prioritizes
skills, or match play. These robots would look extremely different, so we wanted
to figure out what was important to us.
Eventually we decided that we wanted a robot that could do both. While we may
end up having more weight on our robot because of this decision, we have some
strategies to keep us under our projected limit.
- Be able to perform well in both match play and during skills. This means having
a mix of subsystems that support both.
- Keep the robot under 12 pounds.
- Push the boundaries of what our team has been able to do in the past. If there's
a more optimal solution that's more complex, we'd like to attempt it.
|
https://github.com/Clamentos/FabRISC | https://raw.githubusercontent.com/Clamentos/FabRISC/main/src/spec/Section5.typ | typst | Creative Commons Attribution Share Alike 4.0 International | ///
#import "Macros.typ": *
///
#section(
[Input-Output],
[This section is dedicated to the specification that FabRISC uses for communicating with external devices as well as other cores and hardware threads if present. The architecture defines IO mappings, potential DMA behavior and, in the next sections, OS support and inter-process communication schemes will be discussed.],
///.
subSection(
[Memory Mapped IO],
[FabRISC reserves a portion of the high memory address space to _Memory Mapped IO_. This region, which size depends on the `IOS` parameter of the system, is not cached and byte addressable in little-endian order. If a hart wants to transfer data to an IO device it can simply execute a memory operation to this region without further complications. The IO devices must map all of its IO related registers and state to this region in order to be accessible. Multiple channels or buses can potentially be employed to reduce the latency in case other transfers are already taking place as well as increasing the bandwidth. The area starts at address `0xFFF`...`F` and grows upwards based on the `IOS` parameter.],
[FabRISC provides the *Input Output size* (`IOS`) 4 bit ISA parameter, to indicate the size of the memory mapped IO region in bytes. The possible values are listed in the table below:],
tableWrapper([Memory Mapped IO sizes.], table(
columns: (auto, auto),
align: (x, y) => (center, left + horizon).at(x),
[#middle([*Code*])], [#middle([*Value*])],
[0000], [$2^3$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0001], [$2^4$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0010], [$2^5$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0011], [$2^6$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0100], [$2^10$ bytes for 16 bit systems ($"WLEN" = 1$).],
[0101], [$2^11$ bytes for 16 bit systems ($"WLEN" = 1$).],
[0110], [$2^12$ bytes for 16 bit systems ($"WLEN" = 1$).],
[0111], [$2^13$ bytes for 16 bit systems ($"WLEN" = 1$).],
[1000], [$2^15$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1001], [$2^16$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1010], [$2^20$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1011], [$2^24$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1100], [$2^32$ bytes for 64 bit systems ($"WLEN" = 3$).],
[1101], [$2^34$ bytes for 64 bit systems ($"WLEN" = 3$).],
[1110], [$2^36$ bytes for 64 bit systems ($"WLEN" = 3$).],
[1111], [$2^40$ bytes for 64 bit systems ($"WLEN" = 3$).],
)),
comment([
I decided to go with memory mapped IO because of its flexibility and simplicity compared to port based solutions. The IO region can be considered plain memory by the processor internally, which allows for advanced and fancy operations that use locks, barriers, fences and transactions to be done by multiple threads to the same device. Caching this region is not recommended because it can yield potential inconsistencies and unnecessary additional complexities to the cache coherence hardware.
The idea here is to provide general purpose IO system that can be easily implemented on any microarchitecture. The MMIO proposed is basically as simple as it gets and it should be good enough for most low to mid-speed transfers.
The hardware designers can choose from a variety of different sizes for the MMIO space, ranging from the minuscule 8 bytes suitable for tiny toy-like 8 bit implementations, all the way to 1 terabytes suitable for more advanced machines that also implement a full blown operating system.
])
),
///.
subSection(
[Direct Memory Access],
[FabRISC provides the ability for IO devices to access any region of the main system memory directly without passing through the processor. A dedicated centralized controller serving as arbiter may be utilized to achieve this, but the hardware designers are free to choose any another alternative if considered appropriate. If this method of communication is chosen to be used, cache coherence must be ensured between the processor and the IO devices too. Some possible options can be, as discussed earlier:],
list(tight: false,
[*Non cacheable memory region:* _With this configuration coherence isn't a problem because no caching is performed by the CPU and the IO device in question. The region is fixed and must reside outside of the MMIO address space but within the regular memory space. All DMA accesses must be made to that region._],
[*Software IO coherence:* _With this configuration the CPU and the device are required to flush or invalidate the cache explicitly with no extra hardware complexity, however, this option requires the exposure of the underlying organization to the programmer thus shifting a low level concern upwards._],
[*Hardware IO coherence:* _With this configuration, both the CPU and the IO device, will monitor each other's accesses via a common bus or a directory system while proper actions are automatically taken according to a common coherence protocol which can be the already existing one in the processor._]
),
[The DMA protocol or scheme implemented by the hardware designer must also take consistency into account since regular memory operations to different addresses are allowed to be done out-of-order. This means that fencing instructions must retain their effect from the point of view of the hart and IO devices. The IO devices must ultimately provide similar fencing features as well and behave as if they were any other hart.],
[FabRISC provides the *DMA Mode* (`DMAMOD`) 2 bit ISA parameter, to indicate which solution the hardware exposes for DMA. If the system doesn't support any DMA capability, then this parameter must be set to zero for convention. The possible values are listed in following table:],
tableWrapper([DMA modes.], table(
columns: (auto, auto),
align: (x, y) => (center, left + horizon).at(x),
[#middle([*Code*])], [#middle([*Value*])],
[00], [No DMA capabilities present.],
[01], [Non cacheable memory region.],
[10], [Software IO coherence.],
[11], [Hardware IO coherence.],
)),
[FabRISC provides the *DMA Size* (`DMAS`) 4 bit ISA parameter, to indicate the size of the DMA region. If the `DMAMOD` parameter is not equal to one, then this parameter has no meaning and must be set to zero for convention. The possible values are listed in the following table:],
tableWrapper([DMA Sizes.], table(
columns: (auto, auto),
align: (x, y) => (center, left + horizon).at(x),
[#middle([*Code*])], [#middle([*Value*])],
[0000], [$2^3$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0001], [$2^4$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0010], [$2^5$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0011], [$2^6$ bytes for 8 bit systems ($"WLEN" = 0$).],
[0100], [$2^10$ bytes for 16 bit systems ($"WLEN" = 1$).],
[0101], [$2^11$ bytes for 16 bit systems ($"WLEN" = 1$).],
[0110], [$2^12$ bytes for 16 bit systems ($"WLEN" = 1$).],
[0111], [$2^13$ bytes for 16 bit systems ($"WLEN" = 1$).],
[1000], [$2^15$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1001], [$2^16$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1010], [$2^20$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1011], [$2^24$ bytes for 32 and 64 bit systems ($"WLEN" = 2, 3$).],
[1100], [$2^32$ bytes for 64 bit systems ($"WLEN" = 3$).],
[1101], [$2^34$ bytes for 64 bit systems ($"WLEN" = 3$).],
[1110], [$2^36$ bytes for 64 bit systems ($"WLEN" = 3$).],
[1111], [$2^40$ bytes for 64 bit systems ($"WLEN" = 3$).],
)),
comment([
For more bandwidth demanding devices, such as external accelerators, DMA can be used to transfer data at very high speeds in the order of several Gb/s without interfering with the CPU. This scheme however, is more complex than plain MMIO because of the often required special arbiter that handles and grants the requests.
IO coherence, as well as its consistency, are actually the main reasons of this subsection as a remainder that it needs to be considered during the development of the underlying microarchitecture, including the devices themselves via the use of atomic and fencing operations. In essence the external IO devices can be considered as "CPU cores" from the point of view of coherence and consistency.
])
)
)
#pagebreak()
///
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compiler/string-12.typ | typst | Other | // Test the `find` and `position` methods.
#let date = regex("\d{2}:\d{2}")
#test("Hello World".find("World"), "World")
#test("Hello World".position("World"), 6)
#test("It's 12:13 now".find(date), "12:13")
#test("It's 12:13 now".position(date), 5)
|
https://github.com/lucifer1004/leetcode.typ | https://raw.githubusercontent.com/lucifer1004/leetcode.typ/main/solutions/s0004.typ | typst | #import "../helpers.typ": *
#let median-of-two-sorted-arrays-ref(nums1, nums2) = {
if nums1.len() > nums2.len() {
return median-of-two-sorted-arrays-ref(nums2, nums1)
}
let imax = 4000000000
let imin = -4000000000
let m = nums1.len()
let n = nums2.len()
let left = 0
let right = m
let med1 = 0
let med2 = 0
while left <= right {
let i = calc.floor((left + right) / 2)
let j = calc.floor((m + n + 1) / 2) - i
let nums_im1 = if i == 0 { imin } else { nums1.at(i - 1) }
let nums_i = if i == m { imax } else { nums1.at(i) }
let nums_jm1 = if j == 0 { imin } else { nums2.at(j - 1) }
let nums_j = if j == n { imax } else { nums2.at(j) }
if nums_im1 <= nums_j {
med1 = calc.max(nums_im1, nums_jm1)
med2 = calc.min(nums_i, nums_j)
left = i + 1
} else {
right = i - 1
}
}
if calc.rem(m + n, 2) == 0 {
(med1 + med2) / 2
} else {
med1
}
}
|
|
https://github.com/totikom/slides | https://raw.githubusercontent.com/totikom/slides/main/2024-05-01-turing-blockchain/slides-theme.typ | typst | Creative Commons Attribution Share Alike 4.0 International | #import "@preview/polylux:0.3.1": *
#import "colors.typ": background-color, text-color, dim-text-color
#let accent-color = rgb("#eb811b")
#let header-color = background-color.lighten(10%)
#let inverse-theme(aspect-ratio: "16-9", body) = {
set page(paper: "presentation-" + aspect-ratio, fill: background-color)
set text(fill: text-color)
body
}
#let title-slide(title: [], author: none, extra: none) = {
polylux-slide({
block(width: 100%, inset: 2em, {
text(size: 1.3em, strong(title))
if author != none or extra != none {
line(length: 100%, stroke: .05em + accent-color)
}
if author != none {
block(spacing: 1em, author)
}
if extra != none {
set text(size: .8em)
block(spacing: 1em, extra)
}
})
})
logic.logical-slide.update(0)
}
#let slide(title: [], footer: [], content) = {
let header = {
set align(top)
box(width: 100%, height: 100%, inset: 1.5em, fill: header-color, {
set align(horizon)
set text(size: 1.2em)
strong(title)
})
}
if footer == [] {
footer = {
set text(fill: dim-text-color)
set align(right)
box(inset: (right: 0.4em), logic.logical-slide.display())
}
}
set page(header: header, footer: footer, margin: (top: 3em, left: 0em, right: 0em, bottom: 1.5em))
polylux-slide({
show: align.with(horizon)
box(width: 100%, height: 100%, inset: 1.5em, content)
})
}
#let focus-slide(content) = {
set page(fill: background-color)
set text(fill: accent-color, size: 2em)
polylux-slide({
align(horizon + center, content)
})
logic.logical-slide.update(n => n - 1)
}
#let alert = text.with(fill: accent-color)
// vim: sw=2 ts=2 et
|
https://github.com/saffronner/36235-notes | https://raw.githubusercontent.com/saffronner/36235-notes/main/main.typ | typst | #set page(numbering: "1/1")
#set text(font: "CMU Serif")
#show "•": set text(font: "")
#show math.nothing: set text(font: "");
= intro
- foreshadowing/context: under all prob computations are _sample spaces_
- rarely work with sample spaces directly, unless they're simple (heads/tails)
- (so, we start here)
= what is prob?
- objective prob: long run freq of occurrence (eg heads in coin flip)
- often called frequentist/classical methods.
- used more often in undergrad CMU
- subjective prob: a possibly informed belief in rate of occurrence of event
- can called bayesian
= set notation
- $A supset B, A subset B , A union B , A sect B , overline(A) "aka" A^C$
- let the set of all experimental outcomes $Omega = A union overline(A)$
- $A sect B = nothing ==> A "and" B "are mutually exclusive aka disjoin"$
- distributive/associative laws
- de morgan's ($overline(A union B) = overline(A) sect overline(B)$, etc)
= what are experiments?
- make observations
- passive: just collect data
- active: control setting
- sample space ($Omega$)
- two coins tossed? $Omega = {"HH", "HT", "TH", "TT"}$
- HH is simple event
- TH is compound event ("at least one tail")
- free throws until miss? $Omega = {"M, HM, HHM," ...}$
- relative freqs of above? don't know! need more info
= probability
== sample space probabilities
- conditional probability: $A$, when we know $B$
#image("media/conditional_probability.png")
- $A$ and $B$ are independent
- iff $P(A | B) = P(A)$
- iff $P(B | A) = P(B)$
- iff $P(A sect B) = P(A) P(B)$
- if there are three events, $A$ and $B$ are _conditionally_ independent
- if $P(A sect B | C) = P(A | C)P(B | C)$
#image("media/independence.png")
- multiplicative law:
$
P(A sect B) &= P(A)P(B | A) = P(B)P(A|B) \
&= 0 "if" A,B "disjoint" \
&= P(A)P(B) "if" A,B "independent"
$
#image("media/n-long_multiplicative_law.png")
- additive law:
$
P(A union B) &= P(A) + P(B) - P(A sect B) \
&= P(A) + P(B) "if" A,B "disjoint" \
&= P(A) + P(B) - P(A)P(B) "if" A,B "independent"
$
- decision trees: good for when probabilities change
- eg picking colored balls without replacement, not like probability of heads of fair coin
#image("media/decision_tree_ex.png")
- for these next two, let ${B_i}$ be a partition of $Omega$.
- law of total probability.
$
P(A) = sum^k_(i=1) P(A|B_i)P(B_i)
$
#image("media/law_of_total_prob.png", width: 25%)
- "probability of $B_1$. then times the probability that $i$ landed in $A$, in $B_1$, etc etc"
- helpful when given conditional probs but not $A$ itself
- Bayes' Rule:
$
P(B_j|A) = (P(A|B_j)P(B_j))/(sum^k_(i=1)P(A|B_i)P(B_i)) = (P(A|B_j)P(B_j))/P(A)
$
#image("media/bayes's_rule_ex.png")
== other probability paradigm??
- need better paradigm for continuous situations/nondiscrete outcomes: random variables, prob distributions
- random variable: like a function, maps events in $Omega$ to, eg, real number line (the output. meters ran maybe)
- but tbh just think of random variables as their outputs
- can have diff random variables for same experiment: number of tails observed, number of heads, whether not heads observed
- denoted with uppercase Latin eg $X$, $P(X=x)$
- NO INHERENT NOTION OF PROBABILITY!
- functions of random variables are random variables! _statistics_ are _functions of data_ are _random variables_
- properties of discrete and continuous prob distributions
#table(
columns: 3,
stroke: none,
align: horizon,
table.vline(x: 1),
[], [Discrete], [Continuous],
table.hline(),
[Name], [pmf: probability mass function], [pdf: probability density function],
table.hline(),
[Symbol], [$p_X (x)$], [$f_X (x)$],
table.hline(),
[Properties],
[$ 0 <= p_X (x) <= 1 $], [$ f_X (x) >= 0 $],
[],[$ display(sum_("all" x)) p_X (x) = 1 $], [$ integral_("all" x) f_X (x)d x = 1 $],
[],[$ P(a <= X <= b) = sum_(x in [a,b])p_X (x) $], [$ P(a <= X <= b) = integral_a^b f_X (x) d x $],
[],[$ P(a < X < b) = sum_(x in (a,b)) p_X (x) $], [$ P(a < X < b) = integral_a^b f_X (x) d x $],
[],[$ E[X] = sum_("all" x) x p_X (x) $], [$ E[X] = integral_("all" x) x f_X (x) d x $],
[(law of \ unconscious \ statistician)],[$ E[g(x)] = sum_("all" x) g(x) p_X (x) $], [$ E[g(x)] = integral_("all" x) g(x) f_X (x) d x $],
)
- expected value operator $E[X] = mu_X$, mean of the distribution $X$ was sampled from
- $E[c X] = c E[X]$
- $E[c] = c$
- $E[x + y] = E[x] + E[y]$
- variance operator $V[X] = sigma^2$
- $V[X] = E[(x-mu)^2] = "(simplifies to)" E[X^2] - (E[X])^2$
- apparently $V[x + y] = V[x] + V[y]$??? sep 18 class example 2
- variance is not width, but the square of the width. think about units of $V[X]$ vs units of $E[X]$
- translation/scaling's effects on mean and variance: ($X -> X + b$)
- $E[X + b] = E[X] + b$ (translation shifts mean)
- $E[a X] = a E[X]$ (scaling shifts mean multiplicatively)
- $V[X + b] = V[X]$ (translation doesn't effect width)
- $V[a X] = a^2 V[X]$ (scaling widens exponentially. verify via shortcut formula)
#pagebreak(weak: true)
- cumulative distribution function (cdf)
- accumlated prob up to $x$, inclusive
#table(
columns: (7em, 1fr, 1fr),
stroke: none,
align: horizon,
table.vline(x: 1),
[], [Discrete], [Continuous],
table.hline(),
[Symbol], [$F_X (x)$], [$F_X (x)$],
table.hline(),
[Definition], [$ F_X (x) = sum_(y <= x) p_Y (y) $], [$ F_X (x) = integral_(-infinity)^x f_Y (y) d y $],
table.hline(),
[Limiting Properties], table.cell(colspan: 2, align: center)[for both, $F_X (-infinity) = 0$ and $F_X (infinity) = 1$],
table.hline(),
[Reln to pmf/pdf], [$ p_X (x) "is magnitude of jump"\ "in" F_X (x) "at coord" x $], [$ f_X (x) = d/(d x) F_X (x) $],
table.hline(),
[Reln to Quantile $q$], [$ X = "min"{x : F_X (x) >= q} $], [$ "inverse cdf," X = F_X^(-1) (q) $],
table.hline(),
[Reln to Prob. Over Range], [$ "It's complicated." $], [$ &P(a <= X <= b)\ = &P(a < X < b)\ = &F_X (b) - F_X (a) $]
)
- inverse cdf: given total prob $q$ to left of (and including) some $x_0$, what is $x_0$?
#table(
columns: 3,
stroke: none,
align: horizon,
table.vline(start: 1, x:1),
table.vline(start: 1, x:2),
[],[input],[output],
[cdf],$ x_0 $, $ q $,
table.hline(),
[inverse cdf], $ q $, $ x_0 $
)
=== families of distributions
- up till now, practice problems have fixed $theta$ in equations. we often have to find it. (use law of total prob)
- deriving from Law of Total Prob ($P(A) = sum^k_(i=1) P(A|B_i)P(B_i)$) if we know
- $p_(X|theta) (x|theta)$
- with $theta$ weights from $p_Theta (theta)$,
$
p_X (x) = sum_theta p_(X|theta) (x|theta) p_Theta (theta)
$
- if $theta$ is continuous, we may just use an integral
- #image("media/lotp_randomvariable.png")
#pagebreak(weak: true)
- plotting such a pdf: $f_X (x) = integral^infinity_0 theta x^(theta - 1) dot e^(-theta) d theta$
```R
x <- seq(0.001,1,by=0.001)
f.X <- rep(NA,length(x))
f <- function(theta,x) {
return(theta*x^(theta-1)*exp(-theta))
}
for ( ii in 1:length(x) ) { # we loop over x's indices (1, 2, ..., length(x))
f.X[ii] <- integrate(f,0,Inf,x=x[ii])$value
}
# Now let's plot!
library(ggplot2)
df <- data.frame(x,f.X)
ggplot(data=df,mapping=aes(x=x,y=f.X)) +
geom_line(col="firebrick") +
ylim(c(0,3)) +
ylab(expression(f[X]*"(x)"))
```
=== data sampling code
- inverse-transform sampling
+ sample a $q in (0,1)$. (e.g. `runif()`, random uniform)
+ plug $q$ into $x = F_X^(-1) (q)$, record $x$
+ repeat $n$ times for a sample size of $n$
- rejection sampling
+ choose finite domain $[a,b]$ for $f_X (x)$ that's good enough
+ let $"max"(f_X (x)) = m$
+ repeat until $n$ samples recorded:
+ randomly sample $x' in [a,b]$ and $y' in [0,m]$.
+ if $y' <= f_X (x')$, keep the data point. otherwise, reject it and continue
- see `media/data_sampling.Rmd`
=== statistics
- iid: independant and identically distributed
- reiterating: these are just functions of observed data
- $Y = X_1 + cos(X_2) - (X_37)/pi$ is a statistic, but not informative
- $overline(X) = 1/n sum_(i=1)^n X_1$ is as well, and is informative of $mu$
- $S^2 = 1/(n-1) sum^n_(i=1) (X_1 - overline(X))^2$ is informative of $sigma^2$
- statistics are random variables!!!
- drawn from sampling distributions (which are just pmfs/pdfs)
- sample mean, stddev, range, median
- $E[overline(X)] = E[X]$, $V[overline(X)] = (V[X])/n$ hold for all distributions
- standard error is the width of the distribution; the standard deviation of a statistic; $sqrt(V[Y])$, where $Y$ is a random variable/sampling distribution/pmf or pdf for a statistic
- expected value of the sample variance $S^2$ is $sigma^2$ after LOTS of math
- this is Wednesday: Statistics and Sampling Distributions class example 1
- why is $1/(n-1)$ there? create an unbiased example of the population estimate??
=== likelihood function
- the likelihood function quantifies how likely a $theta$ is given our data
- let it be defined:
$
cal(L)(theta | arrow(X)) = product^n_(i=1) f_X (x_i | theta)
$
for continuous data, simply using $p_X (x_i | theta)$ for discrete
- notice that
#image("media/likelihood_function.png")
- why? in inference, we want to estimate $theta$ given data! so we maximize $cal(L)$ for $theta$
- to make math easier, we use the log-likelihood $cal(l)(theta | arrow(X)) = log cal(L)(theta | arrow(X))$
=== bias and variance
- bias: $B[hat(theta)] = E[hat(theta) - theta] = E[hat(theta)] - theta$
- estimator biased: $B[hat(theta)] = 0$, unbiased $B[hat(theta)] != 0$
- variance: $V[hat(theta)]$ (recall defn above)
- mean-squared error (MSE): $"MSE"[hat(theta)] = E[(hat(theta)-theta)^2] =_"simpl to" V[hat(theta)] + (B[hat(theta)])^2$
- select "best" estimator by taking the one with lowest MSE
=== Maximum Likelihood Estimation
- procedure (it's literally just AP Calc maximization):
+ find $cal(L) (theta | arrow(X))$
+ find $cal(l) (theta | arrow(X))$
+ compute $cal(l)'(theta | arrow(X))$, partial or normal with respect to $theta$
+ solve the above equal to 0 for $theta$, now called $hat(theta)_"MLE"$ (also replace $x_i$ with $X_i$)
- this does not work with domain-specifying parameters (e.g. $f_X (x) = 1/theta "for" x in [0, theta]$)
- property of MLEs: invariance property
- if $theta' = g(theta)$, then $hat(theta)'_"MLE" = g(hat(theta)_"MLE")$
- e.g., .0 what
|
|
https://github.com/3w36zj6/textlint-plugin-typst | https://raw.githubusercontent.com/3w36zj6/textlint-plugin-typst/main/test/fixtures/Header/input.typ | typst | MIT License | = header 1
== header 2
=== header 3
|
https://github.com/TypstApp-team/typst | https://raw.githubusercontent.com/TypstApp-team/typst/master/tests/typ/visualize/stroke.typ | typst | Apache License 2.0 | // Test lines.
---
// Some simple test lines
#line(length: 60pt, stroke: red)
#v(3pt)
#line(length: 60pt, stroke: 2pt)
#v(3pt)
#line(length: 60pt, stroke: blue + 1.5pt)
#v(3pt)
#line(length: 60pt, stroke: (paint: red, thickness: 1pt, dash: "dashed"))
#v(3pt)
#line(length: 60pt, stroke: (paint: red, thickness: 4pt, cap: "round"))
---
// Set rules with stroke
#set line(stroke: (paint: red, thickness: 1pt, cap: "butt", dash: "dash-dotted"))
#line(length: 60pt)
#v(3pt)
#line(length: 60pt, stroke: blue)
#v(3pt)
#line(length: 60pt, stroke: (dash: none))
---
// Rectangle strokes
#rect(width: 20pt, height: 20pt, stroke: red)
#v(3pt)
#rect(width: 20pt, height: 20pt, stroke: (rest: red, top: (paint: blue, dash: "dashed")))
#v(3pt)
#rect(width: 20pt, height: 20pt, stroke: (thickness: 5pt, join: "round"))
---
// Dashing
#line(length: 60pt, stroke: (paint: red, thickness: 1pt, dash: ("dot", 1pt)))
#v(3pt)
#line(length: 60pt, stroke: (paint: red, thickness: 1pt, dash: ("dot", 1pt, 4pt, 2pt)))
#v(3pt)
#line(length: 60pt, stroke: (paint: red, thickness: 1pt, dash: (array: ("dot", 1pt, 4pt, 2pt), phase: 5pt)))
#v(3pt)
#line(length: 60pt, stroke: (paint: red, thickness: 1pt, dash: ()))
#v(3pt)
#line(length: 60pt, stroke: (paint: red, thickness: 1pt, dash: (1pt, 3pt, 9pt)))
---
// Line joins
#stack(
dir: ltr,
spacing: 1em,
polygon(stroke: (thickness: 4pt, paint: blue, join: "round"),
(0pt, 20pt), (15pt, 0pt), (0pt, 40pt), (15pt, 45pt)),
polygon(stroke: (thickness: 4pt, paint: blue, join: "bevel"),
(0pt, 20pt), (15pt, 0pt), (0pt, 40pt), (15pt, 45pt)),
polygon(stroke: (thickness: 4pt, paint: blue, join: "miter"),
(0pt, 20pt), (15pt, 0pt), (0pt, 40pt), (15pt, 45pt)),
polygon(stroke: (thickness: 4pt, paint: blue, join: "miter", miter-limit: 20.0),
(0pt, 20pt), (15pt, 0pt), (0pt, 40pt), (15pt, 45pt)),
)
---
// Error: 29-56 unexpected key "thicknes", valid keys are "paint", "thickness", "cap", "join", "dash", and "miter-limit"
#line(length: 60pt, stroke: (paint: red, thicknes: 1pt))
---
// Error: 29-55 expected "solid", "dotted", "densely-dotted", "loosely-dotted", "dashed", "densely-dashed", "loosely-dashed", "dash-dotted", "densely-dash-dotted", "loosely-dash-dotted", array, dictionary, none, or auto
#line(length: 60pt, stroke: (paint: red, dash: "dash"))
---
// 0pt strokes must function exactly like 'none' strokes and not draw anything
#rect(width: 10pt, height: 10pt, stroke: none)
#rect(width: 10pt, height: 10pt, stroke: 0pt)
#rect(width: 10pt, height: 10pt, stroke: none, fill: blue)
#rect(width: 10pt, height: 10pt, stroke: 0pt + red, fill: blue)
#line(length: 30pt, stroke: 0pt)
#line(length: 30pt, stroke: (paint: red, thickness: 0pt, dash: ("dot", 1pt)))
#table(columns: 2, stroke: none)[A][B]
#table(columns: 2, stroke: 0pt)[A][B]
#path(
fill: red,
stroke: none,
closed: true,
((0%, 0%), (4%, -4%)),
((50%, 50%), (4%, -4%)),
((0%, 50%), (4%, 4%)),
((50%, 0%), (4%, 4%)),
)
#path(
fill: red,
stroke: 0pt,
closed: true,
((0%, 0%), (4%, -4%)),
((50%, 50%), (4%, -4%)),
((0%, 50%), (4%, 4%)),
((50%, 0%), (4%, 4%)),
)
---
// Converting to stroke
#assert.eq(stroke(red).paint, red)
#assert.eq(stroke(red).thickness, auto)
#assert.eq(stroke(2pt).paint, auto)
#assert.eq(stroke((cap: "round", paint: blue)).cap, "round")
#assert.eq(stroke((cap: auto, paint: blue)).cap, auto)
#assert.eq(stroke((cap: auto, paint: blue)).thickness, auto)
// Error: 9-21 unexpected key "foo", valid keys are "paint", "thickness", "cap", "join", "dash", and "miter-limit"
#stroke((foo: "bar"))
// Constructing with named arguments
#assert.eq(stroke(paint: blue, thickness: 8pt), 8pt + blue)
#assert.eq(stroke(thickness: 2pt), stroke(2pt))
#assert.eq(stroke(cap: "round").thickness, auto)
#assert.eq(stroke(cap: "round", thickness: auto).thickness, auto)
|
https://github.com/MultisampledNight/flow | https://raw.githubusercontent.com/MultisampledNight/flow/main/src/info.typ | typst | MIT License | // Metadata info and the works.
// Also contains a typecheck machine for absolutely no reason
// other than being a cool sideproject and
// forcing myself to use strings instead of contents for e.g. content warnings.
#import "gfx.typ"
#import "palette.typ": *
#import "tyck.typ"
// Panics if known typo'd metadata fields are contained.
#let _check-typos(it) = {
let typos = (
"alias": "aliases",
"aliase": "aliases",
"content-warning": "cw",
"content-warnings": "cw",
)
for key in it.keys() {
if key in typos.keys() {
panic(
"metadata key `" + key + "` passed to template, which is a typo. "
+ "use `" + typos.at(key) + "` instead."
)
}
}
}
// TODO: add function that goes through value and converts it into a schema using the functions above
#let _schema = {
import tyck: *
_attrs(
aliases: _any(str, _array(str)),
author: _any(str, _array(str)),
cw: _any(str, _array(str)),
tags: _any(str, _array(str)),
keywords: _any(
// shorthand for bolding all listed keywords
_array(str),
// the explicit version which allows using any function for modification
_dict(str, function),
// TODO: one day, implement auto which searches through all keywords
),
lang: str,
)
}
#let _check(it) = {
_check-typos(it)
tyck.validate(it, _schema)
}
// Puts some well-known metadata fields into an array if they stand alone.
// Returns the modified metadata.
#let _normalize(it) = {
let arrayize = ("aliases", "author", "cw", "tags")
for (name, data) in it {
if type(data) != array and name in arrayize {
it.at(name) = (data,)
}
}
it
}
#let preprocess(it) = {
_check(it)
_normalize(it)
}
#let queryize(it) = [
#metadata(it) <info>
]
// Accepts a dictionary where
// the key denotes the metadata field name and
// the value its, well, actual data.
#let render(it) = {
let field(name, data) = {
if "cw" in lower(name) {
data.map(gfx.invert).join()
} else if type(data) == array {
data.join[,]
} else {
[#data]
}
}
grid(
columns: 2,
align: (right, left),
gutter: 1em,
..it
.pairs()
.filter(((name, _)) => name != "keywords")
.map(
((name, data)) => (dim(name), field(name, data))
)
.join()
)
}
|
https://github.com/pawarherschel/typst | https://raw.githubusercontent.com/pawarherschel/typst/main/src/metadata.typ | typst | Apache License 2.0 | /* Personal Information */
#let SOT = yaml("../SOT.yaml")
#let metadata = SOT.metadata
#let firstName = metadata.firstName
#let lastName = metadata.lastName
#let personalInfoEntries = metadata.personalInfo
#let personalInfo = (thing: "meow")
#for key in metadata.personalInfo.keys() {
key
if key == "github" {
personalInfo.insert("github", metadata.personalInfo.github)
} else if key == "phone" {
personalInfo.insert("phone", metadata.personalInfo.phone)
} else if key == "email" {
personalInfo.insert("email", metadata.personalInfo.email)
} else if key == "linkedin" {
personalInfo.insert("linkedin", metadata.personalInfo.linkedin)
} else if key == "gitlab" {
personalInfo.insert("gitlab", metadata.personalInfo.gitlab)
} else if key == "homepage" {
personalInfo.insert("homepage", metadata.personalInfo.homepage)
} else if key == "orcid" {
personalInfo.insert("orcid", metadata.personalInfo.orcid)
} else if key == "researchgate" {
personalInfo.insert("researchgate", metadata.personalInfo.researchgate)
} else if key == "extraInfo" {
personalInfo.insert("extraInfo", metadata.personalInfo.extraInfo)
}
}
#personalInfo.remove("thing")
// #let personalInfo = (
// github: personalInfo.github,
// phone: personalInfo.phone,
// email: personalInfo.email,
// linkedin: personalInfo.linkedin,
// // gitlab: "mintyfrankie",
// homepage: personalInfo.homepage,
// orcid: personalInfo.orcid,
// // researchgate: "John-Doe",
// // extraInfo: "asdf",
// )
#let headerQuoteInternational = none
#if metadata.headerQuote != none {
headerQuoteInternational = (
"": metadata.headerQuote.join("\n"),
)
}
/* Layout Setting */
// Optional: skyblue, red, nephritis, concrete, darknight
#let awesomeColor = metadata.awesomeColor
// Leave blank if profil photo is not needed
// #let profilePhoto = "../src/avatar.png"
#let profilePhoto = metadata.profilePhoto
// Change this variable to control output language & cited module
// INFO: value must matches folder suffix; i.e "zh" -> "./modules_zh"
#let varLanguage = ""
// Decide if you want to put your company in bold or your position in bold
#let varEntrySocietyFirst = metadata.varEntrySocietyFirst
// Decide if you want to display organisation logo or not
#let varDisplayLogo = metadata.varDisplayLogo
// for cvFooter and letterFooter arrays, add your own languages while the keys must match the varLanguage variable
#let cvFooterInternational = (
"": metadata.cvFooter,
// "en": "Curriculum vitae",
// "fr": "Résumé"
)
#let letterFooterInternational = (
"": metadata.letterFooter,
// "en": "Cover Letter",
// "fr": "Lettre de motivation",
)
|
https://github.com/RaphGL/ElectronicsFromBasics | https://raw.githubusercontent.com/RaphGL/ElectronicsFromBasics/main/DC/chap6/chap6.typ | typst | Other | == Divider circuits and kirchhoff's laws
#include "1_voltage_divider_circuits.typ"
#include "2_kirchhoffs_voltage_law.typ"
#include "3_current_divider_circuit.typ"
#include "4_kirchoffs_current_law.typ"
|
https://github.com/NiJingzhe/ZJU_BME_APD | https://raw.githubusercontent.com/NiJingzhe/ZJU_BME_APD/master/cloc/report.typ | typst | MIT License | #set page(
margin: 1cm
)
#set text(font: "Noto Serif CJK SC", size: 12pt)
#set par(first-line-indent: 2em, hanging-indent: 0em)
#set list(body-indent: 1em, indent: 2em, marker: ">", tight: false)
#set enum(indent: 2em, body-indent: 1em, tight: false, numbering: "i.")
#grid(
columns: (5%, 35%, 30%, 5%, 25%),
align: center + horizon,
[],
image("../reports_src_pub/zjuicon.png", width: 100%),
text(font: "FZKai-Z03", size: 24pt)[实验报告],
[],
grid(
rows: (auto, auto, auto, auto),
row-gutter: 6pt,
align: start + horizon,
text(size: 13pt)[专业： 生物医学工程],
text(size: 13pt)[姓名： 倪旌哲],
text(size: 13pt)[学号： 3220100733],
text(size: 13pt)[日期： 2024.10.21]
)
)
\
#align(center)[
#grid(
columns: (auto, auto, auto),
align: center + horizon,
column-gutter: 15pt,
row-gutter: 10pt,
text(size: 13pt)[课程名称: #math.underline([高级程序设计])],
text(size: 13pt)[指导老师: #math.underline([耿晨歌])],
text(size: 13pt)[成绩: #math.underline([#h(2cm)])],
text(size: 13pt)[实验名称: #math.underline([计算代码行数])],
text(size: 13pt)[实验类型: #math.underline([基础实验])],
text(size: 13pt)[同组学生姓名: #math.underline([无])]
)
]
\
= 一、实验目的和要求
\
#par()[
写一个Java程序，统计一个项目中一共有多少行代码, 多少行注释, 多少个空白行.
通过命令行参数给定 目录
对目录下所有java文件，扫描其中有:
+ 多少行代码
+ 多少行注释
+ 多少空白行
]\
= 二、实验内容和原理
\
#par[
+ 统计代码行数
+ 如果我们将目光限制在一个文件上，要统计这个文件内的代码行，空行和注释行，只需要做简单的模式检查即可。
+ 空行很简单，如果```java line = ""```，那么这一行就是空行。
+ 注释行略微复杂，因为有单行注释和多行注释：
+ 针对单行注释，我们只需要检查```java line.startsWith("//")```即可。
+ 针对多行注释，我们需要检查```java line.startsWith("/*")```和```java line.endsWith("*/")```，并且在多行注释中间的行都是注释行，可以用一个```java while```循环来处理。
+ 针对代码行，我们可以通过排除空行和注释行来得到。
+ Folder递归搜索统计
+ 要实现对一个目录下所有java文件的统计，我们需要递归地遍历这个目录，对每一个java文件进行统计。
+ 关键就是判断一个路径是否是一个folder，我们可以通过```java Files.isDirectory()```来判断。
+ 对目录的递归处理可以通过```java Files.walk(path)```来实现，这个方法会返回一个```java Stream<Path>```，我们可以通过```java forEach()```来遍历这个Stream。
+ 命令行参数处理
+ 我们可以通过```java args[]```来获取命令行参数，这个参数是一个```java String[]```，我们可以通过```java args.length```来获取参数的个数。
+ 数据统计
+ 创建一个```java FileState```类来统计文件/文件夹的代码行数，空行数和注释行数。
]
\
= 三、主要仪器设备
\
- 个人电脑
\
\
= 四、操作法方法与实现步骤
\
#par()[
+ 创建UniTest
详见第五部分
+ 定义```java FileState```
```java
public static class FileStats {
public int codeLines = 0;
public int commentLines = 0;
public int blankLines = 0;
public void add(FileStats other) {
this.codeLines += other.codeLines;
this.commentLines += other.commentLines;
this.blankLines += other.blankLines;
}
@Override
public String toString() {
return String.format(
"Code Lines: %d, Comment Lines: %d, Blank Lines: %d",
codeLines, commentLines, blankLines
);
}
}
```
+ 读取命令行参数
```java
// Help menu
if (args.length != 1 || args[0].equals("-h") || args[0].equals("--help")) {
System.out.println("Usage: java Cloc <file or directory path>");
return;
}
// Get the path (dir or single file both ok)
Path path = Paths.get(args[0]);
// Make sure the file or directory exists
if (!Files.exists(path)) {
System.out.println("File or directory does not exist.");
return;
}
```
+ 根据path属性递归travel目录，并统计代码行数，最终打印出总计
```java
// If so, we will create a new FileStats object to store the total statistics
FileStats totalStats = new FileStats();
// Recursively process the directory or a single file
try {
if (Files.isDirectory(path)) {
// 递归处理目录
Files.walk(path).filter(Files::isRegularFile).forEach(file -> {
// If this is a java code file
if (!file.toString().endsWith(".java")) {
return;
}
try {
FileStats stats = processFile(file);
System.out.println(file + ": " + stats);
totalStats.add(stats);
} catch (IOException e) {
System.out.println("Error reading file: " + file);
}
});
} else {
// 处理单个文件
FileStats stats = processFile(path);
System.out.println(path + ": " + stats);
totalStats.add(stats);
}
// 输出总计
System.out.println("\nTotal Stats: " + totalStats);
} catch (IOException e) {
e.printStackTrace();
}
```
+ 其中， 对于processFile的实现如下：
```java
public static FileStats processFile(Path file) throws IOException {
FileStats stats = new FileStats();
boolean blockComment = false; // 标记块注释的状态
List<String> lines = Files.readAllLines(file);
for (String line : lines) {
line = line.trim();
if (line.isEmpty()) {
stats.blankLines++;
} else if (blockComment) {
stats.commentLines++;
if (line.endsWith("*/")) {
blockComment = false;
}
} else if (line.startsWith("//")) {
stats.commentLines++;
} else if (line.startsWith("/*")) {
stats.commentLines++;
if (!line.endsWith("*/")) {
blockComment = true;
}
} else {
stats.codeLines++;
}
}
return stats;
}
```
]
\
\
\
= 五、实验结果与分析
\
#par()[
+ 为了测试这个程序，我们在一开始规划了以下几种测试用例：
+ 测试一个正常的文件，包含5行代码，3行注释，1个空行
+ 测试一个空文件
+ 测试一个只有注释的文件
+ 测试```java FileState``` 的 ```java add()``` 方法
+ 没有文件夹用例的测试，因为以上几种情况能够完全组合出针对文件夹的测试用例
+ 测试结果：
#align(center)[#image("../reports_src_pub/cloc_test.png", width: auto)] \
+ 单元测试代码：
```java
import org.junit.Test;
import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;
import static org.junit.Assert.*;
public class ClocTest {
// Test case for processing files with code comments and blank lines
@Test
public void testProcessFileWithCodeCommentsAndBlankLines() throws IOException {
// 准备测试文件内容
// 5 lines of code
// 3 lines of comments
// 1 blank line
String testContent = "public class Test {\n" +
" // This is a comment\n" +
" public void method() {\n" +
" System.out.println(\"Hello, world!\");\n" +
" }\n" +
" /* Block comment start\n" +
" Block comment end */\n" +
"}\n" +
"\n";
// 创建临时文件
Path testFile = Files.createTempFile("testFile", ".java");
Files.write(testFile, testContent.getBytes());
// 执行 processFile 方法
Cloc.FileStats result = Cloc.processFile(testFile);
// 断言代码行、注释行、空行的统计结果
assertEquals(5, result.codeLines); // 3 行代码
assertEquals(3, result.commentLines); // 3 行注释
assertEquals(1, result.blankLines); // 1 行空行
// 删除临时文件
Files.delete(testFile);
}
// Test case for empty file
@Test
public void testProcessFileEmptyFile() throws IOException {
// 创建空文件
Path emptyFile = Files.createTempFile("emptyFile", ".java");
// 执行 processFile 方法
Cloc.FileStats result = Cloc.processFile(emptyFile);
// 断言结果是 0 行
assertEquals(0, result.codeLines);
assertEquals(0, result.commentLines);
assertEquals(0, result.blankLines);
// 删除临时文件
Files.delete(emptyFile);
}
// Test case for file contains only comments
@Test
public void testProcessFileOnlyComments() throws IOException {
// 准备只有注释的文件内容
String testContent = "// Single line comment\n" +
"/* Block comment start\n" +
" Block comment end */\n" +
"\n";
// 创建临时文件
Path testFile = Files.createTempFile("testFileOnlyComments", ".java");
Files.write(testFile, testContent.getBytes());
// 执行 processFile 方法
Cloc.FileStats result = Cloc.processFile(testFile);
// 断言只有注释行
assertEquals(0, result.codeLines);
assertEquals(3, result.commentLines); // 3 行注释
assertEquals(1, result.blankLines); // 1 行空行
// 删除临时文件
Files.delete(testFile);
}
// Test file for FileStats add method
@Test
public void testFileStatsAddMethod() {
// 创建两个 FileStats 对象
Cloc.FileStats stats1 = new Cloc.FileStats();
stats1.codeLines = 5;
stats1.commentLines = 3;
stats1.blankLines = 2;
Cloc.FileStats stats2 = new Cloc.FileStats();
stats2.codeLines = 10;
stats2.commentLines = 7;
stats2.blankLines = 4;
// 合并统计结果
stats1.add(stats2);
// 断言合并后的结果
assertEquals(15, stats1.codeLines);
assertEquals(10, stats1.commentLines);
assertEquals(6, stats1.blankLines);
}
}
```
]
\
= 六、讨论、心得
\
+ 熟悉了敏捷开发的流程，通过TDD的方式编写代码，提高了代码的质量和可维护性
+ 通过这个实验，我学会了如何处理命令行参数，如何递归地遍历一个目录，如何统计代码行数，空行数和注释行数
+ 通过这个实验，我学会了如何编写单元测试，如何使用JUnit来进行单元测试
+ 熟悉了使用git进行版本管理的流程，学会了如何使用GitHub来托管代码
#align(center)[#image("../reports_src_pub/cloc_gitgraph.png", width: auto)]
|
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/040%20-%20Zendikar%20Rising/004_The%20Magosi%20Steps.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"The Magosi Steps",
set_name: "Zendikar Rising",
story_date: datetime(day: 10, month: 09, year: 2020),
author: "<NAME>",
doc
)
#emph[Note: This is Part 2 of a two-part story. Make sure to check out Part 1 before reading on.]
Morning found the Magosi Portage warm before the dawn, seasonable but no less uncomfortable. The caravan of two dozen merfolk traders milled about the portage's packing yard, their pillarfield oxen laden and hitched together, blindfolded for the coming descent down the stair. The sun trembled up from the far horizon, and Akiri made her first checks of the straps, harnesses, blinds, and guide lines that would see the merfolk's oxen down safely and calmly. The merfolk were Zareth's responsibility; they were nervous, but Zareth did his best to comfort them.
"If you fall, aim for the river," Akiri overheard him say as she walked by on her inspection of the oxen. She couldn't help herself from laughing, which prompted a series of concerned questions from the caravan-master, who Akiri then had to spend another quarter hour reassuring.
"Might be that if you blindfolded him this would be an easier trip," Zareth said, walking behind Akiri as she made a third check of the oxen.
"I think we'd forfeit the rest of our pay if I did that," Akiri said, tugging a strap tight. She checked the lines that held down the crates and bundles of goods packed on the oxen's back. "Though it would certainly make this easier."
"Any idea what they're carrying?" Zareth asked.
"Do you want me to guess, or do you want to tell me?" Akiri said.
"This one has fruits from the interior," Zareth winked. He produced a small handful of deep purple berries. "Want one? I think it's elvish. It has a nice buzz, like morning tea."
Akiri raised a finger to admonish him, but she stopped as Zareth nodded past her toward the approaching caravan leader.
"No more of that," Akiri growled, then turned to the caravan leader, smiling, reassuring him that all was well and that they were ready to depart at his leisure. She watched from the corner of her eye as Zareth walked off down the line of oxen, making small conversation with the merfolk traders, laughing with them, making small adjustments to the harnesses on the beasts, and otherwise making nice. She hated that she watched him with suspicion. Not with distrust, for she knew Zareth well and knew where his heart stood, but certainly with disappointment. She resolved to put a stop to it. But first, they—
The ground shook. A slight tremor, short, accompanied by a sudden burn in the morning's heat, as if the sun grew closer by fractions. The oxen stopped their chuffing and grunting. The merfolk stopped their nervous talk. Even Zareth paused, rooting himself to the shaking ground, hands dropping to the twin knives at his waist. From a humid dawn, calm save for nerves, the world suddenly made itself known. The shaking only lasted for moments, though it felt like an hour, a day, a heartbeat.
Akiri was the only one who did not look around in fear once it passed. She had been surprised, to be sure, but not afraid. To the contrary, as the merfolk whispered and talked in hushed tones about ill signs, as the caravan lead fretted about trying to calm the oxen, Akiri was calm. Resolute.
The Roil—gone briefly after the Eldrazi defeat at Sea Gate—was back. A hint of it at least: Zendikar's reminder that the Battle had only saved the people that lived upon it, not the world itself. The Roil, when it came, never proceeded anything small; it was a herald of Zendikar's incredible power, the strength of the world itself. Despite any fear Akiri felt when the Roil shook, she welcomed its trembling. If you lived through what the Roil did, you understood the scale of the threat before you.
Zareth strode over to her, hands still resting on his knife hilts. "I thought we stopped the Roil," he said. "You think it will get worse?"
"No," Akiri said. "Once it passes, it passes, remember? We should be fine on the steps—they're sturdy enough. The Umara is stable, which is why we only felt a tremor."
"Sea Gate?"
"Will likely deal with some tremor waves out from the Halimar and the ocean beyond," Akiri said, "but the city will stand."
Zareth looked to the merfolk and the caravan. "And us? Elementals? Or—"
His grip on his knives went white, though otherwise, he remained composed, calm, and cool.
"No," Akiri said. She reached out and, with a light touch, lifted Zareth's hands from his weapons. "The Roil has passed. Let it pass," she said. "All we have to do now is go down the stairs, on to Coralhelm, then to Sea Gate."
Zareth nodded, exhaling. "Then we continue the work."
"Then we continue the work," Akiri repeated. She looked past Zareth at the merfolk caravan, who had clustered around their leader and were talking with him in hushed, strained tones. "See how little we shook?" she called over to them. "The route we take down is carved into this same rock. There is nothing to fear."
The merfolk spread out among their oxen, talking among themselves. Their leader approached Akiri and Zareth.
"That was the Roil," the merfolk leader said. "Not just a quake. You can feel it, too, can't you?" he asked Zareth. The merfolk leader touched his jaw. "That sound here, before the shake."
Zareth nodded. "I felt it," he said. "It hurt, but it did not seem like a terrible one."
"In any case," Akiri said to the merfolk caravan leader, "this is the safest place you can be in all of Zendikar. From here to Sea Gate, we're on stable ground. Our biggest worry is the heat."
"And any raiders," Zareth said, interjecting, "those are worth worrying about as well."
The caravan leader balked.
"He's only joking," Akiri said. She shot a glare at Zareth. "You and your people will be fine, and we'll see you to Coralhelm by the end of the day."
The merfolk leader looked between the two of them. Akiri, reassuring, and Zareth, smiling. He shook his head and walked away, to tend to his other duties.
The caravan departed shortly after, the oxen lumbering one by one down the first step of the long switchback path.
On the steps, despite the press of the caravan, the roar of the Magosi gave Akiri and Zareth some privacy in their conversation.
"That was a bad one," Akiri said. "I haven't felt anything like that since the Battle."
"My face felt like it was going to crack," Zareth said, massaging his jaw. "I don't blame these people for being scared," he said. "Depths, that one has me worried."
Akiri adjusted her hooks and lines. "Stay ready, Zareth," she said, "I don't think this will be an easy day."
They both knew, having lived through it before, the nature of the Roil. Like a body struggling with fever, the Roil was Zendikar's response to some deeper pain. The Roil was not the threat, though it could be terrible. The Roil was a warning.
The Magosi tumbled down. The steps continued down. The caravan, Akiri, and Zareth continued down, disappearing into the swirling mists that peeled off the Magosi and shrouded the steps in deep, humid fog.
#figure(image("004_The Magosi Steps/01.jpg", width: 100%), caption: [<NAME>, the Trickster | Art by: <NAME>], supplement: none, numbering: none)
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
The caravan shuddered to a halt somewhere above the midway point of the steps, not yet an hour into the journey. Here, the mist of the tumbling Magosi was all-encompassing, drenching both beast and person. In this high summer, what should have been a cooling fog blanketing the steps was instead a humid, sticky mess, blocking any view out from the switchbacks. With a high wind, the vista was magnificent, showing the full stretch of the lower Umara River Gorge winding from the Magosi to where it spilled into the Halimar, and the distant light of Sea Gate beyond the inland sea; on this rare windless day, the cliffside of the switchbacks dribbled with water. Opposite, a wall of mist showed only as far as the next switchback down. The oxen groaned and chuffed, and their handlers did their best to keep them calm. The roar of the waterfall was all-encompassing, surely as distressing to the caravanners as it was the oxen.
Akiri walked near the back of the caravan, talking with one of the merfolk there about Coralhelm and its cuisine—fish, shark, seaweed, crustaceans—what you would expect from a merfolk settlement (but, as the caravanner promised, unlike anywhere else. Better than Sea Gate's delicacies, even, as it was closer to the source). Akiri resolved to try a certain stall the caravanner recommended when she heard Zareth calling her name from somewhere up the line. She excused herself from the conversation and hustled up to where Zareth crouched, talking with the caravan leader and his retinue around a fallen, moaning ox. The creature lay across the narrow switchback, blocking the entirety of the passage, dividing the caravan in half.
"Broke an ankle," Zareth said. He offered Akiri a chunk of stone. "Looks like a loose cobble, probably eroded on account of all the wet."
Akiri winced, taking the cobblestone from Zareth. "Poor creature."
"Mmm," Zareth said. He looked at the ox, grim sympathy across his face. "They'll have to put it down, there's no way they can carry it out."
Even as he spoke, the caravan leader's slumped shoulders confirmed Zareth's speculation. The leader spoke with his retinue and directed them to start removing the goods from the beast's back. He turned, apologetic, to Akiri and Zareth. Behind him, one of his people moved to the head of the ox and with a quick, firm cut, put it to rest.
"We have to distribute its load out across the other beasts," he said, "and then dispose of the body."
Akiri nodded. "Do what you need, and let us know if we can help."
The caravan leader thanked her then turned back to his people, leaving Akiri and Zareth to stand aside and watch. The caravanners hurried, but unloading a laden ox under normal circumstances was slow going—unloading one that had fallen and scattered its cargo across a narrow, switchbacked stair next to a thundering waterfall was another task entirely.
Zareth rested against the cliffside wall and drank from his canteen. Akiri joined him, leaning with her arms crossed. They didn't talk, but watched the merfolk work instead.
"You've never been to Coralhelm?" Akiri asked Zareth.
"Not once," he said.
Akiri did not ask why. Not her place. Zareth offered her some of his water, she took a sip, and passed the canteen back.
A scream split the roar of the waterfall, followed moments later by a chorus of them, and the wild bleating of oxen. Merfolk at the fallen ox turned and started to flee from the head of the caravan, shouting for others to flee as well.
Akiri and Zareth stood from the wall, starting toward the commotion, then stopped, frozen by what they saw.
It did not make sense to Akiri; Zareth knew what the creature was but did not yet believe it. The size of the thing that loomed in from the swirling mist. The water dripping from what must be its tongue, probing forward from the fog. The dark shape of the creature's head obscuring the already diffuse sunlight, plunging the switchback into deep shadow. The appendage moved like low smoke creeping across the floor of a burning house, rolling forward with a grace not given to things that large, in defiance of what rules bound other living beings.
Akiri and Zareth pushed forward toward the trapped and fleeing merfolk, moving toward the reaching, naked muscle of the thing that remained hidden in the mist and roar of the fall.
"Keep that thing away from them," Akiri ordered Zareth. She loosed a loop of line from her pack and attached it to her slinger's harness, then drew the Makindi-kor hook Zareth had given her.
Zareth drew his twin blades. "I don't think we can fight this, Akiri."
"We have to try," Akiri said. She coiled, sprinted, and then leapt off the switchback, flying out into the open air and swirling mist to face the thing that waited beyond.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
How would Akiri even begin to describe the monster that lurked behind the mist? Could she encompass its great bulk in a thought? The number of teeth that lined its maw? It was far too large; instead, she saw only moments of the coiling beast, and knew it to be a kind of serpent, one as large as the mighty river in which it hid.
The falling water of the Magosi exploded to steam as it drummed off the titan's sinewy body. It should not have been able to move as it did, flowing up and down the Magosi without effort. This was a beast of legend, some #emph[thing] that defied classification and stood alone, a being unlike any other, without community or kin. A world unto itself.
Is this what the Roil had warned them of this humid morning? Or was this thing, this colossal serpent, whose body stretched hundreds of feet up from some unseen pool at the Magosi's base, the Roil itself in terrible, physical form?
The serpent drew its head back from the steps, tongue constricting a pair of merfolk who reached out to her before it swallowed them. Was this serpent a natural beast hidden for eons in the deep heart of Zendikar? Or was it another thing imprisoned and released during the Battle, dumped on this world to plague it? Did it matter to the people that it swallowed? The serpent plunged its head back into the switchback steps, hungry, searching for more.
The answer did not matter, Akiri realized; only the moment.
Akiri swung via an unseen anchor, having thrown her lead hook into the swirling torrent of the Magosi, trusting that the ancient tool would find purchase somewhere behind the water. She left her long knife securely strapped to her hip—she needed both hands free for this kind of line-slinging—and saw on her first pass around the monster that she would have to get close to this creature in order to wound it: its dorsal breadth was armored in thick, mucous-slick hide, split by rigid, spearpoint-tipped fins. Its endless coiling in the waterfall hid its belly and made it impossible to strike in the thundering column of the Magosi. Akiri, unlike the serpent, was still bound by gravity—she could fly by line, but if she swung too close to the falls, she had little doubt that the water would tear her down.
Akiri reached the end of her swing, alighting on an outcropping on the opposite side of the Magosi, slightly above the level of the switchback she had leapt from. She pressed her forehead to the rock, lips not an inch from the damp stone. The day's heat still radiated from the cliff face. The bass rumble of the water pounding into the rock somewhere far below could be heard even this high up.
The screams. Akiri could hear the caravanners and their oxen screaming. That brought her back—
#emph[To Sea Gate's umbral night, and the terror there. The enemy was silent even in death. Her sword buried in the center mass of some wriggling thing, and it spat ichorous blood out on her as it died and didn't make a sound. But the screams of her comrades echoed and clashed with the waves and roar of high magic.]
#emph[—] to the present with sharp purpose.
She can strike the head, maybe find an eye—surely the serpent has eyes—or some other soft spot in the creature's thick hide. She can sink her lead anchor in the cliff face across the Magosi, swing with both arms, and land on the creature's back. Once there, she can find a way under its guard: she might not kill it, but all she needs to do is buy enough time for the merfolk to flee.
Akiri turns around on the outcrop, braces, and jumps. With peerless grace, she throws her lead hook, aiming for an anchor point she sighted on her swing across. There is a weightless moment where Akiri fears that her hook will miss, or that even if it hits, it will fail to bite, and the single-point would skitter off the rock, and she would fall. She worries that time would slow during that fall, that she would feel every whip of tearing air as she plummets. She'd rather not fall at all, but if she's going to, then please let it be fast.
Her worries vanish as her hook hits, bites, and holds her swing through the misty air. Hurtling forward now, she tucks her knees up, twitches free her lead hook, and with her free hand, draws her long knife.
Momentum carries her up and forward and she flies, shouting a war cry that slips primal from deep in her gut—that fear place, that anger place, that place crying out through her for some kind of stop to the pain of this world—and then she hits the back of the serpent, holding on to it by sheer white-knuckle obstinance and honed reflexes.
She throws her free hook up around a nearby spine protruding from the serpent's back, where it loops over itself before catching its own line. Akiri wraps the line around her forearm, securing herself to the back of the serpent, able to move a radius around the spine as big as the slack she lets slip.
Knife in hand, Akiri springs gracefully forward, the crampons on her light boots biting through the serpent's mucosal sheathe just enough to give purchase. The colossus does not notice; it is still focused on the caravan. The thundering waterfall threatens to sweep Akiri from the back of the serpent as she struggles up its body toward its head. She does not look down—she knows it is far, far too far—as being thrown certainly means the death of everyone upon the switchback, and #emph[seeing] the vanishing distance is too much; the serpent moves under her, languid almost, its colossal form rising up the falling Magosi without any apparent effort. Akiri drops to her knees, holds fast to her anchor, and wedges her knife deep as she can into the serpent's integument. This seems to have some kind of an effect: the bloodless wound twitches closed and snaps the blade of her knife in two, easy as one would break a twig.
Akiri holds on. The serpent rises into the falling column of the Magosi. The water hammers down, buffeting her. All she can hear is the roar—the roar of the world, of the beast itself, of #emph[pain] unimaginable and, cruelly, not endless, but ageless—before the segment of the serpent, she clings to burst free of the water. It is as if Zendikar itself attacks her: the world's anger is in the wind of the falling river that hammers her, the bitter cold, and the beast itself.
Akiri drags herself forward. Holding her anchored radial line taught, she looses a free hook and flings it forward, catching a spine closer to its head. Anchored in two places, Akiri searches for a way forward and finds it: there, perhaps forty feet ahead, are the rills and ridges of the serpent's dorsal beak, the upper part of its wicked maw—a forest of handholds and hook-anchors for her to find purchase, and surely vulnerable parts for her to wound in her effort to drive the serpent away from the caravan and—
Zareth. She hopes he is alive, she hopes he can save those Merfolk still trapped on the stair. Akiri sheathes her broken knife and scrambles up the rising, coiling, writhing back of the titan serpent, pulling hand over hand up her newly set line. A moment at her next anchor to catch her breath, to unhook her radial and sight her next point, then to throw—
#emph[And her line caught the anchor. Akiri grinned. Her first. "Good," the slinger captain nodded, her voice a gravel-tint growl. "See it set? Give it a pull to be sure. Put all of your weight on it, kor; you need to trust the line will hold you up!"]
—and climb once more. Hand over hand. Find grip wherever you can. The stink of the serpent this close to its head disorients her. A wind named Rot and Hunger beats against her, a swirling, nauseating gale, but still Akiri climbs on; this far up, every movement of the creature threatens to throw her. How many sizes larger than her is just the head of the serpent? Surely, if it could swallow one of the merfolk's oxen whole, it could devour her without noticing.
Akiri holds on as the serpent lunges once more at the switchbacks, snapping up an ox. It pulls back, dragging a tangle of merfolk with it. They fall before Akiri can do anything to help them, their screams lost in the roar of the Magosi.
Everything lost in the roar of the Magosi.
Akiri draws her broken knife, her target spotted: Eyes. Black, featureless orbs peering out from alongside its mouth, at least two on the side that she could see, likely mirrored on the side she could not. A strike there to blind it, to distract it, to send it reeling back from the switchbacks and to the depths behind the Magosi—that was the plan.
Akiri does not see the second head rising from the base of the mighty tumbling waterfall. Smaller, but still larger than her, it moves swiftly up against a current that should have battered it to pulp, mouth yawning open.
The serpent had not ignored Akiri. To the contrary, during her heroic struggle, it had watched her from below with its second head, and whether cruel or curious, it had allowed her to get this close before striking.
Akiri raises her broken knife to strike, but before she can, it is slapped from her hand by the thick, stinking tongue of the serpent's second head. She turns in time to see it lunge for her—fangs the size of her forearm, white and bloodless gums, a gullet lined with smaller teeth—and is saved only by her preternatural reflexes.
Akiri jumps, keen eyes sighting an anchor she can fly from.
The second mouth catches her in mid-air, teeth and buccal barbs skittering off her armor. Akiri cries out in surprise, and then fear, and loses her anchor.
The second mouth flings her to the side, into the open air.
Akiri is no longer flying.
Akiri is falling.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
#figure(image("004_The Magosi Steps/02.jpg", width: 100%), caption: [Verazol, the Split Current | Art by: Daarken], supplement: none, numbering: none)
Zareth knows the name of the serpent: Verazol. All the merfolk in the caravan recognized it as soon as its head loomed in from the mist. Verazol, the Scourge of the Umara, the demon of the Magosi, the death of the Halimar. He remembers the little coral statuettes of Verazol some merfolk keep in their homes; as a child his family had one as well, back when merfolk had homes and not only places to live.
Verazol was a legend, a myth, a god to some. They can't stop it: try to kill a river or destroy an ocean. Raise your arm and strike down a world. Sure, there were some who could do that—
#emph[A night of fever and ash dust lit only by fire and the chromatic explosions high above, each blast like a dawn in a heartbeat.]
#emph[—] but not Zareth, and even with all her grace and skill, not Akiri.
So Zareth runs. He scrambles back up the switchback, away from Verazol's lashing tongue, shoving some straggling merfolk before him.
"Leave it!" Zareth cries, hauling the merfolk away from their frantic attempts to turn their oxen around. "Leave it! Run!"
The oxen bleat in panic, stumbling backwards. Zareth has enough space to press himself into the cliff face and avoid their lumbering progress, but one of the merfolk is not so lucky. Zareth reaches for the fallen merfolk, but Verazol's tongue snaps forward from the mist, a rippling trunk of steaming muscle, and snatches the fallen caravanner.
Zareth takes a step back from where the fallen caravanner had been not seconds before. The Magosi roars in its thunderous, endless tumbling. Running makes sense, but for one soaring reason:
#emph[Akiri.]
She is still out there, somewhere, trying to fight this monster.
Zareth turns to face the mist behind which the legendary serpent lurks. He can't leave his friend again, even if he was afraid—even if they couldn't win this fight, he would fight by her side.
#emph[To be a bloom of the coming spring.]
With almost deliberate care, Verazol probes its head in from the waterfall mist. The tip of its beak parts the water like the armored keel of a ship, gouged and scarred by legends and beasts that it had consumed in years long gone. Zareth's knives, deadly at their scale, are useless splinters against Verazol. Still, he raises them, and then stops. Somehow, through the roaring water, he hears a sound that chills him to the bone. A horrible sound, colder than any brine depth or howling wind.
Akiri, screaming.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
Akiri's first fall was from a short height to a soft mattress stuffed with raw lambswool. This was a planned fall, the first part of any line-slinger's training. Learn to feel what #emph[falling] feels like.
Her second fall came along a slingers' practice course in the far north of Tazeem. Sturdy anchors lined both sides of the shallow canyon, which was filled with still and deep water, a lake fed by numerous natural springs. There, Akiri learned how to suppress and—in time—ignore the fear of falling for the precious seconds one had at the #emph[top] of a fall. At height, should an anchor fail, a line snap, or a throw miss, you had a window of time to save yourself; slingers learned not to waste that time being afraid.
Her third fall—not counting the hundreds she endured in that distant canyon—was her first real fall. One hundred feet up the face of a sheer escarpment in the Bulwark, chasing down a band of skilled raiders. She was upon them when the kitesail she wore on her back caught a blast of the stiff Bulwark updraft, snapped its locks, and flung her into the air. To this day, she refused to wear a kitesail: yes, it had saved her from that fall, allowing her to glide safely to the ground once she regained control of it, but it had thrown her from safety first.
Her fourth fall was this one.
She doesn't panic (she does, but she tamps down on the panic, suppressing it with decades of training and gut-level experience).
She sights her closest feature (the wet, mist-shrouded switchback steps next to the Magosi. The serpent's body slides in and out from the switchbacks and the waterfall column. She doesn't have much room to work with).
She throws her hook (twenty feet? Thirty? A long throw, in any case).
It bites, and Akiri holds through the swing that follows, slamming into the switchbacks well below the caravan and the bulk of the serpent's body, still some hundred feet above the gorge floor. Winded, she manages as gracefully as she can to untangle herself from the line and scoot back from the edge. A quick inventory shows nothing broken, but her legs are covered in cuts and barbs torn from inside the smaller mouth of the serpent. She pulls the barbs out and tosses them aside, ignoring the pain. She can walk, and once she dresses these wounds, she can start up the switchbacks to—
The air changes. Cold when she landed, the air suddenly runs hot and thick with reek.
Akiri looks up from her triage.
The main head of the serpent looms down from above, plunging Akiri into shadow. She reaches for her knife, but stops, remembering she'd lost it in the fall.
With nothing, Akiri freezes.
The maw yawns wide.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
Zareth slides to a stop at the edge of the switchback, leaning over as far as he dares, hoping as much as he dares that Akiri made it. What he sees send a curse tumbling from him, snatched away by the high cliff wind.
Verazol has Akiri cornered. Her swing took her to a switchback about forty feet below, and now the larger head of the great serpent hovers just level with her, its titanic body spilling and undulating out into the open air. Worse, Verazol's second head made for them, smaller but no less monstrous at Zareth's scale.
Zareth steps back from the edge. He curses. He bought the caravanners some time, but buying them time would not stop Verazol from attacking until it had eaten its fill. Alone, he didn't stand a chance against the legendary serpent; together, he and Akiri didn't stand a chance, but they could at least make it out alive.
A distraction. Something to distract Verazol so they could escape. One of the dead oxen, already near the edge of the switchback.
Zareth curses again, paces, curses at the terrible plan forming. He slams his knives into their scabbards, clips them secure, and claps his hands.
"You," he calls to a group of merfolk. "The second head is coming. Help me with this. We'll distract it so we can run," he cries, pointing to the dead ox.
The caravanners hesitate, but Zareth had protected them, so as one, they hurry to help. With great effort, they shove the ox's corpse over the edge of the switchback. It tumbles, end over end, and slams into Verazol's main head, bouncing off to continue its long, long fall. Verazol's main head screeches, rears back, and looks directly up at them.
Zareth rolls back from the edge, pushing himself up into a standing position. The merfolk start at first to talk concernedly, then to shout, then to scream, as Verazol's main head rises from below. Serrated mouth open wide, breath a furnace-hot blast, Zareth sees in Verazol the rage of Zendikar incarnate, twisted by the terrible #emph[things] that had been imprisoned here. The serpent's black and featureless eyes reflecting the unliving, aberrant Eldrazi—those terrible beings Zareth's people once called gods—and the Roil. The prison and the prisoner, both irrevocably poisoned by the other. Now it was his turn to face it, and he knew what he had to do.
Zareth tries to even out his breathing, to stay still and coiled as the merfolk around him run, panicking, trying to clamber over one another and get away. Zareth keeps his vision through the crowd on the movements of the great serpent, ready, waiting.
Verazol rears back and lunges forward.
Zareth sprints toward the serpent—two, maybe three steps, shouldering aside one merfolk caravanner who gets in his way—and then dives. Verazol's split maw scrapes by on either side of Zareth's leap, coming so close that barbs snag on his clothing, but do not catch him, do not stop him.
Zareth jumps into the open air and falls his first real fall.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
Akiri watches from below as the serpent lunges at the switchback. She cries out as the whole cliff face shakes, as the great gout of shattered rock and dust explodes out from the force of the titanic creature's strike. She watches in horror as merfolk and pieces of merfolk fall with the tumbling rock and shattered steps, as oxen and a spray of glittering trade goods and crafts bound for Coralhelm arc out into the open air.
Her cry strangles short when she sees him.
Zareth, falling.
He flashes past her silently. She sees his eyes are closed and that he has no slinger's harness or line. Akiri stumbles forward, ignoring the serpent as it gorges itself on the poor caravan above, and tumbles off the edge, hook and line in hand.
She falls, catching Zareth's outstretched hand, pulling him in close to brace just before her trailing line catches an anchor, jerking both to a breath-stealing halt.
They swing, both gasping for air, Akiri groaning in pain and Zareth silent. Somewhere far above, the terror gorges itself, but down here, it is just the two of them. They could not even see the body of the colossus; down here, an indeterminable distance to the ground, the roar of the Magosi was all-encompassing.
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
Some time later, Akiri realized Zareth was talking to her. She couldn't make out what he was saying through the obliterating sound of the Magosi. He shouted again, and Akiri could not hear. Finally, he put his lips to her ear, and spoke once more.
"I had no choice."
And Akiri knew he was right. She was furious, but Zareth was right, even if his reasoning began and ended at the day's tragedy. Zareth did not have a choice, she did not have a choice, none of them did; the serpent would have killed them had they stayed, would have killed everyone who didn't run from it. Zareth forced her hand, made her save him, and in doing so, gave her some cover from the shame. At least her friend was alive. At least they could still fight.
Akiri wanted to tell Zareth that it was okay, that he had done the right thing, but she could not, as there was no possible right thing for him to do, no space for anything more than brutal calculus; Zareth's choice meant their effort would continue, but his choice had been a terrible one, and he would carry with him the spirits of the dead he'd doomed. Akiri remained silent and held her friend as he sobbed like he did that dawn after the Battle. The same two people, again the only survivors.
"There was nothing else you could do," Akiri said, whispering to Zareth and herself. The brutal truth of this moment: in Zendikar, they did not have any choice but the grim options presented to them. To change their options, they would have to change the world.
The wind, some time later, drove the mist and heat and great serpent Verazol away.
Akiri and Zareth made it to the bottom of the Magosi. They waited a day, but no one else followed.
They avoided Coralhelm on the road back to Sea Gate.
|
|
https://github.com/ist199211-ist199311/homeworks-nss | https://raw.githubusercontent.com/ist199211-ist199311/homeworks-nss/master/common/template.typ | typst | #let cover_page(title: none, date: none) = {
set page("a4")
set text(12pt)
let kthblue = rgb("#2258a5")
show link: it => underline(stroke: 1pt + kthblue, text(fill: kthblue, it))
show heading: set block(above: 1.4em, below: 1em)
align(
center + horizon,
)[
#image("KTH_logo_RGB_bla.svg", height: 100pt)
#v(20pt)
#heading(outlined: false)[#title]
#heading(
outlined: false,
level: 2,
)[EP2500 Networked Systems Security]
#v(20pt)
#grid(columns: (50%, 50%), align(center)[
<NAME>\
#link("mailto:<EMAIL>")
], align(center)[
<NAME>\
#link("mailto:<EMAIL>")
])
#v(20pt)
#smallcaps[#date]
KTH Royal Institute of Technology
]
}
#let header(title: none, authors: []) = {
set text(10pt)
smallcaps[#title - EP2500 NSS HT23]
h(1fr)
smallcaps[<NAME>, <NAME>]
line(length: 100%, stroke: 0.5pt + rgb("#888"))
}
#let footer = {
set align(right)
set text(10pt)
line(length: 100%, stroke: 0.5pt + rgb("#888"))
[Page ]
counter(page).display("1 of 1", both: true)
}
#let setup_page(content) = {
set par(justify: true)
set heading(numbering: "1.1.")
content
}
|
|
https://github.com/typst-community/valkyrie | https://raw.githubusercontent.com/typst-community/valkyrie/main/src/assertions/comparative.typ | typst | Other | #import "../assertions-util.typ": assert-positive-type
/// Asserts that tested value is greater than or equal to argument
#let min(rhs) = {
assert-positive-type(rhs, types: (int,), name: "Minimum")
return (
condition: (self, it) => it >= rhs,
message: (self, it) => "Must be at least " + str(rhs),
)
}
/// Asserts that tested value is less than or equal to argument
#let max(rhs) = {
assert-positive-type(rhs, types: (int,), name: "Maximum")
return (
condition: (self, it) => it <= rhs,
message: (self, it) => "Must be at most " + str(rhs),
)
}
/// Asserts that tested value is exactly equal to argument
#let eq(arg) = {
assert-positive-type(arg, types: (int,), name: "Equality")
return (
condition: (self, it) => it == arg,
message: (self, it) => "Must be exactly " + str(arg),
)
}
/// Asserts that tested value is not exactly equal to argument
#let neq(arg) = {
assert-positive-type(arg, types: (int,), name: "Equality")
return (
condition: (self, it) => it != arg,
message: (self, it) => "Must not equal " + str(arg),
)
} |
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/math/accent_07.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Test accent size.
$tilde(sum), tilde(sum, size: #50%), accent(H, hat, size: #200%)$
|
https://github.com/maxgraw/bachelor | https://raw.githubusercontent.com/maxgraw/bachelor/main/apps/document/src/0-base/3-short.typ | typst | #set align(start + horizon)
#set heading(numbering: none, supplement: [Abschnitt])
= Kurzfassung
Diese Arbeit befasst sich mit der Konzeption und Entwicklung einer Augmented Reality Konstruktionsumgebung für Möbelsysteme auf Basis von WebXR. Ziel ist es, die Eignung von WebXR für die Entwicklung einer Augmented Reality Anwendung zu validieren und die User Experience sowie Anwendungsmöglichkeiten in der Möbelbranche zu untersuchen. Nach einer Analyse der aktuellen Augmented Reality Nutzung in der Möbelbranche und der technischen Grundlagen von WebXR und Augmented Reality wurde ein Konzept für die Anwendung entwickelt und implementiert. Die Benutzererfahrung wurde mit der User Experience Questionnaire Methode in einer Online-Studie evaluiert, die eine positive Bewertung der Anwendung ergab. Die Ergebnisse müssen jedoch kritisch betrachtet werden, da teilweise eine hohe Streuung festgestellt wurde. Dennoch kann die Anwendung als funktionale Grundlage für weitere Studien und Entwicklungen betrachtet werden.
#pagebreak() |
|
https://github.com/nafkhanzam/typst-common | https://raw.githubusercontent.com/nafkhanzam/typst-common/main/src/touying-themes/its-theme.typ | typst | #import "../common/style.typ": *
#import "touying.typ": *
#import "university.typ": *
#let its-theme(
title,
subtitle,
author: [<NAME>.],
institution: [
Department of Informatics \
Faculty of Intelligent Electrical and Informatics Technology \
Institut Teknologi Sepuluh Nopember
],
logo: image("its-logo.png", width: 4em),
copyright: [
#sym.copyright #datetime.today().year() All rights reserved
],
with-end: true,
..args,
body,
) = [
#show: university-theme.with(
config-info(
title: title,
subtitle: subtitle,
author: author,
institution: institution,
logo: logo,
copyright: copyright,
),
..args,
)
#show link: text.with(fill: rgb("#176B87"))
#show link: underline
#title-slide()
#body
#if with-end {
new-section-slide(level: 1, numbered: false)[End of #subtitle]
}
]
#let announcement(
title,
course,
lecturer: [<NAME>., M.T.],
datetime: [],
timelimit: [],
..args,
body,
) = [
#show: university-theme.with(
config-store(
footer-a: none,
footer-b: none,
footer-c: none,
),
config-page(height: auto),
..args,
)
#set text(size: .8em)
#sl[#title][
#align(center)[*#course*]
#entry-fields((
([*Lecturer*], [#lecturer]),
([*DateTime*], [#datetime]),
([*Timelimit*], [#timelimit]),
))
#body
]
]
|
|
https://github.com/jassielof/typst-templates | https://raw.githubusercontent.com/jassielof/typst-templates/main/upsa-bo/estudio-de-factibilidad/template/capítulos/6.localización y tamaño.typ | typst | MIT License | = Localización y Tamaño
== Localización
=== Macrolocalización
==== Método Seleccionado
==== Alternativas de Selección
==== Factores Estudiados
==== Calificación
==== Alternativas Seleccionadas
=== Microlocalización
==== Método Seleccionado
==== Alternativas
==== Factores
==== Calificaciones
==== Alternativa Seleccionada
== Tamaño
=== Mercado
=== Tecnología
=== Recursos Financieros
=== Disponibilidad de Materia Prima
=== Disponibilidad de Energía
=== Disponibilidad de Agua
=== Disponibilidad de Recursos Humanos
=== Tamaño del Terreno
=== Tamaño del Proyecto |
https://github.com/tingerrr/anti-matter | https://raw.githubusercontent.com/tingerrr/anti-matter/main/example/chapters.typ | typst | MIT License | #set heading(numbering: "1.")
= Chapter
== Section
=== Subsection
= Chapter
== Another Section
= Chapter
|
https://github.com/Mufanc/hnuslides-typst | https://raw.githubusercontent.com/Mufanc/hnuslides-typst/master/utils/colors.typ | typst | #let primary = rgb("#856651")
#let secondary = rgb("#757070")
// 背景的近似色，用于一些 dirty fix
#let background = rgb(235, 231, 222)
|
|
https://github.com/ivaquero/lang-speeches | https://raw.githubusercontent.com/ivaquero/lang-speeches/main/es%20-%20javier%20milei%20-%20davos.typ | typst | #import "@local/scibook:0.1.0": *
#show: doc => conf(
title: "La Reunión Anual del Foro Económico Mundial en Davos",
author: ("<NAME>"),
footer-cap: "",
header-cap: "Speech Collection",
outline-on: false,
lang: "en",
doc,
)
#tip[
Esta es una trasncripción de la sesión Discurso Especial de <NAME>, presidente de Argentina, que tuvo lugar durante la Reunión Anual del Foro Económico Mundial en Davos 2024.
]
Buenas tardes, muchas gracias
Hoy estoy acá para decirles que Occidente está en peligro. Está en peligro porque aquellos que supuestamente deben defender los valores de Occidente, se encuentran cooptados por una visión del mundo, que inexorablemente conduce al socialismo, y en consecuencia, a la pobreza.
Lamentablemente, en las últimas décadas, motivados por algunos deseos bienpensantes de querer ayudar al prójimo y otros por el deseo de querer pertenecer a una casta privilegiada, los principales líderes del mundo occidental han abandonado el modelo de la libertad por distintas versiones de lo que llamamos colectivismo.
Nosotros estamos acá para decirles que los experimentos colectivistas nunca son la solución a los problemas que aquejan a los ciudadanos del mundo, sino que, por el contrario, son su causa. Créanme, nadie mejor que nosotros los argentinos para dar testimonios de estas dos cuestiones.
Cuando adoptamos el modelo de la libertad, allá por el año 1860, en 35 años nos convertimos en la primera potencia mundial, mientras que cuando abrazamos el colectivismo, a lo largo de los últimos 100 años, vimos como nuestros ciudadanos comenzaron a empobrecerse sistemáticamente hasta caer en el puesto número 140 del mundo. Pero antes de poder dar esta discusión, sería importante que primero viéramos los datos que sustentan por qué no solo el capitalismo de libre empresa no solo es un sistema posible para terminar con la pobreza del mundo, sino que es el único sistema moralmente deseable para lograrlo.
Si consideramos la historia del progreso económico, podemos ver cómo desde el año cero hasta el año 1800, aproximadamente, el PBI per cápita del mundo prácticamente se mantuvo constante durante todo el período de referencia. Si uno mira un gráfico de la evolución del crecimiento económico a lo largo de la historia de la humanidad, uno estaría viendo un gráfico con la forma de un palo de hockey, una función exponencial, que se mantuvo constante durante el 90 por ciento del tiempo y se dispara exponencialmente a partir del siglo XIX. La única excepción a esta historia de estancamiento se dio a finales del siglo XV, con el descubrimiento de América. Pero salvando esta excepción, a lo largo de todo el período, entre el año cero y el año 1800, el PBI per cápita, a nivel global, se mantuvo estancado.
Ahora bien, no solo que el capitalismo generó una explosión de riqueza desde el momento que se adoptó como sistema económico, sino que, si uno analiza los datos, lo que se observa es que el crecimiento se viene acelerando a lo largo de todo el período.
Durante todo el período comprendido entre el año cero y el 1800, la tasa de crecimiento del PBI per cápita se mantuvo estable en torno al 0,02 por ciento anual. Es decir, prácticamente sin crecimiento. A partir del siglo XIX, con la Revolución Industrial, la tasa de crecimiento pasa al 0,66 por ciento. A ese ritmo para duplicar el PBI per cápita se necesitaría crecer durante 107 años.
Ahora bien, si observamos el período entre 1900 y 1950, la tasa de crecimiento se acelera al 1,66 por ciento anual. Ya no necesitamos 107 años para duplicar el PBI per cápita, sino 66. Y si tomamos el período comprendido entre 1950 y el año 2000, vemos que la tasa de crecimiento fue de 2,1 por ciento anual, lo que derivaría en que en solo 33 años podríamos duplicar el PBI per cápita del mundo. Esta tendencia, lejos de detenerse, se mantiene viva aún hoy. Si tomamos el período entre el año 2000 y el 2023, la tasa de crecimiento volvió a acelerar el 3 por ciento anual, lo que implica que podríamos duplicar nuestro PBI per cápita en el mundo en tan solo 23 años.
Ahora bien, cuando se estudia el PBI per cápita, desde el año 1800 al día de hoy, lo que se observa es que, luego de la Revolución Industrial, el PBI per cápita mundial se multiplicó por más de 15 veces, generando una explosión de riqueza que sacó de la pobreza al 90 por ciento de la población mundial.
No debemos olvidar nunca que para el año 1800, cerca del 95 por ciento de la población mundial vivía en la pobreza más extrema; mientras que ese número cayó al 5 por ciento para el año 2020, previo a la pandemia.
La conclusión es obvia: lejos de ser la causa de nuestros problemas, el capitalismo de libre empresa, como sistema económico, es la única herramienta que tenemos para terminar con el hambre, la pobreza y la indigencia a lo largo y a lo ancho de todo el planeta. La evidencia empírica es incuestionable.
Por eso, como no cabe duda de que el capitalismo de libre mercado es superior en términos productivos, la doxa de izquierda ha atacado al capitalismo por sus cuestiones de moralidad, por ser, según ellos, dicen sus detractores, que es injusto.
Dicen que el capitalismo es malo porque es individualista y que el colectivismo es bueno porque es altruista, con la ajena. En consecuencia, bregan por la justicia social. Pero este concepto, que desde el Primer Mundo se ha puesto de moda en la última época, en mi país es una constante del discurso político desde hace más de 80 años. El problema es que la justicia social no es justa, sino que tampoco aporta al bienestar general. Muy por el contrario, es una idea intrínsecamente injusta porque es violenta. Es injusta porque el Estado se financia a través de impuestos y los impuestos se cobran de manera coactiva. ¿Acaso alguno de nosotros puede decir que pagan los impuestos de manera voluntaria? Lo cual significa que el Estado se financia a través de la coacción y a mayor carga impositiva, mayor es la coacción, menor es la libertad.
Quienes promueven la justicia social parten de la idea de que el conjunto de la economía es una torta que se puede repartir de una manera distinta, pero esa torta no está dada, es riqueza que se va generando, en lo que por ejemplo <NAME> llama un proceso de descubrimiento de mercado. Si el bien o servicio que ofrece una empresa no es deseado, esa empresa quiebra a menos que se adecúe a lo que el mercado le está demandando. Si genera un producto de buena calidad a un buen precio, atractivo, le va a ir bien y va a producir más.
De modo que el mercado es un proceso de descubrimiento, en el cual el capitalista encuentra sobre la marcha el rumbo correcto. Pero si el Estado castiga al capitalista por tener éxito y lo bloquea en este proceso de descubrimiento, destruye sus incentivos, y las consecuencias de eso es que va a producir menos y la torta será más chica, generando perjuicio para el conjunto de la sociedad.
El colectivismo, al inhibir estos procesos de descubrimiento y al dificultar la apropiación de lo descubierto. ata al emprendedor de las manos y le imposibilita producir mejores bienes y ofrecer mejores servicios a un mejor precio. ¿Cómo puede ser, entonces, que desde la academia, los organismos internacionales, la política y la teoría económica se demonice un sistema económico que no solo ha sacado de la pobreza más extrema al 90 por ciento de la población mundial y lo hace cada vez más rápido, sino que además es justo y moralmente superior.
Gracias al capitalismo de libre empresa, hoy, el mundo se encuentra en su mejor momento. No hubo nunca, en toda la historia de la humanidad, un momento de mayor prosperidad que el que vivimos hoy. El mundo de hoy es más libre, más rico, más pacífico y más próspero que cualquier otro momento de nuestra historia. Esto es cierto para todos, pero en particular para aquellos países que son libres, donde respetan la libertad económica y los derechos de propiedad de los individuos. Porque aquellos países que son libres son 12 veces más ricos que los reprimidos. El decil más bajo de la distribución de los países libres vive mejor que el 90 por ciento de la población de los países reprimidos, tiene 25 veces menos cantidad de pobres en el formato estándar y 50 veces menos en el formato extremo. Y por si eso fuera poco, los ciudadanos de los países libres viven un 25 por ciento más que los ciudadanos de los países reprimidos.
Ahora bien, para entender qué venimos a defender es importante definir de qué hablamos nosotros cuando hablamos de libertarismo. Para definirlo retomo las palabras del máximo prócer de las ideas de la libertad de Argentina, el profesor <NAME> (hijo) que dice: “el libertarismo es el respeto irrestricto del proyecto de vida del prójimo, basado en el principio de no agresión, en defensa del derecho a la vida, a la libertad y a la propiedad, cuyas instituciones fundamentales son la propiedad privada, los mercados libres de intervención estatal, la libre competencia, la división del trabajo y la cooperación social”, donde solo se puede ser exitoso sirviendo al prójimo con bienes de mejor calidad a un mejor precio.
Dicho de otro modo, el capitalista, el empresario exitoso es un benefactor social que, lejos de apropiarse de la riqueza ajena, contribuye al bienestar general. En definitiva, un empresario exitoso es un héroe.
Este es el modelo que nosotros estamos proponiendo para la Argentina del futuro. Un modelo basado en los principios fundamentales del libertarismo: la defensa de la vida, de la libertad y de la propiedad.
Ahora bien, si el capitalismo de libre empresa y la libertad económica han sido herramientas extraordinarias para terminar con la pobreza en el mundo, y nos encontramos hoy en el mejor momento de la historia de la humanidad, vale la pena preguntarse: ¿por qué digo entonces que Occidente está en peligro?
Digo que occidente está en peligro justamente porque en aquellos países que debiéramos defender los valores del libre mercado, la propiedad privada y las demás instituciones del libertarismo, sectores del establishment político y económico, algunos por errores en su marco teórico y otros por ambición de poder, están socavando los fundamentos del libertarismo, abriéndole las puertas al socialismo y condenándonos potencialmente a la pobreza, a la miseria y al estancamiento.
Porque nunca debe olvidarse que el socialismo es siempre y en todo lugar un fenómeno empobrecedor que fracasó en todos los países que se intentó. Fue un fracaso en lo económico. Fue un fracaso en lo social. Fue un fracaso en lo cultural. Y además asesinó a más de 100 millones de seres humanos.
El problema esencial de Occidente hoy es que no solo debemos enfrentarnos a quienes, aun luego de la caída del Muro y la evidencia empírica abrumadora, siguen bregando por el socialismo empobrecedor, sino también a nuestros propios líderes, pensadores y académicos que, amparados en un marco teórico equivocado, socavan los fundamentos del sistema que nos ha dado la mayor expansión de riqueza y prosperidad de nuestra historia.
El marco teórico al que me refiero es el de la teoría económica neoclásica, que diseña un instrumental que, sin quererlo, termina siendo funcional a la intromisión del Estado, el socialismo, y la degradación de la sociedad. El problema de los neoclásicos es que como el modelo del que se enamoraron no mapea contra la realidad, atribuyen el error a supuestos fallos del mercado en vez de revisar las premisas de su modelo.
So pretexto de un supuesto fallo de mercado, se introducen regulaciones que lo único que generan es distorsiones en el sistema de precios, que impiden el cálculo económico, y en consecuencia el ahorro, la inversión y el crecimiento.
Este problema radica esencialmente en que ni siquiera los economistas supuestamente libertarios comprenden qué es el mercado, ya que si se comprendiera, se vería rápidamente que es imposible que exista algo así como un fallo del mercado.
El mercado no es una mera descripción gráfica de una curva de oferta y otra de demanda en un gráfico. El mercado es un mecanismo de cooperación social donde se intercambian voluntariamente derechos de propiedad. Por lo tanto, dada esa definición, hablar de fallo del mercado es un oxímoron. No existe fallo de mercado.
Si las transacciones son voluntarias, el único contexto en el que puede haber un fallo de mercado es si hay coacción. Y el único con la capacidad de coaccionar de manera generalizada es el Estado, que tiene el monopolio de la violencia. En consecuencia, si alguien considera que hay un fallo de mercado, les recomendaría que revisen si hay intervención estatal en el medio. Y si encuentran que no hay intervención estatal en el medio, les sugiero que hagan de nuevo el análisis porque definitivamente está mal. Los fallos de mercado no existen.
Un ejemplo de los supuestos fallos del mercado que describen los neoclásicos son las estructuras concentradas de la economía. Sin embargo, sin funciones que presenten rendimiento creciente a escala, cuya contrapartida son las estructuras concentradas de la economía, no podríamos explicar el crecimiento económico desde el año 1800 hasta hoy.
Fíjense que interesante. Desde el año 1800 en adelante, con la población multiplicándose más de 8 o 9 veces, el producto per cápita creció más de 15 veces. Existen rendimientos crecientes, eso llevó la pobreza extrema del 95% al 5%. Sin embargo, esa presencia de rendimientos crecientes implican estructuras concentradas, lo que se llamaría un monopolio.
¿Cómo puede ser que algo que haya generado tanto bienestar para la teórica neoclásica es un fallo de mercado? Economistas neoclásicos, salgan de la caja. Cuando el modelo falla, no hay que enojarse con la realidad, hay que enojarse con el modelo y cambiarlo.
El dilema que enfrenta el modelo neoclásico es que dicen querer perfeccionar el funcionamiento del mercado atacando lo que ellos consideran fallos, pero al hacerlo no sólo le abren las puertas al socialismo, sino que atentan contra el crecimiento económico.
Ejemplo, regular monopolios, destruirle las ganancias, y destrozar los rendimientos crecientes automáticamente destruiría el crecimiento económico.
Dicho de otro modo, cada vez que ustedes quieran hacer una corrección de un supuesto fallo de mercado, inexorablemente, por desconocer lo que es el mercado o por haberse enamorado de un modelo fallido, le están abriendo las puertas al socialismo y están condenando a la gente a la pobreza.
Sin embargo, frente a la demostración teórica de que la intervención del Estado es perjudicial, y la evidencia empírica de que fracasó - porque no podía ser de otra manera- la solución que propondrán los colectivistas no es mayor libertad sino que es mayor regulación, generando una espiral descendiente de regulaciones hasta que todos seamos más pobres, y la vida de todos nosotros dependa de un burócrata sentado en una oficina de lujo.
Dado el estrepitoso fracaso de los modelos colectivistas y los innegables avances del mundo libre, los socialistas se vieron forzados a cambiar su agenda. Dejaron atrás la lucha de clases basada en el sistema económico para reemplazarla por otros supuestos conflictos sociales igual de nocivos para la vida en comunidad y para el crecimiento económico.
La primera de estas nuevas batallas fue la pelea ridícula y antinatural entre el hombre y la mujer.
El libertarismo ya establece la igualdad entre los sexos. La piedra fundacional de nuestro credo dice que todos los hombres somos creados iguales, que todos tenemos los mismos derechos inalienables otorgados por el creador, entre los que se encuentran la vida, la libertad y la propiedad.
En lo único que devino esta agenda del feminismo radical es en mayor intervención del Estado para entorpecer el proceso económico, darle trabajo a burócratas que no le aportan nada a la sociedad, sea en formato de ministerios de la mujer u organismos internacionales dedicados a promover esta agenda.
Otro de los conflictos que los socialistas plantean es el del hombre contra la naturaleza. Sostienen que los seres humanos dañamos el planeta y que debe ser protegido a toda costa, incluso llegando a abogar por mecanismos de control poblacional o en la agenda sangrienta del aborto.
Lamentablemente, estas ideas nocivas han impregnado fuertemente en nuestra sociedad. Los neomarxistas han sabido cooptar el sentido común de occidente. Lograron esto gracias a la apropiación de los medios de comunicación, de la cultura, de las universidades, y sí, también de los organismos internacionales. Este último caso es el más grave, talvez, porque se trata de instituciones que tienen enorme influencia en las decisiones políticas y económicas de los países que integran esos organismos multilaterales.
Por suerte, somos cada vez más los que nos atrevemos a levantar la voz. Porque vemos que, si no combatimos frontalmente estas ideas, el único destino posible es que cada vez vamos a tener más Estado, más regulación, más socialismo, más pobreza, menos libertad, y, en consecuencia, peor nivel de vida.
Occidente, lamentablemente, ya comenzó a transitar este camino. Sé que a muchos les puede sonar ridículo plantear que Occidente se ha volcado al socialismo. Pero sólo es ridículo en la medida que uno se restringe a la definición económica tradicional del socialismo, que establece que es un sistema económico donde el Estado es el dueño de los medios de producción.
Esta definición debería ser, para nosotros, actualizada a las circunstancias presentes. Hoy los Estados no necesitan controlar directamente los medios de producción para controlar cada aspecto de la vida de los individuos.
Con herramientas como la emisión monetaria, el endeudamiento, los subsidios, el control de la tasa de interés, los controles de precios y las regulaciones para corregir los supuestos “fallos de mercado”, pueden controlar los destinos de millones de seres humanos.
Así es como llegamos al punto en el que, con distintos nombres o formas, buena parte de las ofertas políticas generalmente aceptadas en la mayoría de los países de Occidente son variantes colectivistas. Ya sea que se declaren abiertamente comunistas, fascistas, nazis, socialistas, socialdemócratas, nacional, socialistas, demócratas, cristianos, keynesianos, neo keynesianos, progresistas, populistas, nacionalistas o globalistas.
En el fondo no hay diferencias sustantivas: todas sostienen que el Estado debe dirigir todos los aspectos de la vida de los individuos. Todas defienden un modelo contrario al que llevó a la humanidad al progreso más espectacular de su historia.
Nosotros venimos hoy aquí a invitar a los demás países de Occidente a que retomemos el camino de la prosperidad. La libertad económica, el gobierno limitado y el respeto irrestricto de la propiedad privada son elementos esenciales para el crecimiento económico.
Este fenómeno de empobrecimiento que produce el colectivismo no es una fantasía. Ni tampoco fatalismo. Es una realidad que los argentinos conocemos muy bien de hace por lo menos 100 años.
Porque ya lo vivimos. Ya pasamos por esto. Porque como dije antes, desde que decidimos abandonar el modelo de la libertad que nos había hecho ricos, estamos atrapados en una espiral descendiente en donde cada día somos más pobres.
Eso es: ya lo vivimos nosotros. Y estamos acá para alertarlos acerca de lo que puede pasar si los países de Occidente, que se hicieron ricos con el modelo de la libertad, continúan por este camino de servidumbre.
El caso argentino es la demostración empírica de que no importa cuán rico seas, cuantos recursos naturales tengas, no importa cuán capacitada esté la población, ni cuan educada sea, ni cuantos lingotes de oro haya en las arcas del banco central.
Si se adoptan medidas que entorpecen el libre funcionamiento de los mercados, la libre competencia, los sistemas de precios libres, si se entorpece el comercio, si se atenta contra la propiedad privada, el único destino posible es la pobreza.
Para finalizar, quiero dejarle un mensaje a todos los empresarios aquí presentes y a los que nos están mirando desde todos los rincones del planeta.
No se dejen amedrentar ni por la casta política ni por los parásitos que viven del Estado. No se entreguen a una clase política que lo único que quiere es perpetuarse en el poder y mantener sus privilegios.
Ustedes son benefactores sociales. Ustedes son héroes. Ustedes son los creadores del periodo de prosperidad más extraordinario que jamás hayamos vivido. Que nadie les diga que su ambición es inmoral. Si ustedes ganan dinero es porque ofrecen un mejor producto a un mejor precio, contribuyendo de esa manera al bienestar general.
No cedan al avance del Estado. El Estado no es la solución. El Estado es el problema mismo.
Ustedes son los verdaderos protagonistas de esta historia, y sepan que a partir de hoy, cuentan con Argentina como un aliado incondicional.
Muchísimas gracias y Viva la libertad!
|
|
https://github.com/ymgyt/techbook | https://raw.githubusercontent.com/ymgyt/techbook/master/programmings/js/typescript/specification/primitive.md | markdown | # primitive
* propertyをもたない
* `null.toString()`みたいなことはできない
* autoboxingされると、primitiveがobjectになる
* `name.length`
## primitiveの種別
* boolean
* `true` or `false`
* number
* `1`や`0.2`
* string
* undefined
* null
* symbol
* bigint
### number
* `Nan`
* `Infinity`
### string
#### template literal
```typescript
const count = 100;
console.log(`current count: ${count}`); // => current count: 100
```
### null
* `typeof null`で`"object"`が返ってくる
### undefined
```typescript
let name;
console.log(name);
function func() {}
console.log(func());
const obj = {};
console.log(obj.name);
const arr = [];
console.log(arr[1]);
```
* 変数が未初期化
* 戻り値のない関数の戻り値
* objectに存在しないproperty
* 配列に存在
|
|
https://github.com/SergeyGorchakov/russian-phd-thesis-template-typst | https://raw.githubusercontent.com/SergeyGorchakov/russian-phd-thesis-template-typst/main/thesis.typ | typst | MIT License | #import "lib.typ": *
// Определение шаблона
#show: template.with(
// Это может быть удалено, если не используется программный код:
languages: (
rust:
(name: "Rust",
icon: icon(image("images/brand-rust.svg")),
color: rgb("#CE412B")),
python:
(name: "Python",
icon: icon(image("images/brand-python.svg")),
color: rgb("#3572A5"))
),
logo: image("./images/logo.svg",width: 50%),
)
// Основные части документа
#include "./parts/intro.typ"
#show heading.where(level:1): set heading(numbering: "Глава 1.")
#include "./parts/part1.typ"
#include "./parts/part2.typ"
#include "./parts/part3.typ"
// Выключить нумерацию выходных данных
#show heading: set heading(numbering:none)
// Заключение
#include "./parts/conclusion.typ"
// Выходные данные
= Список сокращений и условных обозначений
#import "./common/acronyms.typ": acronyms-entries
#import "./common/symbols.typ": symbols-entries
#print-glossary(acronyms-entries+symbols-entries)
= Словарь терминов
#import "./common/glossary.typ": glossary-entries
#print-glossary(glossary-entries)
#bibliography(title: "Список литературы", ("./common/external.bib","./common/author.bib"), style: "gost-r-705-2008-numeric")
#show outline: set heading(outlined: true)
#outline(title: "Список рисунков", target: figure.where(kind: image))
#outline(title: "Список таблиц", target: figure.where(kind: table))
// Приложения
#include "./parts/appendix.typ" |
https://github.com/DamienFlury/summaries | https://raw.githubusercontent.com/DamienFlury/summaries/main/DigCod/main.typ | typst | #import "@preview/ctheorems:1.1.2": *
#show: thmrules
#let definition = thmbox("definition", "Definition", inset: (x: 1.2em, top: 1em))
#let theorem = thmbox("theorem", "Theorem", fill: rgb("#eeffee"))
#let proof = thmproof("proof", "Beweis")
#let example = thmplain("example", "Beispiel").with(numbering: none)
#set text(lang: "de", region: "CH")
#set par(justify: true)
#set heading(numbering: "1.1")
#set math.equation(numbering: "(1)")
#let colred(x) = text(fill: red, $#x$)
#align(center, [#text(size: 22pt, weight: "bold", [Digitale Codierungen]) \ Zusammenfassung \ <NAME> \ \ Juni/Juli 2024])
#v(1cm)
#outline()
= Das Stellenwertsystem
== Begriffe
- Nibble: Binärzahl mit 4 Bit
- Oktett: Binärzahl mit 8 Bit (Byte)
== Polynomschreibweise
$d_n = "Ziffer" in Z_n, R^n = "Wertigkeit"$
$N_n = d_n R^n + d_(n-1) R^(n-1) + ... + d_1 R^1 + d_0 R^0$
#example[
$123 = 1 dot 10^2 + 2 dot 10^1 + 3 dot 10^0$
]
Basis $<=>$ Wertigkeit
Potenz $<=>$ Position der Stelle
== Dezimalsystem
$R_10 = 10 "(Basis)"; Z_10 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}$
== Dualsystem
$R_2 = 2 "(Basis)"; Z_2 = {0, 1}$
=== Umerchnung ins Dualsystem
#[
#set math.cases(delim: "|")
$ arrow.t cases(25 / 2 &= 12 &"Rest 1", 12 / 2 &= 6 &"Rest 0", 6 / 2 &= 3 &"Rest 0", 3 /2 &= 1 &"Rest 1", 1 / 2 &= 0 &"Rest 1") $
$= 11001$
]
=== Umrechnung einer Dezimalzahl ins Dualsystem
#[
#set math.cases(delim: "|")
$ arrow.b cases(0.75 dot 2 &= 1.5 &"Stelle 1", 0.5 dot 2 &= 1 &"Stelle 1", 0 dot 2 &= 0 &"Stelle 0") $
$= 0.11$
]
=== Beispiel
$N_2 &= 110$
$N_2 &= 1 dot 2^2 + 1 dot 2^1 + 0 dot 2^0 = 4_d + 2_d = 6_d$
== Oktalsystem
$R_8 = 8 "(Basis)"; Z_8 = {0, 1, 2, 3, 4, 5, 6, 7}$
=== Beispiel
$N_8 = 110$
$N_8 = 1 dot 8^2 + 1 dot 8^1 + 0 dot 8^0 = 72_d$
== Kommazahlen
$RR_10 = 110.13$
$N_10 = 1 dot 10^2 + 1 dot 10^1 + 0 dot 10^0 + 1 dot 10^(-1) + 3 dot 10^(-2)$
$RR_2 = 101.110$
$N_2 = 1 dot 2^2 + 0 dot 2^1 + 1 dot 2^0 + 1 dot 2^(-1) + 1 dot 2^(-2) + 0 dot 2^(-3) = 5.75_d$
== Subtrahieren durch Addieren
Annahme: Bei 1000 gibt es einen *Überlauf*.
$753 + 247 = 0$, daraus folgt $753 equiv -247$
Somit ist $620 - 247 equiv 620 + 753 = 1373 equiv 373$.
=== Additive Zahl berechnen
Gesucht: Additive Zahl von -247 (, also 753).
$
999 - 247 &= 752 "(Neunerkomplement)" \
752 + 1 &= 753 "(Zehnerkomplement)"
$
#example[$ 760 - 233 &= ? \
999 - 233 &= 766 \
760 + 767 &= 1527 &"Überlauf bei 1000" \
527 &= 760 - 233 $]
#example[Zweiersystem][
$ 10110 - 01010 &= ? \
11111 - 01010 &= 10101 \
10110 + 10110 &= 101100 &"Überlauf" \
10110 - 01010 &= 01100 $
]
#example[Negatives Resultat][
$ 0101 &- 0110 \
&-0110 => 1001 + 1 = 1010 \
0101 &+ 1010 = 1111 $
$-1$ ist also $1111$
]
== Dualzahlen
$-1$:\
$1 = 0001_2$. \
Einerkomplement: $1110_2$ \
Zweierkomplement: $1111_2 = -1$
== Multiplikation
=== Unsigned
Die unsigned Multiplikation ist eine Summe von Links-Shifts.
$a = 3, b = 5$
$
0011 dot 0101 \
&= 0101 + 1010 \
&= 1111 = 15_d
$
Oder durch Polynommultiplikation:
$ (2^1 + 2^0) dot (2^2 + 2^0) = 2 dot 4 + 2 dot 1 + 1 dot 4 + 1 dot 1 = 15 $
=== Signed
Die signed Multiplikation funktioniert analog zur unsigned Multiplikation, aber wenn einer der Operanden negativ ist, muss das Zweierkomplement davon gebildet werden:
#example[Signed][
$1101 * 0111$ ($(-3) dot 7 = -21$)
$1101$ ist negativ, das Zweierkomplement ist $0011$.
$0011 * 0111 = 0111 + 01110 = 010101$. Das Zweierkomplement davon ist $101011$ (= -21).
]
== Indexschreibweise
$b = 1010$
$b_3 = 1, b_2 = 0, b_1 = 1, b_0 = 0$
$b_(3..1) = 101, b[3..1] = 101$
== Subtrahieren
=== Betrag mit Vorzeichen
$
5 - 1 \
5 = 0101 \
-1 = 1001 \
0101 - 0001 = 0100 = 4
$
=== Einerkomplement (b-1)
Von negativen Zahlen wird das Einerkomplement gebildet. Gibt es nach Addition einen Überlauf, muss noch +1 gerechnet werden.
$
5 - 1 \
5 = 0101 \
1 = 0001, -1 = 1110 \
0101 + 1110 = 10011 \
=> "Überlauf" => 0011 + 1 = 0100 = 4
$
=== Zweierkomplement (b-Komplement)
$
5 - 1 \
5 = 0101 \
1 = 0001, -1 = 1111 \
0101 + 1111 = 10100 => "Überlauf" => 0100 = 4
$
== Allgemeine Berechnung des b-Komplements
$
C_(b, n)(N) = b^n - N
$
- n = Anzahl Stellen
- b = Basis
- N = Zahl, von welcher das Komplement gebildet werden soll
Beispiel:
- $C_(8, 2)(6) = 8^2 - 6 = 58_10 = 72_8$
Im Dualsystem entspricht dies dem Zweierkomplement.
== Darstellung von negativen Zahlen
=== Vorzeichen und Betrag (Sign and Magnitude)
- Vorzeichenbit (Sign): 0 für positive, 1 für negative Zahlen
- Betrag (Magnitude): absoluter Wert der Zahl
#example[
- Positive Zahl (+5): #underline[0]101
- Negative Zahl (-5): #underline[1]101
]
$->$ Suboptimal: Wir haben zwei Nullen (+0 und -0)
- Einfach, intuitiv
- Zwei Darstellungen von Null
- Weniger effizient für mathematische Operationen (zwei Prozessschritte, Vorzeichen & Operation mit Beträgen)
- Anwendung: Vorallem im Bildungskontext
=== Einerkomplement (b - 1)
Es werden einfach alle Bits invertiert im Binärsystem
#example[$+5 = 0101 => -5 = 1010$]
Im allen Zahlensystem allgemein bildet man das Einerkomplement, indem man von der Basis 1 und die jeweilige Ziffer subtrahiert:
#example[Sei $b$ = 5, Zahl: $234_5$. Das Einerkomplement wird berechnet durch $b - 1 - z$, wobei $z$ die Ziffer ist.
$ (5 - 1 - 2) = 2 \
(5 - 1 - 3) = 1 \
(5 - 1 - 4) = 0 $
Das Einerkomplement von $234_5$ wäre also $210_5$.
]
- Suboptimal: Immernoch zwei Nullen (0 und -0)
- Berechnung effizienter, aber bei einem Überlauf bei Addition muss ein _End-Around-Carry_ angewendet werden, d.h. wir entfernen und addieren den Überlauf zur Zahl hinzu
=== Zweierkomplement (b)
Um das Zweierkomplement zu erstellen, addieren wir 1 zum Einerkomplement
- Nur noch eine 0
- Effizient für Rechnen
=== Excesscode
Der Exzess- oder Überschusscode verschiebt den Zahlenstrahl auf negative Zahlen. So ist z.B. bei Exzess-8 die $0000 = -8$. Die tatsächliche Zahl kann errechnet werden, indem man eine gegebene binäre Zahl minus den Exzess rechnet:
$ 0101 "in Exzess-8" \
0101_b = 5 -> 5 - 8 =-3 $
Somit entspricht 0101 in Exzess-8: -3.
Man schreibt $C_("ex", -q, n)(x)$, wobei:
- $-q$: Bias
- $n$: Länge der binären Schreibweise
- $x$: Zahl (normalerweise im Dezimalsystem)
Der Excesscode, der den Zahlenbereich in zwei gleich grosse Hälften aufteilt, hat einen besonderen Stellenwert. Dabei gehört die 0 zu den negativen Zahlen. Beispiel: Bei vierstelligen Codes würde der Excess-7-Code $C_("Ex", -7, 4)(x)$ die Zahlen von -7 bis 8 darstellen. Der Bias ergibt sich dann durch $2^(n-1) - 1$.
Um eine Zahl $a$ zu kodieren, wählt man die kleinste Zahl b im Wertebereich und bildet die Differenz $d = |a-b|$. Beispiel:
$
C_("ex",-4,3)(-1) = ? \
d = |-1 - (-4)| = 3 => 011
$
== Präfixe
#table(columns: 4, stroke: none, [$2^10$], [$1.024 dot 10^3$], [K Kilo], [Ki Kibi],
[$2^20$], [$1.049 dot 10^6$], [M Mega], [Mi Mebi],
[$2^30$], [$1.074 dot 10^9$], [G Giga], [Gi Gibi],
$2^40$, $1.100 dot 10^12$, [T Tera], [Ti Tebi],
$2^50$, $1.126 dot 10^15$, [P Peta], [Pi Pebi],
$2^60$, $1.153 dot 10^18$, [E Exa], [Ei Exbi])
#example[Wie viele Datensätze zu je 128 Byte passen in einen Speicherbereich der Grösse 4 KB?
$ 128 upright(B) = 2^7 upright(B), 4"KB" = 2^2 dot 2^10 upright(B) \
(2^2 dot 2^10 upright(B)) / (2^7 upright(B)) = 2^5 = 32 $]
== Fixkommazahlen
$C_("FK", k, n)(x)$, wobei
- k = Anzahl Nachkommastellen
- n = Länge der binären Schreibweise
Beispiel:
$C_("FK", 4, 16)(453.1234) = 0001'1100'0101'0001$
=== Absoluter Fehler
$E_"abs" = |x_"korrekt" - x_"gerundet"|$
=== Relativer Fehler
$E_"rel" = (|x_"korrekt" - x_"gerundet"|) / x_"korrekt"$
== Gleitkommazahlen
Bei Gleitkommazahlen wird zusätzlich zum Bitmuster z auch die Stelle k mitgeführt, an der das Komma steht.
- z = Signifikand, Mantisse
- k = Exponent
- $C_("GK", k, n)(z) = z dot 2^k$
Beispiel: $6.25$.
$6 = 0110, 0.25 = 0.01$
Fixkommarepräsentation: $0110.01$
Gleitkommazahlrepräsentation: $1.1001 dot 2^2$
Für die Mantisse wird die Excess-Darstellung verwendet, d.h. bei 8-Bit-Mantisse der $C_("Ex", -127, 8)$. Der Exponent $2$ wird so zu $10000001$.
Als 32-Bit-Gleitkommazahl: $0'10000001'100100000000000000000000$
#table(
columns: (auto, auto, auto),
align: horizon,
[0], [10000001], [100100000000000000000000],
[Vorzeichen], [Exponent], [Mantisse],
stroke: none
)
=== Standard IEEE 754
- Single: 24 Bit Präzision, 8 Bit Exponent
- Double: 53 Bit Präzision, 11 Bit Exponent
- Quadruple: 113 Bit Präzision, 15 Bit Exponent
=== Addition
+ Wenn Vorzeichen unterschiedlich: Subtraktion
+ Hidden Bits ergänzen
+ Wenn Exponenten unterschiedlich: Signifikand der kleineren Zahl um entsprechend viele Bits nach rechts verschieben
+ Addition durchführen
+ Falls Carry = 1: Ergebnis normalisieren:
- Exponent um 1 erhöhen
- Signifikand um 1 nach rechts schieben
#figure(image("images/float-addition.png"), caption: [Floating-Point-Addition])
= Interpretation eines Codewortes
Ein Codewort $1001$ kann auf verschiedene Arten interpretiert werden:
- Als Tupel (1, 0, 0, 1)
- Als Zahl $1001_2 = 9_10$. Es gelten die üblichen Operationen der Ganzzahlrechnung.
- Als Vektor $mat(1, 0, 0, 1)^T$. Es gelten die üblichen Operationen der Vektorrechnung.
- Als Polynom: $g(u) = u^3 + 1$. Es gelten die üblichen Operationen der Polynomrechnung.
Die obigen Darstellungsformen sind äquivalent und beschreiben alle dasselbe Codewort. Alle Berechnungen erfolgen in $ZZ_2$.
== Interpretation als Vektor
Vektorraum $ZZ_2^3$:
$ vec(1, 1, 0) + vec(0, 0, 1) + vec(0, 0, 1) equiv vec(1, 1, 0) mod 2 $
Vektoren werden in der Codierung zur Fehlererkennung und -behebung verwendet.
== Interpretation als Polynom
Codewort $100101$ als Polynom:
$ 1u^5 + 0u^4 + 0u^3 + 1u^2 + 0u^1 + 1u^0 = u^5 + u^2 + u^0 $
Multiplikation zweier Polynome in $ZZ_2$:
$ (u^5 + u^2 + u^0)(u^2 + u^0) mod 2 \
= (u^7 + u^5 + u^4 + 2u^2 + u^0) mod 2 \
= u^7 + u^5 + u^4 + 1 $
Das resultierende Codewort ist $1011#h(2pt)0001$.
= Gruppe, Ring und Körper
Verknüpfung $->$ Gruppe $->$ Ring $->$ Körper
== Verknüpfung
Menge $m$ und Operation $w$: $(M, w)$
Bsp: $(NN, +)$
=== Neutrales Element
#example[$ &(NN, +) &-> 0 \
&(NN, dot) &-> 1 $]
=== Inverses Element
$a circle a' = n$
#example[$ (ZZ, +): 7 + (-7) = 0 \
(RR, dot): 4 dot 1/4 = 1 $]
== Gruppe
Verknüpfung $(G, w)$ mit
- Bezügl. $w$ abgeschlossen
- $w$ assoziativ
- Neutrales Element existiert
- Inverses Element existiert
Zusatz: Wenn Kommutativ $->$ abelsche Gruppe (Bsp. $(ZZ, +)$)
== Ring
Zwei Operationen $R(M, w_1, w_2)$, wobei $(M, w_1)$ abelsche Gruppe.
== Körper
Ein Ring ist ein Körper, wenn:
#enum(numbering: "a)",
[Jedes Element des Rings (ausser der 0) ein multiplikatives Inverses hat],
[Die Multiplikation kommutativ ist: $a b = b a$ (Abel'sche Gruppe)],
[Das Distributivgesetz gilt: $a(1 - b) = a - a b$],
[Wenn er eine 1 hat (multiplikatives neutrales Element)])
Wir definieren Mengen wie:
- $ZZ_2 = {0, 1}$
- $ZZ_5 = {0, 1, 2, 3, 4}$
- $ZZ_M = {0, 1, 2, ..., M - 1}$
Wir bewegen uns haupsächlich in $ZZ_2 = {0, 1}$ und definieren folgende Operationen:
- Addition $+$,
- Subtraktion $-$,
- Multiplikation $dot$,
- Ganzzahldivision mit Rest (Restklassen)
- Um die Abgeschlossenheit sicherzustellen, verwenden wir Operationen zusammen mit Modulo M. Beispiel:
$ ZZ_5 = {1, 2, 3, 4, 5} \
3 dot 4 = 12, 12 in.not ZZ_5 \
12 mod 5 = 2, 2 in ZZ_5 $
Modulo von negativen Zahlen: $-1 equiv 1 mod 2, -4 equiv 1 mod 5$
Codewörter können als Elemente eines endlichen Ganzzahlkörpers betrachtet werden. In der Informatik bewegen wir uns in $ZZ_2$. Die Anzahl der darstellbaren Codewörter wird durch die Codewortlänge bestimmt.
- Byte: $8 "Bit"$
- Word: $16, 32, 64 "Bit"$
- TCP-Paket: $1024 "Bit"$
Im endlichen Ganzzahlkörper gibt es immer eine grösste und eine kleinste Zahl. Die Darstellung dieser Zahl kann durch Speicher oder Definition der Wortgrösse begrenzt werden #sym.arrow Keine Unendlichkeit.
== Zyklische Gruppe
#definition[In der Gruppentheorie ist eine zyklische Gruppe eine Gruppe, die von einem einzelnen Element erzeugt wird. Sie besteht nur aus Potenzen des Erzeugers.]
Veranschaulichung:
$ M &= {0 degree, 90 degree, 180 degree, 270 degree} \
"Verknüpfung" &= "Drehung" #h(2em) mod 360 degree = a \
0 degree dot a^4 &equiv 0 degree mod 360 degree $
#figure(image("images/zyklische-gruppe.png"), caption: [Zyklische Gruppe])
Polynom $f(x) = x^3 + x + 1$, hat nach Fundamentalsatz der Algebra 3 Nullstellen. Die Frage ist nun, ob das Polynom in $ZZ_2$ eine Lösung hat.
=== Idee von Galois
Polynom $f(x) = x^3 + x + 1$ hat keine Nullstelle in $ZZ_2$. Also nehmen wir als (imaginäres) _erzeugendes Element_ $a$:
$ f(a) = a^3 + a + 1 = 0 $
Eine zyklische Gruppe (gemäss Évariste Galois (1811 - 1832)):
- Wird von einem einzigen Element erzeugt
- Besteht nur aus Potenzen des Erzeugers
- Das erzeugende Element $a$ wird als Lösung eingesetzt: $f(a) = a^3 + a + 1$
#example[
$
a &= a \
a^2 &= a^2 \
a^3 &= a + 1 && "Umstellung" f(a) "in" ZZ_2 \
a^4 &= a(a + 1) = a^2 + a \
a^5 &= a(a^2 + a) = a^3 + a^2 = a^2 + a + 1 \
a^6 &= a(a^2 + a + 1) = a^2 + 2a + 1 = a^2 + 1 \
a^7 &= a(a^2 + 1) = 1 \
a^8 &= a && "Zyklus beginnt von vorne"
$<galois>]
Neue Menge ist gemäss @galois: $ ZZ'_2 = {0, 1, a, a^2, a + 1, a^2 + a, a^2 + a + 1, a^2 + 1} $
Diese Menge können wir codieren:
$ {000, 001, 010, 100, 011, 110, 111, 101} $
= Boolsche Algebra
Es gibt genau 16 binäre Funktionen ($2^4$).
#[
#set text(size: 10pt)
#set table(
stroke: (x, y) => (
bottom: if y == 1 { 01pt } else { 0pt },
right: if x == 1 or x == 9 { 1pt } else { 0pt }
),
)
#table(columns: 18, align: center, table.header([], [], [], [AND], [], [], [], [], [XOR], [OR], [NOR], [EQUIV], [], $y => x$, [], $x => y$, [NAND], [], $x$, $y$, $0$, $x y$, $x overline(y)$, $x$, $overline(x) y$, $y$, $x overline(y) or overline(x) y$, $x or y$, $overline(x or y)$, $x y or overline(x) and overline(y)$, $overline(y)$, $x or overline(y)$, $overline(x)$, $overline(x) or y$, $overline(x y)$, $1$), $0$, $0$, $0$, $0$, $0$, $0$, $0$, $0$, $0$, $0$, $1$, $1$, $1$, $1$, $1$, $1$, $1$, $1$,
$0$, $1$, $0$, $0$, $0$, $0$, $1$, $1$, $1$, $1$, $0$, $0$, $0$, $0$, $1$, $1$, $1$, $1$,
$1$, $0$, $0$, $0$, $1$, $1$, $0$, $0$, $1$, $1$, $0$, $0$, $1$, $1$, $0$, $0$, $1$, $1$,
$1$, $1$, $0$, $1$, $0$, $1$, $0$, $1$, $0$, $1$, $0$, $1$, $0$, $1$, $0$, $1$, $0$, $1$)
]
NAND wird auch bezeichnet als: $x | y = overline(x and y) = overline(x y)$.
$x xor y = (not x and y) or (x and not y) = (x | not y) | (not x | y)$
== Minterme und Maxterme
*Minterme* haben als Ergebnis immer 1.
*Maxterme* haben als Ergebnis immer 0.
== Addition
XOR bildet die Addition zweier Bits, AND den Übertrag.
=== Halbaddierer
- Kann 2 einstellige Binärzahlen addieren
- Hat 2 Eingänge $(x, y)$ und 2 Ausgänge
=== Volladdierer
- Hat 3 Eingänge $(x, y, C)$
#figure(grid(
columns: 2,
image("images/halfadder.png"),
image("images/fulladder.png")
), caption: [Half adder und full adder])
== Kanonische Disjunktive Normalform (KDNF)
Bei der KDNF kommen in jedem Minterm *alle Variablen* vor:
$ (A and B) or (A and C) \
<=> (A and B and (C or not C)) or (A and C and (B or not B)) \
<=> (A and B and C) or (A and B and not C) or (A and B and C) or (A and not B and C) \
<=> (A and B and C) or (A and B and not C) or (A and not B and C) $
= Wahrscheinlichkeit
== Begriffe
- Ereignismenge $Omega$: Menge aller möglichen Ausgänge (Ergebnisse) eines Zufallsvorgangs
- Ergebnis $omega$: Ein einzelnes Element $omega in Omega$
#example[Werfen eines Würfels][$Omega = {1, 2, 3, 4, 5, 6}$]
#example[Zweifaches Werfen einer Münze][$Omega = {Z Z, Z K, K Z, K K}$]
#example[Werfen einer Münze so lange, bis Kopf erscheint][$Omega = {K, Z K, Z Z K, Z Z Z K, dots}$]
- Anzahl aller Ergebnisse $|Omega|$
- Wahrscheinlichkeit des Komplementärergebnisses: $P(overline(A)) = 1 - P(A)$
- Wahrscheinlichkeit des unmöglichen Ereignisses: $P(theta) = 0$
- Wertebereich der Wahrscheinlichkeit: $0 <= P(A) <= 1$
== Laplace
$P(A) = ("Anzahl der günstigen Ergebnisse" A)/("Anzahl aller Ergebnisse" Omega) = (|A|)/(|Omega|)$
== Verbundwahrscheinlichkeit
$ p(a, b) = p(a) dot p(b|a) $
== Kombinatorik
=== Übersicht
#[
#set math.equation(numbering: none)
#table(columns: (auto, auto, 1fr, 1fr), align: center + horizon, table.cell(colspan: 2, rowspan: 2, [$n$-Optionen auswählen]), table.cell(colspan: 2, [Beachtung der Reihenfolge]), [MIT], [OHNE],
table.cell(rowspan: 2, [Zurücklegen]), [MIT], $ A = n^k $, $ A = binom(n + k - 1, k) $, [OHNE], $ A = n (n-1) ... (n - k + 1) \ A = n!/(n - k)! $, $ A = n!/(k! (n - k)!) = binom(n, k) $)
]
=== Geordnete Proben (ohne Wiederholung)
Die Anzahl der $k$-Tupel aus einer $n$-Menge:
$ n dot (n - 1) dot (n - 2) dot dots dot (n - k + 1)\
= n!/(n - k)! \
= product_n^(n - k + 1) n $<nck>
=== Permutation
Die Zahl der Permutationen einer $n$-Menge ist $n!$.
Dies ist ein Spezialfall von @nck mit $n = k$.
=== Ungeordnete Proben
Die Anzahl der k-elementigen Teilmengen aus einer n-elementigen Menge ist (Binomialkoeffizient):
$ binom(n, k) = (product_n^(n - k + 1) n)/k! = n!/(k! (n-k)!) $
=== Binomialverteilung
$ P_x = binom(n, x) dot p^x dot q^(n - x) $
#example[Bitstream][
#table(columns: 5, [],table.cell(fill: black, []),[],[],[])
Wie gross ist die Wahrscheinlichkeit, dass *genau* 1 Bit gestört ist?
Die Wahrscheinlichkeit für eine Störung ist $p = 0.1$. Somit ist die Wahrscheinlichkeit für ein korrektes Bit $q = 0.9$.
$ P_1 = binom(5, 1) dot p^1 dot q^4 $
Wahrscheinlichkeit für zwei Fehler:
$ P_2 = binom(5, 2) dot p^2 dot q ^3 $
]
= Informationstheorie
#[
#set table(fill: (x, y) => if x == 0 or y == 0 { rgb("e1faff") })
#table(columns: 3, [Nachricht], [redundant], [nicht-redundant],
[irrelevant], table.cell(colspan: 2, [Zeichenvorrat bei Quelle und Senke verschieden]),
[relevant], [vorhersagbar], text(blue)[Information])
]
== Entscheidungsgehalt
$ H_0 = log_2(N) #h(1em) ["bit"], N = "Anzahl Elemente" $
== Informationsgehalt
Der Informationsgehalt eines Zeichens ist die Anzahl Elementarentscheidungen zur Bestimmung dieses Zeichens.
$ I(x_k) = log_2(1/p(x_k)) #h(1em) ["bit"] $
=== Tatsächliche Codewortlänge L
$ L(x_k) = ceil(I(x_k)) #h(1em) ["Bit"] $
Vorsicht: Wenn die Codewortlänge bekannt ist (z.B. nach Durchführung der Huffman-Codierung), muss die effektive Codewortlänge verwendet werden anstelle dieser Formel. Diese Formel gilt nur für die Quelle, nicht für die Codierung dieser.
== Entropie
Unter der Entropie versteht man den mittleren Informationsgehalt einer Quelle. Also wie viele Elementarentscheidungen die Quelle/Senke im Mittel pro Zeichen treffen muss. Anderes Wort ist auch die "Ungewissheit" einer Quelle, d.h. wie unsicher ist das Erraten eines Codes.
$ H(X) = sum_(k=1)^N p(x_k) I(x_k) = sum_(k=1)^N p(x_k) log_2(1/p(x_k)) #h(1em) ["bit/Zeichen"] $
Die Entropie ist maximal, wenn alle Zeichen dieselbe Wahrscheinlichkeit besitzen. Wenn jedoch nur ein Zeichen vorkommt, d.h. ein Zeichen hat die Wahrscheinlichkeit 1, dann ist die Entropie $= 0$.
=== Mittlere Codewortlänge
$ L = H_c (X) = sum_(i=1)^N p(x_i) L(x_i) = sum_(i=1)^N p(x_i) ceil(I(x_i)) #h(1em) ["bit/Zeichen"] $
=== Quelle mit Gedächtnis
$ H(X, Y) = sum_(i=1)^N sum_(k=1)^N p(x_i) dot p(y_k|x_i) dot log_2(1/(p(x_i) dot p(y_k|x_i))) = H(X) + H(Y|X) $
Redundanz:
$ R_Q = H_0 - H_(o G)(X) <= H_0 - H_(m G)(x) = H_0 - H(Y|X) $
=== Wann wird die Entropie einer Quelle/Senke maximal?
Die Entropie ist maximal, wenn alle Wahrscheinlichkeiten gleich sind.
$ X &= {x_1, x_2} \
p(x_1) &= p \
p(x_2) &= 1 - p \
=> H(X) &= p dot log_2(1/p) + (1 - p) dot log_2(1/(1 - p)) $
#image("images/max_entropy_graph.png")
=== Shannon'sches Codierungstheorem
$ H(X) <= L <= H(X) + 1 $
Wobei $L = "Mittlere Codewortlänge"$
== Redundanz einer Quelle
Absolut:
$ R_Q_"absolut" = H_0 - H(X) #h(1em) ["bit/Zeichen"] $
Relativ:
$ R_Q_"relativ" = R_Q_"absolut" / H_0 = 1 - H(X) / H_0 #h(1em) [dot 100 %] $
Redundanz der Quelle:
$ R_Q = H_0 - H(X) $
Redundanz des Codes:
$ R_c = L - H(X) $
== Präfixeigenschaft
Kodierung nach Binärtree, wobei Zeichen nur bei den Leafs sind, ist kommafrei (siehe @binary-code).
#figure(image("images/binary-tree-encoding.png", width: 4cm), caption: [Kommafreie Codierung nach Binary Tree])<binary-code>
== Quelle mit Gedächtnis
#figure(image("images/quelle-mit-gedächtnis.png"), caption: [Quelle mit Gedächtnis])
Folgende Tabelle kann man ablesen:
#table(columns: (auto, auto, auto, auto),
table.header([], [A], [B], [C]),
[A], [0], [4/5], [1/5],
[B], [1/2], [1/2], [0],
[C], [1/2], [2/5], [1/10]
)
Nun hat man folgende drei Gleichungen:
$ p(A) &= 1/2 dot p(B) + 1/2 dot p(C) \
p(B) &= 4/5 dot p(A) + 1/2 dot p(B) + 2/5 dot p(C) \
p(C) &= 1/5 dot p(A) + 1/10 dot p(C) $
Diese sind jedoch linear abhängig. Somit nimmt man zwei von den obigen drei Gleichungen und die Gleichung
$ p(A) + p(B) + p(C) = 1 $
um ein lösbares lineares Gleichungssystem zu erhalten.
= Kompressionsmethoden
== Lauflängenkomprimierung
Ähnliches Prinzip wie "AAAbbceee" = "3A2bc3e", aber mit Bits. Hierzu muss jeweils nur klar sein welcher Bit als Erstes kommt, 1 oder 0. Beispiel:
$ &1111'1100'0001'1001 \
= &[6 dot 1 ,5 dot 0, 2 dot 1, 2 dot 0, 1] \
= &6, 5, 2, 2, 1 \
= &110'101'010'010'001 $
Start mit einer #colred(1) $-> colred(1)'110'101'010'010'001$
== Lempel-Ziv-Verfaren
Eine Datenstruktur besteht aus:
- Einem Textfenster, dem *search buffer*
- Schon kodierte Symbole
- Wird dynamisch aufgebaut
- Nach vorne gerichteten Puffer, dem *look-ahead buffer*
#example[
#table(
columns: 3,
table.header([*Search Buffer/Textfenster*], [*Look-ahead buffer*], [*Coding (Position, Länge, Zeichen)*]),
[], [#text(orange)[s]ir_sid_eastman], [(0, 0, "s")],
[s], [#text(orange)[i]r_sid_eastman], [(0, 0, "i")],
[si], [#text(orange)[r]\_sid_eastman], [(0, 0, "r")],
[sir], [#text(orange)[\_]sid_eastman], [(0, 0, "\_")],
[#text(green)[si]r\_], [#text(green)[si]d_eastmam], [(4, 2, "d") #text(size: 0.8em, gray)[4 Stellen zurück, 2 Zeichen lang]],
[sir_sid], [\_eastman], []
)
]
=== Lempel-Ziv-Welch (LZW)
Startet im Normalfall mit dem Wörterbuch:
#table(
columns: 2,
table.header([*Index*], [*Eintrag*]),
..for i in range(10) {
([#i], [#i])
}
)
Wir codieren die Zeichenfolge "36363":
#table(columns: 3, table.header([*Buffer*], [*Erkannte Zeichenfolge (Index)*], [*Neuer Eintrag*],
[#underline[*3*\6]363], [3 (3)], [10: 3],
[3#underline[#text(weight: "bold")[6]3]63], [6 (6)], [11: 63],
[36#underline[#text(weight: "bold")[36]3]], [36 (10)], [12: 363],
[3636#underline[*3*]], [3 (3)], [-]))
Codiert wird "3 6 10 3"
=== Lempel-Ziv für Binärzahlen
#figure(image("images/lempel-ziv-binary.png"), caption: [Lempel-Ziv-Algorithmus für Binärzahlen])
== Kombination Lempel-Ziv und Huffman
Es ist möglich, zunächst die Nachricht mit Lempel-Ziv zu komprimieren und dann mit der Huffman-Codierung das entstandene Wörterbuch weiter zu komprimieren.
= Kryptologie
Assymetrische Verschlüsselung ist nicht performant. Deshalb verwendet man oft nur zu Beginn einer Kommunikation asymmetrische Verschlüsselung, damit ein sicherer Kanal entsteht. Ein gemeinsamer Schlüssel für symmetrische Verschlüsselung wird dann über die asymmetrische Verschlüsselung sicher übertragen.
== RSA
Durch $mod b$ wird ein Ereignisraum von $0$ bis $b - 1$ möglich. Somit kann man eine Zahl $c$ ausserhalb dieses Ereignisraums finden, die in dieser Rechenvorschrift eine Inverse Zahl zu a ist.
$ &m^e mod N #h(4em) &&"Verschlüsseln" \
&(m^e)^d mod N &&"Entschlüsseln" \
&= m^(e d) mod N $
Dabei muss folgendes gelten:
$ e dot d equiv 1 mod N $
Für zwei teilerfremde Zahlen $a, b$ existiert eine Zahl $c$, so das gilt:
$ a dot c equiv 1 mod b $
.
=== Eulerfunktion
$phi(n) = "Anzahl der relativ primen (teilerfremden) Zahlen zu" n$
#theorem[$ a^y mod (p dot q) = a^(y mod phi(p dot q)) mod (p dot q) $]
#proof[$ a^y mod (p dot q) &=^! a^(y mod phi(p dot q)) mod (p dot q) \
&= a^(y - n dot phi(p dot q)) mod (p dot q) \
&= a^y dot a^(-n dot phi(p dot q)) mod (p dot q) \
&= (a^y mod (p dot q)) dot underbrace((a^(phi(p dot q)) mod (p dot q)), =1)^(-n) \
&= a^y mod (p dot q) $]
#example[RSA][Seien Primzahlen $p = 47, q = 59$ gegeben. Daraus folgt: $p dot q = 2773$ und $phi(n) = (p - 1) dot (q - 1) = 2668$.
Wir wählen den Wert $e = 17$, relativ prim zu $phi(n)$, wobei $ 1 < e < phi(n)$. Und dann berechnen wir den zu $e$ inversen Wert $d = 157$.
Privater Schlüssel: $(d, n)$, Öffentlicher Schlüssel: $(e, n)$
$ m = 12 &-> c = m^e mod n = 336 #h(20pt) &"Encrypt"\
c = 336 &-> m = c^d mod n = 12 &"Decrypt" $]
=== Euklidischer Algorithmus
#table(columns: 8, table.header[x][y][q][r][u][s][v][t], [], [], [x div y], [x mod y], $u_(k + 1) = s_k$, $s_(k + 1) = u_k − q_k dot s_k $, $v_(k + 1) = t_k$, $t_(k+1) = v_k − q_k dot t_k$)
= Kanalmodell
#image("images/rain-picknick-source.jpeg")
$ p(y_1) &= p(x_1) dot p + p(x_2) dot (1 - q) \
p(y_2) &= p(x_1) dot (1 - p) + p(x_2) dot q $
$ p(Y|X) = mat(p, 1-p; 1-q, q) $
In diesem Beispiel wäre
$ p(Y|X) = mat(0.9, 0.1;0.3, 0.7) $
Fehlerfrei:
$ p(Y|X) = mat(1, 0; 0, 1) $
$ p(P = 1, R = 1) = p(R = 1) dot p(P = 1|R = 1) = 0.35 dot 0.3 = 0.105 $
=== 3x3-Matrix
Eine 3x3-Matrix ist also folgendermassen aufgebaut:
$ mat(p(y_1|x_1), p(y_1|x_2), p(y_1|x_3);
p(y_2|x_1), p(y_2|x_2), p(y_2|x_3);
p(y_3|x_1), p(y_3|x_2), p(y_3|x_3)) $
$ vec(p(y_1),p(y_2), p(y_3)) = vec(p(x_1) dot p(y_1|x_1) + p(x_2) dot p(y_1|x_2) + p(x_3) dot p(y_1|x_3), p(x_1) dot p(y_2|x_1) + p(x_2) dot p(y_2|x_2) + p(x_3) dot p(y_2|x_3), p(x_1) dot p(y_3|x_1) + p(x_2) dot p(y_3|x_2) + p(x_3) dot p(y_3|x_3)) $
=== Symmetrischer Kanal
Fehlerwahrscheinlichkeit des Kanals ist unabhängig von der Auftrittswahrscheinlichkeit der Zeichen der Quelle.
$ mat(0.95, colred(0.025), colred(0.025); colred(0.025), 0.95, colred(0.025); colred(0.025), colred(0.025), 0.95) $
=== Verbundentropie
$ H(X,Y) &= - sum_i^n sum_j^n p(x_i, y_j) dot log_2(p(x_i, y_j)) $
=== Äquivokation (Verlust)
$ H(X|Y) &= - sum_i^n sum_j^n p(x_i, y_j) dot log_2(p(x_i|y_j)) \
&= - sum_i^n sum_j^n p(y_j) dot p(x_i|y_j) dot log_2(p(x_i|y_j)) $
- Ähnliche Formel wie die Verbundentropie (Rückschlussentropie)
- Ungewissheit über das gesendete Zeichen bei bekanntem Empfangszeichen
- Merke: Ist der Kanal fehlerfrei, so ist die Äquivokation gleich 0
=== Irrelevanz (Rauschen)
$ H(Y|X) &= - sum_i^n sum_j^n p(x_i, y_j) dot log_2(p(y_j|x_i)) \
&= - sum_i^n sum_j^n p(x_i) dot p(y_j|x_i) dot log_2(p(y_j|x_i)) $
- AUch Streuentropie genannt
- Ungewissheit der empfangenen Zeichen bei vorgegebenen Sendezeichen
=== Transinformation
$ T &= H(X) - H(X|Y) \
T &= H(Y) - H(Y|X) $
*Fazit*:
- Ein nicht gestörter Kanal (Einheitsmatrix) überträgt den mittleren Informationsfluss ohne weiteren Verlust, d.h. die Transinformation wird nur durch die Quelle beeinflusst
- Verändert sich die Entropie der Quelle, so verändert sich auch die Transinformation
- Nimmt die Fehlerwahrscheinlichkeit zu, nimmt die Transinformation ab
- Sind alle Positionen der Kanalmatrix gleich besetzt, so wird die Transinformation $T = 0$ und $H(Y) = H(Y|X) = 1$ und zwar unabhängig von der Entropie am Kanaleingang
- Die Transinformation gibt den maximalen und somit fehlerfreien Informationsfluss über einen gestörten Kanal an.
=== Maximum-Likelihood-Verfahren
Gegeben sei eine Kanalmatrix $P(Y|X)$. Man wählt in jeder Spalte die höchstwahrscheinliche Zahl:
$ P(Y|X) = mat(colred(0.5), 0.4, 0.1;
0.2, 0.1, colred(0.7);
0.3, colred(0.5), 0.2) $
Der Entscheider ist hier somit:
$ y_1 -> x_1 \
y_2 -> x_3 \
y_3 -> x_2 $
Die Spalten gelten für die $Y$'s, die Zeilen für die $X$'s in der Kanalmatrix.
== Fehlerkorrektur
Idee: Wir fügen Redundanz hinzu, damit sich der Coderaum in gültige und ungültige Codewörter aufteilt (Siehe @error-cube).
#figure(image("images/coderaum.png", width: 50%), caption: [Coderaum. Weisse Punkte sind gültige Codewörter, dunkle Punkte sind ungültig. Hier ist nur Fehlererkennung möglich, keine Fehlerkorrektur.])<error-cube>
Die Distanz zwischen zwei gültigen Codewörtern nennt man Distanz $d$.
Hammingdistanz $h$: Die kleinste Distanz zwischen zwei gültigen Codewörtern (#sym.arrow Flachdrücken des Coderaums).
$ h = min_(i, j)(d(x_i, x_j)) $
#figure(image("images/coderaum-mehr-redundanz.png", width: 50%), caption: [Coderaum mit Fehlerkorrektur möglich, Hammingdistanz 3.])<hammingdistanz>
Anzahl der sicher erkennbaren Fehler $e^* = h - 1$. Im Beispiel @hammingdistanz ist die Hammingdistanz $h = 3$. Die Anzahl erkennbaren Fehler ist somit $e^* = 3 - 1 = 2$.
Anzahl sicher korrigierbaren Fehler $e = floor((h - 1) / 2)$
Bei Hamming-Blockcode ist $h = 3$.
=== Korrigierkugel
#figure(image("images/korrigierkugeln.png", width: 50%), caption: [Korrigierbare Korrigierkugeln dürfen sich nicht berühren.])
Eine Korrigierkugel hat das Zentrum bei einem gültigen Punkt und umfasst alle korrigierbaren Fehler in ihrem Radius. Der Radius ist somit die Anzahl sicher korrigierbarer Fehler $e$. Bei einer Skizze kann man dann noch die Hammingdistanz $h$ und die erkennbaren Fehler $e^*$ einzeichnen.
#example[Quersummencode][
#table(columns: 3, align: center, table.cell(colspan: 2, $m = 2$), $k = 1$, $x_1$, $x_2$, $x_3$,
$0$, $0$, $0$, $0$, $1$, $1$, $1$, $0$, $1$, $1$, $1$, $0$, table.hline(stroke: 2pt), $0$, $0$, $1$, $0$, $1$, $0$, $1$, $0$, $0$, $1$, $1$, $1$)
]
Ein solcher Code hat die Hammingdistanz $d = 2$, da der Abstand zwischen zwei korrekten Kombinationen *zwei Bits Unterschied* hat.
=== Paritätsbit-Code
#[
#table(columns: 2, stroke: none, $0100 #h(4pt) 1111$, table.vline(stroke: .5pt), $1$, $0101 #h(4pt) 0011$, $0$, $0101 #h(4pt) 0100$, $1$, table.hline(stroke: .5pt), $0100 #h(4pt) 1000$, $0$)
Es können mehrere Fehler gefunden und korrigiert werden.
]
=== Hammingcode
k-Kontrollstellen:
$ n &= 2^k - 1 \
n &= m + k $
Die Notation des Hammingcode ist immer ein Tupel $(n, m)$, z.b. $n = 7, m = 4 -> (7, 4)$
#image("images/hamming-code-1.png")
#image("images/hamming-code-1-vectors.png")
Es wird pro Kontrollbit ein Vektor mit jeweils zwei Stellen gebildet. Hammingdistanz ist drei, somit können zwei Fehler erkannt und ein Fehler korrigiert werden. Daraus bildet sich nun folgengde *Generatormatrix*:
$ mat(1, 1, 1, 0, 1, 0, 0; 0, 1, 1, 1, 0, 1, 0; 1, 1, 0, 1, 0, 0, 1; augment: #4) \
arrow(P_1) arrow(P_2) arrow(P_3) arrow(P_4) arrow(P_5) arrow(P_6) arrow(P_7) $
Hieraus folgt die Codebedingung: $sum_i x_i dot arrow(P_i) equiv arrow(0) mod 2$
#example[
Dieselbe Matrix, erhaltenes Codewort: $1010011$.
$ 1 dot vec(1, 0, 1) + 1 dot vec(1, 1, 0) + 1 dot vec(0, 1, 0) + 1 dot vec(0, 0, 1) equiv vec(0, 0, 0) mod 2 $
]
#image("images/syndrom-hammingcode.png")
$->$ Das entstandene Fehlersyndrom ist derselbe Vektor wie der Spaltenvektor an der Stelle des Fehlers!
*Fehlersyndrom:*
#image("images/fehlersyndrom-hammingcode.png")
=== Ermitteln der Kontrollstellen durch rückgekoppeltes Schieberegister
#image("images/rueckgekoppeltes-schieberegister.png")
=== Abramson- bzw. CRC-Code
Diese werden gebildet durch die Multiplikation eines primitiven Polynoms mit dem Term $(1 + x)$:
Abramson-Code: $g(x) = p(x) dot (1 + x)$
CRC-Codes haben immer die Hammingdistanz $h = 4$ (Multiplikation $->$ eins mehr als zyklische Hammingcodes). Sie haben immer die Länge $n = 15$ (Andernfalls ist die Formel bei CRC $n = 2^(k - 1) - 1$).
#example[
$ &g(x) = (1 + x + x^3) dot (1 + x) \
&g(x) = 1 + x^2 + x^3 + x^4 $
]
Wenn die Frage nach einem CRC-Code ist, reicht es, dieses Polynom anzugeben.
Anzahl Kontrollstellen ist dieselbe, wie der Grad des Polynoms, in diesem Beispiel 4.
== Codiergungsdichte
Sei:
- $n$ die Dimension des Codes (Anzahl aller CW $2^n$)
- $m$ die Dimension der Nachrichten (Anzahl aller gültigen CW $2^m$)
- $k$ die Dimension der Kontrollstellen mit $n = m + k$
Codeabschätzung (Dann ist der Code *nicht* dichtgepackt):
$ 2^m dot sum_(w=0)^e binom(n, w) <= 2^n $
== Fehlersyndrom
$ arrow(Z) = sum_i f_i dot arrow(P_i) $
== Zyklischer Hamming-Code
Ermittlung der Kontrollstellen durch Mehrfachaddition (alternativ zu Polynomdivision):
#image("images/hammingcode-multiple-addition.png")
- $X(u)$: Codewort
- $G(u)$: Generatorpolynom
#example[$X(u) = 1000101$, $G(u) = 1011$.
Durch Mehrfachaddition kann berechnet werden, ob $X(u)$ ein gültiges Codewort ist (siehe @remainderless-division).
#figure(image("images/remainderless-division.png", width: 50%), caption: [Polynomdivision ohne Rest])<remainderless-division>]
Wenn man ein gültiges Codewort hat, kann man jeweils einen Fehler einbauen für jede Position und dann wieder durch Polynomdivision die Generatormatrix herleiten (siehe @generator-matrix). Der übrigbleibende Rest entspricht immer dem *Fehlersyndrom*!
=== Ermitteln der Kontrollstellen durch Mehrfachaddition
Wenn wir z.B. wissen, dass wir ein 4-stelliges Codewort (m = 4) kodieren und $k = 3$, und das Generatorpolynom 1010 beträgt, können wir verschiedene Additionen vornehmen, um die korrekten Codeworte zu erhalten:
#table(stroke: none, align: (right, left), columns: 2, [0001], table.vline(), [],
[1], [010], table.hline(),
[0], text(orange)[010],)
$->$ 0001010 ist ein gültiges Codewort.
#table(stroke: none, align: (right, left), columns: 2, [1000], table.vline(), [],
[1010], [], table.hline(),
[0010], [],
[10], [10], table.hline(),
[00], text(orange)[100]
)
$->$ 1000100 ist ein gültiges Codewort
#figure(image("images/generatormatrix.png"), caption: [Herleitung der Generatormatrix])<generator-matrix>
== Faltungscodes
Ein Faltungscode wird als Tupel $(a, e, s)$ angegeben wobei:
- a: Anzahl Ausgänge
- e: Anzahl Eingänge
- s: Anzahl Speicherplätze
Beispiel für einen Faltungscode (3, 1, 2) mit:
- $g_1(x) = 1 + x$
- $g_2(x) = 1 + x^2$
- $g_3(x) = 1 + x + x^2$
#figure(image("images/polynom.png"), caption: [Faltungscode])
=== Zustandsdiagramm
#image("images/state-diagram.png")
Netzdiagramm:
#image("images/net-diagram.png")
Ergibt die Kodierung: 111 010 100 011 111 101 011 $->$ Bitrate: $1/3$ (1 bit wird in 3 bit übersetzt)
Decodierung des $(3, 1, 2)$ Faltungscodes:
#image("images/decoding-faltungscode.png")
#image("images/decoding-faltungscode-complete.png")
#image("images/generatorpolynomial-table.png")
|
|
https://github.com/Languisher/touying-sjtu | https://raw.githubusercontent.com/Languisher/touying-sjtu/main/README.md | markdown | MIT License | # Touying Slide Theme for Shanghai Jiao Tong University
> _CLAIM_: This theme is not, and never will be, the official version of the Touying Slide Theme for Shanghai Jiao Tong University. It is solely for my personal use!
This repository is based on [Touying Slide Theme](https://github.com/touying-typ/touying) and [Touying Slide Theme for Beihang University](https://github.com/Coekjan/touying-buaa) with only minor changes.
An example of a PowerPoint generated by this template can be viewed here: [Click the link!](example/file/main.pdf)
You can start within 30 seconds with this file: [Click the link!](template/test.typ)
## Guidance
### Basic Info of the Presentation PowerPoint
You should first modify these variables:
```typst
// Global information configuration
#let s = (s.methods.info)(
self: s,
title: [TITLE],
subtitle: [SUBTITLE],
author: [AUTHOR],
date: datetime.today(),
institution: [INSTITUTION],
)
```
### Creating a Slide
```typst
#slide[
CONTENTS
]
```
#### Creating a Double-Column Slide
```typst
#slide(composer: (2fr, 1fr))[
COLUMN1
][
COLUMN2
]
```
The `composer` attribute is optional and can be used to adjust the width of the columns.
#### Setting Up the Slide Title
The slide title is determined by its level-2 heading.
```typst
== TITLE
#slide[
CONTENTS
]
```
### Insertion
#### Inserting a Figure
```typst
#figure(
image("FILEPATH", width: NUM%)
)
```
You should change the `FILEPATH` to the relative path of the figure in relation to this file.
The `width` attribute is optional. If it is omitted, the system will automatically scale and resize the figure.
#### Inserting a Box
```typst
#tblock(title: "TITLE")[
CONTENTS
]
``` |
https://github.com/dimchor/big-data-project | https://raw.githubusercontent.com/dimchor/big-data-project/main/report/report.typ | typst | #import "conf.typ": conf
#import "conf.typ": cont
#import "conf.typ": bib
#conf([Εργασία Διαχείρισης Δεδομένων Μεγάλης Κλίμακας], [Ανάλυση σεισμικών δονήσεων και ηφαιστειακών εκρήξεων],
[11/04/24], [21/06/24])
#cont()
#set page(numbering: "1")
#counter(page).update(1)
= Εισαγωγή
// Σκοπός αυτής της εργασίας είναι η ανάλυση και η σύγκριση των δεδομένων που προέρχονται από τις βάσεις δεδομένων
// Database of Volcanic Eruptions και Significant Earthquakes, 1965-2016.
Σε αυτή την εργασία μελετείται η σχέση μεταξύ σεισμών και ηφαιστειακών εκρήξεων εντός μιας ορισμένης περιοχής αντλώντας
πληροφορίες από την Βαση Δεδομένων Ηφαιστειακών Εκρήξεων (Database of Volcanic Eruptions) και την βάση δεδομένων με Μείζονες Σεισμούς (Significant Earthquakes, 1965-2016).
Η βάση δεδομένων των ηφαιστειακών εκρήξεων περιέχει
την χρονική περίοδο τη έκρηξης (χρόνος, μήνας και μέρα), το όνομα του ηφαιστείου το οποίο εξερράγη,
την ώρα της έκρηξης, την τοποθεσία και χώρα άλλα επίσης το γεωγραφικό πλάτος και μήκος και το ύψος του ηφαιστείου.
Η βάση δεδομένων των σεισμικών δονήσεων περιέχει την πλήρης ημερομηνία, την ώρα της έκρηξης, το βάθος,
το μέγεθος της απόστασης που γίνεται αντιληπτή η σεισμική δόνηση, τον τύπο, το γεωγραφικό πλάτος και μήκος του κέντρο της δόνησης
και την απόσταση που γίνεται αντιληπτή η δόνηση. Με την χρήση του γεωγραφικό πλάτους και μήκους θα προσπαθήσουμε
με την επεξεργασία τους να βρούμε τα κοινά στοιχεία μεταξύ των δύο διαφορετικών βάσεων δεδομένων.
// Με τα στοιχεία αυτά θέλουμε να βρούμε ε
Βάσει των παραπάνω στοιχείων θα εξετασθεί
αν υπάρχει συσχέτιση μεταξύ των ηφαιστειακών εκρήξεων και των σεισμικών δονήσεων οι οποίοι γίνονται
σε μικρή απόσταση μεταξύ τους, και ποιο φαινόμενο ήταν η αφορμή για την εκδήλωση του άλλου. Κατά την επεξεργασία των δεδομένων
θα γίνουν οι απαραίτητες τροποποιήσεις ώστε να συμπεριληφθούν μόνο τα δεδομένα που βρίσκονται εντός των προδιαγραφών της μελέτης.
// [...] εντός των προδιαγραφών της μελέτης.
// ίσως να είναι λίγο ασαφές...
= Ορισμός προβλήματος και κίνητρο
// Όπως αναφέρθηκε και στην εισαγωγή το κίνητρο της έρευνας είναι η απάντηση στο κατά πόσο είναι πιθανόν να οφείλονται οι σεισμικές δονήσεις
// σε ηφαιστειακές εκρήξεις, υπάρχει πιθανότητα να συμβαίνει το αντίθετο;.
Ορισμένες μελέτες έχουν δείξει ότι οι σεισμοί ενδεχομένως να προκαλούν ηφαιστειακές εκρήξεις, όμως χωρίς να έχει βρεθεί ο ακριβής μηχανισμός. @earthquakes-volcanic-eruptions-review
Η απάντηση αυτού του ερωτήματος με στατιστικά στοιχεία
θα είναι χρήσιμη για τις προβλέψεις που μπορούν να γίνουν σχετικά με τα δύο φυσικά φαινόμενα, την πιθανότητα εκδήλωσης ηφαιστειακής έκρηξης
έπειτα από σεισμική δόνηση και την έγκαιρη προειδοποίηση του τοπικού πληθυσμού έτσι ώστε να περιοριστεί ο αριθμός θυμάτων και η καταστροφή περιουσίας.
Δηλαδή, τα στοιχεία θα είναι χρήσιμα και για επιστημονική μελέτη και έρευνες καθώς και για πρόληψη.
= Σύνολα δεδομένων
Χρησιμοποιήθηκαν δύο σύνολα δεδομένων: ένα σχετικό με σεισμικές δονήσεις και ένα σχετικό με ηφαιστειακές εκρήξεις. Τα δεδομένα έχουν το γεωγραφικό πλάτος και το γεωγραφικό μήκος ως κοινές πληροφορίες που θα χρησιμοποιηθούν για την εύρεση της σχετικής τοποθεσίας τους και
για την σύγκριση τους. Καθώς τα σύνολα δεδομένων τα οποία χρησιμοποιούνται για την άντληση των δεδομένων έχουν διαφορετικές περιόδους καταγραφής
θα γίνει σύγκριση μόνο των κοινών περιόδων από το 1965 μέχρι το 2016. Τα δεδομένα που αφορούν στα ονόματα των χωρών ή περιοχών καθώς
και τα ονόματα των ηφαιστείων δεν χρησιμεύουν στην παρούσα ανάλυση. Ο τύπος της δόνησης περιέχει μόνο δύο υπάρχουσες διαφορετικές τιμές,
σεισμός και πυρηνική έκρηξη όπου το δεύτερο δεν χρησιμοποιηθεί για την σύγκριση των δεδομένων. Τα στοιχεία σχετικά με τις καταστροφές
και τις ανθρώπινες απώλειες που προκάλεσε η έκρηξη δεν θα χρησιμοποιηθούν. Δηλαδή, πέρα από τις γεωγραφικές συντεταγμένες και
την ημερομηνία των συμβάντων τα άλλα στοιχεία δεν θα είναι χρήσιμα για αυτή την ανάλυση.
// #pagebreak()
= Μέθοδος ανάλυσης
Για την ανάλυση των δεδομένων θα χρησιμοποιήθηκε η γλώσσα προγραμματισμού Python με την χρήση ορισμένων βιβλιοθηκών. Στο αρχείο `requirements.txt` αναγράφονται όλες οι βιβλιοθήκες οι οποίες χρησιμοποιήθηκαν. Οι βιβλιοθήκες μπορούν να εγκατασταθούν αυτοματοποιημένα με χρήση του `pip`, το οποίο είναι διαχειριστής πακέτων.
Μία εκ των βιβλιοθηκών οι οποίες χρησιμοποιήθηκαν είναι η `pandas`, η οποία παρέχει εύκολο χειρισμό και ανάλυση δεδομένων. Η επιλογή αυτής της βιβλιοθήκης έγινε διότι επιτρέπει με ευκολία τον χειρισμό αρχείων τύπου Comma-Separated Values (CSV) που είναι και η μορφή στην οποία βρίσκονται τα σύνολα δεδομένων.
Στο αρχείο `dataset.py` πραγματοποιείτε μια αρχική επεξεργασία των δεδομένων.
Αρχικά, καθορίζεται την τοποθεσία των βάσεων και φορτώνουμε της το αρχείο που δόθηκε ως όρισμα καθορίζοντας την πρώτη γραμμή ως επικεφαλίδα (header)
που περιέχει την ονομασία των δεδομένων για την κάθε στήλη. Στην συνέχεια, αφαιρούνται οι γραμμές οι οποίες δεν είναι
τύπου "σεισμός", καθώς οι άλλοι τύποι δεν αφορούν αυτή την ανάλυση. #footnote[Κάποιοι σεισμοί οι οποίοι καταγράφονται σε αυτό το σύνολο δεδομένων οφείλονται από ανθρωπογενείς παράγοντες (πχ. πυρηνικές εκρήξεις) ή άλλα πιο γενικά αίτια. Αυτή η ανάλυση αφορά τους σεισμούς οι οποίοι προκαλούνται από την μετακίνηση των τεκτονικών πλακών.] Οι συναρτήσεις `load_earthquake_events()` και `load_volcano_events()`
που καλούνται απο την `main()` και φορτώνουν τις βάσεις δεδομένων αντίστοιχα, η `load_volcano_events()` επίσης αφαιρεί τις ηφαιστειακές εκρήξεις που
έγιναν πριν το 1965 και μετά το 2016 λόγω μη ύπαρξης δεδομένων για αυτήν την περίοδο για την βάση των σεισμών.
Η συνάρτηση `convert_to_utm()` μετατρέπει της γεωγραφικές συντεταγμένες σε "Universal Transversal Mercator" (UTM). Το σύστημα
αυτό βασίζεται στον διαχωρισμό του χάρτη σε περιοχές για την καλύτερη μέτρηση των αποστάσεων. Η προβολή αυτή είναι
κυλινδρική με τέτοιο τρόπο ώστε η τιμή των γωνιών να διατηρείται εξασφαλίζοντας καλύτερη ακρίβεια κατά
τον υπολογισμό της θέσης και των αποστάσεων. Οι αποστάσεις δημιουργούν ένα πλέγμα με χρήση των παράλληλων και των μεσημβρινών
με αριθμό από το 1 έως 60 ξεκινώντας από το μεσημβρινό ο οποίος είναι ανατολικά του Γκρίνουιτς.
Κάθε παράλληλος χωρίζεται σε διαφορετικές περιοχές που ονομάζονται με κεφαλαίο γράμμα, ακολουθούν την κατεύθυνση από νότο προς βορρά
και ξεκινούν με το γράμμα C και τελειώνουν με το γράμμα X. Για να την αποφυγή σύγχυσης, δεν υπάρχουν φωνήεντα ή τα γράμματα τα οποία μπορούν
να συγχέονται με έναν αριθμό.
Χρησιμοποιείται αυτή η μετατροπή για την εύκολη και κατανοητή σύγκριση των συνόλων δεδομένων από την χρήση των αρχικών γεωγραφικών συντεταγμένων.
Έτσι, παρουσιάζεται πάνω στον χάρτη σε εύκολα αναγνώσιμη μορφή ομαδοποιώντας περιοχές σε πλέγμα και
θεωρώντας το κάθε πλέγμα που σχηματίζεται την περιοχή που τα φυσικά φαινόμενα θα επηρεάζουν την εκδήλωση του άλλου.
#figure(image("utmworld.gif", width: 80%), supplement: "Εικόνα", caption: "UTM συντεταγμένες")
Στην συνάρτηση με την χρήση της βιβλιοθήκης `utm` #footnote[https://github.com/Turbo87/utm] αντιστοιχίζεται το "Latitude" στους παράλληλους, οι οποίοι χρησιμοποιούν
γράμμα ζώνης, και το "Longitude" στους μεσημβρινούς, οι οποίοι αντιστοιχούν στον αριθμό ζώνης, δημιουργώντας δύο νέες στήλες: την
"Zone number" και "Zone letter". Επίσης, η συνάρτηση αφαιρεί τα αποτελέσματα που δεν ήταν δυνατή η μετατροπή τους.
Με την μετατροπή των συντεταγμένων σε UTM τελειώνει η τροποποίηση των δεδομένων.
// #pagebreak()
Στο αρχείο `association.py` πραγματοποιείται η συσχέτιση των UTM συντεταγμένων των δύο βάσεων δεδομένων. Με την συνάρτηση `hot_encoding()`
δημιουργείται ένα νέο σύνολο δεδομένων το οποίο περιέχει μόνο έναν δείκτη στις συντεταγμένες UTM και τις δύο στήλες οι οποίες αντιστοιχούν
στις δύο βάσεις δεδομένων με τιμή μηδέν ή ένα. Η συνάρτηση ελέγχει ξεχωριστά αν υπάρχουν γραμμές οι οποίες περιέχουν
συγκεκριμένο αριθμό ζώνης και γράμμα ζώνης. Στο τελικό σύνολο δεδομένων καταγράφονται μόνο οι τοποθεσίες στις οποίες έχει υπάρξει τουλάχιστον ένα από τα δύο φυσικά φαινόμενα.
Η συνάρτηση `fp.apriori()` από τη βιβλιοθήκη `mlxtend.frequent_patterns` εφαρμόζει τον αλγόριθμο Apriori στο `DataFrame` "df"
και επιστρέφει ένα νέο `DataFrame` το οποίο περιέχει τα συχνά σύνολα στοιχείων μαζί με την υποστήριξή (support) τους. Αυτό επιτυγχάνετε με την εύρεση
συχνών ζεύγων δεδομένων και την αφαίρεση των μη-συχνών. Ενα ζεύγος θεωρείτε συχνό αν και τα δύο μέλη του είναι συχνά. Αυτό συνεχίζεται
μέχρι την κατασκευή τριπλέτας δεδομένων και την μη-εύρεση νέων συχνών συνόλων. Ο αλγόριθμος τρέχει πολλές φορές κάθε φορά εξαλείφοντας
δεδομένα μέχρι να βρεθεί το τελικό αποτέλεσμα. @mining-of-massive-datasets Τα αποτελέσματα δείχνουν
ότι στις σεισμικές δονήσεις η στήριξη είναι 0.989919, το οποίο σημαίνει ότι το 98.9919% των περιπτώσεων περιέχουν σεισμό. Για τις
ηφαιστειακές εκρήξεις η στήριξη είναι 0.120968, το οποίο σημαίνει ότι το 12.0968% των περιπτώσεων περιέχουν ηφαιστειακή έκρηξη.
Τα δύο συμβάντα μαζί έχουν τελική στήριξη 0.110887, το οποίο σημαίνει ότι το 11.0887% των περιπτώσεων περιέχουν και τα δύο γεγονότα. Εδώ
φαίνεται ότι ο μεγάλος αριθμός σεισμικών δονήσεων σε σχέση με τις λίγες ηφαιστειακές εκρήξεις στις αντίστοιχες βάσεις ενδεχομένως να έχει
αλλοιώσει τα αποτελέσματα.
#figure(image("final.png", width: 80%), supplement: "Εικόνα", caption: "Apriori")
Με βάση την στήριξη προηγουμένου (0.120968) και στήριξη επακόλουθου (0.989919) φαίνεται ότι υπάρχει 91.6667% να εκδηλωθεί σεισμική δόνηση
άν έχει προηγηθεί ηφαιστειακή έκρηξη.
zhangs_metric: Μια εναλλακτική μέτρηση η οποία συγκρίνει την εμπιστοσύνη με τη στήριξη του επακόλουθου. Εδώ είναι -0.083333. Επειδή η ανύψωση είναι μικρότερη του 1 και η επιρροή είναι αρνητική τιμή με βάση των αλγόριθμο τα δύο φαινόμενα δεν παρουσιάζουν
ισχυρή συσχέτιση.
= Πειραματικά Αποτελέσματα
Μετά τις απαραίτητες τροποποιήσεις τα αποτελέσματα αφού μετατράπηκαν σε utm συντεταγμένες φαίνονται στις παρακάτω εικόνες.
Παρατηρούμε ότι οι σεισμικές δονήσεις έχουν περισσότερες εγγραφές (23.217) από τις ηφαιστειακές εκρήξεις (265).
Λόγω αυτού τα αποτέλεσμα μπορεί να επηρεαστούν και να παρουσιάζουν την βάση με τα περισσότερα αποτελέσματα με μεγαλύτερη βαρύτητα.
Η εκτέλεση τους δεν διέφερε από το φόρτωμα των βάσεων και την εκτύπωση των πληροφοριών τους.
#figure(image("earthquake_events.png", width: 80%), supplement: "Εικόνα", caption: "Μέρος της βάσεις σεισμικές δονήσεις")
#figure(image("volcano_events.png", width: 80%), supplement: "Εικόνα", caption: "Μέρος της βάσεις ηφαιστειακές εκρήξεις")
Μετά την συσχέτιση των δεδομένων ο αριθμός των εγγραφών είναι μόνο 495 και βρίσκονται στο αρχείο `association.csv`, η διαδικασία
αυτή κυρίως στις πρώτες μορφές που είχε ο αλγόριθμος έπαιρνε μέχρι και 10 δευτερόλεπτα για την εκτέλεση της. Στον υπάρχοντα
κώδικα η διαδικασία συσχέτισης των δεδομένων και της εκτέλεσης του αλγόριθμου apriori διαρκεί περίπου 5 δευτερόλεπτα.
Αφού έχει πραγματοποιηθεί η συσχέτιση των δεδομένων με χρήση του αλγόριθμου apriori, ο οποίος πραγματοποιεί πολλαπλά
διαδοχικά περάσματα των δεδομένων μέχρι την εύρεση του τελικού συνόλου, θέτουμε το min_support (ελάχιστή υποστήριξη) ως
0.1, δηλαδή το ποσοστό που θα πρέπει να έχουν τα δεδομένα για να θεωρηθούν συχνά. Η υποστήριξη είναι χαμηλή επειδή μια
ενδεχόμενη αύξηση της μπορούσε να οδηγήσει στην μείωση των συχνών δεδομένων και κυρίως μείωση έως εξάλειψη των περισσότερων
δεδομένων που αφορούν στις εκρήξεις λόγο του μικρού όγκου τον δεδομένων σε σύγκριση με τις σεισμικές δονήσεις.
#figure(image("final.png", width: 80%), supplement: "Εικόνα 6", caption: "Αποτελέσματα apriori,min_support=0.1")
Τα αποτελέσματα δείχνουν ότι στις σεισμικές δονήσεις η στήριξη είναι 0.989919, το οποίο σημαίνει ότι το 98.9919% των περιπτώσεων
περιέχουν σεισμό. Για τις ηφαιστειακές εκρήξεις η στήριξη είναι 0.120968, το οποίο σημαίνει ότι το 12.0968% των περιπτώσεων
περιέχουν ηφαιστειακή έκρηξη. Τα δύο συμβάντα μαζί έχουν τελική στήριξη 0.110887, το οποίο σημαίνει ότι το 11.0887% των περιπτώσεων
περιέχουν και τα δύο γεγονότα. Εδώ φαίνεται ότι ο μεγάλος αριθμός σεισμικών δονήσεων σε σχέση με τις λίγες ηφαιστειακές εκρήξεις
στις αντίστοιχες βάσεις ενδέχεται να έχει αλλοιώσει τα αποτελέσματα.
#figure(image("final.png", width: 80%), supplement: "Εικόνα 3", caption: "Apriori")
Με βάση την στήριξη προηγουμένου (0.120968) και στήριξη επακόλουθου (0.989919) δείχνουν ότι υπάρχει 91.6667% να εκδηλωθεί σεισμική δόνηση
εάν έχει προηγηθεί ηφαιστειακή έκρηξη. Το αποτέλεσμα του αλγορίθμου αυτού είναι αντίθετο από το αναμενόμενο και είναι επίσης αντίθετο
με τις μελέτες οι οποίες έχουν γίνει, δηλαδή ότι υπάρχει πιθανότητα σεισμοί να προκαλούν ηφαιστειακές εκρήξεις.
Όμως, σε αυτή την έρευνα όχι μόνο έχουμε αντίθετα αποτελέσματα άλλα υπάρχει συντριπτικά μεγάλη εμπιστοσύνη για την εκδήλωση σεισμού και μετά
έκρηξης. Ακόμα και στις υπόλοιπες μελέτες δεν θεωρείτε δεδομένο τι προκάλεσε το άλλο πόσο μάλλον με τόσες πιθανότητες.
Επειδή όμως η συνολική ανύψωση είναι 0.926001 μικρότερη του 1, μειώνεται ελαφρώς η εμφάνιση του προηγουμένου, δηλαδή των ηφαιστειακών εκρήξεων
εμφάνισης του επακόλουθου (σεισμικών δονήσεων), υπενθυμίζουμε ότι αν η ανύψωση ήταν 1 τότε τα γεγονότα θα ήταν ανεξάρτητα. Το Zhang's Metric και
Leverage όντας και τα δύο αρνητικά -0.083333 και -0.008861 αντίστοιχα, δείχνουν και τα δύο αρνητική συσχέτιση.
Καθώς χρειάζεται πρώτα η συσχέτιση των δεδομένων ο αλγόριθμος apriori έχει σχεδόν άμεση εκτέλεση αν λάβουμε υπόψη μας
την εκτέλεση πρώτα της συσχέτισης των δεδομένων.
Μια δοκιμή εκτέλεσης του αλγορίθμου με τιμές ελάχιστή υποστήριξη πάνω του 0.1 δεν θα παραχθούν συχνά σύνολα
#figure(image("final_empty.png", width: 80%), supplement: "Εικόνα 6", caption: "Αποτελέσματα apriori,min_support=0.1")
= Κριτική αποτίμηση αποτελεσμάτων
Με τις συντεταγμένες UTM παρότι είναι δυνατή η εύκολη διαμοίραση περιοχών πάνω στο χάρτη ο αλγόριθμος συσχέτισης
που χρησιμοποιείται δεν ελέγχει τις γύρω περιοχές/πλέγματα για να συγκρίνει και τις περιοχές αυτές σε περίπτωση που
ένα συμβάν βρίσκεται κοντά στις άκρες ενός πλέγματος. Αν γινόταν και αυτή η σύγκριση τα αποτελέσματα ενδεχομένως να διέφεραν σε έναν βαθμό
κυρίως στις περιοχές που συγκρούονται οι τεκτονικές πλάκες και υπάρχουν ηφαιστειογενείς ζώνες.
Επιπλέον, θα μπορούσε να υπάρξει και ισορρόπηση των αποτελεσμάτων μεταξύ των δύο βάσεων δεδομένων με την ενδεχόμενη απαλοιφή
των σεισμικών δονήσεων που έγιναν σε μια περιοχή λόγω της ύπαρξης πολλών επακόλουθων σεισμικών δονήσεων
την ίδια χρονική περίοδο πριν την συσχέτιση.
= Συμπεράσματα
Λαμβάνοντας υπόψη τα τελικά αποτελέσματα, οι ηφαιστειακές εκρήξεις προηγούνται των σεισμών. Παρόλα αυτά, λόγω πιθανών λαθών μεθοδολογίας δεν μπορεί να δοθεί ξεκάθαρη απάντηση. Όπως προαναφέρθηκε στην εισαγωγή, με βάση την υπάρχουσα βιβλιογραφία οι σεισμοί ορισμένες φορές προκαλούν ηφαιστειακές εκρήξεις, κάτι το οποίο έξω από αυτή την ερεύνα έχει αποτελέσει αφορμή για πολλές συζήτησης.
#pagebreak()
#bib("bib.yml") |
|
https://github.com/Mc-Zen/pillar | https://raw.githubusercontent.com/Mc-Zen/pillar/main/tests/examples/ascii-table/test.typ | typst | MIT License | #set page(width: auto, height: auto, margin: 1pt)
#import "/src/pillar.typ"
#let clr = if "dark" in sys.inputs { white } else { black }
#set page(fill: white) if clr == black
#set text(fill: clr)
#set table.hline(stroke: clr)
#set table.vline(stroke: clr)
#pillar.table(
cols: "ccc|ccc|[1.8pt + blue] l[5cm]",
[Dec],[Hex],[Bin],[Symbol], [HTML code], [HTML name], [Description],
table.hline(),
[32], [20], [00100000], [ ], [], [SP], [Space],
[33], [21], [00100001], [!], [!], [!], [Exclamation mark],
[34], [22], [00100010], ["], ["], ["], [Double quotes],
[35], [23], [00100011], [#], [#], [\#], [Number sign],
[36], [24], [00100100], [$], [$], [\$], [Dollar sign],
[37], [25], [00100101], [%], [%], [%], [Percent sign],
[38], [26], [00100110], [&], [&], [&], [Ampersand],
[39], [27], [00100111], ['], ['], ['], [Single quote],
[40], [28], [00101000], [(], [&lparen;], [(], [Opening parenthesis],
[41], [29], [00101001], [)], [&rparen;], [)], [Closing parenthesis],
)
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/xarrow/0.1.0/lib.typ | typst | Apache License 2.0 | // Create a longer arrow, almost the way TeX does it. That is, repeating a truncated version
// of the symbol. This is arguably less elegant than using the scale function, but
// will look better with most renderers.
// The symbol is divided is three parts, as defined by the section parameter.
// Please adjust this parameter and/or use longer versions of the given arrows
// if artefacts occur.
#let xarrow(
sym: sym.arrow.long, // the arrow symbol to use
margin: 0.15em, // margins surrounding body over the symbol on each side
sections: (40%, 60%), // delimiting the symbol in three parts, the central one is repeated
reducible: false, // whether the symbol can be shorter than the original if body is too narrow
partial_repeats: true, // whether the central part can be partially repeated
body
) = style(styles => {
assert(type(sym) == "symbol", message: "xarrow: input symbol must be of type `symbol`")
let sym = $ #sym $
let (begin, end) = sections
assert(begin > 0%, message: "xarrow: middle section must start within the symbol")
assert(begin < end, message: "xarrow: sections must be given in increasing order")
assert(end < 100%, message: "xarrow: middle section must end within the symbol")
let (body_width, _) = measure($limits("")^#body$, styles).values()
let (sym_w, sym_h) = measure(sym, styles).values()
// Using styles to find the value of the margins, otherwise not comparable
let margin_absolute = measure(line(length: margin), styles).width
let repeated_width = body_width + 2 * margin_absolute - (100% - end + begin) * sym_w
// Repeat the body to fit the given width
let fit_width(width, styles, partial_repeats, body) = {
let (body_width, body_height) = measure(body, styles).values()
if partial_repeats {
let repeats = calc.floor(width / body_width)
let remainder = width - repeats * body_width
body * repeats
box(height: body_height, width: remainder, clip: true, body)
} else {
let repeats = calc.ceil(width / body_width)
body * repeats
}
}
// using non-empty baseline to trick the compiler and not recomputing another
// baseline for the box, which would lead to incorrect alignment.
box(baseline: 1e-10pt, math.attach(
math.limits({
if not reducible and repeated_width < (end - begin) * sym_w {
sym
} else {
// The contents in the boxes are centered, using `place` to center the view
// on the desired sections.
box(width: begin * sym_w, height: sym_h, clip: true,
place(dx: (100% - begin) / 2 * sym_w, sym)
)
h(0cm)
fit_width(repeated_width, styles, partial_repeats,
box(height: sym_h, width: (end - begin) * sym_w, clip: true,
place(dx: (100% - begin - end) / 2 * sym_w, sym)
)
)
h(0cm)
box(width: (100% - end) * sym_w, height: sym_h, clip: true,
place(dx: - end / 2 * sym_w, sym)
)
}
}),
t: body,
))
})
// Some alternative arrow styles.
#let xarrowHook = xarrow.with(sym: sym.arrow.hook)
#let xarrowDouble = xarrow.with(sym: sym.arrow.double.long)
#let xarrowHead = xarrow.with(sym: sym.arrow.twohead, sections: (10%, 20%), partial_repeats: false)
#let xarrowSquiggly = xarrow.with(sym: sym.arrow.long.squiggly, sections: (20%, 45%), partial_repeats: false)
#let xarrowDashed = xarrow.with(sym: sym.arrow.dashed, sections: (20%, 51%), partial_repeats: false)
|
https://github.com/mrtz-j/typst-thesis-template | https://raw.githubusercontent.com/mrtz-j/typst-thesis-template/main/template/chapters/utilities.typ | typst | MIT License | #import "../utils/todo.typ": TODO
#import "../utils/feedback.typ": feedback
#import "../utils/form.typ": form
Now we will take a look at some useful custom utilities included with this template under `utilities/`. If you find yourself needing some other function for your thesis, it's a great idea to implement it here and include it in your chapters in the same manner.
== Figures <subsec:util_figures>
We've already seen the utilities we have implemented for use with figures earlier, refer to @subsec:subfigures.
== TODOs and Feedback <subsec:feedback_todo>
Two functions are available for inserting temporary comments into the document to help you while writing your thesis.
#TODO()[The `#TODO()` function is handy for inserting comments to your future self about your thesis. It has a default yellow color to make it easily visible and prevent you from overseeing it when reviewing the document.]
#TODO(
color: red,
title: "FIXME",
)[Alternatively, you can also pass in another color and/or title to distinguish different types of notes from one another]
#feedback(
feedback: [Another function is `#feedback()`. It lets your advisor easily insert feedback comments into your document...],
response: [...and also lets you add your own response to the note so that you can discuss it in your next meeting. Also note that #link("https://typst.app") has a comment functionality, however it requires a paid subscription.],
)
== Forms <subsec:forms>
In some cases, you might want to print out your document and leave spots for yourself or others to add data such as signatures to it by hand. This can be achieved using the `#form()` utility function. Leaving the second argument empty, we can leave space for the signature:
#form([Leslie Lamport \ Main supervisor], [])
We can also fill in the content with typst by supplying some content:
#form([Date and location], [#datetime.today().display() -- Tromsø, Norway])
== Abbreviations <subsec:abbreviations>
In order to easily deal with abbreviations in an automatic and consistent manner, the glossarium #footnote()[see #link("https://typst.app/universe/package/glossarium/")] package is used in this template. As an input to the thesis function in `thesis.typ` we can supply a dictionary of glossary entries, giving a short version and a long one. These entries will be displayed at the start of the thesis in the List of Abbreviations.
When we refer to an abbreviation the first time in the document, the long version will be printed: @uit. All subsequent references will instead use the short one: @uit. After we have referred to @cpu the first time, we might also want to refer to it in plural when writing about multiple @cpu:pl.
|
https://github.com/thornoar/hkust-courses | https://raw.githubusercontent.com/thornoar/hkust-courses/master/MATH1023-Honors-Calculus-I/homeworks/homework-6/main.typ | typst | #import "@local/common:0.0.0": *
#import "@local/templates:0.0.0": *
#import "@local/drawing:0.0.0": *
#import "@local/theorem:0.0.0": *
#let thmstyle = thmstyle.with(base: none)
#show: thmrules
#let args = (base: none, titlefmt: it => underline(strong(it)))
#let lm = statestyle("lemma", "Lemma", ..args)
#let def = plainstyle("definition", "Definition", ..args)
#let note = plainstyle("note", "Note", ..args)
#show: math-preamble("Part 6", "Fri, Oct 25")
// #show math.lim: math.limits(math.lim)
#let ee = math.epsilon
#let dd = math.delta
#math-problem("2.1.1")
Prove the continuity of $-|x|$ and $|x+a|$ at any $x_0$.\
#math-solution
To prove the continuity of $-|x|$, let $x_0 in RR$ and $ee > 0$.
Take $dd = ee$. We have
$
|x-x_0| <= dd ==>
|-|x|-(-|x_0|)| = abs(|x_0|-|x|) <= |x_0 - x| = |x - x_0| <= dd = ee.
$
To prove the continuity of $|x+a|$, consider $x_0 in RR$ and $ee > 0$.
With $dd = ee$, we write
$
|x-x_0| <= dd ==>
abs(|x+a|-|x_0+a|) <= abs((x+a)-(x_0 + a)) = |x - x_0| <= dd = ee.
$
#math-problem("2.1.3") Prove the continuity of $sqrt(x)$ at any $x_0 > 0$.\
#math-solution
Let $x_0 > 0$ and $ee > 0$ be arbitrary.
For some $x > 0$, the difference $abs(sqrt(x) - sqrt(x_0))$ can be expressed in the following way:
$
abs(sqrt(x) - sqrt(x_0)) = (abs(sqrt(x) - sqrt(x_0)) dot abs(sqrt(x) + sqrt(x_0)))/abs(sqrt(x) + sqrt(x_0)) = abs(x - x_0)/(sqrt(x) + sqrt(x_0)) < abs(x - x_0)/sqrt(x_0).
$
Now we choose $dd = ee sqrt(x_0)$.
For $x$ satisfying $abs(x-x_0) <= dd$, we have
$
abs(sqrt(x) - sqrt(x_0)) < abs(x - x_0)/sqrt(x_0) <= dd/sqrt(x_0) = ee.
$
#math-problem("2.1.5") Prove the continuity at 0:
+ $sin 2x$;
+ $cos 3x$;
+ $sin^2 x$;
+ $cos^2 x$.
#math-solution
+ Let $ee > 0$. Since $sin$ is continuous at 0, there is $dd > 0$ such that
#centering[
$abs(x) <= dd$ implies $abs(sin x) <= ee$.
]
Take $dd' = dd/2$. We have
$
abs(x) <= dd' ==> abs(2x) <= dd ==> abs(sin 2x) <= ee.
$
+ Let $ee > 0$. Since $cos$ is continuous at 0, there is $dd > 0$ such that
#centering[
$abs(x) <= dd$ implies $abs(cos x - 1) <= ee$.
]
Take $dd' = dd/3$. We have
$
abs(x) <= dd' ==> abs(3x) <= dd ==> abs(cos 3x - 1) <= ee.
$
+ Let $ee > 0$. Take $ee' = min(ee, 1)$. There is a $dd > 0$ such that
#centering[
$abs(x) <= dd$ implies $abs(sin x) <= ee'$.
]
Since $abs(sin x) <= 1$ for such $x$, we have
$
abs(x) <= dd ==> abs(sin^2 x) <= abs(sin x) <= ee' <= ee.
$
+ Let $ee > 0$. Take $ee' = ee/2$. There is a $dd > 0$ such that
#centering[
#h(1fr) $abs(x) <= dd$ implies $abs(sin x) <= ee'$. #h(1fr)
]
Since $abs(cos x + 1) <= 2$ for all $x$, we have
$
abs(x) <= dd ==> abs(cos^2 x - 1) = abs(cos x - 1) dot abs(cos x + 1) <= ee' dot 2 = ee.
$
#math-problem("2.1.6 (1)")
Prove the following is equivalent to the definition of the continuity of $f(x)$ at $x_0$:
#centering[
#h(1fr) For any $epsilon > 0$, there is $delta > 0$, such that $abs(x - x_0) < delta$ implies $abs(f(x) - l) < epsilon$. #h(1fr) (1)
]
#math-solution
We prove the equivalence by proving two implications:
/ $==>:$:
Assuming that $f$ is continuous at $x_0$, we prove condition (1).
Consider an arbitrary $ee > 0$. Take\ $ee' := ee\/2$.
Since $f$ is continuous at $x_0$, for our $ee'$ there is $dd' > 0$ such that
#centering[
$abs(x - x_0) <= dd'$ implies $abs(f(x) - l) <= ee'$.
]
Now, take $dd := dd'$. We write
$
abs(x - x_0) < delta ==> abs(x - x_0) <= dd = dd' ==> abs(f(x) - l) <= ee' ==> abs(f(x) - l) < ee,
$
hence we have found $delta$ such that condition (1) holds.
/ $<==:$:
Assuming condition (1), we prove that $f$ is continuous at $x_0$.
Consider an arbitrary $ee > 0$. Take\ $ee' := ee$. By condition (1), for this $ee'$ there is $dd' > 0$ such that
#centering[
$abs(x - x_0) < dd'$ implies $abs(f(x) - l) < ee'$.
]
We now take $dd := dd'\/2$ and have
$
abs(x - x_0) <= dd = dd'/2 ==> abs(x - x_0) < dd' ==> abs(f(x) - l) < ee' = ee ==> abs(f(x) - l) <= ee,
$
hence $f$ is continuous at $x_0$.
#math-problem("2.1.7 (2, 4"))
Find the limits: #v(2mm)
2. $limits(lim)_(x -> 1) (x^3-1)/(x-1)$; #v(2mm)
4. $limits(lim)_(x -> 4) (x-4)/(sqrt(x)-2)$.
#math-solution
2.
$
(x^3 - 1)/(x-1) = ((x-1)(x^2 + x + 1))/(x-1) = x^2 + x + 1 ->_(x -> 1) 3.
$
4.
$
(x-4)/(sqrt(x)-2) = ((sqrt(x)-2)(sqrt(x)+2))/(sqrt(x)-2) = sqrt(x)+2 ->_(x -> 2) sqrt(4) + 2 = 4.
$
#math-problem("2.1.10")
Suppose $limits(lim)_(x -> x_0) f(x) = l != 0$.
Prove $limits(lim)_(x -> x_0) 1/f(x) = 1/l$.\
#math-solution
Let $ee > 0$.
First of all, since $l != 0$, there is a sufficiently small $alpha > 0$ such that $0 in.not [l - alpha, l + alpha]$.
Now, define $ee'$ as follows:
$
ee' = min{alpha,#h(2mm) epsilon abs((l-alpha)l),#h(2mm) epsilon abs((l+alpha)l)}.
$
Since $f(x)$ approaches $l$ when $x -> x_0$, for our $ee'$ there is $dd'$ such that
#centering[
$0 < abs(x - x_0) <= dd'$ implies $abs(f(x) - l) <= ee'$.
]
When $abs(f(x) - l) <= ee'$, we also have $abs(f(x) - l) <= alpha$ (by the definition of $ee'$), hence $f(x) != 0$. What's more, $f(x)$ lies between $l - alpha$ and $l + alpha$, meaning that
$
abs(f(x)) >= min{abs(l-alpha), abs(l+alpha)},
$
and
$
1/abs(f(x)) <= 1/min{abs(l-alpha), abs(l+alpha)} = 1/A,
$
where $A = min{abs(l-alpha), abs(l+alpha)}$. Finally, by the definition of $ee'$ we have that $ee' <= ee dot A dot abs(l)$.
Now, take $dd := dd'$. Our goal is to show
$
abs(x - x_0) <= dd ==> abs(1/f(x) - 1/l) <= ee.
$
Indeed,
$
abs(x - x_0) <= dd = dd' ==> abs(f(x) - l) <= ee' ==>\
==> abs(1/f(x) - 1/l) = abs((l - f(x))/(f(x) l)) = abs(f(x) - l)/(abs(l) dot abs(f(x))) <= ee'/(abs(l) dot A) <= ee,
$
q.e.d.
#math-problem("2.1.11 (4)")
Show that $(x cos x)/(x+1)$ converges to 0 at 0.\
#math-solution
// When $x$ is close to 0, we can assume that $x+1 > 0$.
First, consider the following convergence:
$
abs(x/(x+1)) = abs(1 - 1/(x+1)) ->_(x -> 0) abs(1 - 1/1) = 0.
$
Now, since
$
-abs(x/(x+1)) <= -abs((x cos x)/(x+1)) <= (x cos x)/(x+1) <= abs((x cos x)/(x+1)) <= abs(x/(x+1)),
$
we have that the original function converges to 0 at 0 by the sandwich rule.
#math-problem("2.1.13")
Prove the second part of the order rule.\
#math-solution
Let $limits(lim)_(x -> x_0) f(x) = k$ and $limits(lim)_(x -> x_0) g(x) = l$, such that $k < l$.
Denote the difference $l-k$ by $alpha > 0$.
Take $ee_1 = alpha/3$ and $ee_2 = alpha/3$.
By the definition of limit, we have $dd_1, dd_2 > 0$ such that
$
0 < abs(x - x_0) <= dd_1 ==> abs(f(x) - k) <= ee_1 = alpha/3,\
0 < abs(x - x_0) <= dd_2 ==> abs(g(x) - l) <= ee_2 = alpha/3.\
$
Take $dd = min (dd_1, dd_2)$. We have
$
0 < abs(x - x_0) <= dd ==> f(x) <= k + alpha/3 < l - alpha/3 <= g(x).
$
#math-problem("2.1.15 (2)")
Explain the divergence of $limits(lim)_(x -> 0) 1/x cos 1/x$.\
#math-solution
We will do a proof by contradiction.
Assume that the function *does* converge at 0, and denote its limit by $l$.
Then, choose $ee > 0$ to be arbitrary.
There is a $dd > 0$ such that
$
0 < abs(x) <= dd ==> abs(1/x cos 1/x - l) <= ee
$
For $0 < x <= dd$, the latter implies
$
abs(cos 1/x - l x) <= ee x.
$
Choose $x_0$ such that $0 < x_0 <= dd$, $abs(l) x < 1/3$, and $ee x < 1/3$.
Then, for all $0 < x < x_0$ we have
$
abs(cos 1/x) <= abs(cos 1/x - l x) + abs(l x) <= ee x + abs(l) x < 2/3.
$
Therefore, for all $x > 1/x_0$, we have $abs(cos x) < 2/3$.
This is a contradiction with the fact that $cos x$ is a periodic function.
#math-problem("2.1.16 (4)")
Find the limit, $a, b > 0$:
$
limits(lim)_(x -> 0) 1/x (sqrt((a+x)/b) - sqrt(a/(b+x))).
$
#math-solution
We transform the expression:
$
1/x (sqrt((a+x)/b) - sqrt(a/(b+x))).
$
/*
#math-problem("2.1.18")
#math-problem("2.1.19")
#math-problem("2.1.24 (1, 3, 6)")
#math-problem("2.2.1")
#math-problem("2.2.4 (2)")
#math-problem("2.2.5 (1, 4)")
#math-problem("2.2.7")
#math-problem("2.2.10 (3)")
#math-problem("2.2.12 (first extra condition)")
#math-problem("2.2.14 (5)")
#math-problem("2.2.15")
#math-problem("2.2.18")
#math-problem("2.2.21")
#math-problem("2.2.22 (2, 8, 9)")
#math-problem("2.2.23 (2)")
#math-problem("2.2.27")
*/
// Let us first prove the following lemma:
// #lm[
// Let $f$ and $g$ be functions such that $f$ is continuous at $x_0 in RR$ and $g$ is continuous at $f(x_0)$. Then their composition $g circ f$ is continuous at $x_0$.
// ]
// #pf[
// Let $ee > 0$.
// Then, since $g$ is continuous at $f(x_0)$, there is $dd > 0$ such that $
// abs(x - f(x_0)) <= dd ==> abs(g(x) - g(f(x_0))) <= ee.
// $
// For this acquired $dd$, there is $gamma > 0$ such that
// $
// abs(x - x_0) <= gamma ==> abs(f(x) - f(x_0)) <= dd.
// $
// Finally, we have
// $
// abs(x - x_0) <= gamma ==> abs(f(x) - f(x_0)) <= dd ==> abs(g(f(x)) - f(g(x_0))) <= ee,
// $
// meaning that $(g circ f)(x) = g(f(x))$ is continuous at $x_0$.
// ]
// Now, consider a constant $k > 0$. We shall prove that $f(x) = k x$ is continuous at any $x_0$. Indeed, for every $ee > 0$ choose $dd = ee/k$. We have
// $
// abs(x - x_0) <= dd ==> abs(x - x_0) <= ee/k ==> abs(k x - k x_0) <= ee.
// $
// Finally, we easily see that $sin 2x$ is continuous as the composition of $f(x) = 2x$ and $g(x) = sin x$, and so is $cos 3x$. The function $sin^2 x$ is continuous at 0 as the composition of $f(x) = sin x$ and $g(x) = x^2$, and $cos^2 x$ is continuous at 0 as the composition of $f(x) = cos x$ and $g(x) = x^2$.
|
|
https://github.com/LDemetrios/ProgLectures | https://raw.githubusercontent.com/LDemetrios/ProgLectures/main/02-kotlin-oop.typ | typst | #import "kotlinheader.typ" : *
#show : kt-paper-rule
= Объектно-ориентированное программирование
#kt-par[
Допустим, мы хотим уметь хранить вместе связанные данные. Например, точку ---
две координаты и имя. Ну, _как-то_ это сделать мы умеем:
]
#kt-eval(```
listOf(1.0, 2.0, "A")
```)
#kt-res(`[1.0, 2.0, A]`, `List<Comparable<*>>`)
#kt-par[
И теперь при чтении элементов, если мы абсолютно уверены, какого они типа,
используем знакомый нам оператор as:
]
#kt-eval(```
val arr = listOf(1.0, 2.0, "A")
arr[2] as String
```)
#kt-res(`"A"`, KtString)
#kt-par[
Во-первых, компилятор нам надоест предупреждениями об unchecked cast. Во-вторых,
оператор as на самом деле занимает довольно много времени, так как неявно ещё и
производит дорогую проверку типов. В-третьих, мы сами рискуем быстро забыть, кто
на ком стоял, в каком элементе хранится что и какого типа.
]
#kt-par[
Можно решить проблему с типами с помощью специальных конструкций языка: `Pair` и
`Triple`.
]
#kt-eval(```
Triple(1.0, 2.0, "A")
```)
#kt-res(`(1.0, 2.0, A)`, `Triple<Double, Double, String>`)
#kt-par[
Теперь мы можем обращаться к элементам по именам first, second, third:
]
#kt-eval(```
Triple(1.0, 2.0, "A").third
```)
#kt-res(`"A"`, KtString)
#kt-par[
Для создания пары есть инфиксная функция to:
]
#kt-eval(```
1 to "PTHS"
```)
#kt-res(`(1, PTHS)`, `Pair<Int, String>`)
#kt-par[
Элементы, соответственно, first и second. Вроде всё замечательно?
]
#strikeleft[
#kt-par[
Предположим, вы ведёте курс в ФТШ и хотите, чтобы код в ваших конспектах был
корректно подсвечен. Вы пишете программу, разбирающую код и решающую, что и как
подсветить.
]
#kt-par[
Из чего состоит, скажем, объявление функции?
- Перечень модификаторов
- Имя
- Список параметров
- Возможно, явное объявление возвращаемого типа
- Тело функции
Это пять элементов. Мы так плохо умеем, но ведь пары и тройки можно вкладывать
друг в друга.
]
`Triple<`modifiers`, `name`, Triple<`arguments`, `return type`?, `function
body`>>`
]
#strikeleft[
#kt-par[
Модификаторы --- это строки, имя --- строка. Возвращаемый тип --- для простоты
допустим, тоже, тело функции --- перечень выражений. Аргументы --- список пар
(имя, тип)
]
`Triple<List<String>, String, Triple<List<Pair<String, String>>, String?, List<`statement`>>`
#kt-par[
И это ещё не всё, statement-то это тоже нечто непростое. А лично я уже
запутался.
]
]
#kt-par[
Давайте объявим новый тип данных.
]
#kt-eval-noret(```
data class Point(val x: Double, val y: Double, val name: String)
```)
#kt-par[
data class --- собственно, объявление (чем data class отличается от просто class
--- в конце лекции). Дальше идёт объявление _полей_ --- постоянная (val) или
переменная (var), затем имя и тип.
]
#kt-eval-append(```
Point(1.0, 2.0, "A")
```)
#kt-res(`Point(x=1.0, y=2.0, name=A)`, `Point`)
#kt-par[
Строковое представление тут тоже немного хромает, но читаемо. Да и не это обычно
важно, и это мы ещё научимся менять. Что важно, теперь у нас есть именованные и
типизированные элементы, а ещё лакониченое именование типа.
]
#kt-eval-append(```
val point = Point(1.0, 2.0, "A")
point.y
```)
#kt-res(`2.0`, KtDouble)
#kt-par[
Давайте попробуем написать трёхмерный вектор.
]
#kt-eval(```
data class Vector(val x: Double, val y: Double, val z: Double)
```)
#kt-par[
Отлично. Теперь добавим пару функций для работы с ним.
]
#kt-eval-append(```
fun add(a: Vector, b: Vector) = Vector(a.x + b.x, a.y + b.y, a.z + b.z)
fun sub(a: Vector, b: Vector) = Vector(a.x - b.x, a.y - b.y, a.z - b.z)
fun multiply(a: Vector, k: Double) = Vector(a.x * k, a.y * k, a.z * k)
fun scalar(a: Vector, b: Vector) = a.x * b.x + a.y * b.y + a.z * b.z
fun magnitude(a: Vector) = sqrt(scalar(a, a))
```)
#kt-par[
Проверим теперь, что работает:
]
#kt-eval-append(```
val a = Vector(5.0, 6.0, 6.0)
val b = Vector(30.0, 30.0, 30.0)
val c = Vector(2.0, 3.0, 9.0)
add(a, b)
```)
#kt-res(`Vector(x=35.0, y=36.0, z=36.0)`, `Vector`)
#kt-eval-append(```
sub(a, c)
```)
#kt-res(`Vector(x=3.0, y=3.0, z=-3.0)`, `Vector`)
#kt-eval-append(```
multiply(a, 3.0)
```)
#kt-res(`Vector(x=15.0, y=18.0, z=18.0)`, `Vector`)
#kt-par[
Вроде всё хорошо. Однако теперь стоит заметить, что в глобальном поле может
оказаться очень много функций с одинаковыми названиями. Например, мы захотим
складывать вектора, матрицы, комплексные числа и прочие штуки. Так-то это не
проблема, если типы аргументов известны в момент компиляции, то выберется
правильная версия:
]
#kt-eval(```
fun process(x: Int) {
println("Int version for " + x)
}
fun process(x: Double) {
println("Double version for " + x)
}
process(1)
process(2.0)
```)
#kt-res(`Unit`, KtUnit)
#kt-print(```
Int version for 1
Double version for 2.0
```)
#kt-par[
Тип аргументов, как и название функции, входит в _сигнатуру функции_, то есть, в
некотором роде, её уникальное описание. Возвращаемый тип --- не входит, хотя
есть определённые способы обойти это ограничение, можно посмотреть лекцию про
generics, раздел reified.
]
#kt-par[
Но вот загрязнение глобального пространства имён --- не дело. Давайте поместим
эти функции в отдельный namespace.
]
#kt-par[
Для этого делаем следующее:
]
#kt-eval(```
data class Vector(val x: Double, val y: Double, val z: Double) {
companion object {
fun add(a: Vector, b: Vector) = Vector(a.x + b.x, a.y + b.y, a.z + b.z)
fun sub(a: Vector, b: Vector) = Vector(a.x - b.x, a.y - b.y, a.z - b.z)
fun multiply(a: Vector, k: Double) = Vector(a.x * k, a.y * k, a.z * k)
fun scalar(a: Vector, b: Vector) = a.x * b.x + a.y * b.y + a.z * b.z
fun magnitude(a: Vector) = sqrt(scalar(a, a))
}
}```)
#kt-par[
Теперь, чтобы обратиться к этим функциям, нужно их явно квалифицировать:
]
#kt-eval-append(```
Vector.add(Vector(5.0, 6.0, 6.0), Vector(2.0, 3.0, 9.0))
```)
#kt-res(`Vector(x=7.0, y=9.0, z=15.0)`, `Vector`)
#kt-par[
Технически, теперь `Vector.add` --- это и есть полное имя функции.
]
#nobreak[
#kt-par[Да, давайте
добавим ещё пару интересных функций...
]
#kt-eval(```
data class Vector(val x: Double, val y: Double, val z: Double) {
companion object {
fun add(a: Vector, b: Vector) = Vector(a.x + b.x, a.y + b.y, a.z + b.z)
fun sub(a: Vector, b: Vector) = Vector(a.x - b.x, a.y - b.y, a.z - b.z)
fun multiply(a: Vector, k: Double) = Vector(a.x * k, a.y * k, a.z * k)
fun scalar(a: Vector, b: Vector) = a.x * b.x + a.y * b.y + a.z * b.z
fun magnitude(a: Vector) = sqrt(scalar(a, a))
fun ofList(list: List<Double>) = Vector(list[0], list[1], list[2])
fun ofNumbers(x: Number, y: Number, z: Number) : Vector {
return Vector(x.toDouble(), y.toDouble(), z.toDouble())
}
}
}```)
]
#kt-par[
Честно говоря, можно заметить, что часто функции, которые хотелось бы положить в
companion object класса T, либо принимают T одним из аргументов, либо возвращают
T. Более того, на практике часто приходится писать очень много вложенных
функций, как то, например:
]
#kt-eval-noret(```
joinToString(
takeWhile(
map(
filter(
0 until 100,
{ it % 6 == 0}
),
{ it * it }
),
{ it <= 1000}
)
)
```)
#kt-par[
(Примечание: код выше является иллюстрацией, в текущих версиях Котлина таких
функций в стандартной библиотеке нет).
]
#kt-par[
Что делает этот код?
- Берёт список от нуля до ста
- Фильтрует его, оставляя только числа, кратные шести
- Возводит каждое число в квадрат
- Оставляет только те, которые меньше 1000
- Соединяет всё в строку
]
#kt-res(`"0, 36, 144, 324, 576, 900"`, KtString)
#kt-par[
Всё бы ничего, но выглядит этот код... плохо. Читать снизу вверх, справа налево.
Поэтому существует возможность объявить функцию как условно-постфиксную
(помните, в предыдущей лекции об этом было?).
]
#nobreak[
#kt-par[
И код внезапно обретёт смысл не
только на бумаге, но и визуально:
]
#kt-eval(```
(0 until 100)
.filter({ it % 6 == 0 })
.map({ it * it })
.takeWhile({ it <= 1000 })
.joinToString()
```)
#kt-res(`"0, 36, 144, 324, 576, 900"`, KtString)
]
#kt-par[
И как это сделать? Объявить функцию в теле класса, но не в companion object.
Тогда это будет _метод_, который можно _вызвать на_ объекте этого класса.
Объект, на котором вызывается метод (слева от точки) передаётся функции в
неявный аргумент с именем this.
]
#kt-eval(
```
data class Vector(val x: Double, val y: Double, val z: Double) {
companion object {
fun ofList(list: List<Double>) = Vector(list[0], list[1], list[2])
fun ofNumbers(x: Number, y: Number, z: Number) : Vector {
return Vector(x.toDouble(), y.toDouble(), z.toDouble())
}
}
fun add(that: Vector) = Vector(this.x + that.x, this.y + that.y, this.z + that.z)
fun sub(that: Vector) = Vector(this.x - that.x, this.y - that.y, this.z - that.z)
fun multiply(k: Double) = Vector(this.x * k, this.y * k, this.z * k)
fun scalar(that: Vector) = this.x * that.x + this.y * that.y + this.z * that.z
fun magnitude() = sqrt(this.scalar(this))
}
```,
)
#kt-par[
Если есть второй (на самом деле первый) аргумент того же типа, то его часто
называют `that` или `another`. Проверим, что работает:
]
#kt-eval-append(```
val a = Vector.ofNumbers(5, 6, 6)
val b = Vector.ofNumbers(2, 3, 9)
a.add(b)
```)
#kt-res(`Vector(x=7.0, y=9.0, z=15.0)`, `Vector`)
#kt-eval-append(```
a.magnitude()
```)
#kt-res(`9.848857801796104`, KtDouble)
#kt-par[
Замечание первое: обращаться к this явным образом не всегда обязательно. Если
просто написать идентификатор, то в первую очередь компилятор поищет локальную
переменную с таким именем, потом аргумент функции, и наконец, поле this. Если вы
не занимаетесь странным неймингом, называя одним и тем же именем всё, что
попало, то всё у вас будет хорошо. Замечание второе: чтобы объявить функцию
инфиксной, достаточно дописать к ней модификатор infix (работает только с
методами, имеющими ровно один явный аргумент). Для того, чтобы код лучше
читался, поменяем имена немного (add, sub, multiply на plus, minus, times)
Замечание третье: чтобы обеспечить, наконец, нормальное строковое представление
нашему классу, определим в нём специальный метод toString.
]
#nobreak[
#kt-par[
Итого получаем:
]
#kt-eval(
```
data class Vector(val x: Double, val y: Double, val z: Double) {
companion object {
fun ofList(list: List<Double>) = Vector(list[0], list[1], list[2])
fun ofNumbers(x: Number, y: Number, z: Number): Vector {
return Vector(x.toDouble(), y.toDouble(), z.toDouble())
}
}
infix fun plus(that: Vector) = Vector(x + that.x, y + that.y, z + that.z)
infix fun minus(that: Vector) = Vector(x - that.x, y - that.y, z - that.z)
infix fun times(k: Double) = Vector(x * k, y * k, z * k)
infix fun dot(that: Vector) = x * that.x + y * that.y + z * that.z
fun magnitude() = sqrt(this dot this)
override fun toString(): String = "($x, $y, $z)"
}
```,
)
]
#kt-par[
Два вопроса. Что такое override и что за доллары в строке? Первое --- узнаете в
следующей лекции. Пока так надо, поверьте. Второе --- способ автоматически
встроить строковое представление переменной в строку. Ну, то же самое выглядело
бы в какой-нибудь Java как #box[`"(" + x + ", " + y + ", " + z + ")"`]. _Не очень_ лаконично.
]
#kt-par[
Отлично, давайте попробуем:
]
#kt-eval-append(```
val a = Vector.ofNumbers(5, 6, 6)
val b = Vector.ofNumbers(2, 3, 9)
a plus b
```)
#kt-res(`(7.0, 9.0, 15.0)`, `Vector`)
#kt-par[
А что нам выдаст следующий код?
]
#kt-eval-append-noret(```
a plus b times 3.0
```)
#kt-par[
На самом деле, очевидно, что компилятор не может догадываться о том, какие
приоритеты мы закладываем в инфиксные методы, так что он прочитает это слева
направо:
]
#kt-eval-append(```
(a plus b) times 3.0
```)
#kt-res(`(21.0, 27.0, 45.0)`, `Vector`)
#kt-par[
... Хочется перегрузки операторов. И да, я не просто так назвал методы `plus`,
`minus`, `times`. Это методы, которые отвечают за перегрузку соответствующих
операторов --- сложения, вычитания, умножения. Надо лишь добавить им модификатор
operator.
]
#nobreak[
#kt-eval(
```
data class Vector(val x: Double, val y: Double, val z: Double) {
companion object {
fun ofList(list: List<Double>) = Vector(list[0], list[1], list[2])
fun ofNumbers(x: Number, y: Number, z: Number): Vector {
return Vector(x.toDouble(), y.toDouble(), z.toDouble())
}
}
operator fun plus(that: Vector) = Vector(x + that.x, y + that.y, z + that.z)
operator fun minus(that: Vector) = Vector(x - that.x, y - that.y, z - that.z)
operator fun times(k: Double) = Vector(x * k, y * k, z * k)
infix fun dot(that: Vector) = x * that.x + y * that.y + z * that.z
fun magnitude() = sqrt(this dot this)
override fun toString(): String = "($x, $y, $z)"
}
```,
)
]
#kt-par[
Никто, конечно, не запрещает оставить infix на операторном методе. Но зачем?
]
#kt-par[
Снова проверяем:
]
#kt-eval-append(```
val a = Vector.ofNumbers(5, 6, 6)
val b = Vector.ofNumbers(2, 3, 9)
a + b
```)
#kt-res(`(7.0, 9.0, 15.0)`, `Vector`)
#kt-eval-append(```
a + b * 3.0
```)
#kt-res(`(11.0, 15.0, 33.0)`, `Vector`)
#kt-par[
Вот тут уже результат другой, потому что у операторов `+` и `*` вполне понятные
приоритеты. Полный перечень операторов и методов, им соответствующих, можно
найти #link(
"https://kotlinlang.org/docs/operator-overloading.html",
)[в документации]. Говоря коротко, есть
- `plus`, `minus`, `times`, `div`, `rem`, делающих понятно что,
- `invoke` --- оператор вызова, `()`,
- `get` и `set` --- доступа по индексу, `[]`,
- `compareTo` --- сравнение, `<`, `>`, `>=`, `<=`,
- `equals` --- сравнение на равенство, `==` и `!=` (чаще всего вы _очень_ хотите,
чтобы он был согласован с `compareTo`)
- `contains` --- проверка на включение, `in` и `!in`
- `rangeTo` и `rangeUntil` --- промежутки, `..` и `..<` соответственно.
- Есть ещё операторы для `+=`, `-=` и проч., а также для `++` и `--`, но их надо
реализовывать с большой осторожностью --- читайте документацию.
- И операторы `componentN`, о которых поговорим позже.
]
#kt-par[
А можно ли добавить метод к классу, который определяем не мы? Например, к
чему-то из стандартной библиотеки?
]
#kt-par[
Очень хочется, особенно операторы. А то что за дела, #box[`"1" + 2`] работает, а
#box[`1 + "2"`] --- нет?
]
#nobreak[
#kt-par[
Можно. Для этого нужно всего лишь написать так называемый receiver type --- тип,
для которого этот метод объявляется. Ну, скажем,
]
#kt-eval-noret(```
operator fun Int.plus(str: String) = this.toString() + str
```)
#kt-par[
Вот то, что слева от точки --- это и есть receiver type. Он, кстати, вполне
может быть nullable --- тогда при вызове этого метода необязательно писать safe
call. Но вам придётся разбираться с тем, что this может оказаться null.
Например, есть встроенная перегрузка toString для nullable типов:
]
]
#kt-eval-noret(```
inline fun Any?.toString() = this?.toString() ?: "null"
```)
#kt-par[
У нас в companion object всё ещё остались методы. Это, конечно, не плохо, но...
помните, я говорил?..
_...часто функции, которые хотелось бы положить в companion object класса T, либо
принимают T одним из аргументов, либо возвращают T..._
С первыми мы разобрались, теперь со вторыми. По сути это --- создание нового
объекта, такое же, как `Vector(1.0, 2.0, 3.0)`. Давайте сделаем, чтобы можно
было так же. Для этого есть ключевое слово constructor и абьюз ключевого слова
this.
]
#kt-eval(
```
data class Vector(val x: Double, val y: Double, val z: Double) {
constructor(list: List<Double>) : this(list[0], list[1], list[2])
constructor(x: Number, y: Number, z: Number)
: this(x.toDouble(), y.toDouble(), z.toDouble())
constructor() : this(0.0, 0.0, 0.0)
operator fun plus(that: Vector) = Vector(x + that.x, y + that.y, z + that.z)
operator fun minus(that: Vector) = Vector(x - that.x, y - that.y, z - that.z)
operator fun times(k: Double) = Vector(x * k, y * k, z * k)
infix fun dot(that: Vector) = x * that.x + y * that.y + z * that.z
fun magnitude() = sqrt(this dot this)
override fun toString(): String = "($x, $y, $z)"
}
```,
)
#kt-par[
Заодно создали конструктор без аргументов, создающий нулевой вектор.
]
#kt-par[
Стоит заметить, что такой трюк удастся только если все необходимые параметры
можно вычислить одним выражением. В противном случае придётся всё-таки писать
отдельную функцию.
]
#kt-eval-append(```
Vector()
```)
#kt-res(`(0.0, 0.0, 0.0)`, `Vector`)
#kt-eval-append(```
Vector(566L, 0xEF.toByte(), 3.0)
```)
#kt-res(`(566.0, 239.0, 3.0)`, `Vector`)
#kt-par[
И последний вопрос. Что же значит data в объявлении класса? На самом деле, это
означает, что за нас сгенерируют кучу методов. Давайте попробуем поделать
очевидные штуки:
]
#kt-eval(```
Vector(566, 566, 566) === Vector(566, 566, 566)
```)
#kt-res(`true`, KtBool)
#kt-par[
Очевидно? _Нет_.
]
#nobreak[
#kt-par[
Давайте попробуем без слова data.
]
#kt-eval(```
class Vector(val x: Double, val y: Double, val z: Double)
Vector(566.0, 566.0, 566.0) === Vector(566.0, 566.0, 566.0)
```)
#kt-res(`false`, KtBool)
#kt-eval-append(`Vector(1, 2, 3)`)
#kt-res(`Vector@7a81197d`, `Vector`)
]
#kt-par[
Почему так? Чтобы понять это, придётся пройти несколько этапов. Написать data
class, скомпилировать его, декомпилировать в Java и сконвертировать в Kotlin.
]
#kt-par[А теперь]
#kt-eval(```
data class Vector(val x: Double, val y: Double, val z: Double)
```)
#kt-par[
Посмотрим на результат компиляции... 261 строка байткода. Против 84, если бы мы
не объявляли его data. Я не хочу это читать, ладно? Давайте сразу декомпилируем
в Java (92 строки, уже лучше) и сконвертируем в Kotlin.
]
#kt-eval-noret(
```
class Vector(val x: Double, val y: Double, val z: Double) {
operator fun component1(): Double = x
operator fun component2(): Double = y
operator fun component3(): Double = z
fun copy(x: Double, y: Double, z: Double): Vector {
return Vector(x, y, z)
}
override fun toString(): String = "Vector(x=$x, y=$y, z=$z)"
override fun hashCode(): Int {
return (java.lang.Double.hashCode(x) * 31 + java.lang.Double.hashCode(y)) * 31 + java.lang.Double.hashCode(z)
}
override fun equals(var1: Any?): Boolean {
return if (this !== var1) {
if (var1 is Vector) {
val var2 = var1
if (java.lang.Double.compare(x, var2.x) == 0 &&
java.lang.Double.compare(y, var2.y) == 0 &&
java.lang.Double.compare(z, var2.z) == 0
) {
return true
}
}
false
} else {
true
}
}
}
```,
)
_Ох_. С чего бы начать.
#kt-par[
В общем, за нас сгенерировали equals, hashCode, toString, copy и ещё на закуску
--- `copy$default`, который не помещается на полях этого конспекта. Всего этого
бойлерплейта можно избежать одним ключевым словом --- разве не здорово?
]
#kt-par[
А есть ещё методы `component1`, `component2` и `component3` (нумерация здесь,
что забавно, с единицы). Это методы, отвечающие за _деструктивное присваивание_.
Что означает, что вы можете делать так:
]
#kt-eval-append(```
val v = Vector(1.0, 2.0, 3.0)
val (x, y, z) = v
y
```)
#kt-res(`2.0`, KtDouble)
#kt-par[
И это то же самое, что написать:
]
#indent(kt(```
val v = Vector(1.0, 2.0, 3.0)
val x = v.component1(),
val y = v.component2()
val z = v.component3()
```))
|
|
https://github.com/PgBiel/typst-improv-tables-planning | https://raw.githubusercontent.com/PgBiel/typst-improv-tables-planning/main/template.typ | typst | Other | #import "@preview/ctheorems:0.1.0": thmbox, thmplain, thmref
// #import "@preview/codly:0.1.0" as codly: codly-init, codly as codly-func
#import "pkg/codly.typ" as codly: codly-init, codly as codly-func
#let obs = thmplain("obs", [*Obs.*]).with(numbering: none)
#let note = thmbox("note", "Note", inset: 10pt, /*inset: (x: 1.2em, top: 1em),*/ fill: yellow.darken(6%))
#let n-color-box(..parts, columns: auto, height: auto, text-color: white, bg: green) = {
if columns == auto {
columns = (auto,) * parts.pos().len()
}
let result = table(
columns: columns,
rows: (height,),
stroke: none,
align: start + horizon,
fill: (x, y) => if x == 0 { bg.darken(50%) } else { bg.darken(30%) },
..parts
)
if text-color not in (auto, none) {
set text(fill: text-color)
result
} else {
result
}
}
#let top-level-heading(h, bg: green, columns: (auto, 1fr), text-color: white, height: auto, custom-numbering: none, number-styler: n => n) = locate(loc => block(breakable: false, {
let actual-numbering = if custom-numbering == none { h.numbering } else { custom-numbering }
let number = if actual-numbering == none { none } else { numbering(actual-numbering, ..counter(heading).at(loc)) }
let number = number-styler(number)
n-color-box(number, h.body, columns: columns, height: height, bg: bg, text-color: text-color)
}))
#let outline-heading(h) = {
top-level-heading(
h,
height: 1.75em,
bg: blue.lighten(50%)
)
}
#let rotated-top-level-heading(h) = {
top-level-heading(
h,
height: 1.75em,
bg: green,
custom-numbering: "1",
number-styler: n => {
move(dx: -5pt, dy: -1.1pt, box(clip: true, width: 1.3em, height: 2em)[
#set text(2.5em)
#rotate(11deg, n)
])
}
)
}
// Draws a white sideways triangle at the beginning of the line
#let arrowed(body, inset: 5pt) = style(styles => {
let height = measure(body, styles).height + 2 * inset
place(
top+left,
dx: -inset,
dy: -inset,
polygon(
fill: white,
(-1pt, 0pt - inset),
(4pt, 0.5 * height),
(-1pt, 1 * height + inset)
)
)
h(4pt)
body
})
#let arrowed-heading(h, bg: red.lighten(35%), columns: (2.7em, 1fr)) = {
top-level-heading(h, bg: bg, columns: columns, number-styler: arrowed)
}
// ---
// Creates a requirement, and assigns a label.
#let require(prefix, body, label: none) = {
let count = counter("requirement-" + prefix)
count.step()
// let label-metadata = if label == none {
// none
// } else {
// [#metadata((requirement-prefix: prefix)) #label]
// }
// [FC3]: body (metadata optional when a label is used)
[/ [#prefix#count.display()]: #body]
let label-metadata = metadata((requirement-prefix: prefix))
label-metadata
}
#let display-requirement-refs(doc) = {
show ref: it => {
let sequence = [*a* _a_].func()
if it.element != none and it.element.func() == sequence {
// metadata will be last in the sequence
let last-in-seq = it.element.children.last()
if last-in-seq.func() != metadata {
return it
}
let value = last-in-seq.value
if type(value) == dictionary and "requirement-prefix" in value {
// get the sequence's location
let loc = it.element.location()
let prefix = value.requirement-prefix
// the value of the counter at the sequence is 1 less than it actually is,
// as the counter.step() is inside the sequence, so we add 1 to the counter's
// value.
let number = numbering("1", counter("requirement-" + prefix).at(loc).first() + 1)
// display e.g. [FC3]
let body = [[#prefix#number]]
link(loc, body)
}
} else {
it
}
}
doc
}
// ---
// 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: "", doc-authors: (), authors: (), middle: none, date: none, font: "Linux Libertine", raw-font: none, lang: "en", body) = {
// Set the document's basic properties.
set document(author: doc-authors, title: title)
set page(numbering: "1", number-align: center)
set text(font: font, lang: lang)
show heading.where(level: 2): arrowed-heading
show heading.where(level: 3): arrowed-heading.with(bg: blue.lighten(35%), columns: (auto, auto))
show ref: set text(blue.darken(10%))
show link: set text(blue.darken(10%))
show raw: it => {
if raw-font != none {
set text(font: raw-font)
it
} else {
it
}
}
show raw: set text(1.15em)
show math.equation: set text(1.15em)
show: display-requirement-refs
show: codly-init
codly-func(
languages: (
typ: (name: "Typst", icon: none, color: eastern)
),
numbers-format: it => move(dx: 1pt, text(it, luma(110)))
)
// Title row.
align(center)[
#block(text(weight: 700, 1.75em, title))
#v(1em, weak: true)
]
// Author information.
pad(
top: 0.5em,
bottom: 0.5em,
x: 2em,
grid(
columns: (1fr,) * calc.min(3, authors.len()),
gutter: 1em,
..authors.map(author => align(center, strong(author))),
),
)
align(center)[
#middle
#v(1em, weak: true)
#date
]
set list(marker: ($circle.filled.small$, $circle.small$, $square.filled.small$, $circle.filled.small$))
// Main body.
set par(justify: true)
set heading(numbering: "1.")
show heading.where(level: 1): it => {
if it.numbering == none {
outline-heading(it)
} else {
rotated-top-level-heading(it)
}
}
show outline.entry.where(level: 1): strong
show footnote.entry: set par(justify: false)
body
}
|
https://github.com/Myriad-Dreamin/tinymist | https://raw.githubusercontent.com/Myriad-Dreamin/tinymist/main/syntaxes/textmate/tests/unit/bugs/expression-field.typ | typst | Apache License 2.0 | #link("https://microsoft.github.io/language-server-protocol/")[Language Server Protocol]. tinymist
#{
text(red)[] . fields()
}
|
https://github.com/maucejo/cnam_templates | https://raw.githubusercontent.com/maucejo/cnam_templates/main/src/common/_utils.typ | typst | MIT License | #let over-title(title: none, size: none, color: none) = {
let box1 = {
box(fill: white, stroke: 1pt + color, inset: 8pt)[
#set text(size: size, font: "Crimson Pro", weight: "semibold", fill: color)
#title.first()
]
}
let box2 = {
box(fill: white, stroke: 1pt + color, inset: 8pt)[
#set text(size: size, font: "Crimson Pro", weight: "semibold", fill: color)
#title.last()
]
}
context{
let box1-size = measure(box1).width
let box2-size = measure(box2).width
box1
let dec = box1-size - box2-size/2.5
if dec < 0cm {
dec = box1-size/3
}
place(dx: dec, box2)
}
v(1em)
} |
https://github.com/zjutjh/zjut-report-typst | https://raw.githubusercontent.com/zjutjh/zjut-report-typst/main/template/covers.typ | typst | #import "fonts.typ":*
#import "utils.typ":*
#let cover_normal(
title: "Title",
authors: ("author1", "author2"),
date: (2023, 5, 14),
) = {
set page("a4", numbering: none, margin: (top: 25%));
align(center)[
#set par(leading: 1.5em);
#text(title, size: font_size.小一, weight: "bold");\
#{
if type(authors) == "string" {
text(authors, size: font_size.四号);
} else {
text(authors.join(" "), size: font_size.四号);
}
}\
#date_format(date: date);
]
}
#let _info_key(body) = {
rect(width: 100%, inset: 2pt,
stroke: none,
text(
font: font_style.songti,
size: 16pt,
body
))
}
#let _info_value(body) = {
rect(
width: 100%,
inset: 2pt,
stroke: (
bottom: 1pt + black
),
text(
font: font_style.songti,
size: 16pt,
bottom-edge: "descender"
)[
#body
]
)
}
#let cover_zjut_report(
title:"",
author:"",
name:"",
class:"",
grade:"",
department:"",
date:(2023, 04, 17),
id:"",
) = {
align(center + horizon)[
#image("asserts/校名.png", width: 60%)
#text(title, size: 24pt, font: font_style.songti, weight: "bold")\
#text("(" + grade + "级)", size: 20pt, font: font_style.songti)\
#image("asserts/校徽.png", width: 40%)
#grid(
columns: (70pt, 180pt),
rows: (40pt, 40pt),
gutter: 3pt,
_info_key("实验题目"),
_info_value(name),
_info_key("学生姓名"),
_info_value(author),
_info_key("学 号"),
_info_value(id),
_info_key("专业班级"),
_info_value(class),
_info_key("所在学院"),
_info_value(department),
_info_key("提交日期"),
_info_value(text(font: font_style.songti,size: 16pt,)[#date.at(0) 年 #date.at(1) 月 #date.at(2) 日]),
)
]
pagebreak()
}
#let equation_num(n) = {
locate(loc => {
let chapt = counter(heading).at(loc).at(0)
let c = counter("equation-chapter" + str(chapt))
// let n = c.at(loc).at(0)
str(chapt) + "-" + str(n)
})
}
#let table_num(n) = {
locate(loc => {
let chapt = counter(heading).at(loc).at(0)
let c = counter("table-chapter" + str(chapt))
// let n = c.at(loc).at(0)
str(chapt) + "-" + str(n)
})
}
#let image_num(n) = {
locate(loc => {
let chapt = counter(heading).at(loc).at(0)
let c = counter("image-chapter" + str(chapt))
// let n = c.at(loc).at(0)
str(chapt) + "-" + str(n)
})
}
#let code_num(n) = {
locate(loc => {
let chapt = counter(heading).at(loc).at(0)
let c = counter("code-chapter" + str(chapt))
// let n = c.at(loc).at(0)
str(chapt) + "-" + str(n)
})
}
#let equation(equation, caption: "") = {
figure(
equation,
caption: caption,
supplement: [公式],
numbering: equation_num,
kind: "equation",
)
}
#let tbl(tbl, caption: "") = {
figure(
tbl,
caption: caption,
supplement: [表],
numbering: table_num,
kind: "table",
)
}
#let img(img, caption: "") = {
figure(
img,
caption: caption,
supplement: [图],
numbering: image_num,
kind: "image",
)
}
#let code(code, caption: "") = {
figure(
align(left)[
#code
],
caption: caption,
supplement: [代码],
numbering: code_num,
kind: "code",
)
}
|
|
https://github.com/gl-eb/protocols-phtac | https://raw.githubusercontent.com/gl-eb/protocols-phtac/main/_extensions/gl-eb/minimal-doc/typst-template.typ | typst | #let minimal(
title: none,
subtitle: none,
authors: none,
date: none,
abstract: none,
version: none,
header: none,
titleinheader: true,
authorsinheader: false,
cols: 1,
margin: (x: 20mm, top: 20mm, bottom: 30mm),
paper: "a4",
lang: "en",
region: "UK",
font: (),
fontsize: 10pt,
sectionnumbering: none,
toc: false,
doc,
) = {
// parse arguments
if not titleinheader {
titleinheader = false
}
// if header is unset so far, start assembling it
if header == none {
// if title is specified, add it to the header
if title != none and titleinheader {
header = title
}
// if a version unmber is specified, add it to the header
if version != none {
if header != none {
header = header + " v" + version
} else {
header = "v" + version
}
}
// if authors are specified, add them to the header
if authors != none and authorsinheader {
let by_author = authors.first().name
if authors.len() > 1 {
by_author = by_author + " et al."
}
if header != none {
header = header + " by " + by_author
} else {
header = by_author
}
}
// if date is specified, add it to the header
if date != none {
if header != none {
header = header + " – " + date
} else {
header = date
}
} else {
if header != none {
header = header + " – " + datetime.today().display()
} else {
header = datetime.today().display()
}
}
}
set page(
paper: paper,
margin: margin,
numbering: "1",
header: align(right)[
#set text(9pt)
#header
// #line(length: 100%)
]
)
set par(justify: true)
set text(lang: lang,
region: region,
font: font,
size: fontsize)
set heading(numbering: sectionnumbering)
set table(
inset: 6pt,
stroke: none
)
show figure: set block(breakable: true)
if title != none {
align(center)[#block(inset: 1em)[
#text(weight: "bold", size: 1.5em)[#title]
]]
if subtitle != none {
align(center)[
#text(weight: "bold", size: 1.25em)[#subtitle]
]
}
if authors != none {
let list_authors = ()
for author in authors {
list_authors.push(author.name)
}
list_authors = list_authors.join(", ", last: " and ")
align(center)[#list_authors]
}
if date != none {
align(center)[#date]
}
if abstract != none {
block(inset: 2em)[
#text(weight: "semibold")[Abstract] #h(1em) #abstract
]
}
if toc {
block(above: 0em, below: 2em)[
#outline(
title: auto,
depth: none
);
]
}
v(0.25em)
}
if cols == 1 {
doc
} else {
columns(cols, doc)
}
}
|
|
https://github.com/jomaway/typst-teacher-templates | https://raw.githubusercontent.com/jomaway/typst-teacher-templates/main/ttt-lists/lib/studentlist.typ | typst | MIT License | #import "@preview/ttt-utils:0.1.0": components
#import components: tag as _tag, checkbox
#let eval_row(row) = {
row = row.map(cell => {
let c = cell.trim(" ")
if (c in ("[ ]", "[]")) { align(center, checkbox()) }
else if (c == "[x]") { align(center,checkbox(fill: green.lighten(30%), tick: true)) }
else { cell }
})
row.push("")
row
}
/// utility function to add a column of emtpy checkboxes
#let add_check_column(data, title: "check") = {
let header = data.at(0);
let rows = data.slice(1);
header.push(title)
rows = rows.map(r => (..r,"[ ]"))
return (
header,
..rows
)
}
/// prints a list of students from the given data.
#let studentlist(data, tag: none, numbered: false, lines: false, rh: auto) = {
assert(type(numbered) == bool, message: "expected numbered parameter to be a [bool], found " + type(numbered))
assert.eq(type(lines),bool, message: "expected lines parameter to be a [bool], found " + type(lines))
assert(type(rh) == length or rh == auto, message: "expected rh parameter to be [auto] or a [length], found " + type(rh))
assert(type(tag) == str or tag == none, message: "expected tag parameter tp be a [str] or [none], found " + type(tag))
let header = data.at(0);
let body = data.slice(1).map(row => eval_row(row));
if (numbered) {
header.insert(0, "Nr");
body = body.enumerate().map(((i, row)) => (str(i+1), row).flatten());
}
let cols = (auto,) * header.len()
cols.push(1fr)
header.push(strong(delta: -200, place(end + horizon, _tag(tag))))
// grid settings
show grid.cell.where(y: 0): it => strong(delta: 200)[#it]
let stroke_color = luma(200)
set grid.vline(stroke: stroke_color)
let list = grid(
columns: cols,
rows: rh,
inset: 0.6em,
stroke: (col, _) => if (lines) { (right: stroke_color)},
fill: (_, row) => if calc.odd(row) { luma(240) } else { white },
align: (col,_) => if (numbered and col == 0) {horizon + end} else {horizon + start },
grid.header(..header),
grid.hline(stroke: stroke_color),
..body.flatten(),
if (numbered) {grid.vline(x:1)} // must be at last position
)
// wrapper to display the round corners.
block(
stroke: stroke_color,
radius: 5pt,
clip: true,
list
)
} |
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compiler/if-00.typ | typst | Other | // Test condition evaluation.
#if 1 < 2 [
One.
]
#if true == false [
{Bad}, but we {dont-care}!
]
|
https://github.com/SWATEngineering/Docs | https://raw.githubusercontent.com/SWATEngineering/Docs/main/src/2_RTB/VerbaliInterni/VerbaleInterno_231201/content.typ | typst | MIT License | #import "meta.typ": inizio_incontro, fine_incontro, luogo_incontro
#import "functions.typ": glossary, team
#let participants = csv("participants.csv")
= Partecipanti
/ Inizio incontro: #inizio_incontro
/ Fine incontro: #fine_incontro
/ Luogo incontro: #luogo_incontro
#table(
columns: (3fr, 1fr),
[*Nome*], [*Durata presenza*],
..participants.flatten()
)
= Sintesi Elaborazione Incontro
/*************************************/
/* INSERIRE SOTTO IL CONTENUTO */
/*************************************/
== Sprint di una settimana
Nell'incontro è stata discussa la proposta di modificare la durata degli sprint, attualmente fissata a due settimane. È stato deciso che la durata dello sprint corrente rimarrà invariata e, come precedentemente pianificato, terminerà il giorno 7/12/2023.
Tuttavia, a partire dal prossimo sprint, effettueremo una transizione a sprint settimanali. Tale decisione è motivata dalla volontà di ottimizzare la sincronizzazione con il cambio dei ruoli, e di favorire un aumento degli incontri con la Proponente. Inoltre, questa modifica è stata raccomandata dalla Proponente stessa, riflettendo la volontà di adottare un approccio più flessibile e adattabile. L'unico svantaggio, che è stato evidenziato per gli sprint settimanali, riguarda la pianificazione a lungo termine, poiché la loro frequenza potrebbe complicare la formulazione di piani dettagliati.
In aggiunta, si rende necessario rivedere la pianificazione nel _Piano di progetto_ per adeguarla agli sprint settimanali.
== Assegnazione ruoli
Su proposta dei componenti è stata assegnata questa distribuzione dei ruoli:
- Responsabile: <NAME>;
- Amministratore: <NAME>;
- Analista: <NAME>;
- Analista: <NAME>;
- Analista: <NAME>;
- Verificatore: <NAME>.
Il ruolo di Programmatore non è stato assegnato, poiché la struttura finale del PoC è stata conclusa. Il ruolo di Progettista, invece, non è stato assegnato, in quanto si ritiene che sia prematuro rispetto all'attuale stato di avanzamento del progetto.
== Date Planning
Si sono definite le ipotetiche date del PB e della CA:
- *RTB*: fissata per il 15-03-2024;
- *CA*: fissata per il 01-04-2023.
== Context Switch
Con Context Switch ci si riferisce al cambiamento settimanale dei ruoli all'interno del team. Questo passaggio, da un ruolo ad un altro, comporta la necessità di adattarsi rapidamente alle nuove responsabilità e di comprendere appieno ciò che è stato svolto dal membro del team precedentemente.
Per questa motivazione, verrà incluso il Context Switch all'interno dell'analisi dei rischi del _Piano di progetto_.
Le soluzioni proposte, per ovviare al problema, sono le seguenti:
- La persona che ha precedentemente occupato quel ruolo specifico, offre supporto al membro del team che ha assunto ora quella posizione, facilitandone la transizione e assistendo il Responsabile o l'Amministratore nella creazione delle issue per il prossimo sprint;
- Il primo giorno si dedica unicamente allo studio di quanto fatto precedentemente per riuscire a sincronizzarsi con il contesto del ruolo.
== Pausa degli Sprint
In vista della sessione di esami invernale, il team ha deciso di ridurre il carico di lavoro per un periodo della durata di 2 settimane, precisamente dal 19 gennaio al 2 febbraio. La motivazione principale dietro questa decisione è la consapevolezza che durante questo periodo gli impegni di studio potrebbero rendere difficile mantenere un ritmo a pieno regime.
Pertanto, pur non essendo una vera e propria pausa, il gruppo ridurrà temporaneamente l'intensità del lavoro sul progetto.
== Sprint Review o Retrospective
Durante la discussione è stato affrontato il quesito se gli incontri settimanali con la Proponente debbano essere considerati come Sprint Review, come Sprint Retrospective o normali incontri, trasferendo le due attività citate alla riunione interna successiva. La decisione presa stabilisce che gli incontri esterni con la Proponente debbano essere interpretati come Sprint Review, poiché si focalizzano sull'esame del lavoro completato durante lo sprint e sulla raccolta dei vari feedback. Gli Sprint Retrospective saranno invece inclusi negli incontri interni, in quanto dedicati alla riflessione interna del team, con la possibilità di esaminare criticamente il processo di sviluppo, identificando punti di forza e criticità.
== Diagrammi di Gantt
Si è discusso della necessità di creare diagrammi di Gantt per l'intero periodo, suddividendo il progetto in tre macro milestone, che verranno scomposte in milestone più piccole definite per funzioni relative ai ruoli da usare. Questo compito verrà preso in carico dal Responsabile, dall'Amministratore e dal Verificatore.
Come strumento per la creazione dei diagrammi si è deciso di usare onlinegantt.
|
Subsets and Splits