repo
stringlengths 27
90
| file
stringlengths 57
176
| language
stringclasses 2
values | license
stringclasses 13
values | content
stringlengths 25
180k
|
|---|---|---|---|---|
https://github.com/SWATEngineering/Docs | https://raw.githubusercontent.com/SWATEngineering/Docs/main/src/2_RTB/AnalisiDeiRequisiti/content.typ | typst | MIT License | #import "meta.typ" : title
#import "functions.typ" : glossary, team, modulo, requirements_table, generate_requirements_array
#set list(marker: ([•], [--]))
#set enum(numbering: "1.a.")
= Introduzione
== Scopo del documento
Il presente documento ha lo scopo di fornire una descrizione dettagliata dei casi d'uso e dei requisiti del progetto "InnovaCity". Questi risultano dall'analisi del capitolato C6 presentato dalla Proponente Sync Lab e dalla successiva interazione diretta con essa attraverso gli incontri svolti.
== Scopo del prodotto
Lo scopo del prodotto è la realizzazione di un sistema di persistenza dati e successiva visualizzazione di questi, provenienti da sensori dislocati geograficamente. Tale piattaforma consentirà all'#glossary("amministratore pubblico") di acquisire una panoramica completa delle condizioni della città, facilitando così la presa di decisioni informate e tempestive riguardo alla gestione delle risorse e all'implementazione di servizi.
== Glossario
Al fine di evitare possibili ambiguità relative al linguaggio utilizzato nei
documenti, viene fornito il _Glossario v1.0_, nel quale sono presenti tutte le
definizioni di termini aventi uno specifico significato che vuole essere
disambiguato. Tali termini, sono scritti in corsivo e marcati con una G a pedice.
== Riferimenti
=== Riferimenti normativi
- Capitolato C6 - InnovaCity: Smart city monitoring platform:
#link("https://www.math.unipd.it/~tullio/IS-1/2023/Progetto/C6.pdf")\
#link("https://www.math.unipd.it/~tullio/IS-1/2023/Progetto/C6p.pdf")
- _Norme di Progetto v1.0_
- _Verbale Esterno 10-11-2023 v1.0_
- _Verbale Esterno 24-11-2023 v1.0_
- _Verbale Esterno 06-12-2023 v1.0_
- Regolamento progetto didattico:
#link("https://www.math.unipd.it/~tullio/IS-1/2023/Dispense/PD2.pdf")
=== Riferimenti informativi
Analisi dei requisiti - corso di Ingegneria del Software a.a. 2023/2024: \
#link("https://www.math.unipd.it/~tullio/IS-1/2023/Dispense/T5.pdf") \
Cardin Analisi e descrizione delle funzionalità: Use Case e relativi diagammi (UML) - corso di Ingegneria del Software a.a. 2023/2024: \
#link("https://www.math.unipd.it/~rcardin/swea/2022/Diagrammi%20di%20Attivit%C3%A0.pdf")
= Descrizione
== Obiettivi del prodotto
L'obiettivo consiste nella creazione di una piattaforma di monitoraggio e gestione di una #glossary("Smart City"). L'utente, individuato nell'amministratore pubblico, potrà farne impiego per migliorare la qualità generale della vita e l'efficienza dei servizi nel contesto di un'area urbana. L'utente sarà in grado di monitorare, attraverso la consultazione di una #glossary("dashboard"), lo stato della città, esaminando aspetti ambientali, logistici e di sicurezza. Questo cruscotto includerà rappresentazioni grafiche basate su dati provenienti da dei sensori installati all'interno dell'area geografica della città.
== Funzionalità del prodotto
Il prodotto si compone di due parti principali:
- *Una #glossary("data pipeline")* in grado di raccogliere, persistere e processare dati provenienti da più sorgenti (ovvero i #glossary("sensori")) in #glossary("real-time");
- *una #glossary("dashboard")* che permette di visualizzare i dati raccolti.
La piattaforma prevede fondamentalmente una tipologia di utente: l'amministratore pubblico. Questo utente avrà accesso alla dashboard e prenderà visione di diverse metriche e indicatori sullo stato della città, mediante diversi strumenti di visualizzazione.
== Utenti e caratteristiche
Il prodotto, destinato ad amministratori pubblici, consente loro di ottenere una panoramica sulle condizioni della città. Ciò fornisce loro una base solida per prendere decisioni ponderate riguardo la gestione delle risorse e sull'implementazione dei servizi, risultando cruciale per il miglioramento dell'efficienza complessiva della gestione urbana. Si presuppone che l'amministratore pubblico abbia conoscenze di analisi e di interpretazione dei dati, tali da poter trarre un concreto beneficio dal controllo della #glossary("dashboard").
= Casi d'uso
== Scopo
In questa sezione si vogliono elencare e descrivere tutti i casi d'uso individuati dall'analisi del capitolato e dalle interazioni avute con la Proponente. In particolare, si individuano gli #glossary("attori") e le funzionalità che questi possono svolgere. Ogni caso d'uso possiede un codice, la cui struttura è descritta nelle _Norme di Progetto v1.0_.
== Attori
Il sistema si interfaccerà con due attori diversi:
- *Amministratore pubblico*: è un utente che ha accesso alla dashboard in tutte le sue funzionalità e può visualizzare i dati raccolti dai sensori, mediante quest'ultima;
- *#glossary("Sensore")*: è un dispositivo in grado di effettuare misurazioni relative al proprio dominio di interesse. Questi dati possono essere letti ed utilizzati dal sistema.
Relativamente all'utilizzo della #glossary("dashboard"), viene definito un unico attore con accesso completo alle funzionalità, in quanto per sua natura l' amministratore pubblico possiede le competenze tecniche necessarie per poter interagire con essa in tutte le sue parti.
#figure(
image("assets/attori.png", width: 40%),
caption: [Gerarchia degli attori]
)
#pagebreak()
== Elenco dei casi d'uso
#set heading(numbering: none)
/*TODO: fare immagine apposta*/
=== UC0: Visualizzazione menù dashboard
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza un menù di selezione da cui può scegliere in che dashboard spostarsi tra: Sensori, Ambientale, Urbanistica, Dati anomali & superamento soglie.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
#figure(
image("assets/UML/UC0_Visualizzazione-menù-dashboard.png",width:70%),
caption: [UC1 Visualizzazione dashboard generale sensori]
)
/*TODO: ricontrollare la fine di ogni use case che comprende l'uso di un #glossary("pannello")*/
=== UC1: Visualizzazione dashboard generale sensori
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza #glossary("pannelli") relativi allo stato dei sensori, all'interno di un'unica dashboard.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione della #glossary("dashboard") generale relativa ai sensori;
#figure(
image("assets/UML/UC1_Visualizzazione-dashboard-generale-sensori.png",width:70%),
caption: [UC1 Visualizzazione dashboard generale sensori]
)
#pagebreak()
=== UC1.1: Visualizzazione posizione sensori su mappa
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa che mostra le posizioni dei sensori, come icone, su di essa.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione della #glossary("dashboard") generale relativa ai sensori;
- *Estensioni*: [UC9].
#figure(
image("assets/UML/UC1.1_Visualizzazione-posizione-sensori-su-mappa.png",width:100%),
caption: [UC1.1 Visualizzazione posizione sensori su mappa]
)
=== UC1.2: Visualizzazione tabella sensori
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza il #glossary("pannello") relativo ai dati inerenti ai sensori, riportando la percentuale di batteria, un valore booleano che esprime se il sensore va a batteria autonoma o meno e la data di ultima manutenzione del sensore, in forma tabellare, indicizzato dai nomi dei sensori.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione della #glossary("dashboard") generale relativa ai sensori;
- *Estensioni*: [UC9].
#figure(
image("assets/UML/UC1.2_Visualizzazione-tabella-sensori.png",width:100%),
caption: [UC1.2 Visualizzazione tabella sensori]
)
#pagebreak()
=== UC2: Visualizzazione dashboard dati ambientali
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza #glossary("pannelli") contenenti dati relativi al dominio ambientale.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2_Visualizzazione-dashboard-dati-ambientali.png",width:70%),
caption: [UC2 Visualizzazione dati ambientali]
)
=== UC2.1: Visualizzazione #glossary("pannello") dati ambientali
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente dati relativi al dominio ambientale.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
- *Specializzazioni*: [UC2.2],[UC2.3],[UC2.4],[UC2.5],[UC2.6],[UC2.7],[UC2.8],[UC2.9],[UC2.10],[UC2.11].
- *Estensioni*: [UC9].
#figure(
image("assets/UML/UC2.1_Visualizzazione-pannello-dati-ambientali.png",width:100%),
caption: [UC2.1 Visualizzazione #glossary("pannello") dati ambientali]
)
#pagebreak()
=== UC2.2: Visualizzazione #glossary("pannello") #glossary("time series") per temperatura
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente un grafico relativo alla temperatura, espressa in gradi celsius, in formato #glossary("time series") che ne mostra l'andamento in media aritmetica, distinto per sensore, aggregando i dati per intervalli di 5 minuti.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.2_Visualizzazion-pannello-time-series-per-temperatura.png",width:100%),
caption: [UC2.2 Visualizzazione #glossary("pannello") time series per temperatura]
)
=== UC2.3: Visualizzazione #glossary("pannello") time series per umidità
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente un grafico relativo all'umidità, espressa in percentuale, in formato #glossary("time series") che ne mostra l'andamento in media aritmetica, distinto per sensore, aggregando i dati per intervalli di 5 minuti.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.3_Visualizzazione-pannello-time-series-umidità.png",width:100%),
caption: [UC2.3 Visualizzazione #glossary("pannello") time series per umidità]
)
#pagebreak()
/*TODO: creare nuova immagine*/
=== UC2.4: Visualizzazione grafico a mappa direzione del vento
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa che esprime, mediante frecce aventi orgine nelle coordinate del sensore, la direzione del vento rilevata da ciascun sensore.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.4_Visualizzazione-grafico-a-mappa-direzione-del-vento.png",width:60%),
caption: [UC2.4 Visualizzazione grafico a mappa direzione del vento]
)
/*TODO: creare nuova immagine*/
=== UC2.5: Visualizzazione tabella velocità del vento
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente dati relativi all'ultima velocità del vento, espressa in chilometri all'ora, registrata da ciascun sensore, sotto forma tabellare.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.5_Visualizzazione-tabella-velocità-del-vento.png",width:60%),
caption: [UC2.5 Visualizzazione tabella velocità del vento]
)
#pagebreak()
=== UC2.6: Visualizzazione #glossary("pannello") time series per precipitazioni
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente un grafico relativo all'intensità delle precipitazioni, espressa in millimetri orari, in formato #glossary("time series") che ne mostra l'andamento in media aritmetica, distinto per sensore, aggregando i dati per intervalli di 5 minuti.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.6_Visualizzazione-pannello-time-series-per-precipitazioni.png",width:100%),
caption: [UC2.6 Visualizzazione #glossary("pannello") time series per precipitazioni]
)
=== UC2.7: Visualizzazione #glossary("pannello") precipitazioni medie
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente un indice numerico relativo alle precipitazioni, espresse millimetri di pioggia all'ora, indicante la media dell'intensità delle precipitazioni tra tutti i dati raccolti dai sensori, degli ultimi 5 minuti.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.7_Visualizzazione-pannello-precipitazioni-medie.png",width:100%),
caption: [UC2.7 Visualizzazione #glossary("pannello") precipitazioni medie]
)
#pagebreak()
=== UC2.8: Visualizzazione #glossary("pannello") time series per inquinamento dell'aria
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente un grafico relativo al livello di polveri sottili nell'aria, espresso in $#sym.mu g\/m^3$ (#glossary("PM10")), in formato #glossary("time series"), che ne mostra l'andamento in media aritmetica, distinto per sensore, aggregando i dati per intervalli di 5 minuti.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.8_Visualizzazione-pannello-time-series-per-inquinamento-dell-aria.png",width:100%),
caption: [UC2.8 Visualizzazione #glossary("pannello") time series per inquinamento dell'aria]
)
=== UC2.9: Visualizzazione #glossary("pannello") inquinamento dell'aria medio
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente la media della concentrazione di inquinanti dell'aria, espressa in $#sym.mu g\/m^3$,(#glossary("PM10")), considerando tutti i sensori attivi negli ultimi 5 minuti, e presentata in formato numerico.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.9_Visualizzazione-pannello-inquinamento-dell-aria-medio.png",width:100%),
caption: [UC2.9 Visualizzazione #glossary("pannello") inquinamento dell'aria medio]
)
#pagebreak()
=== UC2.10: Visualizzazione #glossary("pannello") time series per livello dei bacini idrici
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente un grafico relativo alla percentuale di riempimento dei bacini idrici, in formato #glossary("time series"), che ne mostra l'andamento in media aritmetica di tale percentuale, distinto per sensore, aggregando i dati per intervalli di 5 minuti.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.10_Visualizzazione-pannello-time-series-per-livello-dei-bacini-idrici.png",width:100%),
caption: [UC2.10 Visualizzazione #glossary("pannello") time series per livello dei bacini idrici]
)
=== UC2.11: Visualizzazione #glossary("pannello") temperatura media
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente la media della temperatura, espressa in gradi celsius, considerando tutti i sensori attivi negli ultimi 5 minuti, e presentata in formato numerico.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.11_Visualizzazione-pannello-temperatura-media.png",width:100%),
caption: [UC2.11 Visualizzazione #glossary("pannello") temperatura media]
)
#pagebreak()
=== UC2.12: Visualizzazione #glossary("pannello") inquinamento dell'aria massimo
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati ambientali.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente il massimo coefficiente di inquinamento dell'aria registrato tra tutti i sensori, espresso in $#sym.mu g\/m^3$, degli ultimi 5 minuti, presentato in formato numerico.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio ambientale.
#figure(
image("assets/UML/UC2.12_Visualizzazione-pannello-inquinamento-dell-aria-massimo.png",width:100%),
caption: [UC2.12 Visualizzazione #glossary("pannello") inquinamento dell'aria massimo]
)
=== UC3: Visualizzazione dashboard dati urbanistici
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza #glossary("pannelli") contenenti dati relativi al dominio urbanistico.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
#figure(
image("assets/UML/UC3_Visualizzazione-dashboard-dati-urbanistici.png",width:60%),
caption: [UC3 Visualizzazione dati urbanistici]
)
#pagebreak()
=== UC3.1: Visualizzazione #glossary("pannello") dati urbanistici
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente dati relativi al dominio urbanistico.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
- *Specializzazioni*: [UC3.2],[UC3.3],[UC3.4],[UC3.5],[UC3.6].
- *Estensioni*: [UC9].
#figure(
image("assets/UML/UC3.1_Visualizzazione-pannello-dati-urbanistici.png",width:100%),
caption: [UC3.1 Visualizzazione #glossary("pannello") dati urbanistici]
)
=== UC3.2: Visualizzazione grafico a mappa disponibilità parcheggi
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa per indicare la disponibilità dei parcheggi, espressa in numero di parcheggi liberi, registrata da ciascun sensore, attraverso un indicatori numerici posti nelle coordinate dei corrispondenti sensori.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
#figure(
image("assets/UML/UC3.2_Visualizzazione-grafico-a-mappa-disponibilità-parcheggi.png",width:100%),
caption: [UC3.2 Visualizzazione grafico a mappa disponibilità di parcheggi]
)
#pagebreak()
=== UC3.3: Visualizzazione informazioni delle colonne di ricarica
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza dei #glossary("pannelli"), adatti al reperimento di informazioni relative alle colonne di ricarica.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
#figure(
image("assets/UML/UC3.3_Visualizzazione-informazioni-delle-colonne-di-ricarica.png",width:100%),
caption: [UC3.3 Visualizzazione posizione e stato colonne di ricarica]
)
=== UC3.3.1: Visualizzazione posizione e disponibilità delle colonne di ricarica
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa indicante la posizione delle colonne di ricarica per auto, mediante indicatori booleani, i quali indicheranno la disponibilità della colonna corrisponente.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
/* TODO: cambiare l'immagine con una creata apposta per il caso d'uso*/
#figure(
image("assets/UML/UC3.3.1_Visualizzazione-posizione-e-disponibilità-delle-colonne-di-ricarica.png",width:70%),
caption: [UC3.3.1 Visualizzazione posizione e disponibilità colonne di ricarica]
)
#pagebreak()
=== UC3.3.2: Visualizzazione tabella descrittiva delle colonne di ricarica
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una tabella, la quale esprime, per ciascuna colonna di ricarica per auto, l'erogazione in Watt per ora attuale, indicizzando la tabella in base al nome del sensore.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
/* TODO: cambiare l'immagine con una creata apposta per il caso d'uso*/
#figure(
image("assets/UML/UC3.3.2_Visualizzazione-tabella-descrittiva-delle-colonne-di-ricarica.png",width:70%),
caption: [UC3.3.2 Visualizzazione tabella descrittiva delle colonne di ricarica]
)
=== UC3.4: Visualizzazione grafico a mappa congestione stradale
*Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa indicante lo stato di congestione delle strade, mediante gli stati "LOW", "MEDIUM", "HIGH" e "BLOCKED", atto a mostrare il livello di congestione della strada corrispondente.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
#figure(
image("assets/UML/UC3.4_Visualizzazione-grafico-a-mappa-intensità-traffico.png",width:100%),
caption: [UC3.4 Visualizzazione grafico a mappa congestione stradale]
)
#pagebreak()
=== UC3.5: Visualizzazione posizione real time delle biciclette elettriche e relativa percentuale batteria
*Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa indicante la posizione in tempo reale delle biciclette elettriche, mediante degli indicatori numerici indicanti la percentuale della batteria posizionata nelle coordinate del mezzo, atto a mostrare la sua posizione.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
#figure(
image("assets/UML/UC3.5_Visualizzazione-posizione-real-time-delle-biciclette-elettriche-e-relativa-percentuale-batteria.png",width:100%),
caption: [UC3.5 Visualizzazione posizione real time delle biciclette elettriche e relativa percentuale batteria]
)
/*TODO: cambiare nome nell'immagine*/
=== UC3.6: Visualizzazione indicatore percentuale su mappa riempimento zone ecologiche
*Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha selezionato la visualizzazione relativa al dominio dei dati urbanistici.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una mappa indicante lo stato di riempimento delle zone ecologiche, espresse in valori percentuali, posizionate nelle coordinate delle zone.
- *Scenario Principale*:
+ l'amministratore pubblico accede alla piattaforma di visualizzazione;
+ l'amministratore pubblico seleziona la visualizzazione del dominio urbanistico.
#figure(
image("assets/UML/UC3.6_Visualizzazione-indicatore-percentuale-su-mappa-riempimento-zone-rifiuti.png",width:100%),
caption: [UC3.6 Visualizzazione indicatore percentuale su mappa riempimento zone ecologiche]
)
/*TODO: cambiare immagine*/
#pagebreak()
=== UC4: Visualizzazione dashboard #glossary("dati anomali") e superamento soglie
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza #glossary("pannelli") contenenti dati relativi al superamento delle soglie e alle anomalie rilevate.
- *Scenario Principale*:
+ l'amministratore pubblico seleziona la visualizzazione della deshboard delle anomalie.
#figure(
image("assets/UML/UC4_Visualizzazione-dashboard-dati-anomali-e-superamento-soglie.png",width:60%),
caption: [UC4 Visualizzazione dashboard #glossary("dati anomali") e superamento soglie]
)
/*TODO: realizzare immagine corrispondente*/
=== UC4.1: Visualizzazione tabella #glossary("dati anomali")
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza, in forma tabellare, la lista ordinata di #glossary("dati anomali") rilevati dal sistema.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una tabella, la quale mostra tutte le anomalie rilevate, mostrando il valore dell'anomalia, il sensore che l'ha rilevata e il timestamp relativo.
- *Scenario Principale*:
+ l'amministratore pubblico seleziona la visualizzazione della deshboard delle anomalie.
#figure(
image("assets/UML/UC4.1_Visualizzazione-tabella-dati-anomali.png",width:70%),
caption: [UC4.1 Visualizzazione tabella #glossary("dati anomali")]
)
/*TODO: realizzare immagine corrispondente*/
#pagebreak()
=== UC4.2: Visualizzazione tabella superamento soglie
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico visualizza un #glossary("pannello") contenente una tabella, la quale mostra tutti i dati superanti le soglie impostate nel sistema, mostrando il valore superante la soglia, il sensore che ha rilevato tale valore e il timestamp relativo.
- *Scenario Principale*:
+ l'amministratore pubblico seleziona la visualizzazione della deshboard delle anomalie.
#figure(
image("assets/UML/UC4.2_Visualizzazione-tabella-superamento-soglie.png",width:70%),
caption: [UC4.2 Visualizzazione tabella superamento soglie]
)
/*TODO: per gli UC5.X andare a capire se usano soglie fisse o tramite variabili per gli allert (sempre se possibile)*/
=== UC5: Visualizzazione allerte superamento soglie
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico riceve una notifica di superamento di una soglia impostata.
- *Scenario Principale*:
+ il sistema rileva condizioni che richiedono l'invio di una notifica per segnalare il superamento di una soglia impostata.
#figure(
image("assets/UML/UC5_Visualizzazione-allerte-superamento-soglie.png",width:70%),
caption: [UC5 Visualizzazione allerte superamento soglie]
)
/*TODO: andare a fare l'immagine apposta*/
#pagebreak()
=== UC5.1: Visualizzazione allerte superamento soglia temperatura
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico riceve un'allerta relativa alla temperatura che notifica il superamento dei 40° celsius.
- *Scenario Principale*:
+ il sistema rileva una temperatura nella media dei 5 minuti, superiore ai 40° celsius.
#figure(
image("assets/UML/UC5.1_Visualizzazione-allerte-superamento-soglia-temperatura.png",width:70%),
caption: [UC5.1 Visualizzazione allerte superamento soglia temperatura]
)
/*TODO: andare a fare l'immagine apposta*/
=== UC5.2: Visualizzazione allerte superamento soglia precipitazioni
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico riceve un'allerta relativa alle precipitazioni che notifica il superamento dei 50 millimetri di pioggia all'ora.
- *Scenario Principale*:
+ il sistema rileva un livello di precipitazioni medie nell'ora, superiore ai 50 millimetri di pioggia all'ora.
#figure(
image("assets/UML/UC5.2_Visualizzazione-allerte-superamento-soglia-precipitazioni.png",width:70%),
caption: [UC5.2 Visualizzazione allerte superamento soglia precipitazioni]
)
/*TODO: andare a fare l'immagine apposta*/
#pagebreak()
=== UC5.3: Visualizzazione allerte superamento soglia inquinamento dell'aria
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico riceve un'allerta relativa all'inquinamento dell'aria che notifica il superamento di 80#[#sym.mu]g su metro cubo.
- *Scenario Principale*:
+ il sistema rileva un coefficiente di inquinamento dell'aria (#glossary("PM10")), superiore ai 80#[#sym.mu]g su metro cubo.
#figure(
image("assets/UML/UC5.3_Visualizzazione-allerte-superamento-soglia-inquinamento-dell'aria.png",width:70%),
caption: [UC5.3 Visualizzazione allerte superamento soglia inquinamento dell'aria]
)
/*TODO: andare a fare l'immagine apposta*/
=== UC5.4: Visualizzazione allerte superamento soglia bacini idrici
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico riceve un'allerta relativa ai bacini idrici che notifica il superamento del 70% della capienza di un particolare bacino.
- *Scenario Principale*:
+ il sistema rileva che il livello di un particolare bacino idrico è superiore al 70% della sua capienza.
#figure(
image("assets/UML/UC5.4_Visualizzazione-allerte-superamento-soglia-bacini-idrici.png",width:70%),
caption: [UC5.4 Visualizzazione allerte superamento soglia bacini idrici]
)
/*TODO: andare a fare l'immagine apposta*/
#pagebreak()
=== UC5.5: Visualizzazione allerte superamento soglia zone ecologiche
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: nessuna.
- *Postcondizioni*: l'amministratore pubblico riceve un'allerta relativa alle zone ecologiche che notifica il superamento dell'80% della capienza di una particolare zona ecologica.
- *Scenario Principale*:
+ il sistema rileva che il livello di una particolare zona ecologica è superiore all'80% della sua capienza.
#figure(
image("assets/UML/UC5.5_Visualizzazione-allerte-superamento-soglia-zone-ecologiche.png",width:70%),
caption: [UC5.5 Visualizzazione allerte superamento soglia zone ecologiche]
)
/*Cambiare il numero nell'immagine*/
=== UC6: Applicazione filtri
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*:
+ l'amministratore pubblico sta visualizzando uno o più #glossary("pannelli") con i dati.
- *Postcondizioni*: l'amministratore pubblico visualizza solamente i dati relativi al filtro applicato (oppure ai filtri applicati).
- *Scenario Principale*:
+ l'amministratore pubblico seleziona l'icona o il pulsante relativo al filtro dei dati;
+ l'amministratore pubblico seleziona secondo quali valori filtrare il #glossary("pannello") (o i #glossary("pannelli")).
#figure(
image("assets/UML/UC6_Applicazione-filtri.png",width:70%),
caption: [UC6 Applicazione filtri]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC6.1: Filtro sotto-insieme di sensori su grafici time series
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*:
+ l'amministratore pubblico sta visualizzando uno o più #glossary("pannelli") time series con i dati;
+ il #glossary("pannello") offre la funzionalità di filtro dei dati tramite selezione di uno o più sensori.
- *Postcondizioni*: l'amministratore pubblico visualizza solamente i dati relativi ai sensori selezionati, all'interno di tale #glossary("pannello").
- *Scenario Principale*:
+ l'amministratore pubblico seleziona il sensore (o i sensori) da visualizzare tramite la legenda.
#figure(
image("assets/UML/UC6.1_Filtro-sotto-insieme-di-sensori-su-grafici-time-series.png",width:70%),
caption: [UC6.1 Filtro sotto-insieme di sensori su grafici time series]
)
/*Cambiare il numero nell'immagine*/
=== UC6.2: Filtro per tipologia sensore su tabella
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*:
+ l'amministratore pubblico sta visualizzando uno o più #glossary("pannelli") tabellari con i dati;
+ il #glossary("pannello") offre la funzionalità di filtro dei dati tramite apposita icona o pulsante.
- *Postcondizioni*: l'amministratore pubblico visualizza solamente i dati relativi alle tipologie di sensore selezionate, all'interno di tale #glossary("pannello").
- *Scenario Principale*:
+ l'amministratore pubblico seleziona la funzionalità relativa al filtro dei dati;
+ l'amministratore pubblico seleziona i valori delle tipologie di sensore desiderati.
- *Inclusioni*: [UC6.5].
#figure(
image("assets/UML/UC6.2_Filtro-per-tipologia-sensore-su-tabella.png",width:100%),
caption: [UC6.2 Filtro per tipologia sensore su tabella]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC6.3: Filtro per nome sensore su tabella
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*:
+ l'amministratore pubblico ha scelto un #glossary("pannello") su cui effettuare l'operazione di filtro;
+ il #glossary("pannello") offre la funzionalità di filtro dei dati.
- *Postcondizioni*: l'amministratore pubblico visualizza solamente i dati relativi ai sensori selezionati, all'interno di tale #glossary("pannello").
- *Scenario Principale*:
+ l'amministratore pubblico seleziona la funzionalità relativa al filtro dei dati;
+ l'amministratore pubblico seleziona i valori dei nomi dei sensori desiderati.
- *Inclusioni*: [UC6.5].
#figure(
image("assets/UML/UC6.3_Filtro-per-nome-sensore-su-tabella.png",width:100%),
caption: [UC6.3 Filtro per nome sensore su tabella]
)
/*Cambiare il numero nell'immagine*/
=== UC6.4: Filtro per intervallo temporale
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico sta visualizzando uno o più #glossary("pannelli").
- *Postcondizioni*: l'amministratore pubblico visualizza solamente i dati relativi all'intervallo temporale selezionato, in tutti i #glossary("pannelli") della #glossary("dashboard") dove è stato applicato il filtro.
- *Scenario Principale*:
+ l'amministratore pubblico seleziona la funzionalità relativa al filtro dei dati per intervallo temporale;
+ l'amministratore pubblico seleziona l'intervallo temporale desiderato.
- *Inclusioni*: [UC6.5].
#figure(
image("assets/UML/UC6.4_Filtro-per-intervallo-temporale.png",width:100%),
caption: [UC6.4 Filtro per intervallo temporale]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC6.5: Filtro #glossary("pannelli") collegati
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*:
+ l'amministratore pubblico ha filtrato i dati in un #glossary("pannello");
+ altri #glossary("pannelli") sono collegati a quello filtrato.
- *Postcondizioni*: l'amministratore pubblico visualizza, in tutti i #glossary("pannelli") collegati, solamente i dati relativi al filtro applicato (o ai filtri applicati) al pannello sorgente, nel caso di #glossary("pannelli") che dipendono da altri #glossary("pannelli") per la visualizzazione di dati.
- *Scenario Principale*:
+ il sistema aggiorna tutti i #glossary("pannelli") collegati.
/*Cambiare il numero nell'immagine*/
=== UC7: Ordinamento #glossary("pannelli") tabellari
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico ha scelto e sta visualizzando un #glossary("pannello"), con all'interno una tabella, da ordinare per un suo campo.
- *Postcondizioni*: l'amministratore pubblico visualizza i dati ordinati nella tabella, secondo tale campo.
- *Scenario Principale*:
+ l'amministratore pubblico seleziona un campo, della tabella, secondo cui ordinare i dati;
+ in tale campo l'amministratore pubblico seglie tra l'ordinamento crescente e decrescente.
#figure(
image("assets/UML/UC7_Ordinamento-pannelli-tabellari.png",width:70%),
caption: [UC7 Ordinamento #glossary("pannelli") tabellari]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC8: Modifica layout #glossary("pannelli")
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: l'amministratore pubblico sta visualizzando almeno un #glossary("pannello").
- *Postcondizioni*: l'amministratore pubblico visualizza il nuovo layout.
- *Scenario Principale*:
+ l'amministratore pubblico sposta o ridimensiona i #glossary("pannelli") a suo piacimento.
#figure(
image("assets/UML/UC8_Modifica-layout-pannelli.png",width:70%),
caption: [UC8 Modifica layout #glossary("pannelli")]
)
/*Cambiare il numero nell'immagine*/
=== UC9: Visualizzazione errore nessun dato
- *Attore Principale*: amministratore pubblico.
- *Precondizioni*: il sistema di visualizzazione non ottiene alcun dato da mostrare all'interno di un #glossary("pannello").
- *Postcondizioni*: l'amministratore pubblico visualizza un messaggio di errore segnalante l'assenza di dati da mostrare.
- *Scenario Principale*:
+ l'amministratore pubblico vuole visualizzare qualche #glossary("pannello") [UC1.2] [UC1.1] [UC2.1] [UC3.1];
+ il sistema non ha i dati con cui popolare tale pannello.
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC10: Inserimento dati temperatura
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione della temperatura;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la temperatura, espressa in gradi Celsius, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC10_Inserimento-dati-temperatura.png",width:100%),
caption: [UC10 Inserimento dati temperatura]
)
/*Cambiare il numero nell'immagine*/
=== UC11: Inserimento dati umidità
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione dell'umidità;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la percentuale di umidità, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC11_Inserimento-dati-umidità.png",width:100%),
caption: [UC11 Inserimento dati umidità]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC12: Inserimento dati velocità e direzione del vento
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione della velocità e della direzione del vento;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la direzione del vento, espressa in gradi (con gli 0° a Nord e i 180° a Sud), la velocità del vento, espressa in chilometri all'ora, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC12_Inserimento-dati-velocità-e-direzione-del-vento.png",width:100%),
caption: [UC12 Inserimento dati velocità e direzione del vento]
)
/*Cambiare il numero nell'immagine*/
=== UC13: Inserimento dati precipitazioni
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione quantitativa delle precipitazioni;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la quantità di precipitazioni rilevate, espresse in millimetri all'ora, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC13_Inserimento-dati-precipitazioni.png",width:100%),
caption: [UC13 Inserimento dati precipitazioni]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC14: Inserimento dati inquinamento dell'aria
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione quantitativa dell'inquinamento dell'aria;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare rilevazioni #glossary("PM10") relative all'inquinamento dell'aria, espresse in $#sym.mu g\/m^3$, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC14_Inserimento-dati-inquinamento-dell-aria.png",width:100%),
caption: [UC14 Inserimento dati inquinamento dell'aria]
)
/*Cambiare il numero nell'immagine*/
=== UC15: Inserimento dati livello bacini idrici
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione del livello del bacino idrico in cui è installato;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la percentuale di riempimento del bacino idrico controllato, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC15_Inserimento-dati-livello-bacini-idrici.png",width:100%),
caption: [UC15 Inserimento dati livello bacini idrici]
)
#pagebreak()
=== UC16: Inserimento dati disponibilità parcheggi
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore rileva gli ingressi e le uscite del parcheggio in cui è installato;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la quantità di parcheggi liberi rilevati nel parcheggio controllato, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC16_Inserimento-dati-disponibilità-parcheggi.png",width:100%),
caption: [UC16 Inserimento dati disponibilità e occupazione parcheggi]
)
/*Cambiare il numero nell'immagine*/
=== UC17: Inserimento dati colonne di ricarica
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione del wattaggio erogato dalla colonna di ricarica;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la quantità di energia erogata, espressa in chilowatt all'ora, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC17_Inserimento-dati-colonne-di-ricarica.png",width:100%),
caption: [UC17 Inserimento dati colonne di ricarica]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC18: Inserimento dati biciclette elettriche
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione della posizione e della percentuale della batteria della bicicletta elettrica su cui è installato;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare il timestamp di rilevazione, la percentuale di batteria e le coordinate della bicicletta;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC18_Inserimento-dati-biciclette-elettriche.png",width:100%),
caption: [UC18 Inserimento dati biciclette elettriche]
)
/*Cambiare il numero nell'immagine*/
=== UC19: Inserimento dati riempimento zone ecologiche
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione del livello di riempimento del contenitore ecologico associato;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare la percentuale di riempimento della zona ecologica controllata, il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC19_Inserimento-dati-riempimento-zone-ecologiche.png",width:100%),
caption: [UC19 Inserimento dati riempimento zone ecologiche]
)
/*Cambiare il numero nell'immagine*/
#pagebreak()
=== UC20: Inserimento dati congestione stradale
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore effettua una rilevazione del livello di congestione della strada su cui è installato;
+ il sensore formatta il messaggio da inviare al sistema, di modo da mandare lo stato della congestione stradale nella strada controllata, espresso nei seguenti stati (ordinati per ordine di congestione crescente) "LOW", "MEDIUM", "HIGH", "BLOCKED", il timestamp di rilevazione e le proprie coordinate;
+ il sensore invia il messaggio al sistema.
- *Inclusioni*: UC21.
#figure(
image("assets/UML/UC20_Inserimento-dati-congestione-stradale.png",width:100%),
caption: [UC20 Inserimento dati congestione stradale]
)
/*Cambiare il numero nell'immagine*/
=== UC21: Inserimento dati relativi al sensore
- *Attore Principale*: sensore.
- *Precondizioni*: il sensore è acceso e collegato al sistema.
- *Postcondizioni*: il sistema ha persistito i dati inviati dal sensore.
- *Scenario Principale*:
+ il sensore allega i dati relativi al proprio stato, ovvero la propria percentuale di batteria (costantemente a 100% nel caso di sensori senza batteria autonoma), la data di ultima manutenzione effettuata su di esso e la propria frequenza di inserimento dati, espressa in secondi, al messaggio da inviare al sistema.
#set heading(numbering: "1.1")
#pagebreak()
= Requisiti
#show figure: set block(breakable: true)
== Requisiti funzionali
#let C = counter("UC_counter_req")
#let requisiti_funzionali = (
(
"Obbligatorio", "L'utente deve poter accedere all'applicazione senza dover effettuare l'autenticazione.", "Capitolato"
),
/*TODO: andare a creare vincolo per la verifica del menù di selezione tra le dashboard*/
(
"Obbligatorio", [L'utente deve poter visualizzare un menù di selezione delle #glossary("dashboard"), che permetta di selezionare tra Sensori, Ambientale, Urbanistica e Dati anomali & superamento soglie.], [UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare una #glossary("dashboard") generale relativa ai sensori.], [UC#C.step()#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare le posizioni dei sensori come icone su una mappa, appartenente alla #glossary("dashboard") generale relativa ai sensori.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare, in forma tabellare, l'elenco dei sensori con la relativa percentuale di batteria, un valore booleano che indica se il sensore va a batteria autonoma o meno e la data di ultima manutenzione effettuata su tale sensore, all'interno della #glossary("dashboard") generale relativa ai sensori.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter monitorare i dati provenienti dai sensori relativi ai dati ambientali in una #glossary("dashboard") apposita.], [#C.step()UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente un grafico in formato #glossary("time series") rappresentante la media aritmetica della temperatura, espressa in gradi celsius, per ciascun sensore, aggregando i dati per intervalli di 5 minuti, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente un grafico in formato #glossary("time series") rappresentante la media aritmetica della percentuale d'umidità, per ciascun sensore, aggregando i dati per intervalli di 5 minuti, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente una mappa che evidenzi la direzione del vento, mediante frecce aventi origine nelle coordinate del sensore, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente una tabella la quale riporta l'ultima velocità del vento, espressa in chilometri all'ora, per ciascun sensore, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente un grafico in formato #glossary("time series") rappresentante la media aritmetica dell'intensità delle precipitazioni, espresse in millimetri all'ora, per ciascun sensore, aggregando i dati per intervalli di 5 minuti, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente un indice numerico, che esprime l'intensità media delle precipitazioni, espressa in millimetri all'ora, degli ultimi 5 minuti, facendo la media dei dati raccolti tra tutti i sensori, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente un grafico in formato #glossary("time series") rappresentante la media aritmetica del livello di polveri sottili nell'aria, espressi in $#sym.mu g\/m^3$ (#glossary("PM10")), per ciascun sensore, aggregando i dati per intervalli di 5 minuti, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente un indice numerico, che esprime l'inquinamento dell'aria medio, espressa in $#sym.mu g\/m^3$ (#glossary("PM10")), degli ultimi 5 minuti, facendo la media dei dati raccolti tra tutti i sensori, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente un grafico in formato #glossary("time series") rappresentante la percentuale di riempimento dei bacini idrici, per ciascun sensore, aggregando i dati per intervalli di 5 minuti, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente un indice numerico, che esprime la temperatura media, espressa in gradi celsius, degli ultimi 5 minuti, facendo la media dei dati raccolti tra tutti i sensori, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente un indice numerico, che esprime l'inquinamento dell'aria massimo, espresso in $#sym.mu g\/m^3$ (#glossary("PM10")), degli ultimi 5 minuti, tra i dati registrati da tutti i sensori, nella #glossary("dashboard") relativa ai dati ambientali.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter monitorare i dati provenienti dai sensori relativi ai dati urbanistici in una #glossary("dashboard") apposita.], [#C.step()UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente una mappa che evidenzi il numero di posti liberi nei vari parcheggi, mediante indicatori numerici posti nelle coordinate del sensore, nella #glossary("dashboard") relativa ai dati urbanistici.], [#C.step(level: 2)#C.step(level: 2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente una mappa che evidenzi la posizione delle colonne di ricarica per auto, mediante indicatori booleani posti nelle coordinate dei sensori che indicheranno la disponibilità di queste, nella #glossary("dashboard") relativa ai dati urbanistici.], [#C.step(level:2)#C.step(level:3)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente una tabella la quale riporta l'erogazione delle colonne di ricarica per auto, espressa in Watt all'ora, controllata da ciascun sensore, nella #glossary("dashboard") relativa ai dati urbanistici.], [#C.step(level:3)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente una mappa che evidenzi lo stato di congestione delle strade, mediante gli stati "LOW", "MEDIUM", "HIGH", "BLOCKED", posti nelle coordinate dei sensori controllano queste, nella #glossary("dashboard") relativa ai dati urbanistici.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente una mappa che mostri la posizione delle biciclette elettriche controllate, in tempo reale, mediante degli indicatori numerici, indicanti la percentuale della batteria, posizionati nelle coordinate del mezzo, nella #glossary("dashboard") relativa ai dati urbanistici.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un #glossary("pannello") contenente una mappa che mostri la percentuale di riempimento delle zone ecologiche, mediante degli indicatori percentuali, posizionati nelle coordinate della zona, nella #glossary("dashboard") relativa ai dati urbanistici.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter monitorare i #glossary("dati anomali") e i dati superanti delle soglie, in una #glossary("dashboard") apposita.], [#C.step()UC#C.display()]
),
(
"Opzionale", [L'utente deve poter visualizzare un #glossary("pannello") contenente una tabella che mostri i #glossary("dati anomali"), il sensore che li ha rilevati e il timestamp del rilevamento, nella #glossary("dashboard") relativa ai #glossary("dati anomali") e superanti le soglie.], [#C.step(level:2)UC#C.display()]
),
/*TODO: disambiguare relativamente alla citazione delle soglie*/
(
"Desiderabile", [L'utente deve poter visualizzare un #glossary("pannello") contenente una tabella che mostri i dati relativi a temperatura, precipitazioni, inquinamento dell'aria, bacini idrici e zone ecologiche, i cui valori superano una soglia fissata, il sensore che li ha rilevati e il timestamp del rilevamento, nella #glossary("dashboard") relativa ai #glossary("dati anomali") e superanti le soglie.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", "L'utente deve poter visualizzare delle notifiche riguardo ad un valore di un dato di tipo temperatura, superante una soglia di 40° celsius.", [#C.step()#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", "L'utente deve poter visualizzare delle notifiche riguardo ad un valore di un dato di tipo precipitazioni, superante una soglia di 50 millimetri all'ora.", [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter visualizzare delle notifiche riguardo ad un valore di un dato di tipo inquinamento dell'aria (#glossary("PM10")), superante una soglia di 80 microgrammi su metro cubo.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", "L'utente deve poter visualizzare delle notifiche riguardo ad un valore di un dato di tipo percentuale riempimento bacini idrici, superante una soglia corrispondente al 70% della capienza di tale bacino.", [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", "L'utente deve poter visualizzare delle notifiche riguardo ad un valore di un dato di tipo percentuale riempimento zone ecologiche, superante una soglia corrispondente all'80% della capienza di tale zona.", [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter filtrare i dati, visualizzati all'interno di un grafico di tipo #glossary("time series"), in base ad un sottoinsieme selezionato di sensori.], [#C.step()#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter filtrare i dati, visualizzati all'interno di una tabella, in base ad un sotto-insieme di sensori, selezionandone la tipologia di interesse.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter filtrare i dati, visualizzati all'interno di una tabella, in base ad un sotto-insieme di sensori, selezionando i nomi dei sensori di interesse.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter filtrare i dati in base ad un intervallo temporale, mostrando quindi nella #glossary("dashboard") d'interesse, solamente i dati aventi un timestamp in tale intervallo.], [#C.step(level:2)UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare l'applicazione dei filtri in determinati #glossary("pannelli"), riflessi anche sui #glossary("pannelli") collegati ai primi.], [#C.step(level:2)UC#C.display()]
),
(
"Desiderabile", [Nei #glossary("pannelli") con tabelle, l'utente deve poter ordinare i dati in base alle loro colonne, sia in ordine crescente che descrescente.], [#C.step()UC#C.display()]
),
(
"Desiderabile", [L'utente deve poter modificare il layout della #glossary("dashboard") visualizzata, agendo su posizione e dimensione dei #glossary("pannelli").], [#C.step()UC#C.display()]
),
(
"Obbligatorio", [L'utente deve poter visualizzare un messaggio di errore, qualora il sistema di visualizzazione non sia in grado di reperire o non abbia dati da mostrare all'utente per un determinato #glossary("pannello").], [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alla temperatura, espressa in gradi Celsius, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi all'umidità, espressa in percentuale, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alla velocità del vento, espressa in chilometri all'ora, alla direzione del vento, espressa in gradi (con gli 0° a Nord e i 180° a Sud), il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alle precipitazioni, espresse in millimetri all'ora, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", [Il sensore deve poter mandare e far persistere dati relativi all'inquinamento dell'aria, espresso in microgrammi al metro cubo (#glossary("PM10")), il timestamp di rilevazione e le proprie coordinate.], [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alla percentuale di riempimento del bacino idrico controllato, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi al numero di parcheggi disponibili all'interno del parcheggio auto controllato, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alla quantità di energia erogata dalla colonna di ricarica controllata, espresse in chilowatt all'ora, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alle coordinate della bicicletta elettrica controllata, la percentuale di batteria della stessa e il timestamp di rilevazione.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", "Il sensore deve poter mandare e far persistere dati relativi alla percentuale di riempimento della zona ecologica controllata, il timestamp di rilevazione e le proprie coordinate.", [#C.step()UC#C.display()]
),
(
"Obbligatorio", [Il sensore deve poter mandare e far persistere dati relativi allo stato della congestione stradale nella strada controllata, espresse in stati (in ordine di crescente congestione sono: "LOW", "MEDIUM", "HIGH", "BLOCKED"), il timestamp di rilevazione e le proprie coordinate.], [#C.step()UC#C.display()]
),
(
"Desiderabile", "Il sensore deve poter mandare e far persistere dati relativi al proprio stato, ovvero la propria percentuale di batteria (costantemente a 100% nel caso di sensori senza batteria autonoma), la data di ultima manutenzione effettuata su di esso, e la propria frequenza di inserimento dati espressa in secondi.", [#C.step()UC#C.display()]
)
)
#let requisiti_funzionali_con_codice = generate_requirements_array("F", requisiti_funzionali)
#figure(
requirements_table(requisiti_funzionali_con_codice),
caption: "Requisiti funzionali")
#pagebreak()
== Requisiti di qualità
#let requisiti_qualita = (
(
"Obbligatorio","Il superamento di test che dimostrino il corretto funzionamento dei servizi utilizzati e delle funzionalità implementate. La copertura di test deve essere almeno dell'80% e deve essere dimostrata tramite report.","Capitolato",
),
(
"Obbligatorio",[Il sistema deve essere testato nella sua interezza tramite #glossary("test end-to-end")],"Capitolato",
),
(
"Obbligatorio", [Viene richiesta una #glossary("documentazione") sulle scelte implementative e progettuali, che dovranno essere accompagnate da motivazioni.],"Capitolato",
),
(
"Obbligatorio","La documentazione dovrà riguardare anche problemi aperti ed eventuali possibili soluzioni da approfondire in futuro.","Capitolato"
)
)
#let requisiti_qualita_con_codice = generate_requirements_array("Q", requisiti_qualita)
#figure(
requirements_table(requisiti_qualita_con_codice),
caption: "Requisiti di qualità")
#pagebreak()
== Requisiti di vincolo
#let requisiti_vincolo = (
(
"Obbligatorio",[Il sistema deve gestire un carico di #glossary("dati in entrata") tra i 50 e i 100 dati al secondo],"Verbale esterno",
),
(
"Obbligatorio","La creazione di un simulatore di almeno una sorgente dati","Capitolato",
),
(
"Obbligatorio","La simulazione deve produrre dati realistici","Capitolato",
),
(
"Obbligatorio","I dati vanno raccolti in un database OLAP","Capitolato",
),
(
"Obbligatorio","I dati vanno passati ad un sistema di stream processing","Capitolato",
),
(
"Obbligatorio",[Deve esistere una #glossary("dashboard") che riporti almeno i dati di un sensore],"Capitolato",
),
(
"Desiderabile","La simulazione di più sorgenti dati","Capitolato",
),
(
"Opzionale","Messa in evidenza di relazioni tra dati provenienti da sorgenti diverse","Capitolato",
),
(
"Opzionale","Un sistema di allerta che notifichi l'utente in caso di anomalie o eventi critici","Verbale esterno",
),
(
"Opzionale","La previsione di eventi futuri, basata su dati storici e attuali","Capitolato",
),
(
"Desiderabile",[Deve esistere una #glossary("dashboard") avanzata contenente: una mappa della città, widget e informazioni sui sensori (ad esempio il tipo di sensore, il modello, ecc.).],"Capitolato"
)
)
#let requisiti_vincolo_con_codice = generate_requirements_array("V", requisiti_vincolo)
#figure(
requirements_table(requisiti_vincolo_con_codice),
caption: "Requisiti di vincolo")
#pagebreak()
== Tracciamento
=== Requisiti funzionali - Fonti
#figure(
table(
columns: (auto, auto),
inset: 10pt,
align: horizon,
[*Requisiti*], [*Fonti*],
..requisiti_funzionali_con_codice.map(content => (content.at(0),content.at(3))).flatten().map(content => [#content])
),
caption: "Requisiti funzionali - Fonti")
=== Requisiti qualità - Fonti
#figure(
table(
columns: (auto, auto),
inset: 10pt,
align: horizon,
[*Requisiti*], [*Fonti*],
..requisiti_qualita_con_codice.map(content => (content.at(0),content.at(3))).flatten().map(content => [#content])
),
caption: "Requisiti qualità - Fonti")
=== Requisiti vincolo - Fonti
#figure(
table(
columns: (auto, auto),
inset: 10pt,
align: horizon,
[*Requisiti*], [*Fonti*],
..requisiti_vincolo_con_codice.map(content => (content.at(0),content.at(3))).flatten().map(content => [#content])
),
caption: "Requisiti vincolo - Fonti")
#pagebreak()
== Riepilogo
#let funzionale_obb = requisiti_funzionali.filter(content => content.at(0) == "Obbligatorio").len()
#let funzionale_des = requisiti_funzionali.filter(content => content.at(0) == "Desiderabile").len()
#let funzionale_opz = requisiti_funzionali.filter(content => content.at(0) == "Opzionale").len()
#let funzionale_tot = funzionale_des + funzionale_obb + funzionale_opz
#let qualità_obb = requisiti_qualita.filter(content => content.at(0) == "Obbligatorio").len()
#let qualità_des = requisiti_qualita.filter(content => content.at(0) == "Desiderabile").len()
#let qualità_opz = requisiti_qualita.filter(content => content.at(0) == "Opzionale").len()
#let qualità_tot = qualità_des + qualità_obb + qualità_opz
#let vincolo_obb = requisiti_vincolo.filter(content => content.at(0) == "Obbligatorio").len()
#let vincolo_des = requisiti_vincolo.filter(content => content.at(0) == "Desiderabile").len()
#let vincolo_opz = requisiti_vincolo.filter(content => content.at(0) == "Opzionale").len()
#let vincolo_tot = vincolo_des + vincolo_obb + vincolo_opz
#figure(
table(
columns: (auto, auto, auto, auto, auto),
inset: 10pt,
align: horizon,
[*Tipologia*], [*Obbligatori*], [*Desiderabili*], [*Opzionali*], [*Totale*],
[funzionali], [#funzionale_obb], [#funzionale_des], [#funzionale_opz], [#funzionale_tot],
[di qualità], [#qualità_obb], [#qualità_des], [#qualità_opz], [#qualità_tot],
[di vincolo], [#vincolo_obb], [#vincolo_des], [#vincolo_opz], [#vincolo_tot]
),
caption: "Tabella di riepilogo dei vincoli") |
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/fletcher/0.4.2/README.md | markdown | Apache License 2.0 | # Fletcher
[](https://github.com/Jollywatt/typst-fletcher/raw/latest/docs/manual.pdf)
[](https://github.com/Jollywatt/typst-fletcher)
_**Fletcher** (noun) a maker of arrows_
A [Typst]("https://typst.app/") package for drawing diagrams with arrows,
built on top of [CeTZ]("https://github.com/johannes-wolf/cetz").
```typ
#import "@preview/fletcher:0.4.2" as fletcher: node, edge
```
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/first-isomorphism-theorem-dark.svg">
<img src="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/first-isomorphism-theorem-light.svg">
</picture>
```typ
#fletcher.diagram(cell-size: 15mm, $
G edge(f, ->) edge("d", pi, ->>) & im(f) \
G slash ker(f) edge("ur", tilde(f), "hook-->")
$)
```
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/flowchart-trap-dark.svg">
<img src="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/flowchart-trap-light.svg">
</picture>
```typ
// https://xkcd.com/1195/
#import fletcher.shapes: diamond
#set text(font: "Comic Neue", weight: 600)
#fletcher.diagram(
node-stroke: 1pt,
edge-stroke: 1pt,
node((0,0), [Start], corner-radius: 2pt, extrude: (0, 3)),
edge("-|>"),
node((0,1), align(center)[
Hey, wait,\ this flowchart\ is a trap!
], shape: diamond),
edge("d,r,u,l", "-|>", [Yes], label-pos: 0.1)
)
```
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/state-machine-dark.svg">
<img src="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/state-machine-light.svg">
</picture>
```typ
#fletcher.diagram(
node-stroke: .1em,
node-fill: gradient.radial(blue.lighten(80%), blue, center: (30%, 20%), radius: 80%),
spacing: 4em,
edge((-1,0), "r", "-|>", `open(path)`, label-pos: 0, label-side: center),
node((0,0), `reading`, radius: 2em),
edge(`read()`, "-|>"),
node((1,0), `eof`, radius: 2em),
edge(`close()`, "-|>"),
node((2,0), `closed`, radius: 2em, extrude: (-2.5, 0)),
edge((0,0), (0,0), `read()`, "--|>", bend: 130deg),
edge((0,0), (2,0), `close()`, "-|>", bend: -40deg),
)
```
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/feynman-diagram-dark.svg">
<img src="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/feynman-diagram-light.svg">
</picture>
```typ
#fletcher.diagram($
e^- edge("rd", "-<|-") & & & edge("ld", "-|>-") e^+ \
& edge(gamma, "wave") \
e^+ edge("ru", "-|>-") & & & edge("lu", "-<|-") e^- \
$)
```
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/ml-architecture-dark.svg">
<img src="https://github.com/Jollywatt/typst-fletcher/raw/master/docs/example-gallery/ml-architecture-light.svg">
</picture>
```typ
#import fletcher.shapes: house, hexagon
#set text(font: "Fira Sans")
#let blob(pos, label, tint: white, ..args) = node(
pos, align(center, label),
width: 25mm,
fill: tint.lighten(60%),
stroke: 1pt + tint.darken(20%),
corner-radius: 5pt,
..args,
)
#fletcher.diagram(
spacing: 8pt,
cell-size: (8mm, 10mm),
edge-stroke: 1pt,
edge-corner-radius: 5pt,
mark-scale: 70%,
blob((0,1), [Add & Norm], tint: yellow, shape: hexagon),
edge(),
blob((0,2), [Multi-Head\ Attention], tint: orange),
blob((0,4), [Input], shape: house.with(angle: 30deg),
width: auto, tint: red),
for x in (-.3, -.1, +.1, +.3) {
edge((0,2.8), (x,2.8), (x,2), "-|>")
},
edge((0,2.8), (0,4)),
edge((0,3), "l,uu,r", "--|>"),
edge((0,1), (0, 0.35), "r", (1,3), "r,u", "-|>"),
edge((1,2), "d,rr,uu,l", "--|>"),
blob((2,0), [Softmax], tint: green),
edge("<|-"),
blob((2,1), [Add & Norm], tint: yellow, shape: hexagon),
edge(),
blob((2,2), [Feed\ Forward], tint: blue),
)
```
## Todo/wishlist
- [x] Mathematical arrow styles
- [x] Also allow `&`-delimited equations for specifying nodes
- [ ] Support CeTZ arrowheads
- [x] Support arbitrary node shapes drawn with CeTZ
- [ ] Allow referring to node coordinates by their content?
- [ ] Support loops connecting a node to itself
- [x] More ergonomic syntax to avoid repeating coordinates?
- [x] Poly-edges with multiple segments
- [x] Add way to adjust edge connection points while still having them snap to node edges
- [x] Zig-zags and waves
## Change log
### 0.4.2
- Improve edge-to-node snapping. Edges can terminate anywhere near a node (not just at its center) and will automatically snap to the node outline. Added `snap-to` option to `edge()`.
- Fixed node `inset` being half the amount specified. If upgrading from previous version, you will need to divide node `inset` values by two to preserve diagram layout.
- Add `decorations` option to `edge()` for CeTZ path decorations (`"wave"`, `"zigzag"`, and `"coil"`, also accepted as positional string arguments).
### 0.4.1
- Support custom node shapes! Edges connect to node outlines automatically.
- New `shapes` submodule, containing `diamond`, `pill`, `parallelogram`, `hexagon`, and other node shapes.
- Allow edges to have multiple segments.
- Add `vertices` an `corner-radius` options to `edge()`.
- Relative coordinate shorthands may be comma separated to signify multiple segments, e.g., `"r,u,ll"`.
- Add `dodge` option to `edge()` to adjust end points.
- Support `cetz:0.2.0`.
### 0.4.0
- Add ability to specify diagrams in math-mode, using `&` to separate nodes.
- Allow implicit and relative edge coordinates, e.g., `edge("d")` becomes `edge(prev-node, (0, 1))`.
- Add ability to place marks anywhere along an edge. Shorthands now accept an optional middle mark, for example `|->-|` and `hook-/->>`.
- Add “hanging tail” correction to marks on curved edges. Marks now rotate a bit to fit more comfortably along tightly curving arcs.
- Add more arrowheads for the sake of it: `}>`, `<{`, `/`, `\`, `x`, `X`, `*` (solid dot), `@` (solid circle).
- Add `axes` option to `diagram()` to control the direction of each axis in the diagram's coordinate system.
- Add `width`, `height` and `radius` options to `node()` for explicit control over size.
- Add `corner-radius` option to `node()`.
- Add `stroke` option to `edge()` replacing `thickness` and `paint` options.
- Add `edge-stroke` option to `diagram()` replacing `edge-thickness`.
### 0.3.0
- Make round-style arrow heads better approximate the default math font.
- Add solid arrow heads with shorthand `<|-`, `-|>` and double-bar `||-`, `-||`.
- Add an `extrude` option to `node()` which duplicates and extrudes the node's stroke, enabling double stroke effects.
### 0.2.0
- Experimental support for customising arrowheads.
- Add right-angled edges with `edge(..., corner: left/right)`. |
https://github.com/drupol/ipc2023 | https://raw.githubusercontent.com/drupol/ipc2023/main/src/ipc2023/references.typ | typst | #import "imports/preamble.typ": *
#slide(title:"Links", new-section:"References")[
#set text(size: .75em)
- #link("https://www.youtube.com/watch?v=H0A2cSejlZ4")[
#text(font: "Inconsolata Nerd Font")[\u{f167}] <NAME> - On the Importance and Challenges of Reproducible Builds for Software Supply Chain Security
] @FourneWEFA23
- #link("https://www.youtube.com/watch?v=TM5zpCn4piM")[
#text(font: "Inconsolata Nerd Font")[\u{f167}] <NAME> - The Significance of Reproducible Software in International R&D
]
- #link("https://www.youtube.com/watch?v=QYH18NpsRu8")[
#text(font: "Inconsolata Nerd Font")[\u{f167}] <NAME> - Fully Countering Trusting Trust through Diverse Double-Compiling
] @Wheeler10
- #link("https://www.youtube.com/watch?v=6Le0IbPRzOE")[
#text(font: "Inconsolata Nerd Font")[\u{f167}] <NAME> - What Nix Can Do
]
- #link("https://www.youtube.com/watch?v=SxdOUGdseq4")[
#text(font: "Inconsolata Nerd Font")[\u{f167}] <NAME> - Simple Made Easy
]
- #link("https://www.youtube.com/watch?v=fsgYVi2PQr0")[
#text(font: "Inconsolata Nerd Font")[\u{f167}] <NAME> - The dark and murky past of NixOS
]
]
#slide(title:"Bibliography")[
#set text(size: .6em)
#set align(left + top)
#bibliography(title: none, "literature.bib", style: "ieee")
]
|
|
https://github.com/TypstApp-team/typst | https://raw.githubusercontent.com/TypstApp-team/typst/master/tests/typ/bugs/flow-4.typ | typst | Apache License 2.0 | // In this bug, a frame intended for the second region ended up in the first.
---
#set page(height: 105pt)
#block(lorem(20))
|
https://github.com/Ngan-Ngoc-Dang-Nguyen/thesis | https://raw.githubusercontent.com/Ngan-Ngoc-Dang-Nguyen/thesis/main/docs/knapsack.typ | typst | //knapsack book
#include "../tools/multi-section-ref.typ"
#import "../tools/macros.typ": eqref
#include "../tools/multi-section-ref.typ"
#import "../tools/macros.typ": eqref
#import "../typst-orange.typ": theorem, proof, lemma, proposition, corollary, example
#import "@preview/cetz:0.1.2": canvas, plot
#import "@preview/cetz:0.1.2"
#include "../tools/multi-section-ref.typ"
#import "../tools/macros.typ": eqref
#import "../typst-orange.typ": theorem, proof, lemma, proposition, corollary, example
#include "../tools/multi-section-ref.typ"
#import "../tools/macros.typ": eqref
#import "../typst-orange.typ": theorem, proof
== BÀI TOÁN KNAPSACK
Trong phần này, chúng ta sẽ khám phá bài toán xếp ba lô (_Knapsack Problem_) - một bài toán kinh điển trong tối ưu hóa tổ hợp, được sử dụng rộng rãi để giải quyết nhiều bài toán tối ưu phức tạp trong thực tế. Bài toán này đòi hỏi chúng ta phải lựa chọn các đối tượng trong một tập hợp sao cho tối đa hóa giá trị tổng thể mà không vượt quá một giới hạn nhất định, thường là về trọng lượng hoặc dung lượng.
Để dễ hình dung, hãy xem xét ví dụ sau: Một tên trộm đột nhập vào cửa hàng và thấy có $n$ món hàng, mỗi món có trọng lượng và giá trị khác nhau. Tuy nhiên, hắn chỉ có một chiếc ba lô với sức chứa giới hạn $c$. Vấn đề đặt ra là tên trộm nên chọn những món nào, và số lượng bao nhiêu, để tối đa hóa tổng giá trị mà vẫn đảm bảo tổng trọng lượng của những món đồ không vượt quá khả năng chứa của chiếc ba lô.
// Bài toán xếp ba lô (knapsack) có thể được định nghĩa một cách chính thức như sau: Chúng ta có một chiếc ba lô với $N$ là tập hợp các vật phẩm, bao gồm $n$ vật phẩm $x_j$ với lợi nhuận $P_j$ và trọng lượng $W_j$, cùng với sức chứa $c$. Thông thường, tất cả các giá trị này đều là số nguyên dương. Mục tiêu là chọn một tập con của $N$ sao cho tổng lợi nhuận của các vật phẩm được chọn là lớn nhất và tổng trọng lượng không vượt quá $c$.
=== Bài toán xếp ba lô 0-1
==== Định nghĩa bài toán
Bài toán ba lô 0-1 (_0-1 Knapsack Problem_) là một trong những biến thể quan trọng và phổ biến nhất của bài toán xếp ba lô. Trong phiên bản này, mỗi vật phẩm đều chỉ có hai lựa chọn: hoặc được chọn hoàn toàn để đưa vào ba lô, hoặc bị bỏ qua hoàn toàn. Điều này tạo nên tên gọi "0-1", biểu thị rằng quyết định cho mỗi vật phẩm chỉ có thể là "0" (không chọn) hoặc "1" (chọn).
Bài toán ba lô 0-1 thường xuất hiện trong các tình huống thực tế, nơi mà các vật phẩm không thể phân chia hoặc chỉ có thể được lựa chọn toàn bộ. Thách thức chính trong bài toán này là phải cân đối giữa giá trị tổng hợp của các vật phẩm và giới hạn trọng lượng của ba lô, sao cho tối ưu hóa tổng giá trị nhận được mà không vượt quá sức chứa.
Bài toán này thuộc nhóm các bài toán NP-khó, điều đó có nghĩa là không có thuật toán nào giải quyết nó một cách tối ưu trong thời gian đa thức cho mọi trường hợp, khiến việc tìm kiếm các phương pháp gần đúng hoặc giải pháp xấp xỉ trở thành một hướng tiếp cận quan trọng.
Tiếp theo, chúng ta sẽ tiến hành mô hình hóa bài toán xếp ba lô dưới dạng toán học như sau.
Bài toán xếp ba lô (_Knapsack Problem_) có thể được định nghĩa một cách chính thức như sau: Chúng ta có một chiếc ba lô với sức chứa tối đa $c$. Ta có $n$ vật phẩm $(j = 1,...,n)$, mỗi vật phẩm có một giá trị $p_j$ và trọng lượng $w_j$. Thông thường, tất cả các giá trị này đều là số nguyên dương. Mục tiêu của bài toán là chọn ra một tập hợp các vật phẩm sao cho tổng giá trị của chúng là lớn nhất, nhưng tổng trọng lượng không được vượt quá sức chứa $c$.
Bài toán xếp ba lô có thể được viết dưới dạng công thức sau:
// $(K P 0-1)$
$
max quad & sum_(j=1)^n p_j x_j\
"s.t." quad & sum_(j=1)^n w_j x_j <= c\
& x_j in {0,1}, quad quad quad quad j= 1,...,n
$
Trong đó, nếu $x_j = 0$ nghĩa là ta không chọn vật phẩm $x_j$. Ngược lại, nếu $x_j =1$ ta sẽ chọn vật phẩm đó.
// Một cá nhân hoặc nhà đầu tư tổ chức giàu có có một số tiền nhất định $c$ mà họ muốn đầu tư vào các dự án kinh doanh có lợi nhuận. Để làm cơ sở cho những quyết định của mình, họ lập một danh sách dài các khoản đầu tư có thể, bao gồm số tiền cần thiết $W_j$ và lợi nhuận ròng dự kiến $p_j$ trong một khoảng thời gian cố định cho mỗi khoản đầu tư. Yếu tố rủi ro không được xem xét rõ ràng ở đây. Rõ ràng, việc kết hợp các quyết định nhị phân cho mỗi khoản đầu tư sao cho tổng lợi nhuận đầu tư là lớn nhất có thể được mô hình hóa bởi bài toán xếp ba lô $(K P)$.
// Một ví dụ minh họa thứ ba về tình huống thực tế được thể hiện qua bài toán xếp ba lô $(K P)$ là trong kinh doanh vận chuyển hàng hóa của hãng hàng không. Nhân viên điều phối của một hãng hàng không vận chuyển hàng hóa phải quyết định xem yêu cầu vận chuyển nào từ khách hàng nên được thực hiện. Quyết định của anh ta dựa trên danh sách các yêu cầu chứa trọng lượng $W_j$ của mỗi kiện hàng và mức phí trên mỗi đơn vị trọng lượng được tính cho từng yêu cầu. Lưu ý rằng, mức phí này không cố định mà phụ thuộc vào các thỏa thuận dài hạn cụ thể của mỗi khách hàng. Do đó, lợi nhuận $p_j$ mà công ty thu được từ việc chấp nhận một yêu cầu và xếp kiện hàng tương ứng lên máy bay không tỷ lệ trực tiếp với trọng lượng của kiện hàng. Rõ ràng, trong thực tế, mỗi chiếc máy bay có một sức chứa tối đa $c$ cụ thể không được vượt quá bởi tổng trọng lượng của các kiện hàng được chọn. Vấn đề hậu cần này là một tương đồng trực tiếp với việc đóng gói ba lô của người leo núi.
Ngoài những bài toán thực tiễn liên quan đến xếp ba lô, cần lưu ý rằng nhiều phương pháp giải quyết các bài toán phức tạp hơn thường sử dụng bài toán xếp ba lô như một bài toán con. Do đó, việc nghiên cứu kỹ lưỡng về bài toán xếp ba lô không chỉ giúp ta nắm vững vấn đề này mà còn mang lại nhiều lợi ích cho việc phát triển và áp dụng các mô hình toán học đa dạng khác.
==== Giải thuật tham lam cho bài toán xếp ba lô 0-1
Thuật toán tham lam là một phương pháp giải quyết bài toán tối ưu bằng cách đưa ra các lựa chọn tại mỗi bước dựa trên tiêu chí tốt nhất tại thời điểm đó, mà không xem xét các lựa chọn trong tương lai. Mỗi bước lựa chọn là _tham lam_ vì nó cố gắng tối đa hóa hoặc tối thiểu hóa một số yếu tố tức thời, với hy vọng rằng chuỗi các lựa chọn này sẽ dẫn đến kết quả tối ưu toàn cục.
Áp dụng vào bài toán xếp ba lô 0-1, một cách tiếp cận tự nhiên là đánh giá tỷ lệ lợi nhuận trên trọng lượng $e_j$
của mỗi vật phẩm, còn gọi là hiệu suất của vật phẩm.
$ e_j = p_j / w_j $
và cố gắng đặt các đối tượng có hiệu suất cao nhất vào ba lô. Rõ ràng, những đối tượng này sẽ tạo ra lợi nhuận cao nhất trong khi tiêu tốn ít không gian nhất. Do đó, trong phần này, chúng ta sẽ giả định rằng các đối tượng được sắp xếp theo hiệu suất của chúng theo thứ tự giảm dần, sao cho
$ p_1 / w_i >= p_2/w_2 >= ... >= p_n/w_n $ <eq:21>
Ý tưởng của thuật toán tham lam với kết quả tối ưu $z_G$ là bắt đầu với một ba lô trống và lần lượt xem xét các vật phẩm theo thứ tự giảm dần của hiệu suất, thêm từng vật phẩm vào ba lô nếu điều đó không vi phạm ràng buộc về sức chứa của ba lô.
// #set table.hline(stroke: .7pt)
// #table(
// table.hline(),
// stroke: none,
// columns: (auto, 4fr),
// [*ĐẦU VÀO*], [Các vật phẩm $x_j, j=1,...,n$, $p_j, w_j$ lần lượt là giá trị và khối lượng vật phẩm $x_j$, ba lô với sức chứa $c$],
// [*Bước 0*], [Sắp xếp các vật phẩm theo thứ tự giảm dần của hiệu suất $e_j$, $overline(w):= 0, z_G := 0$],
// [*Bước 1*], [Xem xét vật phẩm $x_1$],
// // [*Bước 2*], [Nếu $V={v_k}$ thì trả về: $X^*={v_k}.$],
// [*Bước 3*], [],
// [$w_1$ ], [Trả về: $X^*={x in v_k v_l}$, trong đó $v_l$ liền kề $v_k$.],
// [$w_k >$ $W$/2], [Trả về: $X^*={v_k}$],
// [$w_k <$ $W$/2], [Sang Bước 4.],
// [*Bước 4*], [Đặt $w_l := w_l + w_k$ với $v_l$ liền kề $v_k$ và xét cây mới $T:= T without {v_k}$. Trở về Bước 1.],
// table.hline(),
// [*ĐẦU RA*], [$X^*$ là tập hợp tất cả các điểm 1-median.],
// )
#import "@preview/showybox:2.0.1": showybox
#showybox(
[*THUẬT TOÁN THAM LAM*
*ĐẦU VÀO:* Có $n$ vật phẩm $x_j$, $p_j, w_j$ lần lượt là giá trị và khối lượng vật phẩm, các vật phẩm này đã được sắp xếp theo giá trị giảm dần của hiệu suất $e_j$ và ba lô có sức chứa $c$.
$overline(w) := 0 quad quad quad$ $overline(w)$: _cân nặng tổng cộng của các vật phẩm đã được đóng gói hiện tại_
$z_G:=0 quad quad quad$ $z_G$: _giá trị tối ưu_
*for* $quad$ $j:= 1$ đến $n$ $quad$ *do*
$quad quad $ *if* $quad$ $overline(w)+w_j <= c$ $quad$ *then*
$quad quad quad quad x_j:=1$ _đặt vật phẩm thứ $j$ vào ba lô_
$quad quad quad quad overline(w):= overline(w) + w_j$
$quad quad quad quad z_G := z_G + p_j$
$quad quad$ *else* $quad$ $x_j := 0$
*ĐẦU RA:* $z_G$ và $overline(w)$.
]
)
Để hiểu rõ hơn về cách hoạt động của thuật toán, ta xem xét ví dụ sau
*Ví dụ* Cho ba lô với sức chứa $c=9$ và số vật phẩm hiện có là $n=7$ với giá trị và trọng lượng được cho ở bảng bên dưới.
#import "@preview/tablem:0.1.0": tablem
// #tablem[
// | *j* | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
// | ------ |---|---|----|-----------------|
// | p_j | 6 | 5 | 8 | 9 | 6 | 7 | 3 |
// | w_j | 2 | 3 | 6 | 7 | 5 | 9 | 4 |
// ]
// #import "@preview/tablem:0.1.0": tablem
// #tablem[
// | *Name* | *Location* | *Height* | *Score* |
// | ------ | ---------- | -------- | ------- |
// | John | Second St. | 180 cm | 5 |
// | Wally | Third Av. | 160 cm | 10 |
// ]
#align(center)[#table(
columns: 8,
[$j$], [1], [2], [3], [4], [5], [6], [7],
[$p_j$], [6], [5], [8], [9], [6], [7], [3],
[$w_j$], [2], [3], [6], [7], [5], [9], [4]
)]
Trước tiên, ta thấy rằng, các vật phẩm đã được sắp xếp theo hiệu suất giảm dần. Tiếp theo, thuật toán tham lam sẽ hoạt động như sau:
Xét vật phẩm $x_1$, lúc này $overline(w):= overline(w) + w_1 = 0 + 2 = 2 <= c = 9$, đưa $x_1$ vào ba lô và $z_G := z_G + p_1 = 0 + 6 =6$.
Xét đến vật phẩm $x_2$, $overline(w):= overline(w) + w_2 = 2 + 3 = 5 <= c =9$, đưa $x_2$ vào ba lô và $z_G := z_G + p_2 = 6 +5 = 11 $.
Xét vật phẩm $x_3$, $overline(w) := overline(w)+ w_3 = 5 + 6 = 11 > c = 9$, không đưa $x_3$ vào ba lô.
Xét vật phẩm $x_4$, $overline(w):= overline(w) + w_4 = 5 + 7 = 12 > c =9 $, không đưa $x_4$ vào ba lô.
Xét vật phẩm $x_5$, $overline(w):= overline(w) + w_5 = 5 + 5 = 10 > c =9$, không đưa $x_5$ vào ba lô.
Xét vật phẩm $x_6$, $overline(w):= overline(w) + w_6 = 5 + 9 = 14 > c =9$, không đưa $x_6$ vào ba lô.
Xét vật phẩm $x_7$, $overline(w):= overline(w)+ w_7 = 5 + 4 = 9 = c$, đưa $x_7$ vào ba lô và $z_G := z_G + p_7 = 11 + 3 = 14$.
Vậy, thuật toán tham lam đưa các đối tượng 1,2 và 7 vào ba lô và có giá trị $z_G =14$.
==== Độ phức tạp tính toán
Sau khi sắp xếp các vật phẩm theo #eqref(<eq:21>) trong thời gian $O(n log n)$, thời gian chạy của thuật toán tham lam là $O(n)$ vì mỗi đối tượng được xem xét tối đa một lần.
=== Bài toán xếp ba lô liên tục
Bài toán xếp ba lô liên tục (_continuous knapsack problem_) là một biến thể của bài toán xếp ba lô cổ điển, trong đó các vật phẩm có thể được chia nhỏ thay vì chỉ có thể chọn toàn bộ hoặc bỏ qua. Giả sử bạn có một chiếc ba lô với sức chứa nhất định và cần mang theo các vật phẩm như đường, muối, bột ngọt. Những vật phẩm này có thể được chia nhỏ thành từng phần nhỏ hơn, cho phép bạn tối ưu hóa giá trị tổng thể mà bạn mang theo mà không vượt quá sức chứa của ba lô.
==== Định ngĩa bài toán
Bài toán xếp ba lô liên tục có thể được định nghĩa một cách chính thức như sau: Chúng ta có một chiếc ba lô với sức chứa tối đa $c$. Ta có $n$ vật phẩm $(j = 1,...,n)$, mỗi vật phẩm có một giá trị $p_j$ và trọng lượng $w_j$. Thông thường, tất cả các giá trị này đều là số nguyên dương. Mục tiêu của bài toán là chọn ra một tập hợp các vật phẩm sao cho tổng giá trị của chúng là lớn nhất, nhưng tổng trọng lượng không được vượt quá sức chứa $c$.
Bài toán xếp ba lô liên tục được phát biểu như sau:
$
max quad & sum_(j=1)^n p_j x_j\
"s.t." quad & sum_(j=1)^n w_j x_j <= c\
& x_j in [0,1] quad quad quad quad j= 1,...,n
$
Trong đó $x_j in [0,1]$ nghĩa là phần trăm vật thể $i$ được lấy ra.
==== Giải thuật tham lam cho bài toán xếp ba lô liên tục
Tương tự như bài toán xếp ba lô 0-1, một cách tiếp cận tự nhiên cho bài toán xếp ba lô liên tục là đánh giá hiệu suất của mỗi vật phẩm $e_j$
$ e_j = p_j / w_j $
và cố gắng đặt các đối tượng có hiệu suất cao nhất vào ba lô và cũng giả sử rằng các đối tượng được sắp xếp theo hiệu suất của chúng theo thứ tự giảm dần, sao cho
$ p_1 / w_i >= p_2/w_2 >= ... >= p_n/w_n $
Bắt đầu với một ba lô trống và lần lượt xem xét các vật phẩm theo thứ tự giảm dần của hiệu suất.
#set table.hline(stroke: .7pt)
#table(
table.hline(),
stroke: none,
columns: (auto, 4fr),
table.hline(),
[*ĐẦU VÀO*], [ $n$ vật phẩm, mỗi vật phẩm có giá trị $p_j$ và $w_j$ tương ứng, $j= 1,...,n$, $z := 0, overline(w):= c, x_j := 0, j:= 1$. Các vật phẩm đã được xếp theo thứ tự giảm dần của hiệu suất.],
table.hline(),
[*Bước 1*], [],
[Nếu $w_j <= overline(w)$], [thì $ x_j:= 1, z:= z + p_j.x_j, overline(w):= overline(w) - w_i$],
[Nếu $w_j > overline(w)$], [thì $ x_j:= overline(w)/w_j, z:= z + p_j.x_j, overline(w):= overline(w) - w_i, overline(w):= 0$],
[*Bước 2*], [$j:= j+ 1$, trở về Bước 1],
table.hline(),
[*ĐẦU RA*], [$z$ và $x_j$],
table.hline(),
)
Để hiểu rõ về cách hoạt động của thuật toán tham lam trên, ta xem xét ví dụ sau: Giả sử ta là một nhà buôn muốn vận chuyển hàng hóa bằng một chiếc xe tải với sức chứa tối đa $c=50$ kg và ta có một số loại hàng hóa như sau (mỗi loại hàng hóa bên dưới đều có thể chia nhỏ được):
#align(center)[#table(
columns: 5,
[$j$], [1], [2], [3], [4],
[$p_j$], [120], [200], [300], [240],
[$w_j$], [10], [20], [30], [40]
)]
Nhận thấy rằng, 4 loại hàng hóa trên đã được sắp xếp theo hiệu suất giảm dần, tức là
$ p_1/ w_1 >= p_2/w_2 >= p_3/ w_3 >= p_4/ w_4 $
Tiếp theo, ta sẽ bắt đầu xếp hàng hóa vào xe tải bằng thuật toán tham lam như sau:
$overline(w):= c = 50, z:= 0, x_j := 0, j = 1,...,4$
Xem xét $w_1$:
$w_1 = 10 <= overline(w)= 50$ nên $x_1 := 1, z:= z+ p_1.x_1 = 0 + 120.1 = 120, overline(w):= overline(w)- w_1 = 50 - 10 = 40.$
Xem xét $w_2$:
$w_2 = 20<= overline(w) = 40$ nên $x_2 := 1, z:= z+ p_2.x_2 = 120 + 200.1 = 320, overline(w):= overline(w)- w_2 = 40 - 20 = 20.$
Xem xét $w_3$:
$w_3 = 30 > overline(w) = 20$ nên $x_3: overline(w)/ w_3 = 20/30 = 2/3, z:= z + p_3.x_3 = 320 + 300. 2/3= 520, overline(w):= 0.$
Vậy giá trị tối đa mà xe tải có thể chở là $520$ với hàng hóa thứ 1 và thứ 2 được lấy toàn bộ, hàng hóa thứ 3 được lấy một lượng 2/3 đang có.
*Nhận xét:*
Để giải quyết bài toán này, ta có thể sử dụng thuật toán tham lam với bước sắp xếp các vật phẩm theo hiệu suất có độ phức tạp $O(n log n)$. Sau khi sắp xếp, mỗi vật phẩm sẽ được duyệt qua $n$ lần, do đó độ phức tạp tính toán tổng thể là $O(n log n)$.
Ngoài ra, trong bài toán ba lô liên tục, @balas1980algorithm đã chứng minh rằng bài toán này có thể được giải trong thời gian đa thức, mở ra hướng tiếp cận tối ưu và hiệu quả hơn cho việc xử lý các bài toán tối ưu liên quan đến ba lô trong các tình huống thực tế.
|
|
https://github.com/ntjess/showman | https://raw.githubusercontent.com/ntjess/showman/main/lib.typ | typst | MIT License | #import "src/formatter.typ"
#import "src/runner.typ"
|
https://github.com/tingerrr/masters-thesis | https://raw.githubusercontent.com/tingerrr/masters-thesis/main/README.md | markdown | # Masters Thesis: Dynamic data structures under real time constraints
This repository hosts the thesis and supplementary poster for my masters thesis in applied computer science at the [University of Applied Sciences Erfurt (FHE)][FHE]. The title of this thesis is **Dynamische Datenstrukturen unter Echtzeitbedingungen** (**Dynamic data structures under real time constraints**). At the time of writing this, the thesis is only available in German with an English abstract. After finishing the thesis (sucessfully), a translated version will be provided as I find the time for it.
## Folder Structure
- `etc`: hosts notes I have taken while working on the thesis and project at large
- `out`: ignored by git, hosts the transient compilation artifacts
- `src`: hosts the source files for the thesis and supplementary poster, as well as common assets between them like bibliographies
- `de`: contains the german source files of the thesis and poster
- `en`: does not exist at the time of writing, will contian translated version of the thesis
## Copyright and Licensing
TODO: add this before releasing the sourcing code
## Compiling
This thesis is written in [Typst], to compile it, you need the Typst compiler. You can compile it yourself with a Rust toolchain by cloning [typst/typst], or by downloading the appropriate release for your platform and operating system.
Once installed, run the following within this directory from a sh compatible shell:
```bash
export TYPST_ROOT="$(pwd)"
export TYPST_FONT_PATHS="$(pwd)/assets/fonts"
lang="de" # or "en"
type="thesis" # or "poster"
mkdir -p out
typst compile "src/${lang}/${type}.typ" "out/${type}-${lang}.pdf"
```
To compile either of the two aforementioned documents, an internet connection is required once per document to download and cache the packges. Once all the packages in use are cached the documents can be compiled offline.
Additionally, the [Justfile] contains various useful recipes, mitigating the need for manually setting the environment variables.
To use a non-sh-compatible shell, refer to it's documentation on how to export environment
variables, or consider simply using [just].
[Justfile]: ./Justfile
[Typst]: https://typst.app/
[typst/typst]: https://github.com/typst/typst
[FHE]: https://fh-erfurt.de
[just]: https://just.systems
|
|
https://github.com/SnO2WMaN/typst-tarski-undefinability-report | https://raw.githubusercontent.com/SnO2WMaN/typst-tarski-undefinability-report/main/README.md | markdown | Creative Commons Zero v1.0 Universal | # Tarskiの真理定義不可能性定理に関してのレポート
[](https://builtwithnix.org)
[](https://github.com/SnO2WMaN/typst-tarski-undefinability-report/actions/workflows/gh-pages.yml)
[](https://github.com/SnO2WMaN/typst-tarski-undefinability-report/blob/main/LICENSE)
## 概要
[最新のPDFをここから読むことが出来る．](https://sno2wman.github.io/typst-tarski-undefinability-report/main.pdf)
Gödelの不完全性定理に近い話題であるTarskiの真理定義不可能性定理についてのレポート．
新しい組版システムである[Typst](https://typst.app)の実験を兼ねて書いた．
コミットする度に新しいPDFが生成されるようにActionsが組まれている．
## ライセンス
[CC0 v1.0](https://github.com/SnO2WMaN/typst-tarski-undefinability-report/blob/main/LICENSE)
|
https://github.com/AnsgarLichter/hka-thesis-template | https://raw.githubusercontent.com/AnsgarLichter/hka-thesis-template/main/metadata.typ | typst | #let degree = "Master" //Bachelor or Master
#let program = "Computer Science"
#let titleEnglish = "Title English"
#let subtitleEnglish = "Subtitle English"
#let titleGerman = "Title German"
#let subtitleGerman = "Subtitle German"
#let author = "<NAME>"
#let matriculationNumber = "12345"
#let placeOfWork = "ABC"
#let supervisor = "Prof Dr. <NAME>"
#let advisor = "Prof Dr. <NAME>"
#let startDate = "01.03.2024"
#let submissionDate = "31.08.2024"
#let submissionDateExposé = "29.02.2024"
#let place = "Karlsruhe" |
|
https://github.com/zurgl/typst-resume | https://raw.githubusercontent.com/zurgl/typst-resume/main/templates/resume/header.typ | typst | /* Resume Header */
#import "../../metadata.typ": *
#import "../commun.typ": *
#import "@preview/fontawesome:0.1.0": *
#let headerFont = ("Roboto")
#let headerFirstNameStyle(str) = {
text(
font: headerFont,
size: 32pt,
weight: "light",
fill: regularColors.darkgray,
str,
)
}
#let headerLastNameStyle(str) = { text(font: headerFont, size: 32pt, weight: "bold", str) }
#let headerInfoStyle(str) = { text(size: 10pt, fill: accentColor, str) }
#let headerQuoteStyle(str) = { text(size: 10pt, weight: "medium", style: "italic", fill: accentColor, str) }
#let cvHeader(align: left, hasPhoto: true) = {
let makeHeaderInfo() = {
let personalInfoIcons = (
phone: fa-phone(),
email: fa-envelope(),
linkedin: fa-linkedin(),
homepage: fa-pager(),
github: fa-square-github(),
gitlab: fa-gitlab(),
orcid: fa-orcid(),
researchgate: fa-researchgate(),
location: fa-location-dot(),
extraInfo: "",
)
let n = 1
for (k, v) in personalInfo {
// A dirty trick to add linebreaks with "linebreak" as key in personalInfo
if k == "linebreak" {
n = 0
linebreak()
continue
}
if k.contains("custom") {
// example value (icon: fa-graduation-cap(), text: "PhD", link: "https://www.example.com")
let icon = v.at("icon", default: "")
let text = v.at("text", default: "")
let link_value = v.at("link", default: "")
box({
icon
h(5pt)
link(link_value)[#text]
})
} else if v != "" {
box({
// Adds icons
personalInfoIcons.at(k) + h(5pt)
// Adds hyperlinks
if k == "email" {
link("mailto:" + v)[#v]
} else if k == "linkedin" {
link("https://www.linkedin.com/in/" + v)[#v]
} else if k == "github" {
link("https://github.com/" + v)[#v]
} else if k == "gitlab" {
link("https://gitlab.com/" + v)[#v]
} else if k == "homepage" {
link("https://" + v)[#v]
} else if k == "orcid" {
link("https://orcid.org/" + v)[#v]
} else if k == "researchgate" {
link("https://www.researchgate.net/profile/" + v)[#v]
} else {
v
}
})
}
// Adds hBar
if n != personalInfo.len() {
hBar()
}
n = n + 1
}
}
let makeHeaderNameSection() = table(
columns: 1fr,
inset: 0pt,
stroke: none,
row-gutter: 6mm,
[#headerFirstNameStyle(firstName) #h(5pt) #headerLastNameStyle(lastName)],
[#headerInfoStyle(makeHeaderInfo())],
[#headerQuoteStyle(languageSwitch(headerQuoteInternational))],
)
let makeHeaderPhotoSection() = {
if profilePhoto != "" {
box(image(profilePhoto, height: 3.6cm), radius: 50%, clip: true)
} else {
v(3.6cm)
}
}
let makeHeader(leftComp, rightComp, columns, align) = table(
columns: columns,
inset: 0pt,
stroke: none,
column-gutter: 15pt,
align: align + horizon,
{ leftComp },
{ rightComp },
)
if hasPhoto {
makeHeader(makeHeaderNameSection(), makeHeaderPhotoSection(), (auto, 20%), align)
} else {
makeHeader(makeHeaderNameSection(), makeHeaderPhotoSection(), (auto, 0%), align)
}
} |
|
https://github.com/Mufanc/hnuthss-template | https://raw.githubusercontent.com/Mufanc/hnuthss-template/main/components.typ | typst | // 页眉
#let header = [
#set text(size: 9pt)
#align(center, "湖南大学本科生毕业论文（设计）")
#pad(top: -6pt, line(length: 100%, stroke: 1.5pt))
#pad(top: -8.5pt, line(length: 100%, stroke: 0.6pt))
]
// 锚点，生成一个不可见的标题以供目录定位
#let anchor(content, level: 1) = [
#text(size: 0em, heading(level: 1, content))
]
// 假段落，处理 https://github.com/typst/typst/issues/311 的问题
#let fp = context[
#let base = par(box())
#(2 * base)
#let line-height = measure(2 * base).height - measure(base).height
#v(-2 * line-height)
]
// dirty fix, 抵消刚好在标题后换页时段落内容和页眉重合的问题
#let rfp = v(1em) + parbreak()
// 段落
#let paragraph(content, lp: 0.6em) = [
#show parbreak: br => br + v(lp)
#show heading: h => h + fp
#content
]
#let hstack(captions: none, ..args) = {
let cntr = counter("subfigure")
cntr.update(0)
show image: img => {
stack(dir: ttb, spacing: 0.5em, img)[
#cntr.step()
#if captions != none {
context {
text(weight: "regular")[
#cntr.display("(a)") #captions.at(cntr.get().at(0) - 1)
]
}
}
]
}
stack(dir: ltr, spacing: 2em, ..args)
}
|
|
https://github.com/Nrosa01/TFG-2023-2024-UCM | https://raw.githubusercontent.com/Nrosa01/TFG-2023-2024-UCM/main/Memoria%20Typst/capitulos/3.ProgramacionParalela.typ | typst | En esta sección se hablará sobre qué es la programación paralela, su funcionamiento y usos tanto en CPU como en GPU.
La programación paralela es una técnica de programación que consiste en dividir un problema en tareas más pequeñas y ejecutarlas simultáneamente en múltiples procesadores o núcleos de procesamiento. Esto permite aprovechar el poder de cómputo del hardware y acelerar la ejecución de programas.
Sin embargo, debido a las particularidades de cada tipo de hardware, la forma en que funciona y se aplica varía en función de si se quiere usar la CPU o la GPU.
Cabe destacar que independientemente del hardware utilizado, la paralelización de un problema no incrementa el rendimiento de manera lineal con el número de núcleos utilizados, el incremento de rendimiento tiene un límite.
La ley de Amdahl @ComputerOrganizationPatterson es un principio importante en la programación paralela que establece que el rendimiento máximo que se puede lograr al paralelizar un programa está limitado por la fracción secuencial del código. En otras palabras, aunque se pueda paralelizar una parte del código, siempre habrá una porción que debe ejecutarse de forma secuencial y que limitará el rendimiento general del programa.
La ley de Amdahl se expresa mediante la siguiente fórmula:
#set align(center)
$ "Mejora Total" = 1 / ((1 - P) + (P / N)) $
#set align(left)
Donde:
- `Mejora Total` es la mejora en el rendimiento del programa al paralelizarlo.
- `P` es la fracción del código que se puede paralelizar.
- `N` es el número de núcleos de procesamiento (hilos) disponibles.
Esta fórmula muestra que, a medida que aumenta el número de procesadores o hilos (N), el rendimiento total mejora, pero solo hasta cierto punto. La fracción secuencial del código (1 - P) siempre limitará el rendimiento máximo que se puede lograr.
== Programación paralela en GPU
La GPU (graphics processing unit) es un procesador originalmente diseñado para manejar y acelerar el procesamiento de tareas gráficas, como puede ser el mostrar imágenes o vídeos en pantalla. Para facilitar la aceleración de estas tareas, se crearon los shaders, pequeños programas gráficos destinados a ejecutarse en la GPU como parte del pipeline gráfico. El pipeline gráfico es el conjunto de operaciones secuenciales que finalmente formarán la imagen a mostrar en pantalla. La denominación pipeline hace referencia a que las operaciones que lo componen se ejecutan de manera secuencial y cada operación recibe una entrada de la fase anterior y devuelve una salida que recibirá la siguiente fase como entrada, hasta completar la imagen. @Real-Time-Rendering
El pipeline gráfico comienza con la representación de objetos mediante vértices. Cada vértice contiene información como su posición, normal, color y coordenadas de textura.
Luego, las coordenadas de los vértices se transforman en coordenadas normalizadas mediante matrices de transformación, pasando por etapas de escena, vista y proyección.
Después, se ensamblan los vértices para formar primitivas, se descartan o recortan las que están fuera del campo visual y se mapean a coordenadas de pantalla.
La rasterización determina qué píxeles formarán parte de la imagen final, utilizando un buffer de profundidad para determinar qué fragmentos se dibujan. Se interpola entre los atributos de los vértices para determinar los atributos de cada fragmento y se decide el color de cada píxel, considerando la iluminación, la textura y la transparencia.
Finalmente, los fragmentos dibujados se muestran en la pantalla del dispositivo.
Aunque la funcionalidad inicial de la GPU se limitaba al apartado gráfico, los fabricantes de este tipo de chips se dieron cuenta de que los desarrolladores buscaban formas de mapear datos no relacionados con imágenes a texturas, para así ejecutar operaciones sobre estos datos mediante shaders @LinearAlgebraGPU. Esto significaba que se podía aprovechar las características de este hardware para la resolución de tareas que no tengan que ver con imágenes, por lo que extendieron su uso más allá de la generación de gráficos.
Una de estas extensiones fue la creación de "compute shaders" @compute_shaders que son programas diseñados para ejecutarse en la GPU, pero, a diferencia de los shaders, no están directamente relacionados con el proceso de renderizado de imágenes, por lo que se ejecutan fuera del pipeline gráfico. Los "compute shaders" se emplean para realizar cálculos destinados a propósitos que se benefician de la ejecución masivamente paralela ofrecida por la GPU. Son ideales para tareas como simulaciones físicas, procesamiento de datos masivos o aprendizaje automático.
Para lograr el procesamiento de shaders de la manera más eficiente, la GPU se diseñó con una arquitectura hardware y software que permite la paralelización de cálculos en el procesamiento de vértices y píxeles independientes entre sí.
Este apartado se centra en explicar las diferencias de arquitectura entre una CPU y una GPU a nivel de hardware, así como en explicar cómo este hardware interactúa con el software destinado a la programación de GPUs.
=== Hardware
La tarea de renderizado requería de un hardware diferente al presente en la CPU debido a la gran cantidad de cálculos matemáticos que requiere. Desde transformaciones geométricas hasta el cálculo de la iluminación y la aplicación de texturas, todas estas tareas se basan en manipulaciones matemáticas haciendo uso de vectores y matrices. Para optimizar el proceso de renderizado, es esencial reducir el tiempo necesario para llevar a cabo estas operaciones @GPGP-Architecture.
Por lo tanto, surge la GPU como co-procesador con una arquitectura SIMD (single instruction multiple data) cuya función es la de facilitar a la CPU el procesado de tareas relacionadas con lo gráfico, como renderizar imágenes, vídeos, animaciones, etc @ComputerOrganizationPatterson.
Al ser el objetivo de la GPU el procesar tareas de manera paralela, se puede observar una gran diferencia en cuanto a la distribución de espacio físico (recuento de transistores) dentro del chip con respecto a la CPU, que esta diseñada para procesar las instrucciones secuencialmente @ComputerOrganizationWilliam.
#figure(
image("../images/cpugpu2.png", width: 60%),
caption: [
Comparativa arquitectura de un chip de CPU y de GPU @ComputerOrganizationWilliam
],
)
Una GPU dedica la mayor cantidad de espacio a alojar núcleos para tener la mayor capacidad de paralelización posible, mientras que la CPU dedica, la mayoria de su espacio en chip a diferentes niveles de caché y circuitos dedicados a la logica de control @ComputerOrganizationWilliam.
La CPU necesita estos niveles de caché para intentar minimizar al máximo los accesos a memoria principal, los cuales ralentizan mucho la ejecución. De igual manera, al estar diseñados los núcleos CPU para ser capaces de ejecutar cualquier tipo de instruccion, requieren lógica de control para gestionar los flujos de datos, controlar el flujo de instrucciones, entre otras funciones.
Sin embargo, la GPU al estar dedicada principalmente a operaciones matemáticas y por lo tanto tener un set de instrucciones mucho más reducido en comparación con la CPU, puede prescindir de dedicarle espacio a la logica de control. Al acceder a memoria, a pesar de que los cores tengan registros para guardar datos, la capacidad de estos es muy limitada, por lo que es común que se acceda a la VRAM (Video RAM). La GPU consigue camuflar los tiempos de latencia manejando la ejecucion de hilos sobre los datos. Cuando un hilo esta realizando acceso a datos, otro hilo está ejecutandose @ComputerOrganizationWilliam.
La gran cantidad de cores presentes en una GPU, están agrupados en estructuras de hardware llamados SM (Streaming Multiprocessors) en NVIDIA y CP (Compute Units) en AMD. NVIDIA y AMD son dos de los principales fabricantes de tarjetas gráficas, cada uno con su propia arquitectura y tecnologías específicas. Además de núcleos de procesamiento, estas agrupaciones incluyen normalmente una jerarquía básica de memoria con una cache L1, una memoria compartida entre núcleos, una caché de texturas, un programador de tareas y registros para almacenar datos. Su tarea principal es ejecutar programas SIMT (single-instruction multiple-thread) correspondientes a un kernel, asi como manejar los hilos de ejecución, liberándolos una vez que han terminado y ejecutando nuevos hilos para reemplazar los finalizados. @GPGP-Architecture
#figure(
image("../images/SM2.png", width: 60%),
caption: [
Streaming Multiprocessor @ComputerOrganizationWilliam
],
)
=== Software
Debido a que la implementacion de CUDA fue un punto de inflexión en el desarrollo de GPUs y asentó las bases de lo que hoy es la computación de propósito general en unidades de procesamiento gráfico, se explicará cómo se enlaza el software al hardware ya explicado haciendo uso de CUDA. Todos los conceptos son extrapolables a otras APIs de desarrollo como pueden ser SYCL o OpenMP.
Un programa CUDA puede ser dividido en 3 secciones @ComputerOrganizationWilliam:
- Código destino a procesarse en el Host (CPU).
- Código destinado a ser procesado en el Dispositivo (GPU).
- Código que maneja la transferencia de datos entre el Host y el dispositivo.
El código destinado a ser procesado por la GPU se conoce como kernel. Un kernel está diseñado para contener la menor cantidad de código condicional posible. Esto se debe a que la GPU está optimizada para ejecutar un mismo conjunto de instrucciones en múltiples datos de manera simultánea. Cuando hay muchas ramificaciones condicionales (como if-else), puede haber una divergencia en la ejecución de los hilos, lo que disminuye la eficiencia del paralelismo y puede resultar en un rendimiento inferior.
A cada instancia de ejecución del kernel se le conoce como hilo. El desarrollador define cual es el número de hilos sobre los que quiere ejecutar el kernel, idealmente maximizando la paralelización de los cálculos. Estos hilos pueden ser agrupados uniformemente en bloques, y a su vez estos bloques son agrupados en un grid de bloques. El número de bloques totales que se crean viene dictado por el volumen de datos a procesar. Tanto los bloques como los grids pueden tener de 1 a 3 dimensiones, y no necesariamente tienen que coincidir.
#figure(
image("../images/softwareGPU.png", width: 40%),
caption: [
Jerarquía de ejecución @gpu_arquitecture
],
)
El "scheduler global" en una GPU tiene la función principal de coordinar y programar las unidades de procesamiento disponibles para ejecutar tareas en paralelo.
A la hora de ejecutar el kernel, este scheduler crea warps, sub-bloques de un cierto número de hilos consecutivos sobre los que se llevara a cabo la ejecución, que luego serán programados para ejecutar por el scheduler de cada SM.
Es totalmente imprescindible que estos bloques de hilos puedan ser ejecutados de manera totalmente independiente y sin dependencias entre ellos, ya que a partir de aquí el programador de tareas es el que decide que y cuando se ejecuta. Los hilos dentro del bloque pueden cooperar compartiendo datos y sincronizando su ejecución para coordinar los accesos a datos mediante esperas, mediante una memoria compartida a nivel de bloque. El número de hilos dentro de un bloque esta limitado por el tamaño del SM, ya que todos los hilos dentro de un bloque necesitan residir en el mismo SM para poder compartir recursos de memoria.
== Programación paralela en CPU
La CPU (central processing unit) es el procesador principal de un ordenador y se encarga de ejecutar las instrucciones de los programas. A diferencia de la GPU, la CPU está diseñada para ejecutar instrucciones secuencialmente, es decir, una instrucción tras otra. Sin embargo, la CPU también puede ejecutar tareas en paralelo, pero de una manera diferente a la GPU.
La programación paralela en CPU se basa en la creación de hilos de ejecución, que son unidades de procesamiento independientes que pueden ejecutar tareas simultáneamente. Debido a que los hilos pueden compartir memoria, es posible tanto resolver varios problemas a la vez como dividir un problema en tareas más pequeñas y ejecutarlas en paralelo.
Este acceso compartido a memoria incurre en una serie de problemas que se deben tener en cuenta a la hora de programar en paralelo en CPU. Los problemas mostrados a continuación no siguen un orden de importancia, ya que todos ellos son igual de importantes: Condiciones de carrera, interbloqueos y problemas de inanición.
Las condiciones de carrera se dan cuando dos o más hilos intentan acceder y modificar el mismo recurso al mismo tiempo. Esto puede llevar a resultados inesperados y errores en el programa. Para evitar condiciones de carrera, se desarrollaron lo que se conoce como mecanismos de sincronización, como los semáforos o los mutex.
Un mutex es un recurso compartido entre hilos que permite controlar el acceso a una sección crítica del código. Cuando un hilo adquiere un mutex, ningún otro hilo puede acceder a la sección crítica (usualmente un recurso compartido) hasta que el primer hilo libere el mutex. Esto evita que se produzcan condiciones de carrera y garantiza que solo un hilo pueda acceder a la sección crítica en un momento dado.
Los interbloqueos y problemas de inanición son problemas resultantes del uso incorrecto de los mecanismos de sincronización. Un interbloqueo ocurre cuando dos o más hilos se bloquean mutuamente, es decir, cada hilo espera a que otro hilo libere un recurso que necesita, lo que resulta en que ninguno de los hilos pueda avanzar. La inanición, por otro lado, ocurre cuando un hilo es incapaz de avanzar debido a que otros hilos tienen prioridad sobre él, lo que resulta en que el hilo "hambriento" no pueda completar su tarea al no recibir acceso a los recursos necesarios.
Existe una alternativa para evitar estos problemas relacionados con los mecanismos de sincronización: `canales`. Los canales son estructuras de datos que permiten la comunicación entre hilos de manera segura y eficiente. Cada hilo puede enviar y recibir mensajes a través de un canal, lo que evita la necesidad de utilizar mecanismos de sincronización y reduce la posibilidad de condiciones de carrera.
El uso de canales posibilita un tipo de balance de trabajo entre hilos llamado `work stealing` @workStealing. En este modelo, los hilos ejecutan tareas, al terminar, envía un mensaje a otro hilo para que le envíe una tarea. De esta forma, los hilos que terminan antes pueden ayudar a los que todavía tienen tareas pendientes, evitando la inanición y mejorando el rendimiento del programa. |
|
https://github.com/khicken/CSDS310 | https://raw.githubusercontent.com/khicken/CSDS310/main/Assignment%201/Assignment%201.typ | typst | #import "@preview/lovelace:0.3.0": pseudocode-list
#set align(right)
<NAME> \
9/20/24
#set align(center)
= CSDS 310 Assignment 1
#set align(left)
_Note: Arrays are zero-indexed._
== Problem 1
a) *Loop Invariant*: At the start of each iteration, the greatest common divisor (GCD) of $x$ and $y$ is the same as the GCD of the original input integers $a$ and $b$. In other words, $gcd(x, y) = gcd(a, b)$
b) *Initialization:* Before the first iteration, $x = a$ and $y = b$. Since these values are the same, $gcd(x, y) = gcd(a, b)$.
- *Maintenance*: At the start of the first iteration, the statement $gcd(x, y) = gcd(a, b)$ is true. In the loop, there are two cases:
Case 1: $x > y$. In this case, $x = x - y$. Subtracting the smaller number, $y$, does not change the GCD. For proof, let $c = gcd(x - y, y)$, in which $c in bb(Z)$ and $x > y$. By definition, $c (x-y) = c y$. Distributing, $c x - c y = c y$. Solving, $c x = 2c y = c (2y)$. As both sides of the equation remain integers, $c = gcd(x, 2y) = gcd(x - y, y) = gcd(x, y)$.
Case 2: $x ≤ y$. In this case, $y = y - x$. This uses the same proof as Case 1, in which $gcd(x, y) = gcd(x, y - x)$.
As the $gcd$ remains same, the loop invariant holds.
- *Termination*: The loop terminates when $x = y$. By the loop invariant, $gcd(a, b) = gcd(x, y)$.
c) Inputs $a$ and $b$ are positive integers and $x = a$ and $y = b$, so $x$ and $y$ must be positive. In the loop, $x$ and $y$ decrease by the smaller counterpart. Given that $x$ and $y$ are positive, in both cases of subtraction, it is not possible for one number to subtract the other and be negative. The integers may not decrease below 1 either, since that case implies that the integers are equal, which is the termination condition.
d) Our loop invariant terminates when $x = y$, thus $x = x$. At this point in the algorithm, we have $gcd(x, y) = gcd(x, x)$. $x = x$, thus $x | x$, so we can conclude that $x = gcd(x, x) = gcd(x, y) = gcd(a, b)$.
== Problem 2
a) #pseudocode-list[
+ *procedure* FINDPAIR(A, B, x):
+ i ← 0
+ j ← n - 1
+ *while* i < n and j >= 0:
+ *if* A[i] + B[j] == x *then*
+ return i, j
+ *else if* A[i] + B[j] < x *then*
+ i ← i + 1
+ *else*:
+ j ← j - 1
+ *return* FALSE
]
b)
- *Loop Invariant*: At the start of each iteration, if $A[i] + B[j] = x$, then indices $i, j$ exist in the subarrays $A[i...n-1]$ and $B[0...j]$.
- *Initialization*: Initially, $i = 0$ and $j = n-1$ so the subarrays in the loop invariant are $A[0...n-1]$ and $B[0...n-1]$, which are over the entire arrays $A$ and $B$. Thus, the loop invariant holds initially.
- *Maintenance*: At the start of each iteration, if $A[i] + B[j] = x$, then indices $i, j$ exist in the subarrays $A[i...n-1]$ and $B[0...j]$, which are returned. Else, given that $A, B$ are sorted in nondecreasing order:
$
A[i + 1] >= A[i] \
A[i + 1] + B[j] >= A[i] + B[j] \
$ and $
B[j - 1] <= B[j] \
A[i] + B[j - 1] <= A[i] + B[j]
$
This means that if $A[i] + B[j] < x$, we increment $i$ by 1, maintaining the subarray A[i...n-1]. Otherwise, in the other case that $A[i] + B[j] > x$, we decrement $j$ by 1, maintaining the subarray B[0...j].
- *Termination*: The loop terminates if $A[i] + B[j] = x$ exists, since it returns the existing indices of $i, j$ in subarrays $A[i...n-1]$ and $B[0...j]$, satisfying the loop invariant. Else, when $i >= n$ or $j < 0$, meaning $x$ does not exist in either subarray $A[i...n-1]$ or $B[0...j]$, no valid pair is found and the algorithm returns FALSE.
== Problem 3
#pseudocode-list[
+ *procedure* NATURALSELECTION(m, n):
+ l ← m
+ p ← n
+ *while* l + p > 1:
+ _pick two animals_
+ *if* both Pisidians *then*
+ p $<-$ p - 2
+ l $<-$ l + 1
+ *else*:
+ l $<-$ l - 1
+ *if* p mod 2 = 1:
+ *return* PISIDIAN
+ *else*:
+ *return* LYDIAN
]
- *Loop Invariant*: At the start of each iteration, the parity of initial number of Pisidians $n$ is the same as the remaining number of is Pisidians $p$. In other words, $p mod 2 = n mod 2$.
- *Initialization*: Intially, $l = m$ and $p = n$. Substituting in the loop variant, $n mod 2 = n mod 2$. Thus, the loop invariant holds.
- *Maintenance*: At the start of each iteration, two animals are picked. There are three resulting cases:
- Lydian ($l$) and Lydian ($l$): As $l <- l-1$, $p$ is unchanged. $p mod 2 = p mod 2$, so the parity of $p$ remains unchanged.
- Pisidian ($p$) and Pisidian ($p$): Both Pisidians kill each other, so $p <- p-2$. This means:
$
(p - 2) mod 2 = p mod 2 - 2 mod 2 = p mod 2
$
Thus, the parity of $p$ remains unchanged.
- Lydian ($l$) + Pisidian ($p$): $l <- l-1$, similar to the first case. Thus, the parity of $p$ also remains unchanged.
As the parity of $p$ does not change in all cases, the loop invariant holds.
- *Termination*: The loop terminates when there is one individual left, or $l + p = 1$. By the loop invariant, as the parity of $n$ equals the parity of $p$, $p mod 2 = 1$ means that $p = 1$, thus the last standing population is the Pisidians. Otherwise, the last standing popuation is the Lydians. |
|
https://github.com/Myriad-Dreamin/tinymist | https://raw.githubusercontent.com/Myriad-Dreamin/tinymist/main/crates/tinymist-query/src/fixtures/completion-pkgs/touying-utils-fit-to-height.typ | typst | Apache License 2.0 | // path: lib.typ
// - level (auto, ): The level
#let fit-to-height(
width: none,
prescale-width: none,
grow: true,
shrink: true,
height,
body,
) = {
[
#show before-label: none
#show after-label: none
#v(1em)
hidden#before-label
#v(height)
hidden#after-label
]
}
-----
// contains: 1
#import "lib.typ": *
#fit-to-height(width: /* range 0..1 */)[];
-----
// contains: 1
#import "lib.typ": *
#fit-to-height(prescale-width: /* range 0..1 */)[];
-----
// contains: 1
#import "lib.typ": *
#fit-to-height(height: /* range 0..1 */)[];
|
https://github.com/0xPARC/0xparc-intro-book | https://raw.githubusercontent.com/0xPARC/0xparc-intro-book/main/src/sumcheck.typ | typst | #import "preamble.typ":*
= The sum-check protocol <sumcheck>
== Pitch: Sum-check lets you prove a calculation without having the verifier redo it
Let's imagine we have a _single_ equation
$ Z_1 + Z_2 + dots.c + Z_"big" = H $
for some variables $Z_i$ and constant $H in FF_q$, all over $FF_q$,
and assume further that $q$ is not too small.
Imagine a prover Peggy has a value assigned to each $Z_i$,
and is asserting to the verifier Victor they $Z_i$'s sum to $H$.
Victor wants to know that Peggy computed the sum $H$ correctly,
but Victor doesn't want to actually read all the values of $Z_i$.
Well, at face value, this is an obviously impossible task.
Even if Victor knew all but one of Peggy's $Z_i$'s, that wouldn't be good enough.
Nevertheless, the goal of Sum-Check is to show that,
with only a little bit of extra structure, this is actually possible.
=== An oracle to a polynomial
Assume for convenience that the number of $Z$'s happens to be $2^n$
and change notation to a function $f colon {0,1}^n -> FF_q$,
so our equation becomes
$ sum_(arrow(v) in {0,1}^n) f(arrow(v)) = H $.
In other words, we have changed notation so that our variables are indexed over a
hypercube: from $f(0, dots, 0)$ to $f(1, dots, 1)$.
But suppose that the values of $f$ coincide with a polynomial
$P in FF_q [X_1, ..., X_n]$
of degree at most $d$ in each variable.
#theorem("Sum-check")[
There's an interactive protocol that allows Peggy to convince Victor
that the value $H$ above is the sum, which takes
- $n$ rounds of communication, where each message from Peggy is a
single-polynomial of degree at most $d$;
- For Victor, only a single evaluation of the polynomial $P$ at some point
(not necessarily in ${0,1}^n$).
]
In other words, Sum-Check becomes possible if Victor
can make _one_ call to an oracle that can tell Victor the value of
$P(r_1,...,r_n)$, for one random choice of $(r_1, ..., r_n) in FF_q^n$.
Note importantly that the $r_i$'s do not have to $0$ or $1$;
Victor chooses them randomly from the much larger $FF_q$.
But he can only ask the oracle for that single value of $P$,
and otherwise has no idea what any of the $Z_i$'s are.
This is a vast improvement from the case where Victor had to evaluate $P$ at
$2^n$ points and add them all together.
=== Comment on polynomial interpolation
The assumption that $f$ coincides with a low-degree polynomial might seem
stringent _a priori_.
However, the truth is that _every_ function $f : {0,1}^n -> FF_q$
can be expressed as a _multilinear_ polynomial!
(In other words, we can take $d=1$ in the above theorem.)
The reason is just polynomial interpolation.
For example, suppose $n=3$ and the eight (arbitrary) variable values were given
$
f(0,0,0) &= 8 \
f(0,0,1) &= 15 \
f(0,1,0) &= 8 \
f(0,1,1) &= 15 \
f(1,0,0) &= 8 \
f(1,0,1) &= 15 \
f(1,1,0) &= 17 \
f(1,1,1) &= 29.
$
(So $H = 8+15+8+15+8+15+17+29 = 115$.)
Then we'd be trying to fill in the blanks in the equation
$ P(x,y,z) = square + square x + square y + square z
+ square x y + square y z + square z x + square x y z $
so that $P$ agrees with $f$ on the cube.
This comes down to solving a system of linear equations;
in this case it turns out that $P(x,y,z) = 5x y z + 9x y + 7z + 8$ works,
and I've cherry-picked the numbers so a lot of the coefficients work out to $0$ for
convenience, but math majors should be able to verify that $P$ exists and is unique
no matter what eight initial numbers I would have picked (by induction on $n$).
Earlier, we commented that Sum-Check was an "obviously impossible task"
if the values of $f$'s were unrelated random numbers.
The reason this doesn't contradict the above paragraph is that,
if Peggy just sends Victor the table of $2^n$ values,
it would be just as much work for Victor to manually compute $P$.
However, in a lot of contexts, the values that are being summed
can be construed as a polynomial in some way,
and then the sum-check protocol will give us an advantage.
We'll show two example applications at the end of the section.
== Description of the sum-check protocol
The author's opinion is that it's actually easier to see a specific example for
$n=3$ before specifying the pseudocode in general, rather than vice-versa.
=== A playthrough of the sum-check protocol
Let's use the example above with $n=3$:
Peggy has chosen the eight values above with $H = 115$,
and wants to convince Victor without actually sending all eight values.
Peggy has done her homework and computed the coefficients of $P$ as well
(after all, she chose the values of $f$), so Peggy can evaluate $P$ anywhere she wants.
Victor is given oracle access to a single value of the polynomial $P$
on a point (probably) outside the hypercube.
Here's how they do it.
(All the information sent by Peggy to Victor is $#rect("boxed")$.)
1. Peggy announces her claim $H = #rect($115$)$.
2. They now discuss the first coordinate:
- Victor asks Peggy to evaluate the linear one-variable polynomial
$ g_1(T) := P(T,0,0) + P(T,0,1) + P(T,1,0) + P(T,1,1) $
and send the result. In our example, it equals
$ g_1(T) = 8 + 15 + (9T+8) + (14T+15) = #rect($23T+46$). $
- Victor then checks that this $g_1$ is consistent with the claim $H=115$;
it should satisfy $H = g_1(0) + g_1(1)$ by definition.
Indeed, $g_1(0)+g_1(1) = 46+69 = 115 = H$.
- Finally, Victor commits to a random choice of $r_1 in FF_q$; let's say $r_1 = 7$.
From now on, he'll always use $7$ for the first argument to $P$.
3. With the first coordinate fixed at $r_1 = 7$, they talk about the second coordinate:
- Victor asks Peggy to evaluate the linear polynomial
$ g_2(U) := P(7,U,0) + P(7,U,1). $
and send the result. In our example, it equals
$ g_2(U) = (63U+8) + (98U+15) = #rect($161U + 23$). $
- Victor makes sure the claimed $g_2$ is consistent with $g_1$;
it should satisfy $g_1(r_1) = g_2(0)+g_2(1)$.
Indeed, it does $g_1(7) = 23 dot 7 + 46 = 23 + 184 = g_2(0) + g_2(1)$.
- Finally, Victor commits to a random choice of $r_2 in FF_q$; let's say $r_1 = 3$.
From now on, he'll always use $3$ for the second argument to $P$.
4. They now settle the last coordinate:
- Victor asks Peggy to evaluate the linear polynomial
$ g_3(V) := P(7,3,V) $
and send the result. In our example, it equals
$ g_3(V) = #rect($112V+197$). $
- Victor makes sure the claimed $g_3$ is consistent with $g_2$;
it should satisfy $g_2(r_2) = g_3(0)+g_3(1)$.
Indeed, it does $g_2(3) = 161 dot 3 + 23 = 197 + 309 = g_3(0) + g_3(1)$.
- Finally, Victor commits to a random choice of $r_3 in FF_q$; let's say $r_3 = -1$.
5. Victor has picked all three coordinates, and is ready consults the oracle.
He gets $P(7,3,-1) = 85$.
This matches $g_3(-1) = 85$, and the protocol ends.
=== General procedure
The previous transcript should generalize obviously to any $n > 3$,
but we spell it out anyways.
Peggy has already announced $H$ and pre-computed $P$.
Now for $i = 1, ..., n$,
- Victor asks Peggy to compute the univariate polynomial $g_i$
corresponding to partial sum, where the $i$th parameter is a free parameter
while all the $r_1$, ..., $r_(i-1)$ have been fixed already.
- Victor sanity-checks each of Peggy's answer by making sure $g_i$ is consistent
with (that is, $g_(i-1)(r_(i-1)) = g_i (0) + g_i (1)$,
or for the edge case $i=1$ that $H = g_1(0) + g_1(1)$).
- Then Victor commits to a random $r_i in FF_q$ and moves on to the next coordinate.
Once Victor has decided on every $r_i$, he asks the oracle for $P(r_1, ..., r_n)$
and makes sure that it matches the value of $g_n (r_n)$.
If so, Victor believes Peggy.
Up until now, we wrote the sum-check protocol as a sum over ${0,1}^n$.
However, actually there is nothing in particular special about ${0,1}^n$
and it would work equally well with $HH^n$ for any small finite set $HH$;
the only change is that the polynomial $P$
would now have degree at most $|HH|-1$ in each variable,
rather than being multilinear.
Accordingly, the $g_i$'s change from being linear to up to degree $|HH|-1$.
Everything else stays the same.
=== Soundness
#todo[Can Peggy cheat?]
== Two simple applications of sum-check
If you're trying to sum-check a bunch of truly arbitrary unrelated numbers,
and you don't have an oracle, then naturally it's a lost cause.
You can't just interpolate $P$ through your $2^n$ numbers as a "manual oracle",
because the work of interpolating the polynomial is just as expensive.
However, in real life, sum-check gives you leverage because of the ambient
context giving us a way to rope in polynomials.
We'll give two examples below.
=== Verifying a triangle count
This example was communicated to us by
#link("https://zkproof.org/2020/03/16/sum-checkprotocol/", "<NAME>").
Suppose Peggy and Victor have a finite simple graph $G = (V,E)$ on $n$ vertices
and want to count the number of triangles in it.
Peggy has done the count, and wants to convince a lazy verifier Victor
who doesn't want to spend the $O(n^3)$ time it would take to count it himself.
#proposition[
It's possible for Peggy to prove her count of the number
of triangles is correct with only $O(n^2 log n)$ work for Victor.
]
Note that Victor will always need at least $O(n^2)$ time
because he needs to read the input graph $G$, so this is pretty good.
#proof[
Assume for convenience $n = 2^m$ and biject $V$ to ${0,1}^m$.
Both parties then compute the coefficients of the multilinear function
$g : {0,1}^(2m) -> {0,1}$ defined by
$
g(x_1, ..., x_m, y_1, ..., y_m)
=
cases(
1 "if" (x_1, ..., x_m) "has an edge to" (y_1, ..., y_m),
0 "otherwise".
)
$
In general, this interpolation calculation takes
$O(2^(2m) dot 2m) = O(n^2 log n)$ time.
Once this is done, they set
$ f(arrow(x), arrow(y), arrow(z)) :=
g(arrow(x), arrow(y)) g(arrow(y), arrow(z)) g(arrow(z), arrow(x)). $
they can just run the Sum-Check protocol on:
$ "number triangles"
= sum_(arrow(x) in {0,1}^m) sum_(arrow(y) in {0,1}^m) sum_(arrow(z) in {0,1}^m)
f(arrow(x), arrow(y), arrow(z)) $
This requires some work from Peggy, but for Victor,
the steps in between don't require much work.
The final oracle call requires Victor to evaluate
$ g(arrow(x), arrow(y)) g(arrow(y), arrow(z)) g(arrow(z), arrow(x)) $
for one random choice $(arrow(x), arrow(y), arrow(z)) in (FF_p^m)^(times 3)$.
Victor can do this because he's already computed all the coefficients of $g$.
]
#remark[
Note that Victor does NOT need to compute $f$ as a polynomial,
which is much more work.
Victor does need to compute coefficients of $g$ so that it can be
evaluated at three points.
But then Victor just multiplies those three numbers together.
]
You could in principle check for counts of any
more complicated subgraph as opposed to just the triangle $K_3$.
Just modify the indicator function above.
=== Verifying a polynomial vanishes
Suppose $f(T_1, ..., T_n) in FF_q [T_1, ..., T_n]$
is a polynomial of degree up to $2$ in each variable,
specified by the coefficients.
Now Peggy wants to convince Victor that
$f(x_1, ..., x_n) = 0$ whenever $x_i in {0,1}$.
Of course, Victor could verify this himself by plugging in all $2^n$ pairs.
Because $f$ is the sum of $3^n$ terms, this takes about $6^n$ operations.
We'd like to get this down.
Here's one toy example of how we could do this.
#proposition[
Peggy can convince Victor that $f(x_1, ..., x_n) = 0$ for all $x_i in {0,1}$
with only a single evaluation to $f$ and a single evaluation to a random multilinear polynomial.
]
#proof[
The idea is to take a random linear combination of the $2^n$ values.
Specifically, Victor picks a multilinear polynomial
$g(T_1, ..., T_n) in FF_q [T_1, ..., T_n]$
coefficient by coefficient out of the $q^(2^n)$ possible multilinear polynomials.
Note that this is equivalent to picking the $2^n$ values of
$g(x_1, ..., x_n)$ for $(x_1, ..., x_n) in {0,1}^n$ uniformly at random.
Then we run sum-check to prove that
$ 0 = sum_(arrow(x) in {0,1}^n) f(x_1, ..., x_n) g(x_1, ..., x_n) $
The polynomial $f g$ is degree up to $3$ in each variable, so that's fine.
The final "oracle" call is then straightforward,
because the coefficients of both $f$ and $g$ are known.
]
This takes only $3^n + 2^n$ operations
(i.e. one evaluates two polynomials each at one point, rather than $2^n$ evaluations).
#todo[improvement with $"eq"_w$, mention context in which this comes up]
|
|
https://github.com/AsiSkarp/grotesk-cv | https://raw.githubusercontent.com/AsiSkarp/grotesk-cv/main/README.md | markdown | The Unlicense | <h1 align="center"> grotesk-cv </h1>
<div align="center">Version 1.0.1</div>
<span></span>
grotesk-cv provides a pair of elegant and simple, one-page CV and cover letter templates, inspired by the [Brilliant-cv](https://typst.app/universe/package/brilliant-cv/) and [fireside](https://typst.app/universe/package/fireside/1.0.0/) templates.
### Features
- Templates for multilingual CV and cover letter, enabled by flag
- Separation of styling and content
- Customizable fonts, colors and icons
## Preview
| CV | Cover Letter |
| :---: | :---: |
|  |  |
## Getting Started
To edit this template, changes are mostly made in either of two places. Changes to contact information or layout settings are made in `info.toml`. To change the section contents, navigate to the corresponding section file e.g. `content/profile.typ` to edit the **Profile** section.
### Adding or Removing Sections
To add a new section, create a new `.typ` file in the `content` directory with the desired section name. To include the section in the CV, add the section at the desired position in either left or right panes in the `cv.typ` file. To remove sections, simply remove or comment-out the section name in the same list of section names in the `cv.typ` file. Sections are rendered in the order they appear in the list. The section column width can be adjusted in the `info.toml` file under the `left_pane_width` value.
In the following example, the `projects.typ` section file has been created and is included in the left pane of the CV, and the `education.typ` section has been removed.
```rust
#let left-pane = (
"profile",
"experience",
//"education",
"projects",
)
```
### Changing Profile Photo
To change the profile photo, upload your image to the `content/img` folder. To enable the new image, update the `profile_image` value in `info.toml` with the name of your uploaded image.
### Changing FontAwesome Icons
The template uses [FontAwesome](https://fontawesome.com/) for all icons. To change an icon, change the desired icon string in the `info.toml` file with the corresponding FontAwesome icon name. Icon strings can be found in the [cheat sheet](https://fontawesome.com/v4/cheatsheet/). Note that the icon strings must be written without the `fa-` prefix.
To disable the use of icons, set the `include_icons` value to `false`.
### Customizing Contact Information
To change or add contact information, update the corresponding value under `[personal.info]` in the `info.toml` file. Information is rendered in the order it appears in the file.
To add a new contact information field, add a new variable under `[personal.info]` with the desired string value. Next, assign a valid FontAwesome icon string to a variable of the same name under `[personal.icon]`.
In the following example, a homepage field has been added to the contact information.
```toml
[personal.info]
homepage = "www.myawesomehomepage.com"
[personal.icon]
homepage = "globe"
```
### Changing language
The template provides the option to instantly change the language of the CV and cover letter by using a variable in the `info.toml` file. The template demonstrates the use of the `language` variable to switch between English and Spanish, but any language can be used, provided that the information is entered manually inside the corresponding section files. For instance, to change the alternate language to German, changes would have to be made in the section files to include the German text.
In the following example, the language of the **Profile** section has been changed from Spanish to German, and the required changes have been made in the `content/profile.typ` file.
```
// = Summary
= #if include-icon [#fa-icon(icon) #h(5pt)] #if language == "en" [Summary] else if language == "ger" [Zusammenfassung]
#v(5pt)
#if language == "en" [
Experienced Software Engineer specializing in artificial intelligence, machine learning, and robotics. Proficient in C++, Python, and Java, with a knack for developing sentient AI systems capable of complex decision-making. Passionate about ethical AI development and eager to contribute to groundbreaking projects in dynamic environments.
] else if language == "ger" [
Erfahrener Software-Ingenieur, der sich auf künstliche Intelligenz, maschinelles Lernen und Robotik spezialisiert hat. Er beherrscht C++, Python und Java und hat ein Händchen für die Entwicklung empfindungsfähiger KI-Systeme, die in der Lage sind, komplexe Entscheidungen zu treffen. Leidenschaft für ethische KI-Entwicklung und bestrebt, zu bahnbrechenden Projekten in dynamischen Umgebungen beizutragen.
]
```
### Changing Fonts
If using the template online with Typst Universe, multiple font types are available to use, a list of which can be found by pressing the `Ag` button. To use a different font, upload a `ttf` or `otf` file to the `content/fonts` folder and update the `font` value in the `info.toml` file with the name of the uploaded font.
### Installation
To use the template offline, clone this repository to your local machine. Typst can be used and rendered offline by installing the Typst CLI. My preferred workflow has been to use VSCode with the [Tinymist](https://github.com/Myriad-Dreamin/tinymist/releases) extension, which provides LSP support, syntax highlighting, and error checking, live rendered previews and automatic exports to PDF.
Please feel free to fork this repository and create PRs for any changes or improvements.
|
https://github.com/rabotaem-incorporated/algebra-conspect-1course | https://raw.githubusercontent.com/rabotaem-incorporated/algebra-conspect-1course/master/sections/05-group-theory/07-free-groups.typ | typst | Other | #import "../../utils/core.typ": *
== Свободные группы
#ticket[Свободная группа: определение и проверка единственности]
#def[
Пусть $F$ --- группа, $f_1, f_2, ..., f_k in F$. Говорят, что $F$ --- _свободная группа_ со свободным образом $f_1, ..., f_k$, если для всякой группы $G$ и $g_1, ..., g_k in G$
$
exists! space phi: F --> G space #[--- гомоморфизм]\
phi(f_i) = g_i, i = 1, ..., k
$
]
#pr[
Пусть $F$ --- свободная группа со свободным образом $f_1, ..., f_k$, аналогично $F'$ --- свободная группа со свободным образом $f_1', ..., f_k'$.
Тогда существует изоморфизм $epsilon$ такой, что
$
epsilon(f_i) = f_i', i = 1, ..., k
$
]
#proof[
Существует гомоморфизм $epsilon : F --> F', space epsilon(f_i) = f'_i$ и гомоморфизм $epsilon': F' --> F : epsilon'(f_i') = f_i$
$
epsilon' compose epsilon: F &--> F quad (epsilon' compose epsilon)(f_i) = f_i\
id: F &--> F quad id_F (f_i) = f_i \
==> epsilon' compose epsilon = id_F
$
Аналогично $epsilon compose epsilon' = id_F$. Таким образом $epsilon$ биекция, поэтому изоморфизм.
]
#ticket[Построение свободной группы]
#def[
+ $A = {a_1, ..., a_k, a_1 ', ..., a_k '}$ --- _алфавит_
+ $W = {l_1...l_d bar d >= 0; l_1, ..., l_d in A}$ --- _слово_
+ _Вставкой_ назовем следующую операцию:
$
L R --> L a_i a_i ' R&\
L R --> L a_i ' a_i R&, space (L, R in W)
$
Обратную операцию назовем _сокращением_.
+ Будем говорить, что $omega sim omega'$, если $omega$ можно получить из $omega'$ конечным числом вставок и сокращений.
]
#notice[
$sim$ --- отношение эквивалентности на $W$. Тогда $F = W fg sim$.\
Назовем пустое слово $Lambda$. Таким образом $Lambda = [] = [x_i x_i '] = ...$
]
#notice[
Умножение введем следующим образом:
$
F times F &--> F \
([w], [w ']) &maps [w w ']
$
То есть умножение --- конкатенация двух слов. Нетрудно увидеть, что оно определено корректно.
]
#pr[
$(F, dot)$ --- группа
]
#proof[
+ Ассоциативность
$
(w_1 w_2) w_3 = w_1(w_2 w_3) = w_1 w_2 w_3
$
+ $Lambda$ --- нейтральный элемент
+ Обратный элемент:
$
cases(
[x_j] dot [x_j '] = [x_j x_j '] = Lambda,
[x_j '] dot [x_j] = [x_j ' x_j] = Lambda
) ==> [x_j], [x_j '] space #[--- обратимые] \
[a_1 ... a_n]^(-1) = ([a_1] dot ... dot [a_n])^(-1) = [a_n]^(-1) dot ... dot [a_1]^(-1)
$
]
#notice[
В каждом классе есть ровно одно несократимое слово.
]
#denote[
$f_j = [x_j]$, $j = 1, ..., k$.
]
#pr[
$F$ --- свободная группа с $k$ образующими: $f_1, ..., f_k$.
]
#proof[
$G$ --- группа; $g_1, ..., g_k in G$. Необходимо проверить существование. Построим отображение
$
phi: F &--> G: \
[x_j] &maps g_j \
[x_j '] &maps g_j^(-1) \
[a_1 ... a_n] &maps phi([a_1]) ... phi([a_n])
$
Проверка корректности:
- Пусть мы сделали вставку $L R ~~> L x_j x_j ' R$ или $L x_j ' x_j R$
$
phi([L x_j x_j ' R]) = phi([L]) phi([x_j]) phi([x_j ']) phi([R]) = phi([L]) phi([R]) = phi([L R])
$
Рассмотрим вспомогательный гомоморфизм $Phi$ из группы слов $W$ в $G$
$
Phi: W &--> G\
x_j &maps g_j\
x_j ' &maps g_j^(-1)\
a_1 ... a_n &maps Phi(a_1) ... Phi(a_n)
$
Нетрудно видеть, что равные с точностью до вставки слова переходят в равные элементы $G$.
$
Phi(x_j) Phi(x_j ') = g_j g_j ' = e\
w sim w ' ==> Phi(w) = Phi(w ')
$
Тогда можно показать, что $Phi$ --- это композиция двух гомоморфизмов: факторизации по вставке и некоторого $phi'$, который переводит свободные образующие $f_i$ в $g_i$.
#import "../../packages/commute.typ": *
#align(center)[#commutative-diagram(
node((0, 0), $W$),
node((0, 1), $F$),
node((1, 1), $G$),
arr((0, 0), (0, 1), $\/~$),
arr((0, 0), (1, 1), $Phi$),
arr((0, 1), (1, 1), $phi'$,),
)]
$
exists! phi': F --> G\
forall w in W space phi'([w]) = Phi(w) \
\
phi'(f_j) = phi'([x_j]) = Phi(x_j) = g_j\
forall w_1, w_2 in W space Phi(w_1) Phi(w_2) = Phi(w_1 w_2) ==> \
==> phi'([w_1])phi'([w_2]) = phi'([w_1][w_2]) = phi'([w_1 w_2])
$
Теперь докажем, что гомоморфизм из определения свободной группы единственен. Предположим, что есть 2 гомоморфизма:
$
phi_1, phi_2: F --> G \
phi_1(f_j) = phi_2(f_j) = g_j
$
Тогда
$
forall w in W space w = x_(i_1)^(plus.minus 1) ... x_(i_n)^(plus.minus 1) ==> \
h = [w] = f_(i_1)^(plus.minus 1) ... f_(i_n)^(plus.minus 1) ==> \
Phi(w) = phi_1(h) = phi_1(f_(i_1))^(plus.minus 1) ... space phi_1(f_(i_n))^(plus.minus 1) = phi_2(f_(i_1))^(plus.minus 1) ... space phi_2(f_(i_n))^(plus.minus 1) = phi_2(h)
$
]
#notice[
Можно было для доказательства этого предложения и не рассматривать гомоморфизм $Phi$, он нужен скорее для того, чтобы лучше понимать, что происходит.
]
#ticket[Представление конечно порождённой группы в виде факторгруппы свободной
группы]
#notice[
Видим, что $gen(f_1, ..., f_k) = F$.
]
#follow[
Пусть $G = gen(g_1, ..., g_k)$, F --- свободная группа с $k$ свободными образующими. Тогда $G iso F fg H$ для некоторых $H nsubg F$.
]
#proof[
$
exists phi: F &--> G #[--- гомоморфизм]\
f_k &maps g_k
$
$g_1, ..., g_k in Im phi < G ==> Im phi supset gen(g_1, ..., g_k) = G$, то есть $Im phi = G$.
По теореме о гомоморфизме
$
G = Im phi &iso F fg H \
H &= Ker phi
$
]
// опасно, не раскомментировать
// это просто пример следствия, ну ладно, пофиг
// #examples[
// + Возьмем $ZZ times ZZ = gen((1, 0), (0, 1))$ и $D_5 = gen(R, S)$ (группа симметрий пятиугольника)
// $G = gen(x, y) = x^(alpha_1) y^(beta_1) ... x^(alpha_s) y^(beta_s)$
// ]
// тяжело.....
// анекдот:
// сидят две блондинки в поезде, разговаривают.
// Зашла речь про авиакатастрофы. Тут одна говорит:
// - что мы все про самолеты, да про самолеты. С поездами тоже аварии бывают. Вот например однажды в поезд самолет врезался
|
https://github.com/dainbow/FunctionalAnalysis2 | https://raw.githubusercontent.com/dainbow/FunctionalAnalysis2/main/themes/5.typ | typst | #import "../conf.typ": *
= Самосопряжённые операторы
== Свойства квадратичной формы $(A x, x)$ и собственных значений самосопряжённого оператора $A$.
#definition[
Пусть $E_1 = E_2 = H$ -- гильбертово пространство. Тогда, если $A in cal(L)(H)$ и $A^* = A$,
то оператор $A$ называется *самосопряжённым*:
#eq[
$forall x, y in H : space (A x, y) = (x, A y)$
]
]
#definition[
*Квадратичной формой* оператора $A$ называется функционал, определённый
следующим образом:
#eq[
$K(x) = (A x, x)$
]
]
#proposition[
Пусть $A in cal(L)(H)$ -- произвольный оператор. Если $forall x in H : K(x) = 0$,
то $A equiv 0$.
]
#proof[
Рассмотрим произвольные $x,y in H$. Тогда $x + y, x + i y in H$.
Запишем по определению квадратичную форму для этих точек:
#eq[
$K(x + y) = (A(x + y), x + y) = underbrace(K(x), 0) + underbrace(K(y), 0) + (A x, y) + (A y, x)$
$K(x + i y) = (A(x + i y), x + i y) = underbrace(K(x), 0) - underbrace(K(y), 0) - i(A x, y) + i(A y, x)$
]
Отсюда $(A x, y) = 1/2 (K(x + y) + i K(x + i y)) = 0$. Если варьировать $y$ по
всем возможным значениям, то следствие теоремы Хана-Банаха даст равенство $forall x in H : A x = 0$.
]
#theorem[
+ Оператор $A$ самосопряжён тогда и только тогда, когда $forall x in H : space K(x) in RR$.
+ Если $lambda$ -- собственное значение самосопряжённого $A$, то $lambda in RR$.
+ Если $lambda_1 != lambda_2$ -- собственные значения самосопряжённого $A$, а $e_1, e_2 in H$ -- соотстветствующие
собственные вектора, то $(e_1, e_2) = 0$.
]
#proof[
+ Проведём доказательство в обе стороны.
$=>$ Скалярное произведение эрмитово, поэтому воспользуемся свойством
перестановки аргументов:
#eq[
$K(x) = (A x, x) = (x, A x) = overline((A x, x)) => K(x) in RR$
]
$arrow.l.double$ Аналогично первому пункту, имеем
#eq[
$K(x) = (A x, x) = overline((A x, x)) = (x, A x)$
]
В то же время, $(A x, x) = (x, A^* x)$ по определению. Стало быть, квадратичная
форма для $A - A^*$ нулевая.
По доказанному утверждению, это возможно лишь в том случае, когда $A - A^* equiv 0$,
что и требовалось.
+ Пусть $A v = lambda v$. Тогда
#eq[
$K(v) = (A v, v) = lambda(v, v) in RR <=> lambda in RR$
]
+ Заметим следующее соотношение:
#eq[
$lambda_1 (e_1, e_2) = (A e_1, e_2) = (e_1, A e_2) = lambda_2 (e_1, e_2)$
]
Так как $lambda_1 != lambda_2$, то такое возможно только тогда, когда $(e_1, e_2) = 0$.
]
== Разложение гильбертова пространства $H = ["Im" A_lambda] plus.circle "Ker" A_lambda$, где $A$ -- самосопряжённый оператор.
#theorem[
Для самосопряжённого $A$ верно равенство
#eq[
$forall lambda in CC : space ["Im" A_lambda] plus.circle "Ker" A_lambda = H$
]
]
#proof[
Воспользуемся обычной теоремой о разложении для сопряжённых операторов. Тогда
#eq[
$["Im" A_lambda] plus.circle "Ker" A_lambda^* = H$
]
При этом $A_lambda^* = A^* - overline(lambda)I = A - overline(lambda)I$.
Если $lambda in RR$, то всё доказано. Иначе $lambda != RR$, но это также значит,
что $lambda in.not sigma_p (A)$, а это эквивалентно $"Ker" A_lambda = {0}$. То
же самое верно и для $overline(lambda)$, откуда тоже получаем тривиальное
доказательство.
]
== Критерий принадлежности числа спектру самосопряжённого оператора. Вещественность спектра самосопряжённого оператора.
#theorem(
"Критерий принадлежности спектру самосопряжённого оператора",
)[
+ $lambda in rho(A) <=> A_lambda$ -- ограниченный снизу, то есть $exists m > 0 : forall x in H : space norm(A_lambda x) >= m norm(x)$
+ $lambda in sigma(A) <=> exists seq(x) subset H : norm(x_n) = 1 and lim_(n -> oo)norm(A_lambda x_n) = 0$
]
#proof[
Второй пункт -- отрицание обеих частей первого. Поэтому доказывать будем только
первую эквивалентность.
$=>$ Раз $lambda in rho(A)$, то $A_lambda$ обратим, а значит биективен. По
теоереме об ограниченности снизу обратимого оператора всё доказано.
$arrow.l.double$ По той же теореме, должны доказать, что $A_lambda$ биективен.
Из ограниченности снизу следует $"Ker" A_lambda = {0}$ (иначе образом ненулевого
элемента был бы ноль, что нарушило бы ограниченность), а в силу разложения
пространство имеем следующее:
#eq[
$["Im" A_lambda] plus.circle "Ker" A_lambda = H = ["Im" A_lambda]$
]
Также по лемме о замыкании образа ограниченного снизу оператора, имеем
#eq[
$"Im" A_lambda = ["Im" A_lambda] = H$
]
]
#proposition[
Пусть $A$ -- самосопряжённый, а $lambda = mu + i nu, nu != 0$. Тогда
#eq[
$norm(A_lambda x)^2 >= norm(nu)^2 norm(x)^2$
]
]
#proof[
Заметим, что $A_lambda = A - lambda I = A - (mu + i nu)I = A_mu - i nu I$.
Так как речь идёт о квадрате нормы, то мы можем расписать её через скалярное
произведение:
#eq[
$norm(A_lambda x)^2 = (A_lambda x, A_lambda x) = norm(A_mu x)^2 - i nu (x, A_mu x) + i nu(A_mu x, x) + norm(nu)^2 norm(x)^2$
]
Так как $mu in RR$, то $A_mu$ -- самосопряжённый оператор. Стало быть, мы можем
сократить слагаемые в середине. Тогда:
#eq[
$norm(A_lambda x)^2 = norm(A_mu x)^2 + norm(nu)^2 norm(x)^2 >= norm(nu)^2 norm(x)^2$
]
По доказанной лемме, $A_lambda$ ограничен снизу. В силу критерия принадлежности
спектру, такое возможно лишь в том случае, когда $lambda in rho(A)$.
]
#corollary[
Для самосопряжённого оператора $A$ верно:
#eq[
$sigma(A) subset.eq RR$
]
]
== Теорема о спектре самосопряжённого оператора: $sigma(A) subset.eq [m_-, m_+], r(A) = norm(A)$
#theorem[
Обозначим для самосопряжённого $A$: $m_- := inf_(norm(x) = 1)(A x, x)$ и $m_+ := sup_(norm(x) = 1)(A x, x)$.
Тогда:
+ $sigma(A) subset.eq [m_-, m_+]$, причём $m_-, m_+ in sigma(A)$
+ $norm(A) = r(A) = max(abs(m_-), abs(m_+))$
]
#proof[
+ Покажем, что если $lambda > m_+$, то $lambda in rho(A)$. Будем снова
ограничивать $norm(A_lambda x)$ снизу. С одной стороны, по КБШ:
#eq[
$abs((A_lambda x, x)) <= norm(A_lambda x)norm(x) => norm(A_lambda x) >= 1 / norm(x) abs((A_lambda x, x))$
]
С другой стороны, распишем скалярное произведение:
#eq[
$abs((A_lambda x, x)) = abs((A x, x) - lambda (x, x)) = lambda norm(x)^2 - (A x, x) >= (lambda - m_+)norm(x)^2$
]
Последний переход верен, так как
#eq[
$m_+ = sup_(norm(x) = 1)(A x, x) = sup_x (A x, x) / norm(x)^2 => (A x, x) <= m_+ norm(x)^2 < lambda norm(x)^2$
]
Отсюда сразу $lambda in rho(A)$. Теперь докажем, что $m_+ in sigma(A)$. Для
этого воспользуемся критерием принадлежности спектру. В силу определения $m_+$:
#eq[
$exists seq(x) subset.eq H : norm(x_n) = 1 and lim_(n -> oo)(A x_n, x_n) = m_+$
]
Надо показать, что предел $lim_(n -> oo)norm(A_m_+ x_n) = 0$. Так как норма
векторов единична, то текущий предел можно переписать в следующем виде:
#eq[
$lim_(n -> oo)(A x_n, x_n) - m_+ = 0 = lim_(n -> oo)(A x_n, x_n) - m_+(x_n, x_n) = lim_(n -> oo)(A_m_+ x_n, x_n) = 0$
]
Также из определения $m_+$ следует, что $A_m_+$ -- отрицательно полуопределённый
оператор.
Так как неравенство КБШ справедливо для скалярных произведений, порождённый
положительными полуопределёнными операторами, то перейдём к $B = -A_m_+$. Чтобы
получить требуемое, нам достаточно показать, что $lim_(n -> oo) B x_n = 0$.
Запишем четвёртую! степень нормы следующим образом:
#eq[
$norm(B x_n)^4 = abs((x_n, B x_n)_B^2) <= abs((x_n, x_n)_B)abs((B x_n, B x_n)_B) = abs((B x_n, x_n))abs((B^2 x_n, B x_n))$
]
Первый множитель стремится к нулю, а второй ограничен:
#eq[
$abs((B^2 x_n, B x_n)) <= norm(B^2 x_n) norm(B x_n) <= norm(B)^3 norm(x_n)^2 = norm(B)^3$
]
Требуемый предел установлен. Доказательство для $m_-$ аналогично.
+ Из формулы спектрального радиуса
#eq[
$r(A) = lim_(n -> oo) root(n, norm(A^n))$
]
Докажем, что для $n = 2^k$ верно равенство $norm(A^n) = norm(A)^n$.
Достаточно доказать, что $norm(A^2) = norm(A)^2$.
$<=$ Воспользуемся неравенством для ограниченнх операторов:
#eq[
$norm(A^2 x) = norm(A(A x)) <= norm(A) norm(A x) <= norm(A)^2 norm(x) => norm(A^2) <= norm(A)^2$
]
$>=$ Распишем квадрат нормы $norm(A x)^2$:
#eq[
$norm(A x)^2 = (A x, A x) = (x, A^2 x) <= norm(x)norm(A^2)norm(x)$
]
Осталось взять супремум от обеих частей неравенства:
#eq[
$norm(A)^2 = sup_(norm(x) = 1) norm(A x)^2 <= sup_(norm(x) = 1) norm(A^2)norm(x)^2 = norm(A^2)$
]
Так как предел в формуле спектрального радиуса существует, то достаточно найти
любой частичный предел. Будем брать предел по индексам-степеням двойки.
]
|
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/compiler/show-bare-06.typ | typst | Other | // Error: 6 expected colon
#show it
|
https://github.com/mrcinv/nummat-typst | https://raw.githubusercontent.com/mrcinv/nummat-typst/master/03_tridiag.typ | typst | #import "admonitions.typ": opomba
#import "julia.typ": jlfb, jl, pkg, code_box, repl, out
= Tridiagonalni sistemi
<tridiagonalni-sistemi>
== Naloga
<naloga>
- Ustvari podatkovni tip za tri diagonalno matriko in implementiraj operacije množenja `*` z vektorjem in reševanja sistema $A x=b$ `\`.
- Za slučajni sprehod v eni dimenziji izračunaj povprečno število korakov, ki jih potrebujemo, da se od izhodišča oddaljimo za $k$ korakov.
- Zapiši fundamentalno matriko za #link("https://en.wikipedia.org/wiki/Markov_chain")[Markovsko verigo], ki modelira slučajni sprehod za prvih $k$ korakov.
- Reši sistem s fundamentalno matriko in vektorjem enic.
== Tridiagonalne matrike
Matrika je #emph[tridiagonalna], če ima neničelne elemente le na glavni diagonali in dveh najbližjih diagonalah. Primer $5 times 5$ tridiagonalne matrike
$
mat(
1, 2, 0, 0, 0;
3, 4, 5, 0, 0;
0, 6, 7, 6, 0;
0, 0, 5, 4, 3;
0, 0, 0, 2, 1
)
$
Elementi tridiagonalne matrike, za katere se indeksa razlikujeta za več kot 1, so vsi
enaki 0:
$ |i-j| > 1 => a_(i j) = 0. $
Z implementacijo posebnega tipa za tridiagonalno matriko lahko prihranimo na prostoru, kot tudi časovni zahtevnosti algoritmov, ki delujejo na tridiagonalnih matrikah.
Preden se lotimo naloge, ustvarimo nov paket `Vaja03`, kamor bomo postavili kodo:
#code_box[
#pkg("generate Vaja03", none, env: "nummat")
#pkg("develop Vaja03/", none, env: "nummat")
]
Podatkovni tip za tridiagonalne matrike imenujemo `Tridiag` in vsebuje tri polja z elementi na posameznih diagonalah. Definicijo postavimo v `Vaja03/src/Vaja03.jl`:
#code_box[
#jlfb("Vaja03/src/Vaja03.jl", "# Tridiagonalna")
]
Zgornja definicija omogoča, da ustvarimo nove objekte tipa `Tridiag`
#code_box[
#repl("using Vaja03", none)
#repl("Tridiag([3, 6, 5, 2], [1, 4, 7, 4, 1], [2, 5, 6, 3])", none)
]
#opomba(naslov: [Preverjanje skladnosti polj v objektu])[
V zgornji definiciji `Tridiag` smo poleg deklaracije polj dodali tudi
#link("https://docs.julialang.org/en/v1/manual/constructors/#man-inner-constructor-methods")[notranji konstruktor]
v obliki funkcije `Tridiag`. Vemo, da mora biti dolžina vektorjev `sd` in `zd` za ena
manjša kot dolžina vektorja `d`. Zato je pogoj najbolje preveriti, ko ustvarimo objekt in
se nam s tem v nadaljevanju ni več treba ukvarjati. Z notranjim konstruktorjem lahko te
pogoje uveljavimo ob nastanku objekta in preprečimo, da je sploh mogoče ustvariti objekte,
ki imajo nekonsistentne podatke.
]
Želimo, da se matrike tipa `Tridiag` obnašajo podobno kot generične matrike vgrajenega tipa `Matrix`. Zato funkcijam, ki delajo z matrikami, dodamo specifične metode za podatkovni tip `Tridiag` (več informacij o
#link("https://docs.julialang.org/en/v1/manual/types/")[tipih] in
#link("https://docs.julialang.org/en/v1/manual/interfaces/")[vmesnikih]). Implementiraj metode za naslednje funkcije:
- #jl("size(T::Tridiag)"), ki vrne dimenzije matrike,
- #jl("getindex(T::Tridiag, i, j)"), ki vrne element `T[i,j]`,
- #jl("*(T::Tridiag, x::Vector)"), ki vrne produkt matrike `T` z vektorjem `x`. Za tridiagonalne matrike je časovna zahtevnost množenja matrike z vektorjem bistveno manjša kot v splošnem ($cal(O)(n)$ namesto $cal(O)(n^2)$).
Preden nadaljujemo, preverimo ali so funkcije pravilno implementirane. Napišemo avtomatske teste, ki jih lahko kadarkoli poženemo. V projektu `Vaja03` ustvarimo datoteko `Vaja03/test/runtests.jl` in vanjo zapišemo kodo, ki preveri pravilnost zgoraj definiranih funkcij.
#code_box[
#jlfb("Vaja03/test/runtests.jl", "# glava")
]
V paket `Vaja03` moramo dodati še paket `Test`.
#code_box[
#pkg("activate Vaja03", none, env: "nummat")
#pkg("add Test", none, env: "Vaja03")
#pkg("activate .", none, env: "Vaja03")
]
Teste poženemo v paketnem načinu z ukazom `test Vaja03`:
#code_box[
#pkg("test Vaja03",
"...
Testing Running tests...
Test Summary: | Pass Total Time
Velikost | 1 1 0.0s"
, env: "nummat")
]
Dopolni teste in testiraj še ostale funkcije!
== Reševanje tridiagonalnega sistema
Poiskali bomo rešitev sistema linearnih enačb $T x = b$, kjer je matrika sistema
tridiagonalna. Sistem lahko rešimo z Gaussovo eliminacijo in obratnim vstavljanjem. Ker
je v tridiagonalni matriki bistveno manj elementov, se število potrebnih operacij tako za za Gaussovo eliminacijo, kot tudi za obratno vstavljanje bistveno zmanjša. Dodatno predpostavimo, da med eliminacijo ni treba delati delnega pivotiranja. V nasprotnem primeru se tridiagonalna oblika matrike med Gaussovo eliminacijo podre in se algoritem nekoliko zakomplicira. Na primer za diagonalno dominantne matrike po stolpcih pri Gaussovi eliminaciji pivotiranje ni potrebno.
Časovna zahtevnost Gaussove eliminacije brez pivotiranja za tridiagonalni sistema $T x = b$ je tako linearna ($cal(O)(n)$) namesto kubična ($cal(O)(n^3)$) za splošen sistem. Za obratno vstavljanje pa se časovna zahtevnost z kvadratne ($cal(0)(n^2)$) zmanjša na linearno ($cal(O)(n)$).
Priredite splošna algoritma Gaussove eleminacije in obratnega vstavljanja, da bosta upoštevala lastnosti tridiagonalnih matrik. Napišite funkcijo(operator)
#code_box[ #jl("function \(T::Tridiagonal, b::Vector)")]
ki poišče rešitev sistema $T x = b$. V datoteko `Vaja03/test/runtests.jl` dodajte test, ki na primeru preveri pravilnost funkcije `\`.
== Slučajni sprehod
<slučajni-sprehod>
Metode za reševanje tridiagonalnega sistema bomo uporabili na primeru
#link("https://en.wikipedia.org/wiki/Random_walk")[slučajnega sprehoda]
v eni dimenziji. Slučajni sprehod je vrsta
#link("https://en.wikipedia.org/wiki/Stochastic_process")[stohastičnega procesa],
ki ga lahko opišemo z
#link("https://en.wikipedia.org/wiki/Markov_chain")[Markovsko verigo] z
množico stanj, ki je enako množici celih števil $ZZ$. Če se na nekem koraku slučajni sprehod nahaja v stanju $n$, se lahko v naslednjem koraku z verjetnostjo $p in [0, 1]$ premaknemo v stanje $n - 1$ ali z verjetnostjo $q = 1 - p$ v stanje $n + 1$. Prehodne verjetnosti slučajnega sprehoda so enake:
$
P(X_(i+1) = n + 1 | X_i = n) &= p\
P(X_(i+1) = n - 1 | X_i = n) &= 1-p.
$
#opomba(naslov: [Definicija Markovske verige])[
Markovska veriga je zaporedje slučajnih spremenljivk
$ X_1, X_2, X_3, dots $
z vrednostmi v množici stanj ($ZZ$ za slučajni sprehod), za katere velja Markovska lastnost
$
P(X_(i+1) = x | X_1 = x_1, X_2 = x_2 dots X_i = x_i) = P(X_(i+1) = x | X_i = x_i),
$
ki pove, da je verjetnost za prehod v naslednje stanje odvisna le od prejšnjega stanja
in ne od starejše zgodovine stanj. V Markovski verigi tako zgodovina, kako je proces prišel v neko stanje ne odloča o naslednjem stanju, ampak odloča le stanje v katerem se trenutno nahaja proces.
Verjetnosti $P(X_(i+1) = x | X_i = x_i)$ imenujemo #emph[prehodne verjetnosti] Markovske verige. V nadaljevanju bomo privzeli, da so prehodne verjetnosti enake za vse korake $k$:
$
P(X_(k+1) = x | X_k = y) = P(X_2 = x | X_1 = y).
$
]
Simulirajmo prvih 100 korakov slučajnega sprehoda
#jlfb(
"scripts/03_tridiag.jl",
"# sprehod"
)
#figure(
image("img/03a_sprehod.svg", width: 80%),
caption: [Simulacija slučajnega sprehoda]
)
#opomba(naslov: [Prehodna matrika Markovske verige])[
Za Markovsko verigo s končno množico stanj ${x_1, x_2, dots x_n}$, lahko prehodne verjetnosti zložimo v matriko. Brez škode lahko stanja ${x_1, x_2, dots x_n}$ nadomestimo z naravnimi števili ${1, 2, dots n}$. Matriko $P$, katere elementi so prehodne verjetnosti prehodov med stanji Markovske verige
$
p_(i j) = P(X_n = j| X_(n-1) = i)
$
imenujemo #link("https://sl.wikipedia.org/wiki/Stohasti%C4%8Dna_matrika")[prehodna matrika]
Markovske verige. Za prehodno matriko velja, da vsi elementi ležijo na $[0,1]$
in je vsota elementov po vrsticah enaka 1
$
sum_(j=1)^n p_(i j) = 1,
$
kar pomeni, da je vektor samih enic $bold(1)=[1, 1, dots, 1]^T$ lastni vektor matrike $P$ za lastno vrednost $1$:
$
P bold(1) = bold(1).
$
Prehodna matrika povsem opiše porazdelitev Markovske verige. Potence prehodne matrike $P^k$
na primer določajo prehodne verjetnosti po $k$ korakih:
$
P(X_k=j|X_1=i).
$
]
== Pričakovano število korakov
Stanje, iz katerega se veriga ne premakne več, imenujemo #emph[absorbirajoče stanje]. Za absorbirajoče stanje $k$ je diagonalni element prehodne matrike enak $1$, vsi ostali elementi v vrstici pa $0$:
$
p_(k k) & = P(X_(i+1)=k | X_i = k) = 1\
p_(k l) & = P(X_(i+1)=l | X_i = k) = 0.
$
Stanje, ki ni absorbirajoče imenujemo #emph[prehodno stanje]. Markovske verige, ki vsebujejo vsaj eno absorbirajoče stanje imenujemo
#link("https://en.wikipedia.org/wiki/Absorbing_Markov_chain")[absorbirajoča Markovska veriga].
Predpostavimo lahko, da je začetno stanje enako $0$. Iščemo pričakovano število korakov, ko se slučajni sprehod prvič pojavi v stanju $k$ ali $-k$. Zanemarimo stanja, ki so dlje kot $k$ oddaljena od izhodišča in stanji $k$ in $-k$ spremenimo v absorbirajoči stanji. Obravnavamo absorbirajočo verigo z $2k+1$ stanji, pri kateri sta stanji $-k$ in $k$ absorbirajoči, ostala stanja pa ne. Iščemo pričakovano število korakov, da iz začetnega stanja pridemo v eno od absorbirajočih stanj.
Za izračun iskane pričakovane vrednosti uporabimo #link("https://en.wikipedia.org/wiki/Absorbing_Markov_chain#Canonical_form")[kanonično obliko prehodne matrike].
#opomba(naslov: [Kanonična forma prehodne matrike])[
Če ima Markovska veriga absorbirajoča stanja, lahko prehodno matriko
zapišemo v bločni obliki
$
P = mat(
Q, T;
0, I),
$
kjer vrstice $[Q, T]$ ustrezajo prehodnim stanjem, med tem ko vrstice
$[0, I]$ ustrezajo absorbirajočim stanjem. Matrika $Q$ opiše prehodne verjetnosti
za sprehod med prehodnimi stanji, matrika $Q^k$ pa prehodne
verjetnosti po $k$ korakih, če se sprehajamo le po prehodnih stanjih.
Vsoto vseh potenc matrike $Q$
$
N = sum_(k=0)^infinity Q^k = (I-Q)^(-1)
$
imenujemo #emph[fundamentalna matrika] absorbirajoče markovske verige. Element
$n_(i j)$ predstavlja pričakovano število obiskov stanja $j$, če začnemo
v stanju $i$.
]
Pričakovano število korakov, da dosežemo absorbirajoče stanje iz
začetnega stanja $i$ je $i$-ta komponenta produkta fundamentalne matrike
$N$ z vektorjem samih enic:
$ bold(k) = N bold(1) = (I - Q)^(- 1) bold(1). $
Če želimo poiskati pričakovano število korakov, moramo rešiti sistem
linearnih enačb
$ (I - Q) bold(k) = bold(1). $
Če nas zanima le, kdaj bo sprehod za $k$ oddaljen od izhodišča, lahko
začnemo v $0$ in stanji $k$ in $-k$ proglasimo za absorpcijska
stanja. Prehodna matrika, ki jo dobimo je tridiagonalna z 0 na
diagonali. Matrika $I - Q$ je prav tako tridiagonalna z $1$ na
diagonali in z negativnimi verjetnostmi $-p$ na prvi pod-diagonali
in $-q = p - 1$ na prvi nad-diagonali:
$ I - Q = mat(delim: "(", 1, - q, 0, dots.h, 0; - p, 1, - q, dots.h, 0; dots.v, dots.down, dots.down, dots.down, dots.v; 0, dots.h, - p, 1, - q; 0, dots.h, 0, - p, 1) $
Matrika $I - Q$ je tridiagonalna in po stolpcih diagonalno dominantna. Zato lahko
uporabimo Gaussovo eliminacijo brez pivotiranja. Najprej napišemo funkcijo, ki zgradi
matriko $I - Q$:
#code_box[
#jlfb("scripts/03_tridiag.jl", "# matrika_sprehod")
]
Pričakovano število korakov izračunamo kot rešitev sistema $(I-Q) bold(k) = bold(1)$.
Uporabimo operator `\` za tridiagonalno matriko:
#code_box[
#jlfb("scripts/03_tridiag.jl", "# koraki")
]
Komponente vektorja $bold(k)$ predstavljajo pričakovano število korakov, ki jih
slučajni sprehod potrebuje, da prvič doseže stanji $0$ ali $2k$, če začnemo v stanju $i$.
#code_box[
#jlfb("scripts/03_tridiag.jl", "# koraki slika")
]
#figure(
image("img/03a_koraki.svg", width:60%),
caption: [Pričakovano število korakov, ko slučajni sprehod prvič doseže stanji $-10$ ali $10$, v odvisnosti od začetnega stanja $i in {-9, -8 dots -1, 0, 1 dots 8, 9}$.]
)
Za konec se prepričajmo še s
#link("https://sl.wikipedia.org/wiki/Metoda_Monte_Carlo")[simulacijo Monte Carlo], da so
rešitve, ki jih dobimo kot rešitev sistem res prave. Slučajni sprehod simuliramo z generatorjem naključnih števil in izračunamo #link("https://en.wikipedia.org/wiki/Sample_mean_and_covariance")[vzorčno povprečje] za število korakov.
#code_box[
#jlfb("scripts/03_tridiag.jl", "# simulacija")
]
Za $k = 10$ je pričakovano število korakov enako $100$. Poglejmo, kako se rezultat ujema z vzorčnim povprečjem po velikem številu sprehodov.
#code_box[
#jlfb("scripts/03_tridiag.jl", "# vzorčno povprečje")
]
#code_box[
#jlfb("scripts/03_tridiag.jl", "# poskus")
#out("out/03_tridiag_1.out")
]
== Rešitve
Funkcije definirane v `Vaja03/src/Vaja03.jl`. Metoda `size` vrne dimenzije matrike:
#code_box(
jlfb("Vaja03/src/Vaja03.jl", "# size")
)
Z metodo `getindex` lahko dostopamo do elementov matrike s sintakso `T[i,j]`:
#code_box(
jlfb("Vaja03/src/Vaja03.jl", "# getindex")
)
Z metodo `setindex!` lahko spreminjamo elemente matrike:
#code_box(
jlfb("Vaja03/src/Vaja03.jl", "# setindex")
)
Množenje tridiagonalne matrike z vektorjem:
#code_box(
jlfb("Vaja03/src/Vaja03.jl", "# množenje")
)
Reševanje tridiagonalnega sistema linearnih enačb:
#code_box(
jlfb("Vaja03/src/Vaja03.jl", "# deljenje")
)
=== Testi
V nadaljevanju so navedeni primeri testne kode v `Vaja03/test/runtests.jl`, ki preverjajo
pravilnost metod za podatkovni tip `Tridiag`.
#code_box(
jlfb("Vaja03/test/runtests.jl", "# getindex")
)
#code_box(
jlfb("Vaja03/test/runtests.jl", "# setindex")
)
#code_box(
jlfb("Vaja03/test/runtests.jl", "# množenje")
)
#code_box(
jlfb("Vaja03/test/runtests.jl", "# deljenje")
) |
|
https://github.com/gdg-cnu/thumbnail-renderer | https://raw.githubusercontent.com/gdg-cnu/thumbnail-renderer/main/README.md | markdown | MIT License | # Thumbnail Renderer
[`gdg-cnu/slide-typst`](https://github.com/gdg-cnu/slide-typst) 라이브러리를 이용해 썸네일을 생성하는 방법을 설명합니다.
1. 방법 1. [로컬 런타임을 이용해 렌더링](./using-local-runtime-with-jupyter/note.ipynb)
2. 방법 2. [Typst 앱을 이용해 렌더링](./using-typst-app/)
|
https://github.com/typst/templates | https://raw.githubusercontent.com/typst/templates/main/unequivocal-ams/README.md | markdown | MIT No Attribution | # unequivocal-ams
A single-column paper for the American Mathematical Society. The template comes
with functions for theorems and proofs. It also is a nice starting point for a
classy tech report or thesis.
## Usage
You can use this template in the Typst web app by clicking "Start from template"
on the dashboard and searching for `unequivocal-ams`.
Alternatively, you can use the CLI to kick this project off using the command
```
typst init @preview/unequivocal-ams
```
Typst will create a new directory with all the files needed to get you started.
## Configuration
This template exports the `ams-article` function with the following named arguments:
- `title`: The paper's title as content.
- `authors`: An array of author dictionaries. Each of the author dictionaries
must have a `name` key and can have the keys `department`, `organization`,
`location`, and `email`. All keys accept content.
- `abstract`: The content of a brief summary of the paper or `none`. Appears at
the top of the first column in boldface.
- `paper-size`: Defaults to `us-letter`. Specify a [paper size
string](https://typst.app/docs/reference/layout/page/#parameters-paper) to
change the page format.
- `bibliography`: The result of a call to the `bibliography` function or `none`.
Specifying this will configure numeric, Springer MathPhys-style citations.
The function also accepts a single, positional argument for the body of the
paper.
The template will initialize your package with a sample call to the `ams-article`
function in a show rule. If you, however, want to change an existing project to
use this template, you can add a show rule like this at the top of your file:
```typ
#import "@preview/unequivocal-ams:0.1.0": ams-article, theorem, proof
#show: ams-article.with(
title: [Mathematical Theorems],
authors: (
(
name: "<NAME>",
department: [Department of Mathematics],
organization: [University of South Carolina],
location: [Columbia, SC 29208],
email: "<EMAIL>",
url: "www.math.sc.edu/~howard"
),
),
abstract: lorem(100),
bibliography: bibliography("refs.bib"),
)
// Your content goes below.
```
|
https://github.com/SeniorMars/coc-typst | https://raw.githubusercontent.com/SeniorMars/coc-typst/main/README.md | markdown | MIT License | # coc-typst
Typst support for coc
## Install
`:CocInstall coc-typst`
## Keymaps
`nmap <silent> <C-l> <Plug>(coc-coc-typst-keymap)`
## Lists
`:CocList demo_list`
## License
MIT
---
> This extension is built with [create-coc-extension](https://github.com/fannheyward/create-coc-extension)
|
https://github.com/Vanille-N/kefir | https://raw.githubusercontent.com/Vanille-N/kefir/master/label/v1.typ | typst | The Unlicense | #set page(margin: (
top: 1cm,
bottom: 1cm,
x: 1cm,
))
#import "@preview/cetz:0.2.2"
#let object(orig) = {
import "draw.typ" as cz
let body = (height: 7cm, width: 3cm)
let band = (height: 6cm, width: 1.5cm, overlap: 2cm)
let inset = (depth: band.width / 3)
let cut = (width: band.width / 2, height: body.width + 1cm, top: 0.9)
let font = (title: 21pt, body: 15pt, footnote: 11pt)
// Attachment band
cz.crect(cz.dp(orig, 0, body.height / 2 + band.height / 2 - band.overlap/2), dx: band.width/2, dy: band.height/2 + band.overlap / 2)
cz.circle(cz.dp(orig, band.width/2, body.height/2 + 0.3*inset.depth), radius: inset.depth)
cz.circle(cz.dp(orig, -band.width/2, body.height/2 + 0.3*inset.depth), radius: inset.depth)
cz.line(cz.dp(orig, -cut.width/2, body.height/2 + band.height*cut.top),
cz.dp(orig, cut.width/2, body.height/2 + band.height*cut.top))
cz.line(cz.dp(orig, 0, body.height/2 + band.height*cut.top),
cz.dp(orig, 0, body.height/2 + band.height*cut.top - cut.height))
// Main body and text
cz.crect(orig, dx: body.width / 2, dy: body.height / 2, radius: body.width / 2, fill: white)
cz.content(cz.dp(orig, 0, body.height/2 - body.width/3))[#text(size: font.title)[
*Kéfir*
]]
cz.content(cz.dp(orig, 0, -body.height/2 + body.width/3))[
#align(center)[#text(size: font.footnote)[
_<NAME>_ \ _Grenoble_
]]
]
cz.content(cz.dp(orig, 0, 0))[#text(size: font.body)[#align(center)[
..../..../........ \
\
.................. \
..................
]]]
}
#cetz.canvas({
for i in range(2) {
for j in range(6) {
object((j*3cm, 14cm*i))
}
}
})
|
https://github.com/Quaternijkon/Typst_FLOW | https://raw.githubusercontent.com/Quaternijkon/Typst_FLOW/main/lib.typ | typst | yes! it works!
#let llltable(titles:(),caption:[],align:left,kind:"table",supplement:[表],..items)={
let items=items.pos()//在函数定义中，..bodies 表示接收任意数量的参数，这些参数被收集到一个特殊的 参数对象（arguments object） 中.bodies.pos() 方法从参数对象中提取所有的 位置参数，并返回一个 序列（sequence），即一个有序的参数列表。
figure(
kind:kind,
supplement:supplement,
caption: caption,
table(
stroke: none,
columns: titles.len(),
align: align,
table.hline(),
table.header(
for title in titles {
[#strong(title)]
}
),
table.hline(),
..items,
table.hline(),
),
)
}
#let Ne=("Monaspace Neon")
#let NeW=("Monaspace Neon SemiWide")
#let NeI=("Monaspace Neon Var Italic")
#let Ar=("Monaspace Argon")
#let ArW=("Monaspace Argon SemiWide")
#let ArI=("Monaspace Argon Var Italic")
#let Xe=("Monaspace Xenon")
#let XeW=("Monaspace Xenon SemiWide")
#let XeI=("Monaspace Xenon Var Italic")
#let Rn=("Monaspace Radon")
#let RnW=("Monaspace Radon SemiWide")
#let RnI=("Monaspace Radon Var Italic")
#let Kr=("Monaspace Krypton")
#let KrW=("Monaspace Krypton SemiWide")
#let KrI=("Monaspace Krypton Var Italic") |
|
https://github.com/imkochelorov/ITMO | https://raw.githubusercontent.com/imkochelorov/ITMO/main/src/calculus/s2/main.typ | typst | #import "..\..\..\template.typ": *
#set page(margin: 0.55in)
#set par(leading: 0.55em, first-line-indent: 0em, justify: false)
#set text(font: "New Computer Modern")
#set heading(numbering: "1.1.")
#show raw: set text(font: "New Computer Modern Mono")
#show par: set block(spacing: 0.55em)
#show heading: set block(above: 1.4em, below: 1em)
#show heading.where(level: 1): set align(center)
#show heading.where(level: 1): set text(1.44em)
#show outline.entry.where(
level: 1
): it => {
v(15pt, weak: true)
text(weight: "bold", size: 1.35em, it)
}
#show: project.with(
title: "Математический анализ\nII семестр",
authors: (
"_scarleteagle",
"imkochelorov",
"AberKadaber"
),
date: "зима/весна 2024",
subtitle: "Лектор: <NAME>"
)
#let def = strong("Определение:")
#let dp(first, second)=$angle.l #first, #second angle.r$
#let sum=$limits(sum)$
#let lim=$limits(lim)$
#let proof=par(strong("Доказательство:"))
#let th=strong("Теорема:")
#let lm=strong("Лемма:")
#let defnot = strong("Обозначение:")
#let int=$display(limits(integral))$
#let emptyset=$diameter$
#let qed=$space qed$
#let note=strong("Замечание:")
#let cor(..number)= {
if number.pos().len() == 0 {
strong("Следствие:")
}
else {
strong("Следствие " + str(number.pos().at(0)) + ":")
}
}
#let limsup = $overline(lim)$
#let liminf = $underline(lim)$
#let smile = emoji.face.smile.slight
#let frown = emoji.face.frown.slight
#let wink = emoji.face.wink
#let pole(a, b) = $lr(|, size: #200%)_#pad(bottom: -13pt)[$#a$]^#pad(top: -13pt)[$#b$]$
#outline(title: "Оглавление", indent: auto)
#pagebreak()
= Неопределённый интеграл
#def _первообразная_\ $F, f: dp(a, b) -> RR$\
$F$ --- _первообразная_ $f$, если $forall x in dp(a, b) quad F'(x)=f(x)$
\ \
#th $f$ --- непр на $dp(a, b) => exists$ пер-я $f$
\
#proof
Чуть позже.
\ \
#th $F$ --- пер-я $f$ на $dp(a, b) =>$
- $forall c in RR quad F+c$ --- пер-я $f$
- $G$ --- пер-я $f => exists c in RR: G-F=c$
#proof
- $(F+c)' = f$
- $(G-F)' = f - f = 0 => G-F = "const"$
\
#def _неопределённый интеграл_ \
_Неопределённый интеграл_ функции $f$ на $dp(a, b)$ --- мн-во всех первообразных $={F+c, c in RR, f "- пер-я"}$
\ \
#defnot $int f, int f(x) dif x$
\
*Примеры*:
- $int 1/(x+a^2) dif x = ln abs(x+a^2) + C$
- $int 1/x dif x = ln abs(x) + C$
- $int 1/(x^2+1) dif x = arctan x$
- $int 1/(x^2-1) dif x = 1/2 ln((x-1)/(x+1))$ #emoji.face.frown.slight
- $int 1/(sqrt(1-x^2) dif x) = arcsin x$
- $int 1/(sqrt(1+x^2)) = ln abs(x + sqrt(x^2 + 1))$
\
//#th _о свойствах неопределённого интеграла_\
== Свойства
Пусть $f, g$ имеют пер-е на $dp(a, b) =>$
- $int f+g=int f + int g$
- $forall alpha in RR quad int alpha f = alpha int f$
- Замена переменной: $phi: dp(c, d) -> dp(a, b)$ дифф $=> int f(phi(t)) phi' dif t = (int f(x) dif x bar_(x=phi(t))) = int f(phi(t)) dif phi(t)$
- Можо читать справа налево: $F(phi(t)) = h(t) => x=phi(t) => t = phi^(-1) (x)$
- $forall alpha, beta in RR, alpha != 0 quad int f(alpha x + beta) dif x = 1/alpha F(alpha x + beta)$
#proof
- Тривиально.
- Тривиально.
- $F$ --- пер-я $f => int f(phi(t)) phi'(t)=F(phi(t))$
- Частный случай предыдущего пункта.
\
Пример: $int (dif x)/(sqrt(x^2 + 16)) = 1/4 (dif x)/(sqrt(x^2/16+1))=1/4 int (dif x)/(sqrt((x/4)^2 + 1)) = 1/(1 slash 4) 1/4 ln abs(x/4 +sqrt(x^2/16 + 1))$
#th $f, g$ дифф на $dp(a, b), f'g$ имеет пер-ю на $dp(a, b)=> g'f$ имеет пер-ю на $dp(a, b)$ и $int f g' = f g - int f'g$
\ \
#proof
$(f g - int f'g)' = f'g + f g' - f'g = f g'$
\ \
*Пример:*
\
$int sqrt(1 - x^2) dif x =^(???)_(quad quad space x=sin t\ [-1, 1] <-> [-pi/2, pi/2]) int sqrt(1-sin^2 t) cos t dif t = int cos^2 t dif t = int 1/2 + (cos 2t)/2 dif t = 1/2 t + 1/4 sin 2t=$$=1/2 arcsin x + 1/4 sin(2 arcsin x)=1/2 arcsin x + 1/2 x sqrt(1-x^2)$
\
\
#quote("Если у вас что-то такое в уме - изгоните немедленно!", attribution: "КПК", block: true)
= Определённый интеграл
#def _плоская фигура_\
_Плоская фигура_ --- огр. подмн-во $RR^2$
\ \
#def _множество плоских фигур_\
$cal(E)$ = мн-во плоских фигур\ \
#def _площадь_\
_Площадь_ --- функция $sigma: cal(E) -> [0, +infinity)$:
- Аддитивность: $A_1, A_2 in cal(E) quad A= A_1 union.sq A_2 quad sigma A = sigma A_1 + sigma A_2$
- Нормировка: $sigma(dp(a, b) times dp(c, d)) = (b - a)(d-c)$ _(площадь прямоугольника)_
\
*Новости* (хорошая и странная): \ Площади существуют, площадей много.
\ \
#note
- $sigma$ монотонна: $A, B in cal(E), A subset B => sigma A <= sigma B$
- $sigma ("верт. отрезка")=0$
\
#def _ослабленная площадь_\
_Ослабленная площадь_ $sigma: cal(E)-> [0, +infinity)$:
- $sigma$ монотонна
- Нормировка
- Ослабленная аддитивность: $E in cal(E) quad E=E_1 union E_2$ (разбиение верт. отрезком) $=> sigma E=sigma E_1 + sigma E_2$
\
*Новости* (хорошие и странные):\ Ослабленные площади существуют, ослабленных площадей много
\ \
*Пример:*\ $sigma_1 E = inf {sum sigma(P_k): E subset limits(union.big)_"кон." P_k}$\ \
$sigma_2 E = inf {sum sigma(P_k): E subset limits(union.big)_"счётн." P_k}$
\ \
$sigma_1([0, 1]^2 sect (QQ times QQ))=1$\
$sigma_2([0, 1]^2 sect (QQ times QQ))=sigma_2(limits(union.big)_(k=1)^(+infinity) {P(x_k)}), P(x_k) = [x^k_1 - epsilon/sqrt(2^k), x^k_1 + epsilon/sqrt(2^k)] times [x^k_2 - epsilon/sqrt(2^k), x^k_2 + epsilon/sqrt(2^k)]$\
$=> sigma_2([0, 1]^2 sect (QQ times QQ))=0$
$sigma_1$ и $sigma_2$ различаются только в патологических случаях. Для подграфиков непрерывных ф-ций они дают одно и то же.
\ \
#def _положительная срезка_\
Положительная срезка $f$: $f^+=max(f, 0)$. Отрицательная срезка $f$: $f^-=max(-f, 0)$.
\ \
#note \
$f=f^+-f^-$\ $abs(f)=f^++f^-$
\ \
#def _подграфик функции_\ $f>=0$ на $[a, b], E subset [a, b]$. _Подграфик ф-ции $f$ на мн-ве_ $E$ $"ПГ"(f, E)=$$={(x, y) in RR^2: x in E, 0 <= y <= f(x)}$
\ \
#def _определённый интеграл_\ Определённый интеграл функции $f$ на $[a, b]$ $int_a^b f = sigma("ПГ"(f^+, [a, b])) - sigma("ПГ"(f^-, [a, b]))$
\ \
== Свойства
#note\ Далее считаем $f in C([a, b])$ \
\
#note
- $f >= 0 => int_a^b f >= 0$
- $f equiv c quad int_a^b f = c (b - a)$ #emoji.face.smile.slight
- $int_a^b (-f) = -int_a^b f$
- при $a = b quad int_a^b = 0$
\
*Свойство 1:* _аддитивность по промежутку_\ \ $forall c in [a, b] int _a^b = int_a^c f + int _c^b f$\ \
*Свойство 2.* _монотонность_\ \
$f, g in C([a, b]), f <= g => int_a^b f <= int_a^b g$
\ \
#proof
$f <= g => f^+ <= g^+, f^- >= g^+$\
\
*Следствие:* \
\
$"ПГ"(f^+, [a, b]) < "ПГ"(g^+[a, b]) => &sigma("ПГ"(f^+)) &<= sigma("ПГ"(g^+))\ &sigma("ПГ"(f^-)) &<= sigma("ПГ"(g^-))$\
\ \
*Свойство 3:* $f in C[a, b] =>$\ \
1.$space min f dot (b - a) <= int_a^b f(x) dif x <= max f (b-a) <= max f dot (b - a)$\ \
2.$space abs(int_a^b f) <= int_a^b abs(f)$\ \
3.$space exists c in [a, b]: int_a^b f(x) dif x = f(c) (b-a)$ \ \
#proof
2.\
$-abs(f(x))<=f(x) <= abs(f(x))$\ \
$-int_a^b abs(f) <= int_a^b f <= int_a^b abs(f)$\ \
3.\
Для $a = b$ утверждение тривиально\ \
Если $a != b$: $min f <= 1/(b-a) int_a^b f <= max f$, далее по теореме о промежуточном значении $1/(b-a) int_b^a f$ --- значение $f$ в некоторой точке
\ \
#def _интеграл с переменным верхним пределом_ \ $f in C([a, b]), Phi: [a, b] -> RR, Phi(x) = int_a^x f$ --- _интеграл с переменным верхним пределом_\ \
#th (_Барроу_) \ $Phi$ --- интеграл с пер. верх. пределом, дифф на $[a, b]$, $forall x quad Phi'(x)=f(x)$ \ \
#proof \
$int_a^y f - int_a^x f = (int_a^x f + int_x^y f) - int_a^x f$\ \
$y > x: lim_(y->x+0) (Phi(y)-Phi(x))/(y-x)=lim_(y->x+0) 1/(y-x) int_x^y f = lim_(y->x+0) f(c)=f(x)$\ \
$x > y$: аналогично\ \
*Пример:*\ \
$(int_(x^2)^(x^3) e^(-t^2) dif t)'_x = (int_a^x^3 - int_a^x^2)'_x = (Phi(x^3)-Phi(x^2))' = e^(-x^6) dot 3x^2 - e^(-x^4) dot 2x$\ \
$dif/(dif x)(int_(int_(x^2)^(tg x) e^t^2 dif t)^(int_(sin x)^(ln x) sqrt(s^4 + 2 s) dif s) sin n^2 dif n)$ #emoji.face.wink
\ \
#th (_формула Ньютона-Лейбница_)\ \ $f in C([a, b]), F$ --- пер-я $f => int_a^b f(x) dif x = F(b)-F(a)$\ \ \ \
#proof \
$Phi = F+C$\ \
$int_a^b f = Phi(b) - Phi(a) = (F(b)+C) - (F(a)+C)=F(b)-F(a)$
Согласование: $a > b => int_a^b f = -int_b^a f$
#quote("До Ньютона не было законов Ньютона", attribution: "КПК", block: true)
= Верхний предел последовательности
#def _частичный предел последовательности_\ $(x_n) subset RR$. Если $exists a, exists n_k: x_n_k -> a$, то $a$ --- _частичный предел последовательности_ $(x_n)$\ \
*Пример:*
- $x_n = (-1)^n$\
$n_k: 2, 4, 6, dots => x_n_k->1$\
$n_k = 1, 3, 5, dots => x_n_k -> -1$
\
#def _верхний предел / нижний предел_ \ $(x_n) subset RR, quad y_n = sup(x_n, x_(n+1), dots), quad z_n = inf(x_n, x_(n+1), dots) => z_n <= x_n <= y_n, quad y_(n+1) >= y_n,quad$$z_(n+1)<=z_n$ \ \
_Верхний предел_ $overline(lim_(n->+infinity)) x_n= limits(op("lim sup"))_(n -> +inf) x_n =lim_(n->+infinity) y_n$\ \ _Нижний предел_ $underline(lim_(n->+infinity)) x_n= limits(op("lim inf"))_(n->+inf) x_n = lim_(n->+infinity) z_n$
\ \
#th
- $underline(lim) x_n <= overline(lim) x_n$
- $forall n quad x_n <= tilde(x)_n => overline(lim) x_n <= overline(lim) tilde(x)_n, underline(lim) x_n <= underline(lim) tilde(x)_n$
- $lambda >= 0 quad overline(lim) lambda x_n = lambda overline(lim) x_n, underline(lim) lambda x_n = lambda underline(lim) x_n$ ($lambda = 0 => underline(lim) lambda x_n=overline(lim) lambda x_n=0$)
- $overline(lim) (-x_n) = -(underline(lim) x_n), underline(lim) (-x_n) = -(overline(lim) x_n)$
- $overline(lim) (x_n + tilde(x)_n) <= overline(lim) x_n + overline(lim) tilde(x)_n$\
$underline(lim) (x_n + tilde(x)_n) >= underline(lim) x_n + underline(lim) tilde(x)_n$
\ \
// следующая лекция
#pagebreak()
$(x_n)$\
$y_n = sup(x_n, x_(n+1), dots)$\
$z_n = inf(x_n, x_(n+1), dots)$\
$z_n <= x_n <= y_n$\ \
$overline(lim) x_n eq.def lim y_n in overline(RR)$\
$underline(lim) x_n = lim z_n$\
$overline(lim) (x_n + tilde(x)_n) <= overline(lim) x_n + overline(lim) tilde(x)_n$\
$sup(x_n + tilde(x)_n, x_n + tilde(x)_(n+1), dots) <= underbrace(sup(x_n, x_(n+1), dots), y_n) + underbrace(sup(tilde(x)_n, tilde(x)_(n+1), dots), tilde(y)_n)$
\
// пункт 6
- $t_n -> l in RR => limsup (x_n + t_n) = limsup x_n + l$
#proof
По опр. предела $forall epsilon > 0 quad exists N_0: forall k > N_0 quad l-epsilon < t_k < l + epsilon$\
$x_k + l - epsilon < x_k + t_k < x_k + l + epsilon$\
$~~>_(sup "по" k >= N > N_0) quad y_N + l - epsilon <= limits(sup)_(k >=N) (x_k+t_k) <= y_N + l + epsilon$\
$=> limsup x_n + l - epsilon <= limsup (x_n + t_n) <= limsup x_n + l + epsilon$\
$epsilon -> 0 => limsup (x_n + t_n) = limsup x_n + l$\
\
// пункт 7
- $t_n -> l > 0, l in RR quad limsup (x_n t_n) = limsup x_n dot l$
Без доказательства\ \ // тудааааа
#th (_Техническое описание верхнего предела_)\
$(x_n)$ --- вещ. последовательность $=>$
- $limsup x_n = +infinity <=> x_n$ не огр сверху
- $limsup x_n = -infinity <=> x_n -> -infinity$
- $limsup x_n = l in RR <=>$
- $forall epsilon > 0 quad exists N: forall n > N quad x_n < l + epsilon$
- $forall epsilon > 0 quad exists (n_i): forall i quad x_n_i > l - epsilon$ (т.е. существует бесконечно много n)
#proof
- Очевидно:\ $=>: y_n -> +infinity quad forall k quad exists y_n > k+1$ т.е. $sup(x_n,x_(n+1),dots)>k+1$ (т.е. $forall k quad exists x_i > k$) \
$arrow.l.double: x_n$ не огр сверху $=> y_n equiv +infinity$
- Очевидно: $x_n <= y_n$\
$=>: y_n -> -infinity => x_n -> -infinity$\
$arrow.l.double: forall Epsilon < 0 quad exists N: forall k > N quad x_k < Epsilon => y_(N+1) <= Epsilon$
- $=>:$
- $y_n -> l, x_n <= y_n => forall epsilon > 0 quad exists N: forall n > N quad x_n <= y_n < l-epsilon$
- $y_n$ убывает, $y_n -> l => l <= y_n quad forall n$\
$forall epsilon > 0 quad forall n quad y_n = sup(x_n, x_(n+1), dots)$\
$exists x_k, k >= n: l - epsilon < x_k$\
Берём $n=1$, находим $k=k_1$\
Берём $n>k_1$, находим $k=k_2$\
Берём $n>k_2$, находим $k=k_3$\
И т.д.
- $arrow.l.double:$\
- $space forall epsilon > 0 quad exists N: forall n > N quad x_n < l + epsilon " т.е." x_(n+1) < l + epsilon, x_(n+2) < l+epsilon, dots$
$space => space y_n <= l + epsilon space$по определeнию.\
- $forall epsilon > 0 quad forall n quad y_n >= l - epsilon$\
т.к. $y_n=sup(x_n, x_(n+1), dots), exists$ б.м. $x_i > l-epsilon$\
$=> forall n quad y_n >= l$
$=> y_n -> l$
#th\
$(x_n)$ --- вещ. последовательность $=> exists lim x_n in overline(RR) <=> limsup x_n = liminf x_n$ и если оба утв. верны, все 3 предела совпадают
#proof
- $=>: lim x_n = plus.minus infinity => $ очев.: $limsup x_n = +infinity$ ($x_n$ не огр сверху $=> limsup x_n = +infinity$)\
$liminf x_n = +infinity$ по тех. описанию, п.2\ \
Если $lim x_n = -infinity$ #emoji.face.smile.slight Аналогично\ \
Пусть $lim x_n = l in RR$, выполняется тех. описание $=> limsup x_n=l$\
Аналогично $liminf x_n = l$
- $arrow.l.double: z_n <= x_n <= y_n, z_n -> l, y_n -> l => x_n -> l$
#th (_о характеризации верхнего предела как частичного_)\
$(x_n)$ --- вещ. последовательность $=>$
- $forall l in overline(RR)$ --- частичный предел $x_n: liminf x_n <= l <= limsup x_n$
- $exists n_k: x_n_k ->_(k->infinity) limsup x_n, exists m_j: x_m_j ->_(j->+infinity) liminf x_n$
#proof
- $n_k: x_n_k -> l quad z_n_k <= x_n_k <= y_n_k$\
$z_n_k -> liminf x_n, x_n_k -> l, y_n_k -> limsup x_n => liminf x_n <= l <= limsup x_n$
- Про верхний: $limsup x_n = plus.minus infinity$ очев\
$limsup x_n = l in RR => exists n_k: l-1/k < x_n_k < l+1/k$ (из тех. описания)\
$l-1/k -> l, l+1/k -> l => x_n_k -> l$
*Пример:*\
$x_n = sin n$\
$limsup sin n = 1$\
$forall k quad sup(sin k, sin(k+1), dots)=1$\
Будем блуждать по окружности с шагом $n_i$.\
$n_0 = 1$\
В какой то момент (на 7-ом шаге) наш шаг пересечет точку 0 и разобьется на 2 дуги - большую и меньшую. Теперь будем делать шаги по 6:\
$n_1 = 6$\
И теперь на каждом шаге мы будем отодвигаться от 0 на величину меньшей из тех двух дуг, которые мы описали раньше:\
$n_1, 2n_1, 3n_1, dots$\
В какой то момент и она пересечет точку 0, повторим с ней тот же процесс:\
$n_2 = n_1 k$ или $n_1 (k+1)$ (соответственно более короткой половинке дуги, которую делит 0)\
$n_2, 2n_2, dots$\
$n_3 = n_2 l$ или $n_2 (l+1)$ (аналогично)\
и т.д.\
Длина шага: $1, <1/2, <1/4, <1/8, dots$\
$1/2^k < epsilon$\
Существует б.много $sin x_k > 1-epsilon, sin x_k <= 1 forall k => limsup sin n = 1$\
// тут должна быть 4 лекция
#pagebreak()
= Некоторые приложения определнного интеграла
#lm\
$f, g in C[a, b] quad alpha, beta in RR$\
$int_a^b alpha f + beta g = alpha int_a^b f + beta int_a^b g$\
#proof
$F, G$ --- первоообр. $f$ и $g$\
$alpha F + beta G$ --- первообр. $alpha f + beta g$\
Обе части $= alpha F + beta G pole(a, b)$
*Пример:*\
$f in C[a, b] quad I_f = 1/(b-a) int_a^b f$ --- ср. арифм. $f$ на $[a, b]$\
$f, g in C[a, b]$ монотонно возр.\
Тогда $I_f dot I_g <= I_(f g)$\
(_неравенство Чебышёва_)\
$int_a^b f dot int_a^b g <= (b - a) int_a^b f g$\
#proof
монот $=> forall x, y quad (f(x) - f(y)) (g(x) - g(y)) >= 0$\
$f(x) g(x) - f(y) g(y) - f(x) g(y) + f(y) g(y) >= 0 arrow.wave int_a^b dots dif y, 1/(b-a)$\
$f(x)g(x) - I_f g(x) - f(x) I_g + I_(f g) >= 0 arrow.wave int_a^b dots dif x, 1/(b - a)$\
$I_(f g) - I_f dot I_g - I_g dot I_f + I_(f g) >= 0$ --- удовенное неравенство которое мы хотели #emoji.face.smile.slight #emoji.face.smile.slight
\ \
#th _формула интегрирования по частям_
$f, g in C^1[a, b]$, Тогда $int_a^b f g' pole(a, b) - int_a^b f' g$
#proof
$int_a^b f g' + f' g = f g pole(a, b)$
\ \
*Пример:*\ // спасибо
// и еще, как сделать скобку [ типа системы уравнений чтобы записать по частям интегрирование // йоу спасибо огромное, думаю дальше справлюсь
// $display(cases(delim: "[", 1&\,quad "cond1", -1 dot 10^1000&\,quad "cond2"))$\
$H_n = 1/n! display(int)_(-pi/2)^(pi/2) (pi^2/4 - t^2)^n cos(t) dif t$\
$H_n = display(cases(delim: "[", f = (pi^2/4-t^2)^n&\,quad f' = -2 n t(pi^2/4-t^2)^(n-1), g'=cos(t)&\,quad g = sin(t))) display(cases(delim:"[", reverse: #true, &\ &\ &\ &\ &\ &\ )) = display((pi^2/4 - t^2)^n sin(t)/n! pole(-pi/2, pi/2) + (2n)/n! int^(pi/2)_(pi/2)) t(pi^2/4 - t^2)^(n-1) = display(cases(delim:"[", f = t(pi^2/4-t^2)^(n-1) =>f' = (pi^2/4-t^2)^(n-1) + (-2)(n-1)(t^2-pi^2/4)(pi^2/4-t^2)^(n-2)-pi^2/4(n-1)(pi^2/4-t^2)^(n-2) &\ g' = sin(t) => g = -cos(t))) display(cases(delim:"[", reverse: #true, &\ &\ &\ &\ &\ &\ )) =$
\ \
$= 2/(n-1)! (-t(pi^2/4-t^2)^(n-1) pole(-pi/2, pi/2) + int_(-pi/2)^(pi/2)(pi^2/4-t^2)^(n-1) cos(t) dif t + 2 (n-1) int_(-pi/2)^(pi/2) (pi^2/4-t^2)^(n-1) cos(t) dif t - pi^2/2(n-1) int_(-pi/2)^(pi/2)(dots)^(n-2) cos(t ) dif t) = 2H_(n-1) (4n-4)H_(n-1) -pi^2 H_(n-2) = (4n-2)H_(n-1) - pi^2 H_(n-2)$\ \
Изначально мы считаем что $n in NN$. При $n>2$ все хорошо, везде интегрировать можно, деления на ноль при сокращении не происходило. При n = 2 тоже все хорошо --- в этом можно убедиться при помощи метода присатльного взгляда.\
Остается найти $H_1$ и $H_0$: Очевидно, что $H_0 = 2$.\ \
$H_1 = 2int_(-pi/2)^(pi/2) t sin(t) dif t = display(cases(delim:"[", f = t => f' = 1 &\ g' = sin(t) => g = -cos(t)) cases(delim:"[", reverse: #true, &\ &\ &\ &\ &\ )) = 2t cos(t) pole(-pi/2, pi/2) + 2 int_(-pi/2)^(pi/2) cos(t) dif t = 0 + 4 = 4$
\
#th _Иррациональность числа $pi$_\
Число $pi$ --- иррационально.\ \
#proof
Проверим, что $pi^2$ --- иррационально.\
Для этого исползьуем то что мы только что сделали:\ $H_n = (4n-2)H_(n-1) - pi^2 H_(n-2) = (4n-2)((4n-6)H_(n-2) - pi^2 H_(n-3)) - pi^2 H_(n-2) = dots$\
Продолжая так действовать мы получим, что:
$H_n = dots H_0 + dots H_1 = F_n (pi^2)$ --- многочлен от $pi^2$ с целыми коэффициентами, степени не выше $n$\
Теперь предположим противное: пусть $pi^2$ --- рациональное, т.е. $pi^2 = l/m$\
$H_n = 1/n! display(int)_(-pi/2)^(pi/2) (pi^2/4 - t^2)^n cos(t) dif t = F(l/m) =>^(dot m^n) 0< (m^n)/n! display(int)_(-pi/2)^(pi/2) (pi^2/4 - t^2)^n cos(t) dif t = F_n (l/m)dot m^n in ZZ => (m^n)/n! display(int)_(-pi/2)^(pi/2) (pi^2/4 - t^2)^n cos(t) dif t >= 1$ --- это не верно, т.к. если помахать руками то $n!$ растет слишком бытро.\
Формальное доказательство:
$(m^n)/n! display(int)_(-pi/2)^(pi/2) (pi^2/4 - t^2)^n cos(t) dif t <= m^n / n! dot 10^n dot pi$ --- здесь мы воспользовались тем что $abs(int_a^b f) <= max(abs(f))(b-a) space$ и взяли 10 для большого запаса.\
Теперь видно, что при $n-> infinity$ выражение стремиться к 0, поэтому оно не может быть $>= 1$ для любого $n$.\ \
#th _о замене переменной в определенном интеграле_\
$f in C( dp(a, b)),quad phi: dp(alpha, beta) -> dp(a, b), space phi in C^1(dp(alpha, beta)), quad [p, q] in dp(a, b)$\
Тогда $int_p^q f(phi(t))phi'(t)dif t = int_(phi(p))^(phi(q)) f(x) dif x$\
\
#proof
$F$ --- первообразная $f$, тогда $F(phi(t))$ --- первообразная $F(phi(t))phi'(t)$
#quote("Очень сложное слово первообразная - очень тяжело его на 4-ой паре писать", attribution: "КПК", block: true)
Л.Ч. $= F(phi(t)) pole(t=p, t=q) = F(x) pole(x = phi(p), x = phi(q)) =$ П.Ч.\ \ \
*Очень странная формула:*\
Во первых нам никто не говорил, что $phi([p, q]) = [phi(p), space phi(q)]$, она может выходить за пределы этого отрезка.\
Пример: $int_0^((5pi)/6) f(sin(t))cos(t) dif t = int_0^(1/2)f(x) dif x$ --- здесь пока $t$ гуляет от 0 до $phi/2, space sin(t)$ пробегает от 0 до 1, а потом от 1 до $1/2$.\ \
Проверим что мы делали все верно:
$int_0^((5pi)/6) f(sin(t))cos(t) dif t = int_0^(pi/6) + int_(pi/6)^(pi/2) + int_(pi/2)^((5pi)/6) = int_0^(1/2) + int_(1/2)^1 + int_1^(1/2) = int_0^(1/2)f(x) dif x$\ \
Продолжение теоремы: хотим еще уметь делать преобразования в обратную сторону:\
$int_0^1 sqrt(1-x^2) dif x = [x = sin(t)] = int_(2pi)^(pi/2)sqrt(1-sin^2(t))cos(t)dif t$ \ \
#th _Формула Тейлора с остатком в интегральной форме_\
$dp(a, b) in R, quad f in C^(n+1)(dp(a, b)), quad x, x_0 in dp(a, b)$ \ \
Тогда $f(x) = limits(sum)_(k = 0)^n f^((k))(x_0)/k!(x-x_0)^k + 1/n! int_(x_0)^x (x-t)^n f^((n+1))(t) dif t$ \
#proof Индукция по $n$ и интегрирование по частям. \
База: $n = 0$ \
$f(x) = f(x_0) + int_(x_0)^x f'(t)dif t$ --- это формула Ньютона-Лейбница.\ \
Переход:\
$1/n! int_(x_0)^x (x -t)^n f^((n+1))(t)dif t = display(cases(delim: "[", f = f^((n+1))(t) => f' = f^((n+1))(t) &\ g' = (x-t)^n =>g = - (x-t)^(n+1)/(n+1)) cases(delim: "[", reverse:#true, &\ &\ &\ &\ &\ &\ )) =$ \ \
$= -1/(n+1)! f^((n+1))(x-t)^(n+1) pole(t=x_0, t=x) - int_(x_0)^x (x-t)^(n+1) f^((n+2))(t) dif t$ --- победа, получили ровно то что хотели --- в первом слагаемом после подстановке получиться следующий элемент суммы, интеграл ровно тот котоырй нужен.\ \
#quote("Чтобы обеспечить психическое здоровье на практике, неужели если рассмотреть простецкую фукнцию - целую часть x, неужели ее нельзя проинтегрировать", attribution: "КПК", block: false)
\ \
#def _Кусочно-непрерывная фукнкция_\
$f$ --- кусочно-непрерывная фунция на $[a, b] <=>$ существует конечное число точек $x_1, x_2, dots , x_n$, таких что: $f -$ непрерывна на $[a, x_1), (x_1, x_2), dots , (x_n, b]$, а точки $x_1, dots, x_n$ --- разрывы первого рода.\ \
Замечание --- такая фукнция $f$ --- ограничена.
\ \
#def _Почти первообразная_\
$F$ --- почти первообразная некоторой фукнции $f$ на $[a, b]$, если выполняется $F'(x) = f(x)$ --- при всех $x$ кроме конечного числа точек и $F$ --- непрерывна на $[a, b]$. \ \
*Пример:*\
$F(x) = abs(x), space F -$ почти первообразная $"sign"(x)$
#pagebreak()
*Напоминание:*\
$f: [a, b] -> RR$ --- кусочно непрерывная \
$x_0 = a < x_1 , x_2 < dots < x_(n - 1) < b = x_n$\
--- $forall k quad f$ --- непрерывная на $(x_(k - 1), x_k)$ \
$exists $ конечный $lim_(x->x_k- 0) f, space lim_(x->x_(k-1)+0) f$\
Тогда можно считать, что $ forall k quad f in C([x_(k-1), x_k])$, $quad int_a^b f = sum_(k=1)^n int_(x_(k-1))^(x_k) f$\
#def почти первообразная \ $F$ --- _почти первообразная_ $f(x)$, если \ $F in C[a, b]$, дифф. всюду кроме кон. числа точек, $F'(x) = f(x) space forall x$, где $F$ дифф.
\ \
#th\
$f$ --- кус. непр., $F$ --- почти первообр., $F$ --- дифференцируема всюду кроме $x_i$ из определения кусочно непрерывной \
Тогда: $int_a^b = F(b) - F(a)$\
#proof
На $(x_(k-1), x_k) space F$ --- первообразная $f$\
Но мы знаем что у $f$ есть полноценная первообразная на $[x_(k-1), x_k]$ и при этом эта первообразная с точностью до константы совпадает с $F$ на $(x_(k-1), x_k)$. #v(0.2cm)
Обозначим эту первообразную $tilde(F): tilde(F) in C([x_(k-1), x_k]) space "и"space tilde(F) = F$ на $(x_(k-1), x_(k))$#v(0.2cm)
Мы получили: непрерывную функцию $F$, а также фунцию $tilde(F)$, которая совпадает с нашей на каждом интервале. Получается что эти функции совпадают на все отрезке.#v(0.2cm)
$int_a^b f = sum_(k=1)^n space int_(x_(k-1))^(x_k) f = sum_(k=1)^n F(x_k) - F(x_(k - 1)) = F(x_n) - F(x_0) = F(b) - F(a)$\ #v(0.1cm)
#image("1.png", width: 30%)
\ \
*Пример:* неравенство Чебышева\
$I_f dot I_g <= I_(f g) quad$ ($f, g$ --- возр), $space I_f = 1/(b-a) int_a^b f$
\ \
*Утверждение (неравенство Чебышева для сумм):*\
$a_1 <= a_2 <= dots <= a_n$, $ space b_1 <= b_2 <= dots <= b_n$\ #v(0.2cm)
Тогда $(1/n sum_(k=1)^n a_k) (1/n sum_(k=1)^n b_k) <= 1/n (sum_(k=1)^n a_k b_k)$\ #v(0.2cm)
#proof
#image("2.png", width: 30%)
$f(x) = a_(ceil(x)), quad x in (0, n]$#v(0.2cm)
Тогда $int_0^n f$ --- с одной стороны площадь под графиком, но она как раз и есть одна из сумм неравенства Чебышева#v(0.2cm)
На $(k-1, k) quad F(x) = x dot a_k, space x in [k-1, space k]$ --- возникает проблема: в точках $a_i$ происходит разрыв первого рода, а мы хотим чтобы $F$ была непрерывна. Тогда добавим сдвиги на константу:\
$ F(x) = cases(delim: "[", a_1 x && x in [0, 1], a_2 x + (a_1-a_2) &quad& x in [1, 2], a_3 x + (a_1+a_2-2a_3) && x in [2, 3], dots dots) $
Когда мы рассмотрим такие фукнци для $f, g, f g$ мы получим ровно интегральное неравенство Чебышева.
= Правило Лопиталя
_by_ <NAME>
== Лемма об ускоренной сходимости
$f, g: D subset RR -> RR, space a$ --- предельная точка $D, space a in overline(RR)$#v(0.1cm)
Пусть $exists space dot(U) (a) quad f != 0, g != 0$#v(0.1cm)
$lim_(x->a) f(x) = 0, lim_(x->a) g(x) = 0$#v(0.3cm)
Тогда $forall (x_k), space display(cases(x_k -> a, space x_k in D, space x_k != a)) quad exists (y_k), space display(cases(y_k -> a, space y_k in D, space y_k != a)):quad lim f(y_k)/g(y_k) = 0, space lim g(y_k)/g(x_k) = 0$#v(0.2cm)
#proof
В качестве $y_k$ будем брать некоторые элементы $(x_n)$ так, чтобы:#v(0.2cm)
$display(cases(abs(f(y_k)/g(x_k)) < 1/k arrow.l.double abs(f(y_k)) < 1/k abs(g(x_k)), space abs(g(y_k)/g(x_k)) < 1/k arrow.l.double abs(g(x_k)) < 1/k abs(g(x_k))))$ --- здесь следование в другую сторону, т.к. например в первой строчке $x_k$ нам дано, поэтому значение $1/k abs(g(x_k))$ нам известно, а т.к. $f$ стремиться к 0 точно найдется такой номер, начиная с которого $f$ меньше чем это известное нам значение. Обозначим это $x_i$ как $y_k$. Аналогично во второй строке\
$$
== Лемма 2
Аналогичное верно для случая
$space lim_(x->a) f = +infinity, space lim_(x->a) g = +infinity$\ #v(0.25cm)
$forall (x_k), dots quad exists (y_k), dots: lim f(y_k)/g(x_k) = 0,space lim g(y_k)/g(x_k) = 0$\ \
== Правило Лопиталя
$f, g: (a, b) -> RR, space a in overline(RR),$#v(0.2cm)
$f, g$ --- дифференцируемы на $(a, b), quad g' != 0$ на $(a, b)$\ #v(0.2cm)
$lim_(x->a + 0)f/g = [0/0, space infinity/infinity]$\ #v(0.2cm)
Пусть $lim_(x->a+0) (f'(x))/(g'(x)) = A in overline(RR)$\ #v(0.2cm)
Тогда $exists lim_(x->a+0) f/g = A$ // дошик среди теорем
\ \
#proof
$g' != 0 => g' $ --- сохраняет знак (т. Дарбу) $=> g$ --- строго монотонно $=>$ в окр. точки $a space g != 0$#v(0.1cm)
По Гейне: $display(cases(x_k-> a, space x_k != a, space x_k in (a, b))), space $ строим последовательность $y_k$ из леммы\ #v(0.2cm)
Теорема Коши: $display((f(x_k) - f(y_k))/(g(x_k) - g(y_k)) = (f'(xi_k))/(g'(xi_k)))=> f(x_k) - f(y_k) = display((f'(xi_k))/(g'(xi_k)) (g(x_k) - g(y_k)))=>[
space :g(x_k)]$\ #v(0.25cm)
$=>display(f(x_k)/g(x_k) = limits(f(y_k)/g(x_k))_(arrow.b\ 0)+limits((f'(xi_k))/(g'(x_k)))_(arrow.b\ A) dot (1-limits(g(y_k)/g(x_k))_(arrow.b\ 0)))$\ \
*Пример:*\ #v(0.2cm)
$lim_(x-> +infinity) x/(sqrt(x^2 + 1)) = lim_(x->+infinity) 1/(x/(sqrt(x^2 + 1))) = lim_(x -> + infinity) sqrt(x^2 + 1)/x=$#smile\ #v(0.2cm)
$0 =lim_(x->0) (x^2 sin 1/x)/(sin x) = lim_(x->0) (2limits(x)^(0\ arrow.t) sin 1/x - cos 1/x)/limits(cos x)_(arrow.b\ 1)=$#frown\
$lim_(x->0+) ln(x)/x = lim_(x->+0) (1/x)/1 = lim_(x->+0) 1/x = +infinity$\ \
*Пример:*\ #v(0.2cm)
$int_0^(+infinity)e^(-x^2) dif x = sqrt(pi)/2$ --- интеграл Эйлера-Пуассона\ #v(0.2cm)
$+infinity$ в верхнем пределе означает, что:
$int_0^R e^(-x^2) dif x ->_(R->+infinity) sqrt(pi)/2 space <=>space sqrt(pi)/2 - int_0^R e^(-x^2) ->_(R->+infinity) 0$\ #v(0.2cm)
Теперь мы хотим заменить интеграл на эквивалентную фукнцию, то есть найти $g(R):$#v(0.2cm)
$1 = display(lim_(R->+infinity) (sqrt(pi)/2 - int_0^R e^(-x^2) dif x)/g(R) = [0/0] =^("Лопиталь")lim_(R->+infinity) (-e^(-R^2))/(g'(R))=1)$\ \
I попытка:\
$g(R)=e^(-R^2) => g' = -2R e^(-R^2) => display((-e^(-R^2))/(-2R e^(-R^2)) -> 0)$#v(0.2cm)
II попытка:\
$display(g(R) = (e^(-R^2))/(2R)=> (e^(-R^2))/(e^(-R^2) - underbracket((e^(-R^2))/limits(2R), =o(e^(-R^2)))) ->_(R->+infinity) 1)$#v(0.2cm)
Победа, мы получили: $int_0^R e^(-x^2) dif x = sqrt(pi)/2 - (e^(-R^2))/(2R) + o((e^(-R^2))/R)$
= Приложение определённого интеграла
_Общая схема_ $ space dp(a, space b)$\
$"Segm"(dp(a, space b)) = {[p, q]: [p, q] subset dp(a, b)}$ --- множество всех подотрезков $dp(a, b)$
#align(center)[#image("3.png", width: 20%)_представление $[p, q] in $ Segm$(a, b)$, если $(p, q)$ лежит в заштрихованном треугольнике_] //
\
== Аддитивная функция промежутка
$Phi: "Segm" dp(a, b) -> RR$#v(0.15cm)
$forall [p, q] in "Segm" dp(a, b) quad forall c in [p, q] quad Phi([p, q]) = Phi([p,c]) + Phi([c, q])$#v(0.15cm)
Это похоже на итнетграл, он тоже аддитивен. Поэтмоу попробуем найти некоторую фукнцию $f:$\ $[p, q] |-> int_p^q f$ // this one
== Плотность аддитивной функции промежутка
$Phi: "Segm" dp(a, b) -> RR, space f: dp(a, b) -> RR$\ #v(0.2cm)
$f$ --- плотность $Phi$, если $forall Delta in "Segm": limits(min)_Delta f dot l_Delta <= Phi(Delta) <= limits(max)_Delta f dot l_Delta$\
$l_Delta$ -- длина отрезка $Delta$.\ \
*Теорема:* (о вычислении а. ф. п. по плотности)\
$f: dp(a, b) -> RR, $ --- непрерывна, $Phi: "Segm" dp(a, b) -> RR$ --- а.ф.п,
$f$ --- плотность $Phi$#v(0.1cm)
Тогда:\
$forall [p, q] in "Segm" quad Phi([p, q]) = int_p^q f(x)d x$
#proof
Не умаляя общности рассмотрим $[a, b]$\ #v(0.2cm)
$F(x) = display(cases(delim: "[", 0\, &quad& x=a, Phi([a, x])\, &&x in (a, b]))$\ #v(0.2cm)
Проверим $F$ --- первообразная $f$:\ #v(0.25cm)
$display((F(x + h) - F(x)) / h = (Phi[a, x+h] - Phi[a, x])/h = underbracket( Phi([x, x+h])/h, in [min_Delta f, max_Delta f]) = f(x + Theta h)), space 0 <= Theta <= 1$\ #v(0.2cm)
(В последенм равенстве мы воспользовались теоремой о промежутоном значении для непрерывной фунции)#v(0.2cm)
$F'_+ = lim_(h->+0) f(x + Theta h) = f(x)$\ #v(0.2cm)
Аналогично $F'_- = f(x)$\ #v(0.2cm)
$int_p^q f = F(q) - F(p) = Phi([p, q])$
\ \
*Пример 1.1:* площадь подграфика\ #v(0.2cm)
$f: dp(a, b) -> RR$, непр., $quad Phi: "Segm" dp(a, b) -> RR:quad Phi([p, q]) = sigma("ПГ"(f, [p, q])) $\ #v(0.2cm)
Тогда $f$ --- плотность, из монотонности площади\
#image("4.png", width: 25%)
$(q - p)dot min f <= sigma("ПГ"(f, [p, q])) <= (q - p) dot max f$\ #v(0.2cm)
$Phi([p, q]) = sigma("ПГ"(f, [p, q])) = int_p^q f$\ \
*Пример 1.2:*\ #v(0.2cm)
$display(x^2/a^2 + y^2/b^2 = 1)$\
#align(center)[#image("5.png", width: 25%) _График эллипса_]
\
$sigma_"элл" = int_(-a)^a y^+ (x) dif x =display(cases(delim:"[", x=a cos t, y=b sin t)), quad t in [pi, 0] cases(delim:"[", reverse:#true, &\ &\ &\ &\ ) = -int_pi^0 b sin t dot a sin t dif t=a b int_0^pi sin^2 t dif t = a b pi/2$\ \
#align(center)[#image("6.png", width: 25%) _Геометрический способ поиска площади подграфика_] // из-за свойств симметрии синусоиды площадь подграфика равна половине площади прямоугольника
\
*Пример 2:* площадь криволинейного сектора
$dp(a, b)$\
$Phi: [p, q] |-> sigma("Сектор"([p, q], r(phi)))$ --- аддитивная функция промежутка. Чтобы ее удобно исхать найдем ее плотность:\
Проверим, что $1/2 r^2 (phi)$ --- плотность а.ф.п. $Phi$:#v(0.15cm)
$1/2 (q-p) dot limits(min)_([p, q]) r^2 (phi) <= Phi [p, q] <= 1/2 (q-p) dot limits(max)_([p, q]) r^2 (phi)$#v(0.2cm)
Криволинейный сектор $([p, q], min r) subset$ Сектор $([p, q], r(phi)) subset$ Криволинейный сектор $([p, q], max r)$#v(0.1cm)
Т.е. это была действительтно плотоность а.ф.п $Phi => $ $Phi([p, q]) = 1/2 int_p^q r^2 (phi) dif phi$\
\
*Пример 1:*
Посчитаем площадь круга\ #v(0.2cm)
$sigma "Круга" = 1/2 int_0^(2pi) R^2 d phi = pi R ^2$ #smile#v(0.2cm)
*Пример 2:* \
$S'=1/2 int_p^q r^2 (phi) d phi =display(cases(delim:"[", phi=arctan y(t)/x(t), r=sqrt(x^2+y^2)) cases(delim:"[", reverse:#true, &\ &\ &\ &\ &\ &\ )) = 1/2 int_(t_p)^(t_q) = (x^2+y^2) dot display(1/(1+(y^2(t))/(x^2(t))) dot (y'x - x'y)/(x^2) dif t)=$\
#align(right)[$= 1/2 int_(t_p)^(t_q) y'(t)x(t)-x'(t)y(t))dif t$]\ \
Подставим в получившуюся формулу уравнение окружности с радиусом $R$:#v(0.2cm)
$display(cases(x=R cos t, y=R sin t)),space t in [0, pi/2] space => space S = R^2/2 int_0^(pi/2) cos^2 t + sin^2 t dif t = (pi R^2)/4$
\ \
*Пример:* Изометрическое неравенство\
$G subset RR^2 space space G$ --- замкнутая выпуклая фигура. Диаметр $G = sup(rho(A, space B), space A, space B in G) =d<= 1$\
Тогда $sigma(G) <= pi (d/2)^2 quad$ (равенство для круга $r = 1/2$)
\ \
#proof
Введем с.к. так чтобы вся наша фигура лежала выше оси $O_x$ а также введем функцию $f(x)$ описывающую "нижнюю" часть нашей фигуры#v(0.1cm)
$f(x)$ --- вып., $forall x_0$ где $exists f'(x_0) => exists$ касательная\
$G$ замк., вып. $=> r(phi)$ непр.#v(0.2cm)
$sigma = 1/2 int_(-pi/2)^(pi/2) r^2 (phi) dif phi=1/2 int_0^(pi/2) + int_(-pi/2)^0 = 1/2 int_0^(pi/2) r^2 (phi) dif phi + 1/2 int_0^(pi/2) r^2 (phi_"нов"-pi/2) dif phi_"нов"=$\
$=1/2 int_0^(pi/2) r^2 (phi) + r^2 (phi - pi/2) dif phi=1/2 int_0^(pi/2) \"A B\"^2 dif phi<=1/2 int_0^(pi/2) d^2 dif phi = (pi d^2)/4$\ \
#def циклоида --- траектория точки на окружности, катящейся по прямой\
// см лекцию для объяснения этого треша
$S_"черн" + S_"син" = S_"прям" + S_"лепестка"$\
$S = 2 pi r^2 + pi r^2$\
$S=3 pi r^2$\ \
$ cases(x(phi) = r phi - r sin phi, y(phi) = r - r cos phi), phi in [0, 2pi] $\
$S = int_0^(2pi r) y(x) dif x = int_0^(2pi) (r-r cos phi) (r-r cos phi) dif phi=r^2 int_0^(2pi) 1-2 cos phi + cos^2 phi dif phi = 2 pi r^2 + 0+pi r^2$
// вместо изюминки вы прожевали доширак, я не знаю. чушь какая-то
#pagebreak()
/*
#columns(3)[
50 \
10\
40
#colbreak()
кр\
теор.опрос\
экзaмен
#colbreak()
30\
0\
30 из 40 = 75%\
#line()
60
]
*/
// я час назад в первый раз за сем сел за прогу
// пиздец
// у нас main должен работать за O(log n) или binary search?
// main
// а, то есть нельзя пройтись по всем элементам и перекастовать в int?
// а тут кста хз
// я бы сказал что незя
// но кажется у тех, кто так делал, принимали
// а ты как делал?
// переводил в инт только те элементы, которые бинпоиск смотрит, то есть логарифм
// кринж но окэй
// поч кринж то
// int binarySearch(String[] args)
// да
// вопросы?
// ставишь пред условием $forall i in [0, args.length): args[i] in {`parsable as integers strings`}$
// насколько плохо кастовать x в int O(log n) раз?
== Аналитические функции
$f(x) in C^infinity =>$ для нее можно писать формулу Тейлора:\ #v(0.2cm)
$f(x) = limits(sum)_(k = 0)^(+ infinity) (f^((k)) (x_0))/k!(x - x_0)^k$\ #v(0.2cm)
$e^x = limits(sum)^(+infinity)_(n = 0) x^n/n! $ --- всюду сходится с рядом Тейлора \ #v(0.2cm)
$ ln(1 + x) = x - x^2/2 + x^3 / 3- dots$ --- сходится с рядом Тейлора в точках из $[-1, 1]$
\
\
*Пример неаналитической функции*\ #v(0.2cm)
$ f(x) = cases( e^(-1/x^2)\, &quad x != 0, 0\, &quad x=0) $
*Утверждение:* $forall n in NN quad exists f^((n)) (0) = 0$\ \
*Доказательство:*\ #v(0.2cm)
1) $exists f'(0) quad$ если
$space exists limits(lim)_(x -> x_0 + 0) f'(x) = a$, то $f'_+(x_0) = a$ \
#v(0.2cm)#h(2.8cm)
$space exists limits(lim)_(x -> x_0) #h(0.45cm) f'(x) = a$, то $f'#h(0.1cm) (x_0) = a$
\ #v(0.2cm)
$lim_(x->0) 2/(x^3) e^(-1/x^2) =^"Лопиталь" lim (2 (1/x^3) e^(-1/x^2))/(3x^2) = lim 2/3 dot (e^(-1/x^2))/x^5 $ --- не повезло #v(0.2cm)
#h(2.35cm)$=display( lim (2/x^3)/e^(1/x^3) = [infinity/infinity]=^"Лопиталь"lim (-6/x^3)/(-1/x^3 dot e^(1/x^3)) = lim_(x->0) (6/x)/(e^(1/x^2)) =^"Лопиталь" lim (-6/x^2)/(-1/x^3 e^(1/x^2)) = lim_(x->0) (6x)/(e^(1/x^2)) = 0)$\
#v(0.2cm)
_Следствие:_ $forall k space limits(lim)_(x->0) e^(-1/x^2)/x^k = 0$\
#v(0.2cm)
Итак, $f'(0) = 0, quad$ то есть $f'(x) = cases(delim: "{", 1/x^3 e^(-1/x^2)\, &quad x != 0, 0 &quad x=0)$\ \
Проверим по индукции по $n$, что
$forall n space exists P_n (x)$ --- многочлен: $f^((n)) (x) = cases(delim: "[", display(P_n (1/x) e^(-1/x^2))\, &quad display(x != 0), display(0)\, &quad display(x=0))$\ #v(0.2cm)
База: $n= 0, space 1 $ см. раньше //??? // ??? //всм см раньше 1
$ f^((n+1)) = cases(delim: "[", display((P'_n (1/x) (-1/x^2) + P_n (1/x) dot (1/x^3)) e^(-1/x^2))\, &quad x != 0, ?\, &quad x=0) $#v(0.2cm)
$ f^((n+1)) = limits(lim)_(x->0)(f^((n)) (x)) = limits(lim)_(x->0)P_(n+1)(1/x)e^(-1/x^2) = 0 $
\ \
== Продолжение плотности аддитивной фукнции промежутка
$f$ --- плотность аддитивной функции промежутка $Phi$, если:\ #v(0.2cm)
$forall Delta in "Segm" quad limits(min)_Delta f dot |Delta| <= Phi(Delta) <= limits(max)_Delta f dot |Delta| quad$ _(f непрерывна, в ином случае вместо min и max, inf и sup)_ \ \
\
#th *(Напоминание)*
$f$ --- плотность $Phi$ ($f$ --- непр) $=> Phi([p, q]) = int_p^q f$
#v(0.2cm)
#columns()[
#align(center)[#image("7.png", width: 30%) $f = 1/2 r^2(phi)$]
#colbreak()
Вот здесь нам повезло, что вот эта функция оказалась аддитивной фукнцией промежутка, и это легко доказалось, но на самом деле обычно все не так просто, поэтому нужен более мощный инструмент
]
\
#th (_обобщ. теорема о плотности_)\ #v(0.2cm)
$Phi$ --- а.ф.п: $"Segm"(dp(a, b)) -> RR, f in C[a, b]$\ #v(0.2cm)
Пусть $forall Delta in "Segm"(dp(a, b)) quad exists$ функции промежуткака $m_Delta, M_Delta:$
+ $m_Delta dot abs(Delta) <= Phi(Delta) <= M_Delta dot abs(Delta)$
+ $forall x in Delta quad m_Delta <= f(x) <= M_Delta$
+ #columns(2)[ $forall$ фикс. $x in dp(a, b) quad M_Delta - m_Delta -->_(abs(Delta) -> 0\ x in Delta) 0$#v(0.2cm)
т.е. $forall epsilon > 0 quad exists space delta > 0: forall Delta in "Segm"dp(a, b):$ #v(0.2cm)
$ abs(Delta) < delta, x in Delta quad M_Delta - m_Delta < epsilon$
#v(0.2cm)
#colbreak()
#align(right)[#image("8.png", width: 80%)]
]
Тогда $f$ --- плотность $Phi$ $("и " forall space [p, q] subset dp(a, b) quad Phi([p, q]) = int_p^q f)$
\ \
#proof\
Не умаляя общности рассмотрим отрезок $[a, b]$, $quad F(x) = cases(delim: "[", display(0)\, &display(x = 0), display(Phi[a, x])\, quad &display(x > a)), quad "тогда"space ? F' = f$\ #v(0.2cm)
Фиксируем $x$, Пусть $h >0 $ \ #v(0.2cm) $(F(x + h) - F(x))/h = Phi[x, space x+h]/h,$ то есть из (1) $quad m_[x, space x + h] <= (F(x+h) - F(x))/h <= M_[x, space x + h] $\
#v(0.2cm) #h(5.28cm) из (2) $quad m_[x, space x+h] <= #h(0.7cm) f(x) #h(0.7cm) <= M_[x, space x+h]$\
#v(0.25cm)
Таким образом
$quad abs((F(x + h) - F(x)) / h - f(x)) <= M_[x, space x+ h] - m_[x, x+h] limits(-->)_(h -> 0)^("из" (3)) 0$\ #v(0.3cm)
Т. е. $(F(x + h) - F(x)) / h limits(-->)_(h -> 0) f(x),$ т.е. $quad F'_+(x) = f(x)$\
#v(0.3cm) #h(3.3cm) Аналогично $F'_- (x) = f(x)$
\ \
== Фигуры вращения
#columns(2)[
I тип:\
$f >= 0$, непр.\
$T([a, b]) = {(x, y, z) in RR^3:$#v(0.2cm)
#h(2.5cm)$ x in [a, b], space y^2 + z^2 <= f^2 (x) }$\
$$
#colbreak()
#align(right)[#image("9.png", width: 55%)]
]\
#columns(2)[
II тип:#v(0.2cm)
$U limits(([a, b]))_(0 <= a < b) = {(x, y, z) in RR^3:$#v(0.1cm)
#h(2cm)$ space a^2 <= x^2 + z^2 <= b^2,$#v(0.2cm)
#h(2cm)$space 0 <= y <= f(sqrt(x^2 + z^2))}$\ \
#colbreak()
#align(right)[#image("10.png", width: 73%)]
]
Нам хочеться считать объемы, поэтому введем а.ф.п.:\
$[a, b] |-> Phi[a, b] = V(T[a, b])$\
#v(0.2cm)
#h(1.4cm)$Psi[a, b] = V(U[a, b])$
\ \
#th
#v(0.2cm)
1) $Phi[a, b] = pi int_a^b f^2 (x) dif x$
#v(0.2cm)
2) $Psi[a, b] = 2 pi int_a^b x f(x) dif x$
\ \
#proof
#v(0.2cm)
1) ИЕЯ (упражнение)
#v(0.2cm)
2) ? $2 pi x f(x) $ --- плотность $Psi$#v(0.2cm)
$quad U[a, b] subset $ Цилиндр над кольцом (с основанием) $quad a^2 <= x^2 + z^2 <= b^2, space$высоты $limits(max)_[a, space b] f$\ #v(0.2cm)
- $Psi[a, b] <= (pi b^2 - pi a^2) max f = pi (b + a) (max f )(b - a) <= pi dot limits(max)_(x in [a, space b]) 2 x dot (limits(max)_(x in [a, space b]) f) dot (b-a)$\ #v(0.2cm)
$Psi[a, b] >= pi min 2x dot (min f) (b - a)$\
#v(0.2cm) $M_[a, space b] = pi dot limits(max)_(x in [a, space b]) = pi dot max 2x dot max f$\
#v(0.2cm) $m_[a, space b] = pi dot min 2x dot min f$\
#v(0.2cm) Это ровно первый пункт обобщенной теоремы плотности #v(0.2cm)
- $m_[a, space b] <= 2 pi x f(x) <= pi dot max 2x dot max f(x)$\
#v(0.2cm) Это второй пункт теоремы#v(0.2cm)
- $M-m -->_(x in Delta\ abs(Delta ->0)) 0$\ #v(0.2cm)
$max f -> f(x) <- min f$\ #v(0.2cm)
$limits(max)_(t in Delta) 2 t -> 2 x <- min 2 t$
#v(0.2cm) Это третий пункт
Получилось что все 3 пункта выполнены $=>$ это действительно плотность $Psi$\ \
*Посчитаем объём бублика:*\
$(x-R)^2 + y^2 = r^2$ --- это формула которой задается сечение бублика. $R$ --- расстояние от центра координат, $r$ --- радиус круга сечения.
#v(0.4cm)
$V_"бублика" = 2 dot 2pi int_(R-2)^(R+2) x sqrt(r^2 - (x-R)^2) dif x=4pi int_(R-2)^(R+2) (x-R) sqrt(r^2 - (x-R)^2) dif x + 4pi R int_(R-2)^(R+2) sqrt(r^2 - (x-R)^2) dif x$\ #v(0.4cm)
$=0+4pi R dot (pi r^2)/2 = 2pi R dot pi r^2 = 2pi^2 R r^2$
#align(center)[#image("11.png", width: 50%)]
// до начала 6 дней // начала чего? // стрима
// начал же... // в waiting room было написано "начало 4 марта 13:30"
#pagebreak()
== Интегральные суммы
$f in C[a, space b]$\ \
#columns(2)[
#def дробление отрезка\ #v(0.2cm)
_Дробление отрезка $[a, b]$_ --- набор точек $x_0 = a < x_1 < x_2 < dots < x_n = b$
#colbreak()
#align(right)[#image("12.png", width: 60%)]
]\
\ \
#columns(2)[
#def ранг дробления (мелкость)\ #v(0.2cm)
_Ранг дробления_ --- $limits(max)_(1<=k<=n) (x_k - x_(k-1))$
#colbreak()
#align(right)[#image("13.png", width: 60%)]
]
\
#columns(2)[
#def оснащение\ #v(0.2cm)
_Оснащение_ --- набор точек $xi_1, dots, xi_n: forall k quad xi_k in [x_(k-1), x_k]$
#colbreak()
#align(right)[#image("14.png", width: 60%)]
]
\
#columns(2)[
#def интегральная (риманова) сумма\ #v(0.2cm)
_Интегральная сумма_ --- $sum_(k=1)^n f(xi_k) (x_k - x_(k-1))$
#colbreak()
#align(right)[#image("15.png", width: 60%)]
]
\
#th (_об интеграле как о пределе интегральной суммы_)\ #v(0.2cm)
$f in C[a, space b] quad $ Тогда\ #v(0.2cm)
$forall epsilon > 0 space exists space delta > 0: forall $ дробление $x_0 = a < x_1 < dots < x_n = b, $ где ранг дробления $< delta$\ #v(0.2cm)
$ abs(int^b_a f - limits(sum)_(k = 1)^n f (x_(k - 1)) (x_k - x_(k-1) )) < epsilon $
\ \
#proof #v(0.2cm)
<NAME> о равномерной непрерывности: $f$ --- непр. на $[a, b] => f$ --- равн. непр.\ #v(0.2cm)
Равномерно непрерывно означает: $display(forall epsilon > 0 quad exists space delta > 0: forall x\, space overline(x): abs(x - overline(x)) < delta quad abs(f(x) - f(overline(x))) < epsilon/(b-a))$\ #v(0.4cm)
$display(abs(int_a^b f - sum_(k=1)^n dots) =^((*)) abs(sum_(k=1)^n int_(x_(k-1))^(x_k) (f(x) - f(x_(k-1))) dif x) <= sum abs(dots) <= sum_(k=1)^n int_(x_(k-1))^(x_k) abs(f(x) - f(x_(k-1))) dif x < sum int_(x_(k-1))^(x_k) epsilon/(b-a) dif x =)$\ #v(0.4cm) $display(= sum_(k=1)^n epsilon/(b-a) abs(b-a) = epsilon)$\ \
$(*):$ здесь интеграл разбился по аддитивности на $display(sum_(k=1)^n int_(x_(k-1))^(x_k) f(x)), space$ а каждый элемент суммы представили в виде $display(sum_(k=1)^n int_(x_(k-1))^(x_k) f(x_(k-1))), space$ так как у нас каждый элемент суммы --- прямоугольник с основанием $x_k - x_(k-1)$ #v(0.2cm) и высотой $f(x_(k-1))$.
\ \
*Замечание:* в общем случае можно взять не конец отрезка, а некоторую точку $xi_k$ на нем и все будет работь.\ \ \
#def модуль непрерывности\ #v(0.2cm)
$f: [a, b] -> RR$\ #v(0.2cm)
$display(omega(delta) := limits(sup)_(x, f in [a, b]\ abs(x - t) < delta) abs(f(x) - f(t)))$ --- модуль непрерывности\ \
<NAME>: $omega(delta) ->_(delta -> 0) 0$ [для непр. $f$]\ #v(0.2cm)
<NAME>: $f$ --- дифф на $[a, space b] quad M = max abs(f') quad$ Тогда $omega(delta) <= M dot delta$\ #v(0.2cm)
\ #v(0.2cm)
_Предыдущая теорема:_ если ранг дробления $< delta$, то $abs(int_a^b f - sum_(k=1)^n f(x_(k-1))(x_k - x_(k-1))) <= omega(delta) dot (b-a)$#v(0.2cm)
Если хотим в терминах теоремы Лагранжа: $f in C^1 quad M = max abs(f') quad abs(int - sum) <= M delta(b - a)$
#columns()[
#align(center)[#image("16.png", width: 62%)
#colbreak()
Сделаем равномерное дробление отрезка $[a, b]$ \
Посмотрим на сколько отличается интеграл от суммы.\
Он отличается ровно на площадь красных треугольничков.\
Сместим все треугольнички в последний столбец и оценим их площадь площадью прямоугольника --- победа.]
]
\ \
#th (_об интегральной сумме центральных прямоугольников_) #columns(2)[
$f in C^2[a, space b] quad a = x_0 < x_1 < x_2 < dots < x_n = b$#v(0.2cm)$ quad delta = max(x_k, space x_(k - 1)), space xi_k = (x_(k-1) + x_k)/2$\ #v(0.2cm)
Тогда $abs(int_a^b f - sum_(k=1)^n f(xi_k) (x_k - x_(k-1))) <= delta^2/8 int_a^b abs(f'')$
\ \
#proof #v(0.2cm)
Упражнение (зная доказательств следующей теоремы)
#colbreak()
#align(right)[#image("17.png", width: 30%)]
]
\ \
#th (_формула трапеций_)\ #v(0.2cm) // да
$f in C^2 [a, b] quad a = x_0 < x_1 < dots < x_n = b quad delta = max (x_k - x_(k-1))$\ #v(0.2cm)
Тогда $abs(int_a^ f - limits(sum)_(k = 1)^n (f(x_(k-1)) + f(x_k)) / 2(x_k - x_(k-1))) <= delta^2/8 int_a^b abs(f'')$ \ \
#proof #v(0.2cm)
Хотим интегрировать по частям: $int_alpha^beta u'v = u v pole(alpha, beta) - int_alpha^beta v' u $\
#v(0.4cm)
$int_(x_(k-1))^(x_k) f = int_(x_(k-1))^(x_k) f(x) dif x = $ \ \ $display(mat(delim: "[", v=f, v=f'; u'=1, u=x-xi_k)) =f(x) (x-xi_k)pole((x=x_(k-1)), (x=x_k)) - int_(x_(k-1))^(x_k) f'(x) (x-xi_k) dif x = (f(x_k) + f(x_(k-1))) (x_k - x_(k-1))/2 +$\ #v(0.4cm)
$+display(1/2)int_(x_(k-1))^(x_k) f' (-2(x-xi_k)) dif x = display(mat(delim: "[", v=f', f'=f''; u'=-2(x-xi_k), limits(u=(x-x_(k-1))(x_k-x))_("на" [x_(k-1), x_k])))=$\ #v(0.4cm)
$=display((f(x_k) + f(x_(k-1)))/2 (x_k - x_(k-1)) + 1/2) (u dot f'pole(x=x_(k-1),x=x_k) - int_(x_(k-1))^(x_k) f'' dot u(x) dif x), space $ где $space u(x) = (x-x_(k-1))(x_k - x)$\ \ \ #v(0.2cm)
Суммируем эти формулы по $k=1,2,dots,n$\ #v(0.2cm)
$int_a^b f = display(sum_(k=1)^n) "трап" - 1/2 int_a^b f'' (x) u(x) dif x$\ #v(0.4cm)
$abs(int_a^b f - sum "трап") = 1/2 abs(int_a^b f'' (x) u(x) dif x) <= 1/2 int_(a)^b abs(f'') u(x) dif x <=^((*)) delta^2/8 int _a^b abs(f'')$\ \
$(*)$ Здесь мы заменили $u(x)$ на ее максимальное значение. Заметим что $u(x)$ выглядит как набор парабол ветвями вниз, которые проходят через точки $x_i$, при этом расстояние между $x_i <= delta => max(u) = delta^2/4$ \
#image("31.png", width: 30%)
\
Подсказка для центральных прямоугольников:\
#image("32.png", width:35%)
\ \ \
$[a, b] = [0, n], x_k = k$\
Формула трапеций: $abs(int_0^n f(x) dif x - sum_(k=1)^n (f(x_k) + f(x_(k-1)))/2 dot 1) <= 1/8 int_0^n abs(f'')$\
#smile $f(x) = x$#v(0.2cm)
$abs(int_0^n x dif x - (0/2 + 1/2 + (1+2)/2 + (2+3)/2 + dots + ((n-1)+n)/2)) <= 0$\
$=> 1+2+dots+n = n/2 + int_0^n x dif x = (n^2+n)/2$ #smile\
Это частный случай формулы Эйлера-Маклорена
#pagebreak()
== Простейший случай формулы Эйлера-Маклорена
$m, space n in ZZ quad f in C^2 [m, space n] quad$ Тогда\
$int_m^n f(x) d x = limits(sum)_(i = m)^n f(i) - 1/2 int_m^n f''(x) dot {x} (1 - {x}) d x$ \
Это очевидно, АГА. Это формула трапеции\
$limits(sum)_(k = 1)^n (f(x_(k - 1)) +f(x_k))/2 (x_k - x_(k-1))$\
Дробим $[m, space n]$ на единичные отрезки\
$psi(x) = (x - x_(k-1)) (x_k - x)$\
$delta^2/8 int dots quad 1/2 f(m) + f(m+1) + dots + f(n - 1) + 1/2f(n)$\
$-delta^2/2 int_a^b abs(f'') quad int f'' dot psi(x)$
//TODO
\
\
*Пример 1:* $f(x) = x^p, space p>-1$\
$1^p + 2 ^p + dots + n^p = n^p/2 + 1/2 + int_1^n x^p d x + 1/2 int_1^n (x^p)'' {x}(1 0 {x})d x$
//TODO
#pagebreak()
// скип
#pagebreak()
= Неравенства
== Интегральное неравенство Йенсена
#th\
$display(cases(reverse:#true,
f -" выпуклая, непр. на" dp(A, B),\
phi: [a, b] -> dp(A, B) - "непрерывная",\
lambda: [a, b] -> [0, +infinity)- "непр. и" int_a^b lambda = 1)) => f(underbrace( int_a^b lambda(t) phi(t) dif t, c)) <= int_a^b lambda(t) f(phi(t)) dif t$
// привет
//ку
// ты пришел дотехать те 2 лекции?
//могу и их, но вообще я зашёл перед тем, как аисд доделать
// тогда удачи, мне тут еще дофига
//оке, тебе тоже удачи
// <3
#proof\
Пусть $m = min phi, M = max phi$#v(0.2cm)
$c = int_a^b lambda(t) phi(t) dif t <= M int_a^b lambda(t) dif t = M, space$ аналогично $c >= m$#v(0.2cm)
Если $phi = "const" => display(cases(f(int_a^b lambda(t)dot "const" dif t) = f("const"dot int_a^b f(t) dif t) = f("const"), int_a^b lambda(t) f("const")dif t = f("const")dot int_a^b lambda(t) dif t = f("const")))$#v(0cm) \
В таком случае неравенство очевидно выполняется: $f("const") <= f("const")$#v(0.3cm)
В противном случае: $phi != "const" => m < c < M$ \ \
Берём в точке $c in dp(A, B)$ опорную прямую к графику: $y = alpha x + beta quad (*)$\
#image("18.png", width: 40%)
$f(c) = alpha c + beta=alpha int_a^b lambda(t) phi(t) dif t + beta underbracket((int_a^b lambda(t) dif t), =1) = int_a^b lambda(t) (alpha phi(t) + beta) dif t <=^("в силу")_(" выпуклости") int_a^b lambda(t) f(phi(t)) dif t$ \ \
Комментарий по $(*)$: мы не хотим, чтобы опорная прямая была вертикальной, поэтому мы берём $c$ не на #v(0.15cm) конце отрезка. Можно это записать так: $c = int_a^b lambda(t) phi(t) dif t < M int_a^b lambda(t) dif t$ вместо нестрогого неравенства.\ \
== Пример (неравенство Коши в интегральной форме):
*Напоминание (обычное неравенство Коши):* $root(n, a_1 dots a_n) <= (a_1 + dots + a_n)/n$#v(0.2cm)
Теперь интегральная форма:
$f in C[a, b], space f > 0 => exp(1/(b-a) int_a^b ln f dif x) <= 1/(b-a) int_a^b f(x) dif x$#v(0.2cm)
_В качестве упражнения можно доказать при помощи интегральных сумм_#v(0.1cm)\
Доказательство при помощи неравенства Йенсена:\
$f^* <-> exp$ --- здесь $f^*$ на самом деле тот $f$ который был в формулировке неравенства Йенсена, но во избежании коллизии обозначений с тем $f$ который введен в этой теореме немного его переименуем.#v(0.1cm)
$lambda <-> 1/(b-a)$#v(0.1cm)
$phi <-> ln$#v(0.1cm)
Если исползьовать эти фукнци то наше неравенство ровно сведется к неравенство Йенсена.
== Неравенство Гёльдера для сумм
#th\
$p > 1,space q > 1,space 1/p + 1/q = 1,space a_i, b_i > 0 space forall i = 1 dots n$#v(0.2cm)
Тогда $display(sum_(i=1)^n a_i b_i <= (sum a_i^p)^(1/p) (sum b_i^q)^(1/q))$\ \
#proof
$f(x) = x^p$ --- вып. на $[0, +infinity) quad quad f'' = p(p-1)x^(p-2) >= 0$#v(0.2cm)
Нер-во Йенсена для этой фукнции: $(sum alpha_i x_i)^p <=^((1)) sum alpha_i x_i^p, space$ где $sum alpha_i = 1$#v(0.2cm)
В качестве $alpha_i$ возьмем $alpha_i =display((b_i^q)/(sum b_i^q))$ --- подходит под нужное нам условие#v(0.2cm)
В качестве $x_i$ возьмем $x_i = a_i b_i^(-1/(p-1)) (sum b_i^q)$\ \
Найдем $a_i x_i$ чтобы подставить его в Л.Ч. (1): $alpha_i x_i = a_i b_i^(q - 1/(p-1)) = a_i b_i$\ \
Найдем $alpha_i x_i^p$ чтобы подставить его в П.Ч. (1):
$alpha_i x_i^p = display(cancel(b_i^q)/(sum b_i^q)) a_i^p cancel(b_i^(-p/(p-1))) (sum b_i^q)^p = a_i^p (sum b_i^q)^(p-1)$\ \
Подставляем то что мы только что получили в (1): $(sum a_i b_i)^p <= (sum a_i^p) (sum b_i^q)^(p-1)$\ \
Возводим предыдущее равенство в степень $1/p: (sum a_i b_i) <= (sum a_i^p)^(1/p) (sum b_i^q)^((p-1)/p=1/q)$\ \
*Наблюдение 1:* неравенство работает для нулевых слагаемых т.к нулевые множители не влияют на сумму слева и не уменьшают сумму справа#v(0.2cm)
*Наблюдение 2:*\
$a_i, b_i in RR$\
$abs(sum a_i b_i) <= sum abs(a_i b_i) <= (sum abs(a_i)^p)^(1/p) (sum abs(b_i)^q)^(1/q)$\ \
*Замечание для нер-ва Йенсена:* #v(0.1cm)
$f(sum alpha_i x_i) <= sum alpha_i f(x_i)$, $f$ --- строго выпукла, $alpha_i != 0$. Равенство достигается при $x_1 = x_2 = dots = x_n$#v(0.2cm)
Идя по док-ву нер-ва Гёльдера, заметим, что если нет нулей, то $f(x)=x^p$ --- строго выпукла на $(0, +infinity)$. Равенство достигается тогда, когда:\
$forall i quad quad display(cases(reverse: #true, a_i b_i^(-1/(p-1)) = lambda ,a_i^p b_i^(-p/(p-1))=lambda^p=lambda_0)) => a_i^p = lambda_0 b_i^q => (a_1^p dots a_m^p) arrow.t arrow.t (b_1^q dots b_n^q)$ --- эта запись означает что вектора #v(0.2cm)пропорциональны дург другу\ \
== Интегральное нер-во Гёльдера
$p > 1,space q > 1,space 1/p + 1/q = 1,space f, g in C[a, b] => abs(int_a^b f g) <= (int_a^b abs(f)^p)^(1/p) (int_a^b abs(g)^q)^(1/q)$\ \
#proof #v(0.2cm)
$[a, b]$ дробим на $n$ равных частей: $display(x_k = a + k dot (b-a)/n = a + k Delta x_k)$#v(0.1cm)
*Дискретное неравенство Гёльдера:*\
$a_k = f(x_k) (Delta x_k)^(1/p)$#v(0.1cm)
$b_k = g(x_k) (Delta x_k)^(1/q)$#v(0.1cm)
$a_k b_k = f(x_k) g(x_k) Delta x_k$#v(0.1cm)
$sum abs(f(x_k) g(x_k)) Delta x_k <= (sum abs(f(x_k))^p Delta x_k)^(1/p) (sum abs(g(x_k))^q Delta x_k)^(1/q)$\ \
Свертка интегральных сумм в интеграл: $n -> +infinity: int_a^b abs(f(x) g(x)) dif x <= (int_a^b abs(f)^p)^(1/p) (int_a^b abs(g)^q)^(1/q)$\
Из-за предельного перехода равенство найти не получится #frown \ \
Неравенство Гёльдера, случай $n=2$:#v(0.2cm)
$sum a_i b_i <= (sum a_i^2)^(1/2) (sum b_i^2)^(1/2)$ --- нер-во Коши-Буняковского\ \
$p -> 1, q -> +infinity$:\
$sum a_i b_i <= sum a_i lim_(q -> +infinity) (sum b_i^q)^(1/q) = sum a_i max(b_i)$\
== Неравенство Минковского
#th\
$p >= 1, space a_i, b_i in RR$\
Тогда $(sum_(i=1)^n abs(a_i + b_i)^p)^(1/p) <= (sum abs(a_i)^p)^(1/p) + (sum abs(b_i)^p)^(1/p)$\
$p=1$ --- очев\
Смысл неравенства: елси $p>1$, тогда мы можем задать норму в $RR&^n: (a_1 dots a_n) |-> (sum abs(a_i)^p)^(1/p)$ \ \
#proof
$sum a_i abs(a_i + b_i)^(p-1) <= (sum a_i^p)^(1/p) (sum abs(a_i+b_i)^(q (p-1)=p))^(1/q)$#v(0.2cm)
$sum b_i abs(a_i + b_i)^(p-1) <= (sum b_i^p)^(1/p) (sum abs(a_i + b_i)^p)^(1/q)$#v(0.2cm)
Просуммируем два полученых неравенства:#v(0.2cm)
$sum(a_i + b_i) abs(a_i + b_i)^(p-1) = (sum (a_i + b_i)^p)^1 <=((sum abs(a_i)^p)^(1/p) + (sum abs(b_i)^p)^(1/p)) (sum abs(a_i + b_i)^p)^(1/q)$#v(0.2cm)
$(sum (a_i + b_i)^p)^(1/p) <= dots$\ \ \
#th (инт. н-во Минковского)\
$f, g in C[a, b], p >= 1$. Тогда $(int_a^b abs(f+g)^p)^(1/p) <= (int_a^b abs(f)^p)^(1/p) + (int_a^b abs(g)^p)^(1/p)$\ \
Смысл интегрального н-ва Минковского: $f |-> (int_a^b abs(f)^p)^(1/p)$ --- норма\
#proof
Вариант 1. Переписать дискр. доказательство.\
Вариант 2. Интегральные суммы\
В н-ве Гёльдера в предельном переходе $(sum b_i^q)^(1/p) -> max abs(b_i)$\
$(b_1, dots, b_n) |-> max abs(b_i)$ --- норма
= Конечные $epsilon$-сети
#def $epsilon$-сеть\
$(x, rho)$ --- МП, $D subset X$\
Мн-во $N subset X$ называется $epsilon$-сетью для $D quad forall x in D quad exists space n in N: rho(x, n) < epsilon$\ \
#def сверхограниченность\
$D$ --- сверхограниченно, если $forall epsilon > 0$ в $X quad exists$ конечная $epsilon$-сеть $N$ для мн-ва $D$\ \
#lm\
$D$ --- сверхограниченно в $X <=> D$ --- сверхограниченно в $D$#v(0.2cm)
#proof
$arrow.l.double:$ тривиально\
$=>:$ Берём конечную $epsilon/2$-сеть в $X$\
$forall n in N$ рассмотрим шар $B(n, epsilon/2)$. Отметим в каждом шаре точку $d_n$ --- конечное число.\
Тогда ${d_n}$ --- $epsilon$-сеть, лежащая в $D$.\ \
#lm\
Сверхограниченность сохраняется при равномерно непрерывных отображениях.\
Т.е. $D subset X$ --- сверхогр., $f: X -> Y$ --- равн. непр. ($forall epsilon > 0 quad exists delta > 0: forall x_1, x_2: rho(x_1, x_2) < delta => rho(f(x_1), f(x_2)) < epsilon$)#v(0.2cm)
Тогда $f(D)$ --- св.огр. в $Y$, т.к. $f(delta"-сеть")=epsilon$-сеть\ \
*Вопрос из зала:* почему не получиться так, что ограниченное всегда является свехрограниченным?#v(0.2cm)
Ответ: рассмотрим нормированное пространство последовательностей $L = {(x_1, x_2, dots), abs(overline(x)) = sum_(i=1)^(+infinity) abs(x_i)}$\
$D = (e_1,e_2, dots) subset overline(B(arrow(0), 1))$ --- ограниченное множество.#v(0.2cm)
$e_k = (underbrace(0\, dots\, 0, (k-1)), 1, 0, dots)$\ \
$rho(e_k, e_j) = norm(e_k - e_j) = 2$ --- но это говорит нам о том что $D$ не сверхограниченно\ \
#lm\
$D$ --- сверхогр. $=>$ замыкание $D$ тоже\
$D subset limits(union.big)_N B(n, epsilon) => overline(D) subset limits(union.big)_N B(n, 2epsilon) => N$ --- $2epsilon$-сеть для $overline(D)$\ \
#lm\
$D$ --- сверхогр. $<=> forall$ посл. точек из $D$ содержит фундоментальную подпоследовательность#v(0.1cm)
*Напоминание (фундаментальная посл-ть):* $x_n$ --- фунд. $<=> forall epsilon > 0 quad exists N: forall m, k > N quad rho(x_n, x_k) < epsilon$#v(0.2cm)
#proof
$=>: epsilon := 1$. Строим конечную 1-сеть $N_1$\
$limits(union.big)_(a in N_1 \ ("кон.")) B(a, 1) supset D$#v(0.2cm)
$exists a_1 in N_1:$ в $B(a_1, 1)$ сод. беск. много членов последовательности $x_n$.#v(0.2cm)
Берём все эти бесконечно много $x_n$ и объединяем в подпоследовательность $(x_n^((1)))$, возьмём любой её член и обозначим $x_n_1$#v(0.2cm)
Теперь $epsilon := 1/2$, строим конечную $1/2$-сеть $N_2$#v(0.2cm)
$limits(union.big)_(a in N_2) B(a, 1/2) supset D$\
$exists a_2 in N_2:$ в $B(a_2, 1/2)$ содержит бесконечно много элементов из $x_n^((1))$\
Берём эти элементы и обозначем $(x_n^((2)))$, возьмём член $x_n_2 (n_2 > n_1)$\
$dots.v$\
$(x_n_i)$ --- фундаментальная#v(0.3cm)
$arrow.l.double epsilon:$. Нет $epsilon$-сети?#v(0.2cm)
Какая то $x_1, "другая" x_2 in.not B(x_1, epsilon) " и " x_3 in.not B(x_1, epsilon) union B(x_2, epsilon)$#v(0.2cm)
Таким образом построим посл-ть: $forall x_k, x_m quad rho(x_k, x_m) >= epsilon$ #v(0.2cm)
У посл-ти $(x_n)$ нет фунд. подпосл. Противоречие в определении для обсуждаемого $epsilon$.\ \
#lm\
$X$ --- сверхогр. $=>$ в $X$ имеется счётное всюду плотное подмножество $Q$. (т.е. $X$ --- сепарабельное)#v(0.2cm)
#proof
$Q = limits(union.big)_(n=1)^(+infinity) (1/n"-сеть")$\ \
#th\
$(X, rho)$ --- МП. Эквивалентны:
+ $X$ --- компактно
+ $X$ --- полно и сверхограниченно
#proof
*Замечание:* в МП комп. $<=>$ секв. комп.\
$(1)=>(2):$\
$X$ --- неполно $=> exists$ фундаментальная последовательнсоть, не имеющая предела $=> forall$ подпоследовательности верно, что она тоже не имеет предела $=>$ это противоречит секвинциальной компактности\
$X$ --- не сверхограничено $=>$ по лемме 4 $exists$ последовательность, у которой $exists.not$ фунд. подпосл. $=>$ у этой последовательности нет сходящейся подпоследовательности $=>$ противоречит секвинциальной компомпактности\
$(2)=>(1):$\
$X$ --- сверхограниченно $=> forall$ последовательность точек из $X quad exists$ фундаментальная подпоследовательнсоть $=>_(X" - полное")forall$ последовательнсоть точек из $X$ имеет схододящейся подпоследовательности, т.е. это секвинциальная компактность.
= Несобственный интеграл
#def несобственный интеграл#v(0.1cm)
$f:[a, b) -> RR quad (-infinity < a < b <= +infinity)$#v(0.2cm)
$f$ --- *допустима*, если $forall A: a <= A < b quad f$ --- кусочно-непрерывна на $[a, A]$\ \
$Phi(A)=int_a^A f(x) dif x$, где $A in [a, b)$\
Если $exists lim_(A->b-0) Phi(A) in overline(RR)$, то величина называется несобственным интегралом $int_a^(arrow b) f(x) dif x$\
Если $exists.not lim_(A->b-0) Phi(A) in overline(RR)$, то несобств. инт. не существует.\
Если $lim Phi(A) in RR$, то интеграл сходится.\
Если $lim Phi(A) = {plus.minus infinity}$ или не сущ., то интеграл расходится.\ \
*Пример:*#v(0.2cm)
+ $int_1^(+infinity) 1/x dif x$\ \
$int_1^A 1/x dif x = ln A ->_(A -> +infinity) +infinity$ --- расходиться #v(0.2cm)
+ $int_0^1 1/x dif x = lim_(A->+0) int_A^1 1/x dif x = -ln A ->_(A->+0) +infinity$ --- расходиться#v(0.25cm)
+ $int_1^(+infinity) (dif x)/x^2 = lim_(A -> +infinity) (-1)/x pole(1, A) = lim_(A -> +infinity) -1/A + 1 -> 1$ --- сходиться #v(0.25cm)
+ $int_1^(+infinity) sin x dif x = lim_(A->+infinity) int_1^A sin x = lim_(A->+infinity) -cos A + cos 1$ --- не существует
\ \
#note
+ $f in C[a, b]: int_a^(arrow b) f = int_a^b f$ --- очевидно\
+ Теперь можно находить $int_a^(+infinity)$ (стрелочка не нужна, потому что нет путаницы)\
+ Стрелочка не меняет значения для собственных интегралов, а несобственность и так понятна#v(0.2cm)
$int_a^(arrow b) f = F pole(a, ->b) = lim_(A -> b-0) F(A) - F(a)$\
\ \
*Свойства:*
+ Критерий Больцано-Коши#v(0.1cm)
*Напоминание для фунций:*#v(0.2cm)
$exists$ кон. $lim_(x->a) f(x) <=> forall epsilon > 0 quad exists delta > 0: forall x_1: abs(x_1 - a) < delta, forall x_2: abs(x_2 - a) < delta: abs(f(x_1)-f(x_2)) < epsilon$ #v(0.2cm)
*Для интегралов:*#v(0.1cm)
Сходимость $int_a^(arrow b) f <=> forall epsilon > 0 quad exists Delta in [a, b): forall A, B > Delta quad abs(int_A^B f) < epsilon$\
Отрицание: $exists space epsilon > 0: forall Delta in [a, b) quad exists A, B > Delta: abs(int_A^B) >= epsilon$,#v(0.2cm)
т.е. если $exists space epsilon space exists space (a_n), (b_n) -> b-0 quad abs(int_(a_n)^(b_n) f) >= epsilon => int_a^(arrow b) "расходится"$\ \
*Пример:*#v(0.1cm)
$int_1^(+infinity) sin x dif x$ --- расходится#v(0.2cm)
$A_n = 2 pi n, B_n = 2 pi n + pi:$
$int_(A_n)^(B_n) sin x = 2 >= epsilon = 2$
+ Аддитивность по промежутку#v(0.2cm)
$forall c in (a, b)$, пусть $exists int_a^(arrow b) f => $
$int_a^(arrow b) f = int_a^c f + int_c^(arrow b) f$#v(0.2cm)
#proof#v(0.1cm)
Очевидно. Берём $A: c < A < b$#v(0.2cm)
$int_a^A f = int_a^c + int_c^A, quad A ->b-0$\ \
_Соглашение._ $f$ --- допустимая для $int_0^(->+infinity), int_(->-infinity)^0 quad => quad$
$int_(-infinity)^(+infinity) f = int_0^(+infinity) f + int_(-infinity)^0 f = int_(2024)^(+infinity) f + int_(-infinity)^2024 f$, если сложение#v(0.2cm) корректно (не случается ситуации $+infinity-infinity$)#v(0.4cm)
_Общее соглашение._ $f: RR -> RR$ непрерывна, кроме $a_1, a_2, a_3$#v(0.2cm)
$b_1 < a_1 < b_2 < a_2 < b_3 < a_3 < b_4$#v(0.2cm)
$int_(-infinity)^(+infinity) f = int_(-infinity)^(b_1) + int_(b_1)^(->a_1) + int_(->a_1)^(b_2) + int_(b_2)^(->a_2) + int_(->a_2)^(b_3) + int_(b_3)^(->a_3) + int_(->a_3)^(b_4) + int_(b_4)^(+infinity)$, если все существует и сложение корректно.\ \
*Пример:*\
$int_(-1)^(1) 1/x dif x space cancel(=0)$, т.к. он расходится (возникает выражение $-infinity+infinity$)#v(0.2cm)
Можно сделать небольшой трюк:$int_(-1)^1 = lim_(epsilon -> 0) int_([-1, 1] without [-epsilon, epsilon]) 1/x dif x = 0$, но это достатоно опасно так что не стоит так делать.\ \
#cor()\
$a < A < b, int_a^(->b) f$ сходится,
тогда $int_(A)^(->b) f -->_(A->b-0) 0$#v(0.2cm)
#proof#v(0.2cm)
$int_a^(->b) f = limits(int_a^A f)_(space arrow.b\ int_a^(->b) f) + limits(int_A^(->b) f)_(arrow.b\ 0)$
+ $f, g$ --- допустимые на $[a, b)$, $int_a^(->b) f, int_a^(->b) g$ сходятся, $lambda in RR$\ \
Тогда $lambda f, f plus.minus g$ --- допустимы и $int_a^(->b) lambda f = lambda int_a^(->b) f, quad int_a^(->b) f + g = int_a^(->b) f + int_a^(->b) g$
#proof
Упражнение читателю.\
+ $f, g$ --- допустимы, $int_a^(->b) f, int_a^(->b) g$ сущ., $f <= g$\
Тогда $int_a^(->b) f <= int_a^(->b) g$#v(0.2cm)
#proof
При $a < A < b quad int_a^A f <= int_a^A g, quad A -> b-0$\
+ Интегрирование по частям:#v(0.2cm)
$f, g$ --- дифф, $f', g'$ --- допустимы. Тогда\*\ #v(0.2cm)
$int_a^(->b) f g' = f g pole(a, ->b) - int_a^(->b) f'g$\ \
#proof #v(0.2cm)$int_a^A f g' = f g pole(a, A) - int_a^A f'g, quad A -> b-0$#v(0.2cm)
\*: если $exists space 2$ выражения со стрелочками, то $exists$ и третий и имеет место "="
+ Замена переменной: #v(0.2cm)
$phi:[alpha, beta) -> dp(A, B), space phi in C^1$ #v(0.2cm)
$phi(beta - 0) in overline(RR), f in C(dp(a, b))$ #v(0.3cm)
Тогда: $int_alpha^(->beta) (f op(circle.small) phi) phi' = int_(phi(alpha))^(->phi(beta-0)) f$ #v(0.2cm)
#proof
$f in C[a, b] quad lim_(A->b-0) int_a^A f = lim_(A->b-0) (int_a^b f - int_A^b f) = int_a^b f$\
$abs(int_A^b f) <= max abs(f) dot (b-A) -> 0$
= Признаки сходимости интеграла
*Наблюдение.*\
$f$ --- допустима на $[a, b)$, $f >= 0, Phi(A) = int_a^A f$\
$int_a^b f$ --- сходится $<=> Phi$ --- огр. $quad$ (очевидно: $Phi arrow.tr$)\
В этом случае $lim_(A->b-0) Phi(A) = limits(sup)_[a, b) Phi$\ \
#th _признак сравнения_\
$f, g$ --- допустимые на $[a, b), f, g >= 0$\
+ $f <= g$ на $[a, b]$. Тогда:
- Если $int_a^b f$ расходится, то $int_a^b g$ расходится #v(0.2cm)
- Если $int_a^b g$ сходится, то $int_a^b f$ сходится #v(0.2cm)
+ $lim_(x->b-0) f(x)/g(x) = l$
- $l in (0, +infinity): int_a^b f, int_a^b g$ сходятся одновременно, расходятся тоже #v(0.2cm)
- $l = 0: int_a^b f$ расходится $=> int_a^b g$ расходится; $int_a^b g$ сх $=> int_a^b f$ сходиться #v(0.2cm)
- $l = +infinity: int g$ расходится $=> int f$ расходится; $int f$ сх $=> int g$ сходиться #v(0.2cm)
#proof
+ $f <= g quad Phi(A) = int_a^A f, Psi(A) = int_a^A g,quad Phi <= Psi$\
$int_a^b f$ расходиться $=> Phi$ неограничена $=> Psi$ неограничена $=> int_a^b g$ расходиться\ #v(0.2cm)
$int_a^b g$ сходиться $=> Psi$ ограничена $=> Phi$ ограничена $=> int_a^b f$ сходиться #v(0.2cm)
+ Сходимость $int_a^b f$ или при $c in (a, b)$ сходимостьсть $int_c^b f$ --- одно и то же #v(0.4cm)
- $l in (0, +infinity): exists space c in (a, b): "при" x in (c, b) quad l/2< f(x)/g(x) < 3/2 l$ #v(0.1cm)\
$int_a^b f$ сходиться $=> int_c^b f$ сходиться, на $(c, b) quad l/2 g(x) < f(x) => int_c^b l/2 g$ сходиться $=> int_c^b g$ сходиться #v(0.3cm)
$int_a^b g$ сходиться $=> int_c^b g$ сходиться, $f < 3/2 g => int_c^b 3/2 g$ сходиться $=> int_a^b f$ сходиться #v(0.3cm)
- $l = 0 quad$ для $epsilon = 1 quad exists space c: forall x in (c, b) quad f(x)/g(x) < 1$, т.е. $f < g$ и результат слеюует из 1 части признака #v(0.2cm)
#h(37pt)для $Epsilon = 1 quad exists space c: forall x in (c, b) quad f(x)/g(x) > 1$ #v(0.2cm)
*Примеры:*\ #v(0.2cm)
+ "Эталоны":\
$int_a^(+infinity) 1/(x^p) dif x = display(cases(delim: "[", 1/(1-p) x^(1-p) pole(a, +infinity)&\, quad p!=1, ln x pole(a, +infinity)&\, quad p=1)) = display(cases(delim: "[", "кон"&\, quad p > 1, +infinity&\, quad p <= 1))$\ \
$int_(->0)^1 1/(x^p) dif x = display(cases(delim: "[", "кон"&\, quad p < 1,
+infinity&\, quad p >= 1))$\ \
+ $int_0^(+infinity) (cos^2 x)/(x^2 + 1) dif x$ #v(0.2cm)
$(cos^2 x)/(x^2 + 1) <= 1/(x^2 + 1)=>$ проверим
$int_0^(+infinity) 1/(x^2 + 1) dif x = arctan x pole(0, +infinity) = pi/2$ --- он сходиться $=>$ изначальный сходиться\
+ $int_10^(+infinity) (arctan x)/(sqrt(x) ln x) cos 1/x dif x$#v(0.2cm)
Попробуем заменить $f$ на эквивалентную: $f tilde_(x->+infinity) c/(sqrt(x) ln x)$#v(0.2cm)
$int_10^(+infinity) c/(sqrt(x) ln x) dif x$\ \
$display(cases(reverse: #true,
int_10^(+infinity) 1/sqrt(x) = +infinity\, int^(+infinity) 1/x = +infinity,
lim_(x->+infinity) ln(x)/sqrt(x) = 0,
1/sqrt(x) > 1/(sqrt(x) ln x) > 1/x
)) => int_10^(+infinity) c/(sqrt(x) ln x) dif x$ --- расхдится\ \
+ $int_10^(+infinity) (dif x)/(x^alpha (ln x)^beta)$#v(0.2cm)
+ $alpha > 1:$
$alpha = 1 + 2 a, space a > 0$#v(0.2cm)
$display(1/(x^(1+2a) (ln x)^beta) = 1/(x^(1+a)) dot 1/(x^a (ln x)^beta))$#v(0.2cm)
#emoji.face.wink $lim_(x->+infinity) x^a (ln x)^beta = +infinity =>$ при больших $x: (exists space c: forall x > c: space display(1/(x^a (ln x)^beta) < 1))$ --- но это надо доказать\
Докажем что предел $+infinity$ при помощи правила Лопиталя: $lim_(x->+infinity) (x^a)/((ln x)^(-beta)) = (lim limits((x^(a/(-beta))/(ln x)))_(arrow.br +infinity))^(-beta) = +infinity$#v(0.4cm)
Предел в скобках тоже найдем при помощи правила Лопиталя: $lim (x^gamma)/(ln x) = lim (gamma x^(gamma - 1))/(1/x) = lim gamma x^gamma = +infinity$#v(0.4cm)
$int_10^(+infinity) -> int_c^(+infinity) 1/(x^(1+a)) dot underbracket(1/(x^a (ln x)^beta), <1) < int_c^(+infinity) 1/(x^(1+a))$ --- сходистся $=>$ при $alpha > 1$ интеграл начальный сходиться.#v(0.2cm)
Название только что примененного приёма: _удавить логарифма_) #v(0.2cm)\
+ $alpha < 1:$
$alpha = 1-2a, a > 0$\ #v(0.2cm)
$display(1/(x^(1-a)) dot 1/(x^(-a) (ln x)^beta))$#v(0.2cm)
$display(lim_(x->+infinity) (x^a)/(ln x)^beta) = dots = +infinity$#v(0.2cm)
При $x > c: quad display(1/(x^(-a) (ln x)^beta)) > 1 => display(1/x^(1-a) dot 1/(x^(-a ln x)) > 1/x^(1 - a)) =>$ интеграл расходиться#v(0.4cm)
+ $alpha = 1$:#v(0.2cm)
$display(int_10^(+infinity) (dif x)/(x (ln x)^beta) =_(y=ln x) int_(ln 10)^(+infinity) (dif y)/(y^beta))$ --- это эталонный случай: $beta <= 1$ --- расходится, $space beta > 1$ --- сходится
\
== $Gamma$-функция Эйлера
$Gamma(t) = int_(0)^(+infinity) x^(t - 1) e^(-x) dif x, t > 0$\
+ При $t > 0$ интеграл сходится: $int_0^1 x^(t-1) e^(-x) dif x$, т.к.
$space x^(t-1) e^(-x) tilde_(x->+0) x^(t-1)$ --- эталонный случай (сходиться)\
$display(x^(t - 1) e^(-x) dif x = int_1^(+infinity) e^(-x/2) dot underbracket(e^(-x/2) dot x^(t - 1), -->_(x->+infinity) 0))$\ #v(0.2cm)
то, что выделеная часть стремиться к 0, означает, что $exists space c: forall x > c quad e^(-x/2) x^(t - 1) < 1$ #v(0.2cm)
Получается, что $e^(-x/2) dot underbracket(e^(-x/2) x^(t-1), <1) < e^(-x/2) space$ и нам необходимо проверить сходимость следующего интеграла: #v(0.1cm)
$int_c^(+infinity) e^(-x/2) dif x = -2 e^(-x/2) pole(c, +infinity)$ --- сходиться, значит и изначальный сходиться. #v(0.2cm)\
+ $Gamma$ --- выпукла на $(0, +infinity) => Gamma$ --- непрерывна\
Для начала покажем, что подынтегральная фукнция выпукла:
$t |-> f_x(t) = x^(t-1) e^(-x)$\
Для этого возьмем две производные:\
$f'(t) = x^(t-1) ln x e^(-x)$ #v(0.2cm)
$f''(t) = x^(t-1) ln^2 x e^(-x) >= 0$ --- значит действительно выпукла. #v(0.2cm)
Напишем определение выпуклосьи: $forall t_1, t_2 space forall alpha in (0, 1) quad f_x(alpha t_1 + (1-alpha t_2)) <= alpha f(t_1) + (1-alpha) f_x (t_2)$\ \
Интегрируем это неравенство по
$x :int_0^(+infinity) f_x (alpha t_1 + (1-alpha) t_2) dif x <= alpha int_0^(+infinity) f_x (t_1) dif x + (1-alpha) int_0^(+infinity) f_x (t_2) dif x$\ \
Для понимания происходящего: последнее слагаемое имеет такой вид: $(1-alpha) int_0^(+infinity) x^(t_2 - 1) e^(-x) dif x$ #v(0.2cm)
Итого мы получили, что $Gamma(alpha t_1 + (1-alpha) t_2) <= alpha Gamma(t_1) + (1-alpha) Gamma(t_2)$, а это как раз занчит что #v(0.2cm)
$Gamma$ выпуклая $=> Gamma$ --- непрерывна\ \ \
+
+ $Gamma(t + 1) = int_0^(+infinity) limits(x^t)_f limits(e^(-x))_g' dif x = limits(x^t (-e^(-x)))_(=0) pole(x=0, x=+infinity) + t int_0^(+infinity) x^(t-1) e^(-x) dif x = t dot Gamma (t)$ #v(0.2cm)
+ $Gamma(1) = int_0^(+infinity) e^(-x) = -e^(-x) pole(0, +infinity) = 1$ #v(0.2cm)
+ $Gamma(n+1) = n!, n in NN$ #v(0.2cm)
$Gamma(t+1) = t Gamma(t) => Gamma(t) = Gamma(t+1)/t tilde_(t->0) 1/t$ #v(0.2cm)
+ $Gamma(1/2) = sqrt(pi)$\
#image("19.png", width: 40%)
== Интеграл Эйлера-Пуассона
$I = int_0^(+infinity) e^(-x^2) dif x = 1/2 sqrt(pi)$ #v(0.2cm)
$int_0^(+infinity) e^(-x^2) dif x =_(x=sqrt(y)) int_0^(+infinity) 1/(2 sqrt(y)) dif y = 1/2 Gamma(1/2)$ #v(0.4cm)
#proof #v(0.2cm)
$1-x^2 <= e^(-x^2) <= 1/(1+x^2) quad forall x in RR$ --- левая часть это выпуклость в прямом её виде, правая часть: $1+x^2 <= e^x^2$ #align(right)[--- тоже выпуклость.]\
#image("20.png", width: 20%)
$display(limits(int_0^1 (1-x^2)^n)_(=_(x=cos t) w_(2n+1)) <= int_0^1 e^(-n x^2) <= limits(int_0^(+infinity) e^(-n x^2))_(=_(x=y/sqrt(n)) 1/sqrt(n) I) <= limits(int_0^(+infinity) 1/(1+x^2)^n dif x)_(=_(x=tg t) w_(2n-2)))$\ \
Здесь в качестве $w$ использовался интеграл из формулы Валлиса:\
#box(stroke: 1pt, inset: 7pt, "Формула Валлиса:\n"+$w_n = int_0^(pi/2) sin^n x = display(cases(delim: "[", (n-1)!!/n!! pi/2&\, quad "четн", (n-1)!!/n!!&\, quad "нечет"))$ +"\n\n В частности: "+
$(2k)!!/(2k-1)!! dot 1/sqrt(k) -> sqrt(pi)$)\ \
Итого мы получили:\
$display(w_(2n+1) <= 1/sqrt(n) I <= w_(2n - 2))$ #v(0.4cm)
$display(limits((2n)!!/(2n+1)!!) sqrt(n) <= I <= (2n-3)!!/(2n-2)!! pi/2 sqrt(n) = 1/((2n-2)!!/(2n-3)!! 1/sqrt(n-1)) dot (pi/2)/(sqrt(n-1)/sqrt(n)) -> sqrt(pi)/2)$#v(0.4cm)
$display((2n)!!/((2n-1)!! sqrt(n)) n/(2n+1) -> sqrt(pi))$\ \
== Абсолютно сходящиеся интегралы
#def абсолютно сходящийся интеграл\
$f$ --- допустимая на $[a, b)$ #v(0.2cm)
$int_a^b f$ абсолютно сходится $<=>
display(cases(int_a^b f - "сходится", int_a^b abs(f) - "сходится" ))$
\ \
#th\
$f$ --- допустимая на $[a, b)$. Тогда эквивалентны:
+ $int_a^b f$ --- абсолютно сходиться
+ $int_a^b abs(f)$ --- сходится
+ $int_a^b f_+, int_a^b f_-$ оба сходятся
#v(0.2cm)
#proof
$1=>2$: Да. #emoji.face.cool\
#v(0.2cm)
$2=>3$: $0 <= f_plus.minus <= abs(f)$\
#v(0.2cm)
$3=>1$: $int_a^b f = int_a^b f_+ - int_a^b f_-, quad int_a^b abs(f) = int_a^b f_+ + int_a^b f_-$\
*Замечание:*\ #v(0.2cm)
$int_a^b f$ сходится $arrow.r.double.not f -->_(x->b-0) 0$\ #v(0.4cm)
*Пример:*\ #v(0.2cm)
$sum_(n=1)^(+infinity) 1/2^n = 1$
#image("21.png", width: 30%)
Можно подобрать ширину так, чтобы высота $n$-го треугольника $=n!$, площадь $=1/2^n$ и получиться кусочно непрерывная функция, у которой сходящийся интеграл, но которая при этом не стремиться к 0 и даже не ограничена.
#pagebreak()
*Продолжаем абсолютно сходящиеся интегралы* \ \
*Пример:*\ #v(0.2cm)
$int_1^(+infinity) (sin x)/x^p dif x, quad p in RR$ --- изучим абсолютную сходимость\ #v(0.2cm)
1\. $abs((sin x)/x^p) <= 1/x^p quad => space $ при $p > 1$ сходится абсолютно
\ \
2\. При $p < 0 quad int_(2 pi n)^(2 pi n + pi) (sin x)/x^p >= (2 pi n)^(-p) int_(2 pi n)^(2 pi n + pi) sin x >= 2 ( 2 pi n)^(-p)$ расходится (в т.ч. абс. расх.)\ \
3\. При $p = 0$ тоже расходится: $abs(int_(A^n)^(B_n) sin x) > 1/1000, quad A_n = 2pi n, B_n = 2pi n+pi, A_n, B_n -> +infinity$\ \
4\. $int_1^(+infinity) abs(sin x)/x^p dif x, quad p in (0, 1] tilde.triple int_1^(+infinity) 10^(-6)/x^p dif x$ расходится\ \
$int_(pi n)^(2 pi n) abs(sin x)/x^p >= int_(pi n)^(2 pi n) abs(sin x)/x dif x >= 1/(pi n) int_(pi n)^(2 pi n) abs(sin x) dif x = 2/pi$ --- нет абс сходимости
\ \ \ \
#image("22.png", width: 50%)
$int_(2 pi n)^(2 pi n + pi) 1/x^p sin x + int_(2 pi n + pi)^(2 pi n + 2 pi) 1/x^p sin x$\ \ $y = x - pi$ \ \
$int_(2 pi n)^(2 pi n + pi) (sin x)/x^p - int_(2 pi n)^(2 pi n + pi) (sin y)/(y+pi)^p sin x$\ \
$int_(2 pi n)^(2 pi n + pi) sin x(1/x^p - 1/((x+pi)^p))$\ \
$int_1^(+infinity) (sin x)/x^p = display(mat(delim: "[", f=1/x^p, g' = sin x))=-(cos x)/x^p pole(1, +infinity) - p underbracket(display(int)_1^(+infinity) (cos x)/x^(p+1), "абс. сх.")$\ \
$int_1^(+infinity) abs(sin x)/x^p >=_(wink) int_1^(+infinity) (sin^2x) / x^p = int_1^(+infinity) (1 - cos 2 x)/(2 x^p) d x = underbracket(int_1^(+infinity) 1/(2 x ^p), =+infinity) - underbracket(int_1 ^(+infinity) (cos 2 x)/(2x^p), "сх")$
\ \
// Я НИХРЕНА НЕ ПОНЯЛ, поэтому временно этот интеграл отправляется в
== Признаки сходимости
#th (_признак Дирихле_)\ #v(0.2cm)
$f, g$ --- допустимы на $[a, b)$\ #v(0.2cm)
Пусть: #v(0.2cm)
1\. первообразная $f$ ограничена: $exists C: forall B in (a, b) quad abs(int_a^B f) <= C$
#v(0.2cm)
2\. $g(x)$ --- монотонная, $g in C^1 ([a, b]), quad g(x) -->_(x->b-0) 0$ #v(0.2cm)
Тогда $int_a^(->b) f g$ --- сходится\
\
#proof
Обозначим $F(B) = int_a^B f$ --- первообразная.\
$int_a^b f g = underbracket(F(x) g (x) pole(a, ->b), "огр" dot "б.м.") - underbracket(int_a^(->b) F(x) g'(x) dif x, "абс. сх.": int_a^(->b) abs(F(x)) dot abs(g'(x)) dif x <=\ <= C int_a^(->b) abs(g') dif x = plus.minus C int_a^(->b) g' dif x =\ = plus.minus g(x) pole(a, ->b))$ #v(0.2cm)
Тут в оценке у второго интеграла мы воспользовались тем что, $g(x)$ --- монотонная, поэтому $g'(x)$ всегда одного знака и модуль может раскрыться только двумя способами.
\ \
#th (_<NAME>_)\ #v(0.2cm)
$f, g$ --- допустимые на $[a, b)$\ #v(0.2cm)
Пусть:
#v(0.2cm)
1\. $int_a^(->b) f$ --- сходится
#v(0.2cm)
2\. $g in C^1 ([a, b]), g(x)$ монотонна, ограничена
#v(0.2cm)
Тогда $int_a^(->b) f g$ сходится.
\ \
#proof #v(0.2cm)
Пусть $lim_(x->b-0) g(x) = alpha in RR$\ #v(0.2cm)
$int_a^(->b) f g = underbracket(int_a^(->b) f alpha, "сх по п.1") + underbracket(int_a^(->b) f (g-alpha), "сх по Дирихле")$
\ \
*Пример:*\ #v(0.2cm)
$int_1^(+infinity) (sin x)/x^p: quad f = sin x quad F = cos x$ --- огр. $quad g = 1/x^p, space p > 0 =>$ монот, $->0 -->$ сх по Дирихле\ \
$int_10^(+infinity) sin(x^3 - x) dif x: quad underbracket(f = (3 x^2 - 1) sin(x^3 - x), F = -cos(x^3-x) - "огр.") , quad underbracket(g = (1)/(3x^2 - 1), "монот"\,space ->0) =>$ сходится\ \
== Интеграл Дирихле
$display(int_0^(+infinity) (sin x)/x dif x = pi/2)$\
Для начала покажем, что:
$display(cos x + cos 2 x + dots + cos n x = (sin (pi + 1/2) x)/(2 sin x/2) - 1/2)$\ \
*Напоминание из тригонометрии:* $space cos(alpha) sin(beta) = 1/2 (sin(alpha + beta) - sin(alpha - beta))$\ \
$2 sin x/2 cos k x = sin (k+1/2)x - sin((k-1/2)x)$\ \
Получается телескопическая сумма, и после сокращения всего получисться верное равенство.\ \
Теперь проинтегрируем обе части :
$space display(0 = int_0^pi cos x + dots + cos n x = int_0^pi (sin(n + 1/2)x)/(2sin x/2) dif x - pi/2)$#v(0.2cm)
Переносим $pi/2$ в другую сторону:
$display(int_0^pi (sin(n+1/2)x)/(2sin x/2) dif x = pi/2)$\ \
Проверим, что $display(int_0^pi (sin (n+1/2)x)/(2sin x/2) - int_0^pi (sin(n+1/2) x)/(x)) -->_(n -> +infinity)0$ #v(0.2cm)
Если это выполняется, то $display(int_0^pi ((sin n + 1/2)x) / x -> pi/2 = int_0^((n + 1/2)pi) (sin y)/y dif y -> int_0^(+infinity) (sin y)/y)$
\ \
*Утверждение.* Функция $f(x) = display(1/(2 sin x/2) - 1/x)quad $ (пусть $f(0) = 0$) чтобы была непрерывность на $RR$)\
$display(f' = (-cos x/2)/(2^2 dot sin^2 x/2) + 1/x^2), quad x != 0$\ \
$display(lim_(x->0) f' = lim_(x->0) (4 sin^2 x/2 - x^2 cos x/2)/(4 x^2 sin^2 x/2) = lim_(x->0) (4(x/2 - x^3/48 + o(x^3))^2 - x^2 (1-x^2/8 + o(x^2)))/x^4 = -1/12 + 1/8) quad smile$\ \
$display(int_0^pi limits(sin(n+1/2) x)_g' dot limits(f(x))_f dif x = underbracket(-(cos(n+1/2)x)/(n+1/2) dot f(x)pole(0, pi), = space 0) + 1/(n+1/2) underbracket(int_0^pi underbracket(cos(n+1/2) x underbracket(f'(x), "непр"), "непр") dif x, <= "const") -->_(n->+infinity)0)$
#image("23.png", width: 35%)\ \
== Интегрирование ассимптотических разложений
*Напоминание:*#v(0.2cm)
$phi_k: (a, b) -> RR$\ \
$underline(x -> a) quad forall k quad phi_(k+1) = o(phi_k)," тогда при " x->a quad {phi_k}$ --- шкала асимпт. разложения\ \
$forall n space f = c_0 phi_0 (x) + c_1 phi_1 (x) + dots + c_n phi_n (x) + o(phi_n)$\ \
Пример --- формула Тейлора: $f(x) = sum_(k=0)^n (f^((k)) (a))/k! (x-a)^k + o((x-a)^n)$\ \
$f tilde sum_(k=0)^(+infinity) c_k phi_k (x)$\ \
$g tilde sum_(k=0)^(+infinity) c_k phi_k (x)$\ \
$forall n quad f - g = o(phi_n), n -> +infinity$\ \
\
#lm (_об интегрировании асимптотических равенств_)\
$f, g in C([a, b)), quad g >= 0, int_a^(->b) g$ расх\
$F(x) = int_a^x f, quad quad $
$G(x) = int_a^x g$\
Тогда при $x -> b-0$ из соотношений #v(0.2cm) #h(1.5cm)$f = O(g),#h(10pt)f = o(g),#h(7pt)f tilde g$#v(0.2cm) следует $F = O(G), space F = o(G), F space tilde G $
\ \
#proof #v(0.2cm)
1\. $F = O(G):$ #v(0.2cm)
$exists M space exists x_0$ при $x in [x_0, b) quad abs(f(x)) <= M g(x)$\ \
Чего мы хотим? Мы хотим похожее неравенство на интегралы: $int_a^x f <= mu dot int_a^x g$ //quad int_(x_0) ^x int_a ^ (x_0 f)$
#v(0.2cm)
Пусть $int_a^(x_0) abs(f) dif x = c_1. quad$ Возьмём $x_1: x_0<x_1<b quad quad int_(x_0)^(x_1) g = alpha > 0$\ \
При $x > x_1 quad abs(int_a^x f) <= int_a^x abs(f) = int_a^(x_0) + int_(x_0)^x <= c_1 + M dot int_(x_0)^x g = c_1 / alpha int_(x_0)^(x_1) g + M int_(x_0)^(x_1) g <= (c_1/alpha + M) int_(x_0)^x g <= (c_1/alpha + M) int_a^x g$
\ \
2\. $F = o(G):$\ #v(0.2cm)
$display(forall epsilon > 0 quad exists x_0: abs(x_0) < epsilon/2 g(x))$\ \
Хотим: $display(forall epsilon > 0 quad exists x_0: abs(int_(x_0)^x f) <= epsilon/2 int_(x_0)^x g)$\ \
$exists x_1 > x_0 quad$ для $с:= int_a^(x_0) f$ при $x > x_1 quad abs(c + int_(x_1)^x) <= epsilon int_(x_0)^x g$\ \
$abs(int_(x_1)^x f) < epsilon/2 int_(x_1)^x g$\ \
$int_a^B -->_(B->b-0) +infinity$\ \
$c < epsilon/2 int_(x_0)^x g$\ \
$abs(int_a^(x_0) f) <= epsilon int_(x_0)^x g <= epsilon int_a^x g$ при $x > x_1$
\ \
3\. $f tilde g$\ \
$lim_(x->b-0) F(x)/G(x) = [infinity/infinity] =^"Лопиталь" lim_(x->b-0) f(x)/g(x) = 1$
\ \ \
#lm\
1. $phi_n in C([a, b]) space phi_n >= 0$ --- шкала асимптотического разложения при $x -> b-0$ \ \
Пусть $forall n quad Phi_n (x) = int_(x)^(->b) phi_n (x)dif x$ --- сходится, тогда $Phi_n$ --- тоже шкала\
+ $f in C([a, b]) quad F(x) = int_x^b f$ --- сходится\
Пусть $f(x) tilde sum c_n phi_n (x)$\ #v(0.2cm)
Тогда $F tilde sum c_n Phi_n$
\
#proof #v(0.2cm)
+ Проверим, что $Phi_(n+1) = o(Phi_n): quad display(lim_(x->b-0) (Phi_(n+1) (x))/(Phi_n (x)) = [0/0] =^"Лопиталь" lim_(x->b-0) (-phi_(n+1))/(-phi_n) = 0)$\ #v(0.3cm)
+ $f(x) = sum_(k=1)^n c_k phi_k (x) + o(phi_n)$\ #v(0.3cm)
$display(lim (F(x) - sum_(k=1)^n c_k Phi_k)/Phi_n = [0/0] =^"Лопиталь" lim (f(x)-sum c_k phi_k (x))/(phi_n (x)) = 0)$\ \
*Пример:*\
$arctan x tilde_(x->+infinity) ?$\ #v(0.2cm)
При дифференцировании:\ #v(0.2cm)
$display(1/(x^2 + 1) tilde 1/x^2)$\ \
$display(pi / 2 - arctan x = int_x^(+infinity) (dif t)/(t^2 + 1) tilde int_x^(+infinity) (dif t)/t^2 = 1/x)$\ \
$display(arctan x = pi/2 - 1/x + o(1/x))$\ \
II способ:\ \
$display(1/(x^2 + 1 )= 1/x^2 dot 1/(1+1/x^2) = 1/x^2 - 1/x^4 + 1/x^6 - 1/x^8 + dots)$ --- ряд Тейлора \ \
Проинтегрируем и получим:
$display(pi/2 - arctan x = 1/x - 1/(3x^3) + 1/(5 x^5) - dots)$\
#pagebreak()
= Ряды
//я открываю для себя #strike()[чужие гитхабы] новые главы // открыты для #strike()[код-ревью от Корнеева] изучения
#align(center)[$(a_k)$ --- вещественная последовательность\ \ $a_1 + a_2 + a_3 + dots $ --- ряд]\
#align(center)[$sum_(k=1)^(+infinity) a_k$ --- ряд в другой записи] \
#align(center)[$forall n space S_n = a_1 + a_2 + dots + a_n$ --- частичная сумма ряда]\
Рассмотрим предел:
$ lim_(n->=infinity) S_n $
Если предел существует и равен $S in overline(RR)$, то $S$ --- сумма ряда\
- $S in RR:$ ряд сходится
- $S in {-infinity; +infinity}:$ ряд расходится\
Если предел не существует, то ряд расходится\ \
*Замечание:*\ #v(0.3cm)
$S_n - S_(n-1) = a_n$
\ \
*Примеры рядов:*\ #v(0.3cm)
+ Ряд, состоящий из нулей: $sum_(k=1)^(+infinity) 0 = 0$ --- сходится к 0 #v(0.3cm)
Ряд, состоящий из единиц: $sum_(k=1)^(+infinity) 1 = +infinity$ --- расходится #v(0.3cm)
Ряд, состоящий из чередующихся единиц и минус единиц: $sum_(k=0)^(+infinity) (-1)^k$ --- расходится\ \
+ Геометрическая последовательность: $sum_(k=0)^(+infinity) q^k = 1/(1-q) quad abs(q) < 1$\ #v(0.3cm)
$S_n = 1 + q + q^2 + dots + q^n = (q^(n+1) - 1)/(q-1) -->_(n->+infinity) 1/(1-q)$\ \
+ $1 + 1/1! + 1/2! + dots = e$\ #v(0.3cm)
$sum_(k=0)^(+infinity) 1/k! x^k = e^x$ --- чтобы это доказать распишем формулу Тейлора для
$e^x$ в $x_0 = 0:$\ #v(0.3cm)
#align(right)[$e^x = sum_(k=0)^n display(1/k! x^k + underbracket(e^c/(n+1)! x^(n+1), ->0))$]
+ $sum_(k=1)^(+infinity) 1/(k^alpha), quad alpha > 0$\ #v(0.3cm)
$sum_(k = 1)^(+infinity) 1/k^alpha = 1/(1-alpha) (1/(n^(alpha - 1)) - 1) + 1/2 dot 1/n^alpha + 1/2 + underbracket(O(max(1, dots)), = O(1))$\ #v(0.3cm)
При $alpha <= 1 quad$ ряд расходится\ #v(0.2cm)
При $alpha > 1$ ряд сходится\ #v(0.2cm)
#columns(2)[
#def $n$-й остаток ряда\ #v(0.3cm)
$sum_(k=n)^(+infinity)$ --- $n$-й остаток ряда\ \
#colbreak()
_Соглашение:_ \
$sum a_k$ --- будем называть рядом $A$\
$sum b_k$ --- будем называть рядом $B$
]
*Свойства:*\
- $sum a_k, space sum b_k, space c_n = a_n + b_n => sum c_k = sum a_k + sum b_k$
- $sum a_k$ сходится, $lambda in RR$ Тогда $sum_(k=1)^n lambda a_k$ сходится, $sum lambda a_k = lambda sum a_k$
-
- $sum a_k$ сх $=>$ любой остаток тоже сходится
- Если $k$-й остаток ряда сходится $=>$ сам ряд сходится
- $r_n = sum_(k=n)^(+infinity) a_n, space $ ряд сходится $<=> r_n -> 0$\ #v(0.3cm)
#proof
а) ($m$-й ост.) $n > m$\ #v(0.3cm)
$sum_(k=1)^n a_k = sum_(k=1)^m a_k + sum_(k=m+1)^n a_k$\ #v(0.3cm)
$sum_(k=1)^(+infinity) a_k = sum_(k=1)^m a_k + sum_(k=m+1)^(+infinity) a_k$\ #v(0.3cm)
б) Очевидно\ #v(0.3cm)
в) $=>: sum_(k=1)^(+infinity) a_k = limits(S_m)_(->sum_(k=1)^(+infinity) a_k) + limits(r_(m+1))_(->0)$\ #v(0.3cm)
#h(0.4cm) $arrow.l.double:$ тривиально
\
#columns(3)[
#strike()[*нано*]#th (_о граблях_):\ #v(0.3cm)
$sum a_n$ --- сходится, тогда $a_n ->0$
#colbreak()
#proof #v(0.3cm)
$a_n = S_n - S_(n-1) -->_(n->+infinity) 0$
#colbreak()
*Пример:*\ #v(0.3cm)
$alpha in (0, pi): sum sin n alpha$ --- расх, т.к. \ #v(0.3cm) #h(2.4cm)$sin n alpha arrow.not_(n->+infinity) 0$]
*Грабли:*\ #v(0.3cm) $sum 1/n, quad 1/n ->0 quad$ _Значит, эээ..., ничего, показалось._\ \
// кста не гуглится
//грабли
//а ну кажется очев. это личный термин Кохася
\
*<NAME>-Коши:* \ #v(0.3cm) ряд сходится $<=> forall epsilon > 0 quad exists N: forall n > N quad forall m in NN quad abs(S_n - S_(n+m)) < epsilon$\ #v(0.3cm)
#h(2.15cm) $abs(a_(n+1) + a_(n+2) + dots + a_(n+m)) < epsilon$\ #v(0.3cm)
ряд расходится $<=> exists epsilon > 0: forall N quad exists n > N, exists m: abs(a_(n+1) + a_(n+2) + dots + a_(n+m)) >= epsilon$
\ #v(0.3cm)
#h(0.0cm) *Пример:*\ #v(0.3cm) $1/(n+1) + 1/(n+2) + dots + 1/(n+n) >= n dot 1/(2n) = 1/2$\ #v(0.3cm)
$sum_(k=1)^n 1/(n+k) = sum 1/n dot 1/(1+k/n) -> int_0^1 1/(1+x) dif x = ln(1+x) pole(0, 1) = ln 2$\ #v(0.2cm)
Здесь мы воспользовались суммами Риманна: $sum 1/n f(k/n) -> int_0^1 f(x) dif x$
= Сходимость неотрицательных рядов
#lm\ #v(0.2cm)
$a_n >= 0$. Тогда $sum a_n$ --- сходится $<=> S_n^((a))$ --- ограничена #v(0.2cm)
#proof #v(0.2cm)
$S_n^((a)) = sum_(k=1)^n a_k$ --- возрастает\
$S_n$ --- ограничена и монотонна $=> exists$ кон $lim S_n$\
$ exists$ кон $lim S_n => S_n$ --- ограничена.
\ \
#th (_признак сравнения_)\ #v(0.2cm)
$forall a_k, forall b_k, quad a_k, b_k >= 0$\ #v(0.2cm)
+ $forall n quad a_n <= b_n$ (или даже $forall k > 0: forall n quad a_n <= k b_n$)\ #v(0.2cm)
Тогда $display(cases(sum b_k "сх" => sum a_k "сх", sum a_k "расх" => sum b_k "расх")) quad (*)$ #v(0.2cm)
+ Пусть $lim_(n->+infinity) a_n/b_n = l in [0, +infinity)$\ #v(0.2cm)
- $0 < l < infinity quad sum a_k$ сх $<=> sum b_k$ сх\ #v(0.2cm)
- $l = 0 quad "выполняется " (*)$\ #v(0.2cm)
- $l = +infinity quad display(cases(sum a_k "сх" => sum b_k "сх", sum b_k "расх" => sum a_k "расх"))$ #v(0.2cm)
// Эталонные ряды:\
// $sum 1/n^alpha quad display(cases(alpha > 1 &quad "сх", alpha <= 1 &quad "расх"))$\ \
// $sum q^n quad display(cases(0 < q > 1 &quad "сх", q >= 1 &quad "расх"))$\
// Попытаемся заменить на эквивалентный ряд:\
// $sum_(n=1)^(+infinity) (sqrt(n) arctan n)/(n^2 + sin^2 n)$\
// $a_n tilde (c sqrt(n))/n^2 = c/n^1.5$
+ Пусть начиная с некоторого места $(exists N_0 quad forall n > N_0)$ $a_(n+1)/a_n <= b_(n+1)/b_n$\
Тогда выполняется $(*)$
#proof
+ $S_n^((a)) <= S_n^((b))$ при всех $n quad (S_n^((a)) <= k S_n^((b)))$\ #v(0.2cm)
- $sum b_n$ сх $=> S_n^((b))$ огр $=> S_n^((a))$ огр $=> sum a_n$ сх\ #v(0.2cm)
- $sum a_n$ расх $=> S_n^((a))$ --- не огр $=> S_n^((b))$ --- не огр $=> sum b_n$ --- расх
*Замечание:* Можно быдо бы в условии $a_n <= b_n$ начиная с некоторого места \
*Соглашение:* фразу "начиная с некоторого места" будем обозначать абривеатурой НСНМ
#v(0.2cm)
+ $l in (0, +infinity):$\ #v(0.2cm)
- Для $epsilon = l/2 quad exists N: forall n > N: quad 0 < l/2 < a_n/b_n < 3/2 l space <=> space a_n < 3/2 l b_n,space b_n < 2/l l a_n$ \ #v(0.2cm)
Теперь использую первое утверждение мы получаем что $sum a_k$ сх $<=> sum b_k$ сх#v(0.2cm)
- $l = +infinity:$\ #v(0.2cm)
$exists N: forall n > N quad a_n/b_n > 1 =>a_n > b_n$ --- здесь опять используем первое утверждение и победа\ #v(0.2cm)
- $l = 0:$\ #v(0.2cm)
$exists N: forall n > N quad a_n/b_n < 1$ --- аналогично предыдущему пункту #v(0.2cm)
+ Пишем неравенства при $n = N_0 + 1, n + 1, dots, n+k-1:$\ #v(0.2cm)
$display(cases(reverse:#true,
a_(n+1)/a_n <= b_(n+1)/b_n,
a_(n+2)/a_(n+1) <= b_(n+2)/b_(n+1),
dots,
a_(n+k)/a_(n+k-1) <= b_(n+k)/b_(n+k-1)
)) => ^("перемножаем") space a_(n+k)/a_n <= b_(n+k)/b_n => a_(n+k) <= a_n/b_n b_(n+k)$ --- выполено замечание к I пункту\ \ \
*Пример:*\ #v(0.2cm)
*Эталонные ряды:*\ #v(0.2cm)
#box(stroke: 1pt, inset: 7pt, $sum 1/n^alpha quad display(cases(alpha > 1 &quad "сх", alpha <= 1 &quad "расх"))$+"\n\n"+ $sum q^n quad display(cases(0 < q > 1 &quad "сх", q >= 1 &quad "расх"))$)
#v(0.4cm)
- Исследуем $sum_(k=1)^(+infinity) k^2024 e^(-k)$\ #v(0.2cm)
Попробуем доказать, что $k^2024 e^(-k) < 1/k^2$ при больших $k$\ #v(0.2cm)
То есть нужно проверить (после домножения на $k^2$): $display(k^2026/e^k < 1?)$\ #v(0.2cm)
$lim k^2026/e^k = (lim k/e^(k/2026))^2026 =^"Лопиталь" (lim 1/e^(k/2026) 2026)^2026 = 0 =>$ НСНМ то что мы пытались доказать верно. #v(0.2cm)
Теперь исползьуем первый пункт предыдущей теоремы и первый эталонный ряд --- победа\ \
- $sum_(k=1)^(+infinity) e^(-sqrt(k))$\ #v(0.2cm)
Перепишем эталоны:\ #v(0.2cm)
$sum e^(-alpha ln k), sum e^(k ln q)$\ #v(0.2cm)
НСНМ $e^(-sqrt(k)) < 1/k^2 <=> e^overbrace(-sqrt(k) + 2 ln k, ->-infinity) < 1$. Числитель стремится к бесконечности, т.к.
$lim sqrt(k)/(ln k) = +infinity$\ #v(0.2cm)
Используем то же что и в предыдущем пункте --- победа\ \
#th (_признак Коши_)\
$sum a_n, space a_n >= 0, quad K_n := root(n, a_n)$\ #v(0.2cm)
*light:* #v(0.1cm)
+ $exists space q < 1 quad K_n <= q space $ НСНМ, тогда $sum a_n $ сх #v(0.2cm)
+ $K_n >= 1$ для беск. мн-ва $n$, тогда $sum a_n$ расх
*pro:* #v(0.1cm)
$K := limsup K_n = limsup root(n, a_n)$\ #v(0.2cm)
+ $K > 1 quad sum a_n$ расх #v(0.2cm)
+ $K < 1 quad sum a-n$ сх
*Замечание:* Для рядов $sum 1/n, sum 1/n^2 quad K = lim root(n, 1/n) = 1$, но при этом первый ряд расходится, а второй сходится
$=> "при" K = 1$ признак не работает #v(0.2cm)
#proof
+
+ $K_n <= q => root(n, a_n) <= q => a_n <= q^n "а значит" space sum limits(q^n)_((q < 1))$ сх $=> sum a_n$ сх #v(0.2cm)
+ $K_n >= 1 quad a_n >= 1$ для беск мн-ва номеров $=> a_n arrow.not 0 =>$ расходится #v(0.3cm)
+
+ $K > 1 quad limsup K_n > 1 => exists$ беск много $n: K_n > 1$ (техн. описание верхнего предела) $ => #v(0.2cm) sum a_n$ расх #v(0.2cm)
+ $K < 1 quad exists N_0: forall n > N_0 quad K_n <= q$, где $q in (k, 1)$ --- тоже техн. описание верхнего предела. #v(0.2cm)
*Пример:*\ #v(0.2cm)
$sum k^2024 e^(-k)$\ \
$root(k, k^2024 e^(-k)) = k^(2024/k) 1/e = underbrace(e^(2024/k ln k), -> 1) 1/e -> 1/e < 1$\ \
#th (_п<NAME>_)\ #v(0.2cm)
$sum a_n, a_n > 0 quad D_n := a_(n+1)/a_n$\ #v(0.2cm)
*light:*\ #v(0.2cm)
+ $exists space q < 1 quad D_n <= q space$ НСНМ. Тогда $sum a_n$ сх #v(0.2cm)
+ $D_n >= 1$ НСНМ. Тогда $sum a_n$ расх #v(0.2cm)
*pro:* Пусть $exists lim_(n->+infinity) D_n = D$ #v(0.2cm)
+ $D < 1 quad sum a_n$ сх #v(0.2cm)
+ $D > 1 quad sum a_n$ расх #v(0.2cm)
*Замечание:* $sum 1/n, sum 1/n^2 quad D=1 frown$\ #v(0.3cm)
#proof
+
+ НСНМ $a_(n+1)/a_n <= q quad a_(n+1) <= q a_n$\
$display(cases(reverse:#true, a_(n+1) <= q a_n,
a_(n+2) <= q a_(n+1),
dots.v,
a_(n+k) <= q a_(n+k - 1))) => a_(n+k) <= q^k a_n => sum_(k=1)^(+infinity) a_(n+k)$ --- сходится\
2. НСНМ $a_(n+1) >= a_n$, т.е. $a_n arrow.not 0$ --- расходится #v(0.3cm)
+
+ $D < 1 quad$ НСНМ $D_n <= q <1 => sum a_n$ сх --- первый пункт light #v(0.2cm)
+ $D > 1 quad$ НСНМ $D_n >= 1 => sum a_n$ расх --- второй пункт light #v(0.2cm)
*Пример:* #v(0.2cm)
- $sum k^2024 e^(-k)$\ #v(0.2cm)
$lim ((k+1)^2024 e^(-(k+1)))/(k^2024 e^(-k)) = 1/e < 1$\ #v(0.3cm)
- $sum e^(-sqrt(k))$\ #v(0.2cm)
$e^(-1/sqrt(k)) -> 1$\ \
= Функциональные последовательности и ряды. Равномерная сходимость последовательности функций
#def поточечная сходимость\ #v(0.2cm)
$f_n, f_0: E subset X --> RR$\ #v(0.2cm)
Последовательность $f_n$ сходится поточечно на $E$ к $f_0$\ #v(0.2cm)
$f_n -->_(n->+infinity) f_0$ на $E <=> forall x in E quad lim_(n->+infinity) f_n (x) = f_0 (x)$\ #v(0.2cm)
$forall x in E quad forall epsilon > 0 quad exists N: forall n > N quad abs(f_n (x) - f_0 (x)) <epsilon$\ #v(0.2cm)
*Пример:*\ #v(0.2cm)
+ $f_n: [0, +infinity) --> RR, quad f_n (x) = x^n/n$\ #v(0.2cm)
Если $E subset (0, 1] quad f_n (x) -> f_0 (x) equiv 0$ на мн-ве $E$\ #v(0.2cm)
Если же $E sect (1, +infinity) != emptyset =>$ поточечной сходимости нет т.к. значения $f_n ->_(n, x->+infinity) + infinity$#v(0.2cm)
+ $f_n (x) = (n^alpha x)/(1+n^2 x^2), quad 0 < alpha < 2, x in [0, 1]$\ #v(0.2cm)
при $x in [0, 1] quad f_n (x) -> f_0 (x) equiv 0$\ #v(0.2cm)
$wink max f_n = ? quad f'_n = n^alpha (1 + n^2 x^2 - x n^2 2x)/((1 +n^2 x^2)^2) = 0 => n^2 x^2 = 1 => x = 1/n$\ #v(0.2cm)
$max f_n = f_n (1/n) = (n^alpha 1/n)/(1+1) = n^(alpha-1)/2 -->^(alpha > 1)_(n->+infinity) +infinity$
#columns()[#image("24.png", width: 50%)
#colbreak()
Итого мы получили последовательнсоть фукнций которая поточечно сходиться к тождественному 0, но при этом при $n-> +infinity$ её максимальное значение $->+infinity$.\
Почему она поточечно сходитсья?\
С точки зрения графика джля каждой точки будем ждать когда $n$ станет настолько большим, что этот "гребень" окажется сильно левее нее, а значение соответственно в нашей точке будет стремится к 0.
]\
#def равномерная сходимость\ #v(0.2cm)
$f, f_n: X --> RR, E subset X$\ #v(0.2cm)
$f_n$ равномерно сх-ся к $f$ на мн-ве $E$, обозначается:$ space f_n arrows_(n->+infinity) f$ на мн-ве $E$\ #v(0.1cm)
$M_n := sup_(x in E) abs(f_n (x) - f(x)) -->_(n->+infinity) 0$\ #v(0.2cm)
$forall epsilon > 0 quad exists N = N(epsilon): forall n > N quad forall x in E quad abs(f_n (x) - f(x)) <= epsilon$\ #v(0.4cm)
*Замечание:* Если $f_n arrows f$ на $E$, то $forall x in E quad f_n (x) -> f(x)$, т.е. $f_n -> f$ поточечно\ #v(0.4cm)
*Пример:*\ #v(0.2cm)
+ $f_n: [0, +infinity) --> RR, quad f_n (x) = x^n/n$\ #v(0.2cm)
Мы уже выяснили, что: $E subset (0, 1] quad f_n (x) -> f_0 (x) equiv 0$ на мн-ве $E$\ #v(0.2cm)
Проверим, есть ли равномерная сходимость: $ f_n arrows^? f_0 equiv 0$\ #v(0.2cm)
$M_n := limits(sup)_(x in E) x^n/n <= 1/n -> 0 =>f_n arrows f_0 equiv 0 $\ #v(0.2cm)
+ $f_n (x) = (n^alpha x)/(1+n^2 x^2), quad 0 < alpha < 2, x in [0, 1]$\ #v(0.2cm)
при $x in [0, 1] quad f_n (x) -> f_0 (x) equiv 0$\ #v(0.2cm)
Есть ли равномерная сходимость?\ #v(0.2cm)
$M_n := display(limits(sup)_(x in [0, 1]) (n^alpha x)/(1+n^2 x^2) = n^(alpha-1)/2) => display(cases(alpha >= 1 => M_n arrow.not 0 &quad "нет равномерной сходимости", alpha < 1 &quad "есть равномерная сходимость"))$\ #v(0.2cm)
#columns(2)[
#image("25.png", width: 60%)
#colbreak()
#image("26.png", width: 60%)
]\
*Замечание:* $f_n arrows f$ на $E, E_0 subset E$ Тогда $f_n arrows f$ на $E_0$\ #v(0.2cm)
*Замечание:* $cal(F) = {f : X --> RR, f "огр"}$\ #v(0.2cm)
$f_1, f_2 in cal(F) quad rho(f_1, f_2) = limits(sup)_X abs(f_1 - f_2)$ --- это метрика #v(0.2cm)
+ $rho >= 0, rho = 0 <=> f_1 = f_2$ --- очевидно #v(0.2cm)
+ $rho(f_1, f_2) = rho(f_2, f_1)$ --- очевидно #v(0.2cm)
+ $rho(f_1, f_2) <= rho(f_1, f_3) + rho(f_2, f_3)$ #v(0.2cm)
#proof
Напишем определение $sup$: #v(0.2cm)
$forall epsilon > 0 quad exists x: underline(rho(f_1, f_2) - epsilon) <= abs(f_1 (x) - f_2 (x)) <= abs(f_1 (x) - f_3 (x)) + abs(f_3 (x) - f_2 (x)) <= underline(rho(f_1, f_2) + rho(f_3, f_2))$ #v(0.2cm)
Получили ровно то, что хотели: $rho(f_1, f_2) <= rho(f_1, f_3) + rho(f_2, f_3) + epsilon$ \ \
#th (_Стокса-Зайделя_)\ #v(0.2cm)
$f_0, f_n: X --> RR, X$ --- МП, $c in X, f_n$ непр в точке $c$, $f_n arrows f_0$ на $X$, тогда $f_0$ непр в точке $c$ #v(0.3cm)
#proof #v(0.2cm)
$abs(f_0 (x) - f_0 (c)) <= ["берём любое " n] <= underbrace(abs(f_0 (x) - f_n (x)), <epsilon "по" (*)) + abs(f_n (x) - f_n (c)) + underbrace(abs(f_n (c) - f_0 (c)), <epsilon "по" (*)) <=^? 3epsilon$\ #v(0.1cm)
Только что сверху мы дважды написали неравенство треугольника / одно неравенство ломаной, кому как удобнее
#v(0.2cm)
$f_n arrows f_0: forall epsilon > 0 quad exists N: forall n > N quad sup abs(f_n (x) - f_0 (x)) < epsilon quad (*)$\ #v(0.2cm)
Фиксируем любое такое $n$\ #v(0.2cm)
$f_n$ непрерывна $ <=> forall epsilon > 0 quad exists U(c): forall x in U(c) quad abs(f_n (x) - f_n (c)) < epsilon$\ #v(0.2cm)
Подставим это в неравенство с ? которое мы хотелипрвоерить: #v(0.2cm)
$forall epsilon > 0 quad exists U(c): forall x in U(c) quad abs(f_n (x) - f_n (c)) <= 3epsilon$ --- непрерывность $f_0$ в точке $c$\ \
#cor()\ #v(0.2cm)
$f_n in C(X), f_n arrows f_0$ Тогда $f_0 in C(X)$\ \
*Замечание:*\ #v(0.2cm)
+ Теорема верна в топологическом пространстве с тем же доказательством
+ Для непрерывности $f_0$ в точке $c$ достаточно иметь равномерную сходимость: $f_n arrows f$ на $V(c)$\ \
*Пример:* #v(0.2cm)
$f_n (x) = x^n quad x in (0, 1) quad f_n (x) -> f_0 equiv 0$\ #v(0.2cm)
$f_n arrows f_0? quad limits(sup)_(x in (0, 1)) x^n= 1 arrow.not 0$, нет равномерной сх-сти\
*Но!*
#columns(2)[
#image("27.png")
#colbreak()
$limits(sup)_(x in (alpha, beta)) abs(f_n - f_0) = sup x^n = beta^n -->_(n -> +infinity) 0$\ \ т.е. в каждой точке кроме 1 есть равномерная сходимость на ее окрестности\ \
]\ \
*Пример:* #v(0.2cm)
Пусть $X = K$ --- компактно, $f_1, f_2 in C(K)$\ #v(0.2cm)
$M_n := limits(sup)_(x in X) abs(f_1 (x) - f_2(x)) = max abs(f_1 (x) - f_2 (x))$ --- чебышёвское расст.\ \
#th\ #v(0.1cm)
$K$ --- компакт, для $f_1, f_2 in C(K) quad rho(f_1, f_2) = max abs(f_1-f_2)$ --- метрика на $C(K)$. Тогда $C(K)$ --- полное МП #v(0.3cm)
#proof
Берём фунд. посл. в $C(K) quad (f_n)$\ #v(0.2cm)
$forall epsilon > 0 quad exists N: forall n, m > N quad limits(max)_(x in K) abs(f_n (x) - f_m (x)) < epsilon$\ #v(0.2cm)
Заметим, что $forall x_0$ посл. $f_n (x_0)$ --- фунд. числ. посл. $=> forall x_0 quad exists lim f_n (x_0) = f_0 (x_0)$\ #v(0.2cm)
Итого мы получили: $exists f_0: f_n -> f_0$ поточечно на $X$\
// метод имитации двоечника
\
? Почему $f_0 in C(K)$ и $f_n arrows f_0$?\ #v(0.2cm)
$forall epsilon > 0 quad exists N: forall n, m > N quad forall x in K quad abs(f_n (x) - f_m (x)) < epsilon$ --- в силу фундаментальности $f_n (x)$\ #v(0.2cm)
Устремим в этой формуле $m$ к $+infinity:$ #v(0.2cm)
$f_m (x) ->_(m ->+infinity) f_0 (x) => $ при
$ m -> +infinity "формула перепишется так":$ #v(0.2cm)
$ forall epsilon > 0 quad exists N: forall n > N quad limits(max)_(x in K) abs(f_n (x) - f_0 (x)) <= epsilon$\ #v(0.2cm)
Ну а это как раз и означает, что
$rho(f_n, f_0) -> 0 => f_n arrows f_0$ и тогда $f_0 in C(K)$ (по т. Стокса-Зайделя)
// теоропрос в конце 2 пары ))))
// у нас всё ещё есть проблемы с красивыми рисунками?
#pagebreak()
= Предельный переход под знаком интеграла
*Хотим сформулировать теорему:*\ #v(0.2cm)
Некоторые функции $f_n (x) -> f_0(x)$\ #v(0.2cm)
Тогда $ int_a^b f_n (x) -> int_a^b f_0 (x) $
*Антипример:*\ #v(0.2cm) $f_n (x) = n x^(n-1) (1-x^n) quad x in [0, 1]$\ \
$lim_(n->+infinity) f_n (x) = f_0 (x) equiv 0$\ #v(0.2cm)
$ int_0^1 n x^(n-1) (1-x^n) dif x= [t = x^n] = int_0^1 1-t dif t = 1/2 $
Функции стремятся к 0, но интеграл равен $1/2 =>$
Желаемой теоремы не существует
$ lim (int_a^b f_n (x) dif x) != int_a^b (lim f_n (x)) dif x $
\ \
#th Предельный переход под знаком интеграла \ #v(0.2cm)
$f_n, f in C[a, b], quad f_n arrows f$ на $[a, b]$\
$ int_a^b f_n -> int_a^b f $
#proof #v(0.2cm)
Тривиально. $ abs(int_a^b f_n - int_a^b f) <= int_a^b abs(f_n - f) dif x <= (b - a) limits(sup)_([a, b]) abs(f_n - f) -> 0 $
\ \
#cor() (правило Лейбница: дифференцирование интеграла по параметру) #v(0.2cm)
$f: [a, b] times [c, d] -> RR$ --- непрерывна на $[a, b] times [c, d]$
$ forall x, y: exists f'_y (x, y) = lim_(h->0) (f(x, y+h) - f(x, y))/h $ /*--- непрерывна на $[a, b] times [c, d]$ */ //зач дублированно // хз
$Phi(y) = int_a^b f(x, y) dif x. "Тогда" Phi "дифференцируема на" [c, d]:\ Phi'(y) = int_a^b f'_y (x, y) dif x $ // wtf
// Phi-нальная #emoji.face.cool
\ \
#proof
$ (Phi(y + h) - Phi(y)) / h = int_a^b (f(x, y+h) - f(x, y)) / h dif x = int_a^b f'_y (x, y + theta h) dif x \ theta in (0, 1), space theta = theta(x, y) $
(В последнем равенстве нами была использована теорема Лагранжа) #v(0.2cm)
Хотим в этой формуле считать $lim_(h->0)$. Будем делать это по Гейне, $h_n -> 0$\ #v(0.2cm)
Проверим, что $f'_y (x, y + theta h_n) arrows_(n -> +infinity) f'_y (x, y)$ равномерно по $x in [a, b]$\ #v(0.2cm)
Т.е. $limits(sup)_(x in [a, b]) abs(f'_y (x, y + theta h_n) - f'_y (x, y)) arrow.dashed_(n->+infinity) 0$\ #v(0.2cm)
Знаем: $f'_y$ --- непрерывно на $[a,b] times [c, d] space ("компакт") =>$
$f'_y$ --- равномерно непрерывно:\ #v(0.2cm)
$ forall epsilon > 0 space exists delta > 0 space attach(forall, tr: (x, y), br:(x_1, y_1)) space rho((x, y), (x_1, y_1)) < delta: abs(f'_y (x, y) - f'_y (x_1, y_1)) <epsilon $//\ #v(0.2cm)
Используем это чтобы проверить что предел действительно 0:
$ forall epsilon > 0 space ["текст" (*)] space forall n > N quad forall x, forall y quad abs(f'_y (x, y + theta h_n) - f'_y (x, y)) < epsilon $
$(*): h_n -> 0 => exists N: forall n > N quad abs(h_n) < delta$ --- из определения равн. непр.\ \
Это победа, предел действительно 0!\ \
Итак: $ display(lim_(n->+infinity) (Phi(y+h) - Phi(y))/h_n = lim_(n->+infinity) int_a^b f'_y (x, y + theta h_n) dif x = int_a^b f'_y (x, y) dif x) $
\ \
*Хотим предельный переход под знаком производной:*\ #v(0.2cm)
Возьмём функцию, стремящуюся к другой\ #v(0.2cm)
$f_n (x) -> f_0(x)$\ #v(0.2cm)
Продифференцируем:
$f'_n (x) arrow.dashed^? f_0(x)$\ #v(0.4cm)
*Контрпример:* #v(0.2cm)
$f_n (x) = x + 1/n sin (n^2024 dot x)$\ #v(0.4cm)
$f_n(x) arrows x$\ #v(0.4cm)
$f'_n ->^? 1$ \ #v(0.2cm)
НЕТ:
$f'_n (x) = 1 + underbrace(n^2023 dot cos(n^2024 x), frown)$\
\
#th (о предельном переходе под знаком производной)\ #v(0.2cm)
$f_n in C^1 (dp(a, b))$\ #v(0.2cm)
#columns(2)[
Пусть: \ #v(0.2cm)
$f_n -> f_0 " на " dp(a, b)\ #v(0.2cm)
f'_n arrows phi " на " dp(a, b)$\ #v(0.2cm)
#colbreak()
Тогда:\ #v(0.2cm)
$f_0 in C^1(dp(a, b))$\ #v(0.2cm)
$f'_0 = phi$ на $dp(a, b)$
]
#line(length:17cm)
#columns(2)[
$quad space f_n -> f_0$\
$dif/(dif x) arrow.b quad quad arrow.b.dashed$\
$quad space f'_n arrows phi$
#colbreak()
$lim_(n->+infinity) (f'_n (x)) = (lim_(n->+infinity) f_n (x))'$
] #v(0.2cm)
#proof #v(0.2cm)
$x_0, x_1 in dp(a, b), quad f'_n arrows phi$ на $[x_0, x_1]$\ #v(0.4cm)
#columns(2)[
$ int_(x_0)^(x_1) f'_n (x) dif x quad space -->_(n->+infinity) int_(x_0)^x phi(x) dif x$\
$quad quad quad #rotate(90deg)[$=$]$\ #v(0.2cm)
$f_n (x_1) - f_n (x_0) -> f_0 (x_1) - f_0 (x_0)$\
#colbreak()
$int_(x_0)^(x_1) phi(x) dif x = f_0 (x_1) - f_0 (x_0)$\ #v(0.2cm) --- при всех $x_0, x_1 in dp(a, b)$\ #v(0.2cm)
По теореме Барроу: #v(0.2cm)
$=> f_0$ --- первообразная $phi$; $quad f'_0 = phi$
]
\ \
/*
Т<NAME> - теорема 1\
Сегодняшняя теорема - теорема 2\
Правило Лейбница - теорема 3\
*/
/*$a_(n+1)/a_(n) <= b_(n+1)/b_n$\
*/
== <NAME>
$a_n > 0$\
+ НСНМ $space n (a_n/a_(n+1) - 1) >= r > 1 => sum a_n$ сходится
+ НСНМ $space n(a_n/a_(n+1) - 1) <= 1 => sum a_n$ расходится
#proof
2. \
Сравним ряды$space sum a_n$ и $limits(sum 1/n)_(=b_n)$\ #v(0.2cm)
$display(a_(n+1)/a_n >= (1/(n+1))/(1/n) <=> a_n/(a_(n+1)) <= (n+1)/n = 1 + 1/n <=> n (a_n/a_(n+1) - 1) <= 1 => a_n)$ --- большое, $b_n$ --- маленькое,\ #v(0.2cm)
$sum 1/n$ расх $=> sum a_n$ расх\ \
1. \
Пусть $1 < s < r$.\
Сравним ряды $sum a_n$ и $sum 1/n^s$\ \
$display(a_(n+1) / a_n <=^((?)) (1/(n+1)^s) / (1/n^s) <=> a_n/a_(n+1) >=^((?)) ((n+1) / n) ^s = (1 + 1/n)^s)$\ \
$display(cases(n(a_n / a_(n+1) - 1) >=^((?)) n (1 + 1/n) ^ s - 1 -->_(n->+infinity) s, "НСНМ" n (a_n/a_(n+1) - 1) >= r) =>)$
неравенство $(?)$ выполнено при больших n
#align(right)[т.е. ряд $sum a_n$ --- "маленький", $sum 1/n^s$ --- "большой" ($s > 1$)]\
\
#cor()\
$ a_n > 0: quad lim_(n -> +infinity) n ((a_n)/(a_n + 1) - 1) = r $
*Тогда:*
+ $r > 1: quad sum a_n$ --- сходится
+ $r < 1: quad sum a_n$ --- расходится\
\
*Упражнение:*\
Доказать, что:
$ sum_(n = 2)^(+infinity) 1/(n (ln n)^a) $
+ При $a > 1$ --- сходится
+ При $a <= 1$ --- расходится
\ \
#th интегральный признак Коши\ #v(0.2cm)
$f: [1, +infinity) -> [0, +infinity)$ --- непр, монот\
*Тогда:* $ sum_(k=1)^(+infinity) f(k),space int_1^(+infinity) f(x) dif x - "сх/расх одновременно" $\
#proof
Основной случай: $f arrow.b, f > 0$\
#columns(2)[
#align(center)[#image("28.png", width: 50%) $int_1^n f(x) d x >= sum_(k = 2)^n f(k)$]
#colbreak()
#align(center)[#image("29.png", width: 50%) $sum_(k = 1)^(n-1) >= int_1^n f(x) d x$]
]
$ int_1^n f = sum_(k = 1)^n int_(k - 1)^k f(x) d x >= sum_(k = 2)^n int_(k - 1)^k f(k) = sum_(k = 2)^n f(x) $
*Замечание:* можно требовать\
$ exists M quad forall x > M: f - "монотонна" $
\
*Следствие* из интегрального признака Коши:\
$ d/(d n) (1/(n (ln n)^a)) = -1/(n^2 (ln n)^a) - a/(n^2 (ln n)^(a+1)) $
\ \
#def абсолютная сходимость ряда\ #v(0.2cm)
$sum a_n$ --- абсолютно сходидтся, если $ sum a_n "сходится и" sum abs(a_n) "сходится" $
\ \
*Пример:*\ #v(0.2cm)
$display(1/(1+x^2) = 1 - x^2 + x^4 - x^6 + dots + (-1)^n x^(2n) + ((-1)^(n+1) x^(2n+2))/(1+x^2))$\ #v(0.4cm)
Проинтегрируем от 0 до 1: #v(0.2cm)
$display(pi/4 = int_0^1 1/(1+x^2) dif x = 1 - 1/3 + 1/5 - 1/7 + dots + ((-1)^n)/(2n+1) + underbrace(int_0^1 ((-1)^(n+1) x^(2n+2))/(1+x^2) dif x, abs(int_0^1 dots arrow.t) <= int_0^1 x^(2n+2)/(1+x^2) dif x <= int_0^1 x^(2n+2) = 1/(2n+3)))$
Итог: $display(pi/4 = 1 - 1/3 + 1/5 - 1/7 + dots)$ (ф-ла Грегори-Лейбница)\
\
При этом абсолютной сходимости нет:
$sum 1/n$ --- расходится, поэтому $sum 1/(2 k )$ --- расходится, #v(0.2cm)
а $sum 1/(2k + 1) $ можно почленно оценить снизу $sum 1/(2 k )$, а значит он тоже расходится
\ \
*Объяснение для идиотов:*\ // для нас
<NAME>: \ #v(0.2cm)
$ display(n(1/(2n+1)/(1/(2n + 8)) - 1) = (2n) / (2n + 1) <= 1) - "расходится!" $
#quote("Если вы думаете так, то к вам не придраться, но вы полный идиот", attribution: "КПК", block: false)\
// #h(0cm) #emoji.face.cool
\ \
#th\ #v(0.2cm)
$forall$ ряда $sum a_n$ экв:
+ $sum a_n$ --- абс сх
+ $sum abs(a_n)$ --- сх
+ $sum a_n^+, sum a_n^-$ --- сх ($a_n^+ = max(a_n, 0), a_n^- = max(-a_n, 0)$)
\
#proof
Упражнение слушателям.
= Сходимость произвольных рядов
#th (_признак Лейбница_)\ #v(0.2cm)
$c_0 >= c_1 >= c_2 >= c_3 >= dots >= 0, c_n -> 0$\ #v(0.2cm)
Тогда $ sum (-1)^n c_n - "сх" $
_Секретное дополнение признака Лейбница:_
Если ряд сх., то $ forall N quad abs(sum_(k >= N) (-1)^k c_k) <= c_N $
// пойдет?
// ы, лан
// че не так, давай
// да норм
// че не так?
// ес че в геогебре нарисую
\
#columns(2)[
#image("30.png", width: 70%)
Доказательство сходимости ряда\
$(c_0 - c_1) + (c_2 - c_3) + (c_4 - c_5) + dots$
#colbreak()
$s_(2n-1) = (c_0 - c_1) + (c_2 - c_3) + (c_4 - c_5) + dots >= 0$\ #v(0.2cm)
$s_(2n+1) = s_(2n-1) + underbracket((c_(2n) - c_(2n+1)), >= 0) >= s_(2n-1)$\
$(s_(2n-1))$ --- возрастает\ #v(0.2cm)
$s_(2n-1)$ --- ограничено (за счет площади):\ #v(0.2cm)
$s_(2n-1) = c_0 - (c_1 - c_2) - (c_3-c_4) - dots - (c_(2n-3) - c_(2n-2)) - c_(2n-1) <= c_0$\ #v(0.2cm)
Значит $exists lim s_(2n - 1)$\ #v(0.2cm)
$limits(s_(2n), inline: #false)_(arrow.br s) = limits(s_(2n - 1), inline: #false)_(arrow.br s) + limits(c_(2n), inline: #false)_(arrow.br 0)$
]
\ \
*Ряд, для которого не работает признак Лейбница:*\ #v(0.2cm)
$ sum_(k = 2)^(+infinity) ((-1)^k)/(sqrt(k) + (-1)^k) $
Наш ряд $(-1)^k c_k, quad"где" c_k = 1/(sqrt(k) + (-1)^k) >= 0$\ #v(0.2cm)
Монотонность?\
$k = 10^6 quad c_k = 1/1001$\
$k = 10^6 + 1 quad c_k approx 1/999$\ #v(0.2cm)
$k = 10^6 + 2 quad c_k approx 1/1001$\ #v(0.2cm)
$f(x)$ --- монотонности нет\ #v(0.2cm)
// [insert cursed drawing here]
НЕ РАБОТАЕТ
#frown\ \
$display(sum (-1)^k/sqrt(k))$ --- сходится по Лейбницу\ #v(0.4cm)
$display(a_k\, b_k > 0\, sum a_k\, sum b_k\, a_k tilde b_k => sum a_k\, sum b_k)$ сх одновр\ #v(0.4cm)
$display(sum_(k=2)^(+infinity) ((-1)^k)/(sqrt(k) + (-1)^k) - sum_(k=2)^(+infinity) ((-1)^k)/sqrt(k) = sum_(k=2)^(+infinity) ((-1)^k (-(-1)^k))/(sqrt(k) (sqrt(k) + (-1)^k)) = sum 1/(sqrt(k) (sqrt(k) + (-1)^k)))$\ #v(0.4cm)
$sum 1/k$ --- расх #frown\ #v(0.4cm)
Признак сравнения протух.
\ \
*Преобразование Абеля: (суммирование по частям)*\ #v(0.2cm)
$sum_(k=1)^n a_k b_k = A_n b_n + sum_(k=1)^(n-1) (b_k - b_(k+1)) A_k$\ #v(0.2cm)
$A_k = a_1 + a_2 + dots + a_k <=> int f$ --- для аналогии с интегралами можно сделать такое сравнение\ #v(0.2cm)
$int f g = F(x) g(x) - int F(x) g'(x)$\
\ \
*Признак Дирихле* _(не про зайцев)_ и *признак Абеля:*\ #v(0.2cm)
Дан $sum a_k b_k$ #v(0.2cm)
+ (_Дирихле_) $A_n$ --- огр. посл-ть $(A_n = sum_(k=1)^n a_n)$, $b_n$ --- монот, $b_n -> 0$. Тогда $sum a_n b_n$ сх\
+ (_Абеля_) Ряд $sum a_n$ сх, $b_n$ --- монот, огр. Тогда $sum a_n b_n$ сходится
\
#proof
+ $A_n$ --- огр, $b_n -> 0 => A_n b_n -> 0, exists c_A: abs(A_n) <= C_A quad forall n$\ #v(0.2cm)
Применим преобразование Абеля: $sum_(k=1)^n a_k b_k = underbracket(A_n b_n, -> 0) + sum_(k=1)^(n-1) (b_k - b_(k + 1)) A_k quad (*)$\ #v(0.2cm)
$sum_(k=1)^(n-1) abs(b_k - b_(k+1)) abs(A_k) <= c_A sum_(k=1)^(n-1) abs(b_k - b_(k+1)) = plus.minus c_A sum_(k=1)^(n-1) b_k - b_(k+1) = plus.minus c_A (b_1 - b_n) <= 2 c_A c_B$\ #v(0.2cm)
$b_n$ --- огр. $quad forall n space abs(b_n) <= c_B$\ #v(0.2cm)
Значит, $sum_(k=1)^(+infinity) (b_k - b_(k+1)) A_k$ --- абс. сходящийся $=>$ он сходится $=>exists$ кон $lim_(n->+infinity) sum_(k=1)^(n-1) dots =>$ в $(*)$ всё сходится
+ $exists$ кон $lim_(n->+infinity) b_n = beta$\
$sum_(k=1)^(+infinity) a_k b_k = underbracket(sum a_k beta, "сх") + underbracket(sum a_k (overbrace(b_k - beta, ->0)), "сх по Дирихле")$\
$sum a_k$ сх $=> A_k$ --- огр
\ \
_Загадка._ $sum_(k=1)^(+infinity) (sin n)/n - ?$ |
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/bugs/pagebreak-bibliography_00.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
#pagebreak(weak: true)
#bibliography("/assets/files/works.bib")
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/text/raw-07.typ | typst | Other | // Text show rule
#show raw: set text(font: "Roboto")
`Roboto`
|
https://github.com/donabe8898/typst-slide | https://raw.githubusercontent.com/donabe8898/typst-slide/main/opc/linux01/main.typ | typst | MIT License | #import "@preview/polylux:0.3.1": *
#import themes.university: *
#show: university-theme.with(
aspect-ratio: "16-9",
short-title: "ディストロはデスクトップ環境で選べばいいと思う",
short-author: "donabe8898",
short-date: none,
color-a: rgb("#0C6291"),
color-b:rgb("#A63446"),
color-c:rgb("#FBFEF9"),
progress-bar: true
)
#show link: set text(blue)
#set text(font: "Noto Sans CJK JP")
#show heading: set text(font: "Noto Sans CJK JP")
#show raw: set text(font: "Noto Sans Mono CJK JP")
#show raw.where(block: true): block.with(
fill: luma(240),
inset: 10pt,
radius: 4pt
)
#title-slide(
title:"デスクトップ環境で選べ",
subtitle: "LinuxのGUI事情",
authors: "OECU Programming Circle 岡本 悠吾",
date: "2024-2-14",
institution-name: "OPC"
)
#slide(title: none)[
= GUIなんてもんはあとからやってきた
#v(1em)
- OSをGUIで操作する仕組みは, コンピュターの歴史上で途中から始まった
#v(1em)
- Linuxを含むUNIX系OSはUIを規定していない.
- そもそもGUIなしでも動く（Windowsとは大違い）
- サーバーとかGUIいらないのでこれでもいい
#v(1em)
- *でも, GUIはほしいよね*
- X window Systemの使用
]
#slide(title: "X window system")[
- ビットマップディスプレイ上でウィンドウシステムを提供する*表示プロトコル*
- ウィンドウシステム → ソフトのGUIサイズを自由に変更できる窓を表示するアレ
#v(1em)
- お陰で複数のソフトを立ち上げて並べて表示できるぜ
#v(1em)
- リファレンス実装としてX.Org Serverがある.
]
#slide()[
#figure(
image("images/xwindowsystem.png")
)
]
#slide()[
= デスクトップ環境
#v(1em)
- ウィンドウシステム, ディスプレイサーバー, GUIツールキット and more...を含むソフトウェア群
- GUIを構成する仲間たち
- ディストロは大体決まったデスクトップ環境を含んでる
]
#focus-slide()[
Q. なんでデスクトップ環境で選ぶの?
]
#focus-slide()[
A. *使い勝手が全ｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯｯ然違うから*
]
#slide(title: "GNOME")[
#grid(
columns: (auto,auto),
gutter: 15pt,
text()[
== 特徴
#v(0.5em)
- GNUプロジェクトのデスクトップ環境
- マテリアルチックなデザイン
#v(0.5em)
== メリット・デメリット
#v(0.5em)
- #text(fill:blue)[独特の使い勝手]
- #text(fill:blue)[情報多め]
- #text(fill:red)[低スペPC殺し]
- #text(fill:red)[設定項目が少ねぇ]
],
text()[
== 採用
- Debian,Ubuntu
- Fedora,RHEL,RockyLinux
- ArchLinux,Manjaro
- Gentoo Linux
- FreeBSD(ports, pkg)
- OpenBSD(pkg_add)
- NetBSD(pkgsrc)
- Solaris（OracleのUNIX）
- AIX（IBMのUNIX）
- HP-UX（HPのUNIX）
]
)
]
#slide()[
#figure(
image("images/gnome.jpeg",width: 90%)
)
]
#slide(title: "KDE Plasma")[
#grid(
columns: (auto,auto),
gutter: 15pt,
text[
== 特徴
#v(0.5em)
- Windowsライクな使い心地
- Qt使ってる
#v(1em)
== メリット・デメリット
#v(0.5em)
- #text(fill:blue)[高カスタマイズ性]
- #text(fill:blue)[動作速度○]
- #text(fill:red)[メモリーバカ食い]
- #text(fill:red)[依存関係が大杉謙信]
],
text[
== 採用
- Debian,Kubuntu
- KDE Neon
- Fedora,RockyLinux
- ArchLinux,Manjaro
- GentooLinux
- OpenSUSE
- Slackware
- FreeBSD
]
)
]
#slide()[
#figure(
image("images/plasma01.png",width: 90%)
)
]
#slide(title: "Xfce")[
#grid(
columns: (auto,auto),
gutter: 15pt,
text[
=== 特徴
#v(0.5em)
- 軽い!速い!
- スイスポかな？
- UNIX哲学に則ったデザイン
#v(1em)
=== メリット・デメリット
#v(0.5em)
- #text(fill:blue)[非常に軽快]
- #text(fill:blue)[カスタマイズ性○]
- #text(fill:red)[15年前くらいのデザイン]
- #text(fill:red)[アニメーションとか知らない]
],
text[
== 採用
- Debian,Xubuntu
- Fedora,RockyLinux
- ArchLinux,Manjaro
- GentooLinux
- FreeBSD
- OpenBSD
- NetBSD
]
)
]
#slide()[
#figure(
image("images/xfce01.png",width: 90%)
)
]
#slide(title: "Mate")[
#grid(
columns: (auto,auto),
gutter: 15pt,
text[
=== 特徴
#v(0.5em)
- 一昔前のGNOME
#v(1em)
=== メリット・デメリット
#v(0.5em)
- #text(fill:blue)[分かりやすい配置]
- #text(fill:blue)[Linux以外でも採用されがち]
- #text(fill:red)[古臭いデザイン]
],
text[
== 採用
- Debian,Ubuntu Mate
- Fedora
- ArchLinux
- GentooLinux
- FreeBSD
- OpenBSD
- NetBSD
- OpenIndiana（フリーなSolaris）
]
)
]
#slide()[
#figure(
image("images/mate01.png",width: 80%)
)
]
#slide(title: "Cinnamon")[
#grid(
columns: (auto,auto),
gutter: 15pt,
text[
=== 特徴
#v(0.5em)
- GNOME3のフォーク
- windowsっぽいデザイン
#v(1em)
=== メリット・デメリット
#v(0.5em)
- #text(fill:blue)[分かりやすい配置]
- #text(fill:blue)[アニメーション少なめ]
- #text(fill:red)[何故か動作が激重]
- #text(fill:red)[ハードウェアアクセラレーションがポンコツ]
],
text[
== 採用
- Debian,Ubuntu
- Linux Mint (default)
- Fedora
- ArchLinux
- GentooLinux
]
)
]
#slide()[
#figure(
image("images/cinnamon_debian.png",width: 90%)
)
]
#slide(title:"まとめ")[
= ワイ的おすすめ順
#v(1em)
GNOME $approx$ KDE Plasma $gt$ Xfce $gt.triple$ Mate $gt$ Cinnamon
#v(1em)
- GNOMEは採用率No.1で扱いやすい
- とにかく格好良さを求めるならKDE
- 軽くて壊れにくいパッケージならXfce
- 古い物好きはMate
- 飽きたら他のやつを使えばいい（どれも）
]
// #matrix-slide[
// left
// ][
// middle
// ][
// right
// ]
/*
参考
https://polylux.dev/book/themes/gallery/university.html
*/ |
https://github.com/syrkis/esch | https://raw.githubusercontent.com/syrkis/esch/main/README.md | markdown | MIT License | # esch
Create beautiful presentations and visualizations inspired by Escher.
## Components
1. Typst presentation template
2. CLI tool for generating presentations from Typst files
3. Python package for Escher-inspired numpy array visualizations
## Installation
```bash
npm install -g esch
pip install esch
```
## Usage
### Generate presentation
```bash
esch presentation input.typ
```
### Create visualization
```python
import esch
from jax import random
rng = random.PRNGKey(0)
data = random.normal(rng, (100, 37, 37))
esch.hinton(data).saveas('hinton.svg') # save a svg animation with 100 frames (each frame is a 37x37 hinton-like plot)
```
## Development
1. Clone the repo
2. Install dependencies: `npm install` and `poetry install`
## License
MIT
For detailed documentation, visit [our docs](https://github.com/syrkis/esch/wiki).
|
https://github.com/EpicEricEE/typst-plugins | https://raw.githubusercontent.com/EpicEricEE/typst-plugins/master/hash/src/hash.typ | typst | #let lib = plugin("hash.wasm")
/// Hashes the given data with the given digest.
///
/// Arguments:
/// - digest: The digest to use for hashing. Must be one of
/// "blake2", "blake2s", "md5", "sha1", "sha224",
/// "sha256", "sha384", "sha512", or "sha3".
/// - data: The data to hash. Must be of type array, bytes, or string.
///
/// Returns: The hashed data as bytes.
#let hash(digest, data) = lib.hash(bytes(digest), bytes(data))
/// Converts a byte array to a hexadecimal string.
///
/// Arguments:
/// - bytes: The bytes to convert.
///
/// Returns: The hexadecimal string.
#let hex(bytes) = for byte in array(bytes) {
if byte < 16 { "0" }
str(int(byte), base: 16)
}
#let blake2 = hash.with("blake2")
#let blake2s = hash.with("blake2s")
#let md5 = hash.with("md5")
#let sha1 = hash.with("sha1")
#let sha224 = hash.with("sha224")
#let sha256 = hash.with("sha256")
#let sha384 = hash.with("sha384")
#let sha512 = hash.with("sha512")
#let sha3 = hash.with("sha3")
|
|
https://github.com/Tran-Thu-Le/typst-collection | https://raw.githubusercontent.com/Tran-Thu-Le/typst-collection/main/multi-files-reference/file2.typ | typst | #include "multi-ref.typ"
In the second file, the second reference is @vaswani2017attention
|
|
https://github.com/SSSayon/analytical-mechanics | https://raw.githubusercontent.com/SSSayon/analytical-mechanics/main/conf/conf.typ | typst |
#let conf(doc) = {
set page(
paper: "a4",
numbering: "1",
)
set heading(numbering: "1.1. ")
// font
set text(font: ("linux libertine", "STSong"))
show emph: text.with(font: ("linux libertine", "STKaiti"))
show strong: text.with(font: ("linux libertine", "STHeiti"))
// code
show raw.where(block: false): box.with(
fill: luma(240),
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)
show raw.where(block: true): it => block(
// Layout
width: 100%,
fill: rgb("f2f2f2"),
outset: (y: 5pt),
radius: 1pt,
stroke: (1.5pt + rgb("e6e6e6")),
)[
// Title's layout
#block(
width: 100%,
fill: rgb("e6e6e6"),
outset: (y: 5pt),
radius: 0pt,
)[#" " #str(it.lang)]
// Line numbering
#let num = it.lines.len()
#let arr = ()
#for i in range(1, num+1).map(str) {
if i.len() <= str(num).len() {
i = (str(num).len()-i.len()+1) * " " + i
}
arr.push(i)
}
// Fill in elements
#grid(
columns: (1.5em + str(num).len() * 1em, auto),
[
#set text(
fill: rgb("8e8a8a")
)
#grid(
rows: num * (12.4pt,),
..arr
)
],
it,
)
]
// link & reference
show link: link => {
set text(fill: rgb("#ee0000"))
underline(link)
}
show ref: it => {
let el = it.element
set text(fill: rgb("#ee0000"))
if (el == none) [??] else { it }
}
// args
doc
}
// font
#let bold_italic(txt) = {
set text(font: ("linux libertine", "STFangsong"))
txt
}
#let italic(txt) = {
set text(font: ("linux libertine", "STKaiti"))
txt
}
// table
#import "@preview/tablex:0.0.6": tablex, hlinex
#import "@preview/tablem:0.1.0": tablem
#let three-line-table = tablem.with(
render: (..args) => {
tablex(
columns: auto,
auto-lines: false,
align: center + horizon,
hlinex(y: 0),
hlinex(y: 1, stroke: 0.5pt),
..args,
hlinex(),
)
}
)
#let table3(args, cap) = figure(
three-line-table(args),
supplement: [表],
kind: table,
caption: {
if cap == [] { none } else { cap }
}
)
// math
#let math_block(case, args) = rect(
width: 100%,
fill: if case == "注记" {luma(240)}
else if case == "定义" {rgb("e3ffe3")}
else if case == "命题" or case == "引理" {rgb("ccebff")}
else {rgb("c3ffcf")},
stroke: if case == "注记" {(left: 1.5pt + black)}
else if case == "定义" {(left: 1.5pt + rgb("00a652"))}
else if case == "命题" or case == "引理" {(left: 1.5pt + rgb("00aef7"))}
else {(left: 1.5pt + rgb("007f00"))},
)[
*#case.* #math.space
#if case != "注记" {
italic(args)
} else {
args
}
]
#let proof(args) = [#grid(columns: (5pt, 100%-5pt),
[],
[
_证明._ #math.space
#args
],
) #align($square$, right)]
// shortcuts
#import "@preview/quick-maths:0.1.0": shorthands
#show: shorthands.with(
($perp$, $tack.t$),
)
|
|
https://github.com/Toniolo-Marco/git-for-dummies | https://raw.githubusercontent.com/Toniolo-Marco/git-for-dummies/main/book/organization.typ | typst | #let wgc = "Working group coordinator"
#let gl = "Group leader"
#let gm = "GitHub maintainer"
= Organization
L'organizzazione è un'account condiviso@gh-orgs da più utenti dove è possibile collaborare su uno o più progetti, definendo ruoli e funzioni.
Utilizzando le organizzazioni è possibile creare una suddivisione che rispecchia quella in classe, dove il *Working group coordinator* ha tutti i permessi
i *Git Maintainer* possono creare, modificare, accettare, rifiutare le pull request e scrivere ed eseguire delle Actions (di cui parleremo più avanti) e tutti gli altri possono aprire issue, fare fork e creare delle pull request.
== Creare un'organizzazione
Per creare un'organizzazione recatevi sulla homepage di GitHub dopo aver fatto il login col vostro account, cliccate sul vostro nome utente (vicino alla foto) nell'angolo in alto a sinistra, e poi su crea organizzazione. Vi si aprirà la pagina coi piani, selezionate quello gratuito, poi compilate il form con i dettagli prestando attenzione a selezionare che l'organizzazione appartiene al vostro account personale e non ad un'azienda.
== Creare i team
GitHub per gestire i permessi nelle organizzazioni fa uso dei team, un team è un insieme di utenti, ad ogni team sono associati dei permessi, gli utenti di un team ereditano i permessi.
Per creare i gruppi@gh-groups, cambiate dal vostro account a quello dell'organizzazione, se non lo avete già fatto, cliccando sempre sul vostro nome e selezionando quello dell'organizzazione, poi spostatevi su *Teams*, e create i seguenti team:
- Organization Owners
- Members
- Tutors
=== Organization Owners
Composto dal Working group coordinator e dai Git Maintainers, questo team *deve avere tutti i permessi*, i membri di questo team devono essere manualmente
impostati come Owners dell'organizzazione andando su *people*, cliccando sui *tre pallini* e poi su *change role* e in fine *owner*. In questo modo, avranno pieni poteri su tutta l'organizzazione.
=== Members
Questo team, deve poter forkare, creare issue e pull request sul repository del common crate, il ruolo da associarvi è *Triage* ma solo sul singolo repository
dopo vi spiegheremo come fare, per ora create il team e non aggiungete membri, visto che sarete in \~100/150 persone è impensabile che qualcuno aggiunaga manualmente tutti i partecipanti, per questo si userà l'inviter, come spiegato successivamente.
=== Tutors
Questo team avrà acesso in lettura al repository, conterra i tutors i quali andranno aggiunti manualmente in base al loro interesse, alcuni vi chiederanno di entrare e altri invece no, anche qui, il i permessi del team vanno impostati sul singolo repository.
== Il repository
Create adesso il repository contenente il codice del Common Crate, come visibilità mettete private (il professore vi spiegherà che è per evitare che i futuri studenti trovino tutto pronto), le altre opzioni sceglietele in base
alle vostre preferenze. Una volta creato andate in *settings*, poi *collaborators e teams* e cliccate *add teams*, cercate *Organization Owners* e come ruolo assegnategli *Admin*. Ripetete per i *Members* e come ruolo
scegliete *Triage*, per ultimo il team *Tutors* ai quali va il ruolo di *Read*.
== Workflow consigliato
Lo scorso anno, abbiamo provato a mimare l'approccio utilizzato dai grandi progetti open source per la gestione dei repository, questo cosisteva nelle seguenti fasi@git-contribution
+ Fork del repository
+ Apertura di una issue e implentazione
+ Votazione (se si tratta di una feature proposta)
+ Merge nel main
+ Pubblicazione della nuova versione
=== Apertura di una issue e implentazione
Le issue sono una feature delle piattaforme come GitHub per tracciare e gestire attività, bug, richieste di funzionalità o discussioni generali relative a un progetto. Serve ai membri del team, ai collaboratori e agli utenti per comunicare su specifici lavori o problemi all'interno di un repository.
Ogni issue ha un *titolo* che deve fornire una sintesi chiara, una *descrizione* dove si descrive nel dettaglio la issue, il testo è in markdown, quindi è possibile integrare codice (opportunamente formattato), immagini e molto altro. Ad ogni issue può essere associata a una pull request, questo è fondamentale per associare un fix o una implentazione all'effettivo codice che andrà inserito nel common crate e in fine, una issue può avere 0 o più labels e vi consigliamo vivamente di usarle, perchè fornisco una rapida descrizione del tipo di issue e permettono di filtrarle facilmente. Per esempio l'anno scorso avevamo le seguenti labels:
- *approved* (la issue è stata approvata con una votazione)
- *bug* (la issue solleva la presenza di un bug e o propone un fix)
- *check* required (la issue non è chiara e richiede un approfondimento)
- *CIRITICAL* (la issue è fondamentale e va completata il prima possibile)
- *discussion needed* (la issue presenta l'implentazione di una nuova feature e va discussa alla prossima riunione)
- *documentation* (la issue aggiunge documentazione al codice o alle specifiche)
- *in progress* (la issue è in fase di elaborazione da parte di qualcuno, non è stata ne chiusa ne approvata)
- *proposal* (la issue propone l'implentazione di qualcosa di nuovo e va votata)
- *question* (la issue è una domanda riguardante il common crate)
- *rejected* (la issue non è stata approvata durante la riunione)
- *test* (la issue aggiunge o modifica uno o più test)
- *TODO code* (la issue presenta un'idea ma manca il codice)
- *vote required* (la issue richiede una votazione, indipendentemente dal tipo)
Solitamente chi apre la issue imposta il se stesso come *Assignees*, assegna le label appropriate e linka la pull request col codice. I #gm controllano le issue, richiedono di approfondire aggiungendo del testo o un esempio (se necessario) e in fine aggiungono le label che ritengono necessarie.
=== Votazione
Se la issue richiede una votazione, allora alla prima riuone dei #gl chi ha aperto la issue espone la propria idea e implentazione, poi i #gl votano se accettarla o meno, a questo punto un #gm imposta la label appropriata (approved o rejected), accetta la pull request (solo se approvata) e poi chiude la issue. È quindi necessario che almeno un #gm sia presente durante le riunioni.
== Merge nel main
Dopo che un #gm ha approvato la PR (pull request), il codice proposto viene mergiato nel main, prima di accettare una PR è fondamentale che un #gm cloni il conentuno della PR localmente, la testi e poi in caso sia necessario richieda modifiche, rispondendo alla issue. Tutto questo è automatizzabile tramite le action, ma ne parleremo più avanti.
=== Pubblicazione della nuova versione
Dopo aver accettato una PR, è consigliabile incrementare la versione del common crate modificando il cargo.toml e successivamente pubblicando la nuova versione.
= Software fair e archiviazione del repository
Il professore ad certo punto in accordo col Working group coordinator, fisserà la data della software fair, lo svolgimento dell'evento verrà ampiamente spiegato a lezione, quello che è importante ai fini di questa guida è che il repository, il giorno prima di quella data deve essere *archiviato* e messo in readonly per prevenire ulteriori modifiche. L'ideale sarebbe che tutte le pr approvate vengano mergiate prima di tale date, il codice testato, le specifiche ultimate e che venga creata la release finale, è fondamentale anche a costo di tagliare qualche feature, che la release sia il più stabile e funzionante possibile perchè dopo tale data anche in caso emergano bug *non si potrà modificare*.
== Come archiviare il repository
Per prima cosa andate sulla pagina principale del repository, poi cliccate su *Settings*, *General*, scorrete *a fine pagina* e in fine *Archive this repository*, vi verrà richiesta la conferma e in fine il repository sarà in sola lettura, questo include@git-archive:
- Pull request
- Contenuto
- Actions
- Issue
|
|
https://github.com/crd2333/crd2333.github.io | https://raw.githubusercontent.com/crd2333/crd2333.github.io/main/src/docs/Reading/跟李沐学AI（论文）/Swin%20Transformer.typ | typst | // ---
// order: 14
// ---
#import "/src/components/TypstTemplate/lib.typ": *
#show: project.with(
title: "d2l_paper",
lang: "zh",
)
= Swin Transformer: Hierarchical Vision Transformer using Shifted Windows
- 时间：2021.5
- Swin Transformer 为 ICCV21 最佳论文，是 ViT 之后，第二个证明 Transformer 在 CV 领域强大表现的工作
#hline()
- [ ] Todo |
|
https://github.com/cronokirby/typst-templates | https://raw.githubusercontent.com/cronokirby/typst-templates/main/example-paper.typ | typst | #import "paper.typ"
#let abstract = lorem(40)
#show: doc => paper.template(
title: "On The Nature of Examples",
author: (name: "<NAME>", email: "<EMAIL>"),
abstract: abstract,
doc,
)
= Introduction
Systems and the partition table, while unproven in theory, have not until
recently been considered unfortunate. Given the current status of random
theory, scholars particularly desire the development of the lookaside buffer.
Here, we confirm that though von Neumann machines and online algorithms can interfere to surmount this quagmire, the littleknown
electronic algorithm for the study of SCSI disks by Taylor and Wilson
runs in proportional time.
== Section
#lorem(30)
#lorem(30)
If you consider a function that goes on and on and on:
$ sum FF_i arrow.r GG $
then it might not be great, even if it goes on and on and on.
But, on the other hand.
See #cite("can01", "bdfkk18", "yil09")
#paper.definition[
Woah mama, that's a nice definition.
]
#lorem(40)
#paper.theorem[
Nice theorem.
]
#paper.proof[
Woah mama that's a nice proof.
]
#paper.lemma[
Nice lemma.
]
#paper.proof[
Woah mama that's a nice proof.
]
#paper.claim[
Nice claim.
]
#paper.proof[
Woah mama that's a nice proof.
]
= Another section
#paper.definition[
Woah mama, that's a nice definition.
]
#paper.definition[
Woah mama, that's a nice definition.
]
#pagebreak()
#bibliography(style: "chicago-notes", "test.bib")
|
|
https://github.com/noriHanda/my-resume | https://raw.githubusercontent.com/noriHanda/my-resume/main/icons.typ | typst | The Unlicense | #let icon(
name,
color: white,
baseline: 0.125em,
height: 1.0em,
width: 1.25em) = {
let originalImage = read("icons/" + name + ".svg")
let colorizedImage = originalImage.replace(
"#ffffff",
color.to-hex(),
)
box(
baseline: baseline,
height: height,
width: width,
image.decode(colorizedImage)
)
}
#let linkIcon(..args) = {
icon(..args, width: 1.25em / 2, baseline: 0.125em * 3)
}
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/big-todo/0.2.0/lib.typ | typst | Apache License 2.0 | //Function to insert TODO
#let todo(body, inline: false, big_text: 40pt, small_text: 15pt, gap: 2mm) = {
if inline {
set text(fill: red, size: small_text, weight: "bold")
box([TODO: #body
#place()[
#set text(size: 0pt)
#figure(kind: "todo", supplement: "", caption: body, [])
]])
}
else {
set text(size: 0pt) //to hide default figure text, figures is only used for outline as only headings and figures can used for outlining at this point
figure(kind: "todo", supplement: "", outlined: true, caption: body)[
#block()[
#set text(fill: red, size: big_text, weight: "bold")
! TODO !
]
#v(gap)
#block[
#set text(fill: red, size: small_text, weight: "bold")
#body
]
#v(gap)
]
}
}
//Function to insert TODOs outline
#let todo_outline = outline(
title: [TODOs],
target: figure.where(kind: "todo")
) |
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/text/features-08.typ | typst | Other | // Error: 26-31 expected integer or none, found boolean
#set text(stylistic-set: false)
|
https://github.com/TGM-HIT/typst-diploma-thesis | https://raw.githubusercontent.com/TGM-HIT/typst-diploma-thesis/main/template/chapters/vorwort.typ | typst | MIT License | #import "../lib.typ": *
#let highlighted-link(..args) = {
set text(fill: blue.darken(20%))
link(..args)
}
= Vorwort <preface>
Die Diplomarbeit ist kein Aufsatz! Auch wenn sie interessant gestaltet werden sollte, ist sie unpersönlich und im passiv zu schreiben. Besonders sind die Quellenangaben, welche entsprechend gewählt und referenziert werden müssen. Innerhalb dieser Vorlage existieren zwei Dateien, die zu genau diesem Zweck erstellt wurden. Die Datei `bibliography.bib` beinhaltet alle Quellenangaben und verwendete Literatur, `glossaries.typ` alle Definitionen von Begriffen und Akronymen, welche in der Arbeit selbst nicht genauer erklärt werden.
Während der Großteil dieser Vorlage nur die Struktur einer typischen Diplomarbeit vorzeigt enthält das Vorwort Informationen zur Verwendung der Vorlage. Es ist natürlich zur Gänze zu ersetzen. Die Informationen hier umfassen neben vorlagenspezifischen Beispielen auch solche, die sich auf Funktionen von Typst oder #highlighted-link("https://typst.app/universe/")[zur Verfügung stehenden Paketen] beziehen und für die Erstellung von Diplomarbeiten nützlich sein können. Es lohnt sich einen Blick in `chapters/vorwort.typ` zu werfen um zu sehen, wie die Beispiele umgesetzt wurden.
== Quellen
Das richtige zitieren spielt innerhalb der wissenschaftlichen Arbeit eine wichtige Rolle. Die Verwaltung von Literatur ist bereits in Typst enthalten. Die Datei `bibliography.bib` ist bereits vorgegeben, es kann aber wie in der Dokumentation beschrieben auch das _Hayagriva_-Format verwendet werden.
Als kleines Beispiel findet sich hier nun ein Zitat über Schall, aus dem ersten Phsyik Lehrbuch der Autoren Schweitzer, Svoboda und Trieb.
#quote(attribution: [@physik1[S. 145]], block: true)[
"Mechanische Longitudinalwellen werden als Schall bezeichnet. In einem Frequenzbereich von 16 Hz bis 20 kHz sind sie für das menschliche Ohr wahrnehmbar. Liegen die Frequenzen unter diesem Bereich, so bezeichnet man diese Wellen als Infraschall, darüber als Ultraschall."
]
In `bibliography.bib` ist die referenzierte Quelle folgendermaßen definiert:
#figure(
```bib
@book{ physik1,
title = {Physik 1},
author = {<NAME>, <NAME>, <NAME>},
year = {2011},
subtitle = {Mechanik, Thermodynamik, Optik},
edition = {7. Auflage},
publisher = {Veritas},
pages = {140, 145-150},
pagetotal = {296}
}
```,
caption: [Eintrag einer Buchquelle in BibTeX],
)
Als allererstes sieht man die ID dieser Quelle, `physik1`, damit lässt sich diese entweder mit ```typ @physik1``` referenzieren, oder mit einer zusätzlichen Detailangabe wie etwa für die Seitenzahl: #box[```typ @physik1[S. 145]```]. Besonders bei direkten Zitaten empfiehlt es sich auch die Seitenzahl anzugeben.
Nach der Verwendung einer Quelle wird diese auch im @bibliography gelistet, welche sich am Ende des Dokuments befindet. Quellen die nicht referenziert werden, werden nicht angezeigt. Es ist also unproblematisch, großzügig Quellen in `bibliography.bib` aufzunehmen: besser mehr Literatur parat zu haben, als sie dann nachträglich suchen zu müssen.
Relevante Dokumentation:
- #highlighted-link("https://typst.app/docs/reference/model/bibliography/")[```typc bibliography()```]
- #highlighted-link("https://typst.app/docs/reference/model/cite/")[```typ @key``` bzw. ```typc cite()```]
- #highlighted-link("https://www.bibtex.com/g/bibtex-format/")[das BibTeX-Dateiformat]
- #highlighted-link("https://github.com/typst/hayagriva/blob/main/docs/file-format.md")[das Hayagriva-Dateiformat]
== Glossar
Das @glossary enthält Erklärungen von Begriffen und Abkürzen, die im Fließtext keinen Platz haben. Dadurch wird sichergestellt, dass der Lesefluss für Fachkundige nicht gestört wird, die Arbeit aber trotzdem auch für ein breiteres Publikum zugänglich ist. In der Datei `glossaries.typ` werden Begriffe -- oder in diesem Fall eine Abkürzung -- in der folgenden Form definiert:
#figure(
```typ
#glossary-entry(
"ac:tgm",
short: "TGM",
long: "Technologisches Gewerbemuseum",
)
```,
caption: [Eintrag einer Abkürzung in `glossaries.typ`],
)
Verwendet werden kann dieser Glossareintrag ähnlich einer Quellenangabe durch ```typ @ac:tgm```. Bei der ersten Verwendung wird die Langform automatisch auch dargestellt: @ac:tgm. Bei weiteren Verwendungen wird dagegen nur die Kurzform angezeigt: @ac:tgm.
Das für die Glossar-Funktion im Hintergrund verwendete _Glossarium_-Paket stellt auch weitere Funktionen zur Verfügung, die z.B. bei der Anpassung an die deutschen Fälle hilfreich sein können. Außerdem kann so die Langform erzwungen werden: _diese Diplomarbeit wurde im #gls("ac:tgm", display: "Technologischen Gewerbemuseum") erstellt; "#gls("ac:tgm", long: true)" wird man im Fließtext aufgrund der Struktur der deutschen Sprache wahrscheinlich selten finden._
Relevante Dokumentation:
- #highlighted-link("https://typst.app/universe/package/glossarium/0.4.1/")[das Glossarium-Paket]
#set-current-authors("<NAME>", "<NAME>")
== Autorenschaft innerhalb des Dokuments
Innerhalb der Diplomarbeit ist es notwendig, dass die Individuelle Autorenschaft der einzelnen Teile nachvollzogen werden kann. Üblich ist dafür, dass die Autoren in der Fußzeile angegeben werden. In dieser Vorlage kann aus zwei Modi gewählt werden: ```typc current-authors: "highlight"``` zeigt alle Autoren in der Fußzeile an, druckt aber die aktuellen Autoren fett; ```typc current-authors: "only"``` zeigt nur die aktuellen Autoren in der Fußzeile an.
Vor diesem Abschnitt wurden die Autoren auf _<NAME>_ und _Tricia McMillan_ gesetzt (siehe den Quellcode dieses Kapitels), deshalb sind diese ab dieser Seite fett gedruckt.
== Abbildungen und Gleichungen
Abbildungen, Tabellen, Codestücke und ähnlich eigenständige Inhalte werden oft verwendet, um den Fließtext zu komplementieren. In den vorangegangenen Abschnitten wurden bereits zwei _Auflistungen_, also Codestücke, verwendet. Abbildungen sollten normalerweise im Fließtext referenziert werden, damit die inhaltliche Relevanz explizit klar ist. Zum Beispiel könnte mittels ```typ @fig:picture``` auf die in @lst:figure-definition gezeigte Abbildung verwiesen werden. Die Verweise in diesem Abschnitt benutzen genau diesen Mechanismus, in der PDF-Version der Arbeit sind diese Verweise funktionierende Links. Der Präfix `fig:` wurde dabei durch das _i-figured_-Paket eingefügt und anhand die Art des Inhalts bestimmt, siehe @tbl:figure-kinds. Dieses Paket bewirkt auch, dass Abbildungen nicht durchlaufend nummeriert sind, sondern kapitelweise.
#figure(
```typ
#figure(
image(...),
caption: [Ein Bild],
) <picture>
```,
placement: auto,
caption: [Definition einer Abbildung],
) <figure-definition>
#figure(
table(
columns: 4,
align: (center,) * 3 + (left,),
table.header(
[Supplement], [Inhalt], [Präfix], [Anmerkung],
),
[Abbildung], [```typ image()```], [`fig:`], [Standard-Abbildungsart für andere Inhalte],
[Tabelle], [```typ table()```], [`tbl:`], [],
[Auflistung], [```typ raw()```], [`lst:`], [```typ raw()``` hat auch die Spezial-Syntax ```typ `...` ``` oder ````typ ```...``` ````],
[Gleichung], [```typ math.equation()```], [`eqt:`], [```typ math.equation()``` hat auch die Spezial-Syntax ```typ $ ... $```],
),
placement: auto,
caption: [Arten von Abbildungen und deren Präfixe in _i-figured_],
) <figure-kinds>
Es ist in wissenschaftlichen Arbeiten auch üblich, Abbildungen zur besseren Seitennutzung zu verschieben -- normalerweise an den oberen oder unteren Rand einer Seite. In Typst kann dazu ```typc figure(.., placement: auto)``` benutzt werden. Die Abbildungen in diesem Abschnitt benutzen diese Funktionalität: obwohl dieser Absatz im Quelltext nach den Abbildungen kommt, beginnt er vor ihnen und endet erst auf der nächsten Seite, danach. Ob die Ergebnisse der automatischen Platzierung zufriedenstellend sind sollte für die Endversion natürlich nochmal manuell geprüft werden.
Mathematische Gleichungen werden gemäß den Konventionen ein bisschen anders dargestellt und haben in Typst außerdem eine eigene Syntax. Die Definition von @eqt:pythagoras kann im Quelltext des Vorworts eingesehen werden:
$ a^2 + b^2 = c^2 $ <pythagoras>
Relevante Dokumentation:
- #highlighted-link("https://typst.app/docs/reference/model/figure/")[```typc figure()```]
- #highlighted-link("https://typst.app/docs/reference/foundations/label/")[```typ <...>``` bzw. ```typc label()```]
- #highlighted-link("https://typst.app/docs/reference/model/table/")[```typc table()```]
- #highlighted-link("https://typst.app/docs/reference/text/raw/")[````typ ```...``` ```` bzw. ```typc raw()```]
- #highlighted-link("https://typst.app/docs/reference/math/equation/")[```typ $ ... $``` bzw. ```typc math.equation()```]
- #highlighted-link("https://typst.app/universe/package/i-figured/0.2.4/")[das i-figured-Paket]
== Interne Verweise <internal-references>
Neben Referenzen auf Quellen, Abbildungen und Glossar-Einträge kann die ```typ @key```-Syntax auch verwendet werden, um auf Kapitel und Abschnitte zu referenzieren. Da dieses Kapitel mit dem Label ```typ <preface>``` versehen ist lässt sich zum Beispiel mit ```typ @preface``` leicht ein Verweis einfügen: @preface. Gleichermaßen funktioniert ein Verweis auf @internal-references, in dem dieser Text steht. Im PDF sind auch diese Verweise Links.
Einige Teile der Diplomarbeit sind durch die Vorlage mit Labels versehen und können damit wenn nötig referenziert werden:
- @declaration
- #text(lang: "de")[@abstract-de]
- #text(lang: "en")[@abstract-en]
- @contents
- @bibliography
- (#l10n.list-of-figures -- kein Link da in der Vorlage keine "normalen" Abbildungen sind) // @list-of-figures
- @list-of-tables
- @list-of-listings
- @glossary
Da diese Überschriften keine Nummerierung haben, werden Referenzen zu ihnen mit dem vollen Namen dargestellt.
|
https://github.com/PgBiel/typst-diagbox | https://raw.githubusercontent.com/PgBiel/typst-diagbox/main/diagbox.typ | typst | Apache License 2.0 | /**
* A diagonal box going from top left to bottom right. (The right-most position determines the prefix.)
* Note: If using this outside of a table, setting inset to '0pt' is recommended.
*
* 'text_left' is the text that appears at the bottom left;
* 'text_right', at the top right;
* 'width' is the total width the diag box should span. Specify the table's column width
* in this option;
* 'inset' is the inset (inner cell padding) of the table - defaults to 5pt (just like tables do). Set
* this to 0pt if not inside a table;
* 'text_pad' is the general inner padding applied to text, which makes it move more 'inside'. It is used,
* with negative values, to 'counter' a table's inner padding (inset). By default, it follows the
* formula '-2 * inset/3 + 3pt', which covers both low insets (with the 3pt) and
* high insets (due to '-2 * inset/3'). Setting this option shouldn't normally be necessary.
* 'box_stroke' optionally gives a border to the box (e.g., if outside a table) - defaults to 'none'
* (uses the table's cell rendering), but you may write, e.g., `teal + 1pt`, `yellow`, `3pt` etc.
* 'line_stroke' optionally controls the diagonal line's color and stroke size, with, for example,
* `yellow + 2pt`, `blue`, `3pt` etc. Defaults to `1pt`.
*
* Additional options:
* 'inner_width' overrides width calculation of the inner box (the width of the diagbox,
* not considering the table's 'inset' padding). The default formula for inner width is
* 'width - 2*inset', if column width is specified; otherwise, it simply measures the width
* of the given texts: '2*calc.max(left, right)'. You shouldn't generally need to change this
* option.
* 'left_sep', 'right_sep' define the distance of the bottom left and top right texts to their nearest
* respective vertical borders (they move those texts horizontally, away from the nearest border) -
* they default to 0pt, and may be negative to move in the opposite direction;
* 'left_outer_sep', 'right_outer_sep' define where the diagonal line starts and ends, respectively.
* They move each end of the line horizontally, away from the nearest vertical border, and may
* be negative.
*/
#let bdiagbox(
text_left, text_right,
width: none, height: none,
inset: 5pt, text_pad: none,
box_stroke: none, line_stroke: 1pt,
inner_width: none,
left_sep: 0pt, right_sep: 0pt,
left_outer_sep: 0pt, right_outer_sep: 0pt,
) = context {
let left_measure = measure(text_left)
let right_measure = measure(text_right)
let text_pad = if text_pad == none {
// some adjusting; sum 3pt for the base case (5pt)
// for larger insets, it isn't very relevant
-2*inset/3 + 3pt
} else {
text_pad
}
let height = if height != none {
height
} else {
2*(left_measure.height + right_measure.height)
}
let inner_width = if inner_width != none {
inner_width
} else if width != none {
width - 2*inset
} else {
2*calc.max(left_measure.width, right_measure.width)
}
box(width: inner_width, height: height, stroke: box_stroke)[
#show line: place.with(top + left)
#place(top + right, move(dx: -right_sep - text_pad, dy: text_pad, text_right))
#line(start: (left_outer_sep - inset, -inset), end: (inner_width + inset - right_outer_sep, height + inset), stroke: line_stroke)
#place(bottom + left, move(dx: left_sep + text_pad, dy: -text_pad, text_left))
]
}
/**
* Same as 'bdiagbox', but with the line going from bottom left to top right. Thus,
* 'text_left' goes on the top left, while 'text_right' goes on the top right,
* and the corresponding options affect the equivalent parameters (left -> `text_left`,
* right -> `text_right`).
*/
#let tdiagbox(
text_left, text_right,
width: none, height: none,
inset: 5pt, text_pad: none,
box_stroke: none, line_stroke: 1pt,
inner_width: none,
left_sep: 0pt, right_sep: 0pt,
left_outer_sep: 0pt, right_outer_sep: 0pt,
) = context {
let left_measure = measure(text_left)
let right_measure = measure(text_right)
let text_pad = if text_pad == none {
// some adjusting; sum 3pt for the base case (5pt)
// for larger insets, it isn't very relevant
-2*inset/3 + 3pt
} else {
text_pad
}
let height = if height != none {
height
} else {
2*(left_measure.height + right_measure.height)
}
let inner_width = if inner_width != none {
inner_width
} else if width != none {
width - 2*inset
} else {
2*calc.max(left_measure.width, right_measure.width)
}
box(width: inner_width, height: height, stroke: box_stroke)[
#show line: place.with(top + left)
#place(top + left, move(dx: left_sep + text_pad, dy: text_pad, text_left))
#line(start: (left_outer_sep - inset, height + inset), end: (inner_width + inset - right_outer_sep, -inset), stroke: line_stroke)
#place(bottom + right, move(dx: -right_sep - text_pad, dy: -text_pad, text_right))
]
}
// TODO: Add function for two diagonal lines (for a third text option, in the middle).
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/quill/0.2.0/src/quill.typ | typst | Apache License 2.0 | #import "utility.typ"
#import "length-helpers.typ"
#import "decorations.typ": *
/// Create a quantum circuit diagram. Children may be
/// - gates created by one of the many gate commands (@@gate,
/// @@mqgate, @@meter, ...),
/// - `[\ ]` for creating a new wire/row,
/// - commands like @@setwire, @@slice or @@gategroup,
/// - integers for creating cells filled with the current wire setting,
/// - lengths for creating space between rows or columns,
/// - plain content or strings to be placed on the wire, and
/// - @@lstick, @@midstick or @@rstick for placement next to the wire.
///
///
/// - wire (stroke): Style for drawing the circuit wires. This can take anything
/// that is valid for the stroke of the builtin `line()` function.
/// - row-spacing (length): Spacing between rows.
/// - column-spacing (length): Spacing between columns.
/// - min-row-height (length): Minimum height of a row (e.g., when no
/// gates are given).
/// - min-column-width (length): Minimum width of a column.
/// - gate-padding (length): General padding setting including the inset for
/// gate boxes and the distance of @@lstick and co. to the wire.
/// - equal-row-heights (boolean): If true, then all rows will have the same
/// height and the wires will have equal distances orienting on the
/// highest row.
/// - color (color): Foreground color, default for strokes, text, controls
/// etc. If you want to have dark-themed circuits, set this to white
/// for instance and update `wire` and `fill` accordingly.
/// - fill (color): Default fill color for gates.
/// - font-size (length): Default font size for text in the circuit.
/// - scale (ratio): Total scale factor applied to the entire
/// circuit without changing proportions
/// - baseline (length, content, string): Set the baseline for the circuit. If a
/// content or a string is given, the baseline will be adjusted auto-
/// matically to align with the center of it. One useful application is
/// `"="` so the circuit aligns with the equals symbol.
/// - circuit-padding (dictionary): Padding for the circuit (e.g., to accomodate
/// for annotations) in form of a dictionary with possible keys
/// `left`, `right`, `top` and `bottom`. Not all of those need to be
/// specified.
///
/// This setting basically just changes the size of the bounding box
/// for the circuit and can be used to increase it when labels or
/// annotations extend beyond the actual circuit.
/// - ..children (array): Items, gates and circuit commands (see description).
#let quantum-circuit(
wire: .7pt + black,
row-spacing: 12pt,
column-spacing: 12pt,
min-row-height: 10pt,
min-column-width: 0pt,
gate-padding: .4em,
equal-row-heights: false,
color: black,
fill: white,
font-size: 10pt,
scale: 100%,
scale-factor: 100%,
baseline: 0pt,
circuit-padding: .4em,
..children
) = {
if children.pos().len() == 0 { return }
if children.named().len() > 0 {
panic("Unexpected named argument '" + children.named().keys().at(0) + "' for quantum-circuit()")
}
set text(color, size: font-size)
style(styles => {
// Parameter object to pass to draw-function containing current style info
let draw-params = (
wire: wire,
padding: measure(line(length: gate-padding), styles).width,
background: fill,
color: color,
styles: styles,
// roman-gates: roman-gates,
x-gate-size: none,
multi: (wire-distance: 0pt),
em: measure(line(length: 1em), styles).width
)
draw-params.x-gate-size = layout.default-size-hint(gate($X$), draw-params)
let items = children.pos().map( x => {
if type(x) in ("content", "string") and x != [\ ] { return gate(x) }
return x
})
/////////// First pass: Layout (spacing) ///////////
let column-spacing = length-helpers.convert-em-length(column-spacing, draw-params.em)
let row-spacing = length-helpers.convert-em-length(row-spacing, draw-params.em)
let min-row-height = length-helpers.convert-em-length(min-row-height, draw-params.em)
let min-column-width = length-helpers.convert-em-length(min-column-width, draw-params.em)
let colwidths = ()
let rowheights = (min-row-height,)
let (row-gutter, col-gutter) = ((0pt,), ())
let (row, col) = (0, 0)
let wire-ended = false
for item in items {
if item == [\ ] {
if rowheights.len() < row + 2 {
rowheights.push(min-row-height)
row-gutter.push(0pt)
}
row += 1; col = 0
wire-ended = true
} else if utility.is-circuit-meta-instruction(item) {
} else if utility.is-circuit-drawable(item) {
let isgate = utility.is-gate(item)
if isgate { item.qubit = row }
let ismulti = isgate and item.multi != none
let size = utility.get-size-hint(item, draw-params)
let width = size.width
let height = size.height
if isgate and item.floating { width = 0pt }
if colwidths.len() < col + 1 {
colwidths.push(min-column-width)
col-gutter.push(0pt)
}
colwidths.at(col) = calc.max(colwidths.at(col), width)
if not (ismulti and item.multi.size-all-wires == none) {
// e.g., l, rsticks
rowheights.at(row) = calc.max(rowheights.at(row), height)
}
if ismulti and item.multi.num-qubits > 1 and item.multi.size-all-wires != none {
let start = row
if not item.multi.size-all-wires {
start = calc.max(0, row + item.multi.num-qubits - 1)
}
for qubit in range(start, row + item.multi.num-qubits) {
while rowheights.len() < qubit + 1 {
rowheights.push(min-row-height)
row-gutter.push(0pt)
}
rowheights.at(qubit) = calc.max(rowheights.at(qubit), height)
}
}
col += 1
wire-ended = false
} else if type(item) == "integer" {
for _ in range(colwidths.len(), col + item) {
colwidths.push(min-column-width)
col-gutter.push(0pt)
}
col += item
wire-ended = false
} else if type(item) == "length" {
if wire-ended {
row-gutter.at(row - 1) = calc.max(row-gutter.at(row - 1), item)
} else if col > 0 {
col-gutter.at(col - 1) = calc.max(col-gutter.at(col - 1), item)
}
}
}
/////////// END First pass: Layout (spacing) ///////////
rowheights = rowheights.map(x => x + row-spacing)
colwidths = colwidths.map(x => x + column-spacing)
if equal-row-heights {
let max-row-height = calc.max(..rowheights)
rowheights = rowheights.map(x => max-row-height)
}
let center-x-coords = layout.compute-center-coords(colwidths, col-gutter).map(x => x - 0.5 * column-spacing)
let center-y-coords = layout.compute-center-coords(rowheights, row-gutter).map(x => x - 0.5 * row-spacing)
draw-params.center-y-coords = center-y-coords
(row, col) = (0, 0)
let (x, y) = (0pt, 0pt) // current cell top-left coordinates
let center-y = y + rowheights.at(row) / 2 // current cell center y-coordinate
let center-y = center-y-coords.at(0) // current cell center y-coordinate
let circuit-width = colwidths.sum() + col-gutter.slice(0, -1).sum(default: 0pt) - column-spacing
let circuit-height = rowheights.sum() + row-gutter.sum() - row-spacing
let wire-count = 1
let wire-distance = 1pt
let wire-stroke = wire
let prev-wire-x = center-x-coords.at(0)
/////////// Second pass: Generation ///////////
let bounds = (0pt, 0pt, circuit-width, circuit-height)
let circuit = block(
width: circuit-width, height: circuit-height, {
set align(top + left) // quantum-circuit could be called in a scope where these have been changed which would mess up everything
let to-be-drawn-later = () // dicts with content, x and y
for item in items {
if item == [\ ]{
y += rowheights.at(row)
row += 1
center-y = center-y-coords.at(row)
col = 0; x = 0pt
wire-count = 1; wire-stroke = wire
prev-wire-x = center-x-coords.at(0)
} else if utility.is-circuit-meta-instruction(item) {
if item.qc-instr == "setwire" {
wire-count = item.wire-count
wire-distance = item.wire-distance
if item.stroke != none { wire-stroke = item.stroke }
} else if item.qc-instr == "gategroup" {
assert(item.wires > 0, message: "gategroup: wires arg needs to be > 0")
assert(row+item.wires <= rowheights.len(), message: "gategroup: height exceeds range")
assert(item.steps > 0, message: "gategroup: steps arg needs to be > 0")
assert(col+item.steps <= colwidths.len(), message: "gategroup: width exceeds range")
let y1 = layout.get-cell-coords(center-y-coords, rowheights, row)
let y2 = layout.get-cell-coords(center-y-coords, rowheights, row + item.wires - 1e-9)
let x1 = layout.get-cell-coords(center-x-coords, colwidths, col)
let x2 = layout.get-cell-coords(center-x-coords, colwidths, col + item.steps - 1e-9)
let (result, b) = draw-functions.draw-gategroup(x1, x2, y1, y2, item, draw-params)
bounds = layout.update-bounds(bounds, b, draw-params.em)
result
} else if item.qc-instr == "slice" {
assert(item.wires >= 0, message: "slice: wires arg needs to be > 0")
assert(row+item.wires <= rowheights.len(), message: "slice: number of wires exceeds range")
let end = if item.wires == 0 {rowheights.len()} else {row+item.wires}
let y1 = layout.get-cell-coords(center-y-coords, rowheights, row)
let y2 = layout.get-cell-coords(center-y-coords, rowheights, end)
let x = layout.get-cell-coords(center-x-coords, colwidths, col)
let (result, b) = draw-functions.draw-slice(x, y1, y2, item, draw-params)
bounds = layout.update-bounds(bounds, b, draw-params.em)
result
} else if item.qc-instr == "annotate" {
let rows = layout.get-cell-coords(center-y-coords, rowheights, item.rows)
let cols = layout.get-cell-coords(center-x-coords, colwidths, item.columns)
let annotation = (item.callback)(cols, rows)
if type(annotation) == "dictionary" {
assert("content" in annotation, message: "Missing field 'content' in annotation")
let (content, b) = layout.place-with-labels(
annotation.content,
dx: annotation.at("dx", default: 0pt),
dy: annotation.at("dy", default: 0pt),
draw-params: draw-params
)
content
bounds = layout.update-bounds(bounds, b, draw-params.em)
} else if type(annotation) == "content" {
place(annotation)
} else {
assert(false, message: "Unsupported annotation type")
}
}
// ---------------------------- Gates & Co. ------------------------------
} else if utility.is-circuit-drawable(item) {
let isgate = utility.is-gate(item)
let size = utility.get-size-hint(item, draw-params)
let single-qubit-height = size.height
let center-x = center-x-coords.at(col)
let top = center-y - single-qubit-height / 2
let bottom = center-y + single-qubit-height / 2
if isgate {
item.qubit = row
if item.box == false {
bottom = center-y
top = center-y
}
if item.multi != none {
if item.multi.target != none {
let target-qubit = row + item.multi.target
assert(center-y-coords.len() > target-qubit, message: "Target qubit for controlled gate is out of range")
let y1 = center-y
let y2 = center-y-coords.at(target-qubit)
if item.multi.wire-label.len() == 0 {
draw-functions.draw-vertical-wire(
y1,
y2,
center-x,
wire,
wire-count: item.multi.wire-count,
)
} else {
let (result, gate-bounds) = draw-functions.draw-vertical-wire-with-labels(
y1,
y2,
center-x,
wire,
wire-count: item.multi.wire-count,
wire-labels: item.multi.wire-label,
draw-params: draw-params
)
result
bounds = layout.update-bounds(bounds, gate-bounds, draw-params.em)
}
}
let nq = item.multi.num-qubits
if nq > 1 {
assert(row + nq - 1 < center-y-coords.len(), message: "Target
qubit for multi qubit gate does not exist")
let y1 = center-y-coords.at(row + nq - 1)
let y2 = center-y-coords.at(row)
draw-params.multi.wire-distance = y1 - y2
size = (item.size-hint)(item, draw-params)
}
}
}
let current-wire-x = center-x
draw-functions.draw-horizontal-wire(prev-wire-x, current-wire-x, center-y, wire-stroke, wire-count, wire-distance: wire-distance)
if isgate and item.box { prev-wire-x = center-x + size.width / 2 }
else { prev-wire-x = current-wire-x }
let x-pos = center-x
let y-pos = center-y
let offset = size.at("offset", default: auto)
if offset == auto {
x-pos -= size.width / 2
y-pos -= single-qubit-height / 2
} else if type(offset) == "dictionary" {
let offset-x = offset.at("x", default: auto)
let offset-y = offset.at("y", default: auto)
if offset-x == auto { x-pos -= size.width / 2}
else if type(offset-x) == "length" { x-pos -= offset-x }
if offset-y == auto { y-pos -= single-qubit-height / 2}
else if type(offset-y) == "length" { y-pos -= offset-y }
}
let content = utility.get-content(item, draw-params)
let result
if isgate {
let gate-bounds
(result, gate-bounds) = layout.place-with-labels(
content,
size: if item.multi != none and item.multi.num-qubits > 1 {auto} else {size},
dx: x-pos, dy: y-pos,
labels: item.labels, draw-params: draw-params
)
bounds = layout.update-bounds(bounds, gate-bounds, draw-params.em)
} else {
result = place(
dx: x-pos, dy: y-pos,
if isgate { content } else { box(content) }
)
}
to-be-drawn-later.push(result)
x += colwidths.at(col)
col += 1
draw-params.multi.wire-distance = 0pt
} else if type(item) == "integer" {
col += item
// let t = col
// if col == center-x-coords.len() { t -= 1}
let center-x = center-x-coords.at(col - 1)
draw-functions.draw-horizontal-wire(prev-wire-x, center-x, center-y, wire-stroke, wire-count, wire-distance: wire-distance)
prev-wire-x = center-x
}
} // end loop over items
for item in to-be-drawn-later {
item
}
}) // end circuit = block(..., {
/////////// END Second pass: Generation ///////////
// grace period backwards-compatibility:
let scale = scale
if scale-factor != 100% { scale = scale-factor }
let scale-float = scale / 100%
if circuit-padding != none {
let circuit-padding = process-args.process-padding-arg(circuit-padding)
bounds.at(0) -= circuit-padding.left
bounds.at(1) -= circuit-padding.top
bounds.at(2) += circuit-padding.right
bounds.at(3) += circuit-padding.bottom
}
let final-height = scale-float * (bounds.at(3) - bounds.at(1))
let final-width = scale-float * (bounds.at(2) - bounds.at(0))
let thebaseline = baseline
if type(thebaseline) in ("content", "string") {
thebaseline = height/2 - measure(thebaseline, styles).height/2
}
if type(thebaseline) == "fraction" {
thebaseline = 100% - layout.get-cell-coords1(center-y-coords, rowheights, thebaseline / 1fr) + bounds.at(1)
}
box(baseline: thebaseline,
width: final-width,
height: final-height,
// stroke: 1pt + gray,
move(dy: -scale-float * bounds.at(1), dx: -scale-float * bounds.at(0),
layout.std-scale(
x: scale,
y: scale,
origin: left + top,
circuit
))
)
})
} |
https://github.com/ufodauge/master_thesis | https://raw.githubusercontent.com/ufodauge/master_thesis/main/src/template/components/common/empty.typ | typst | MIT License | #let Empty = par[#text(size:0.5em)[#h(0.0em)]] |
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/020%20-%20Prologue%20to%20Battle%20for%20Zendikar/005_Unkindness%20of%20Ravens.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"Unkindness of Ravens",
set_name: "Prologue to Battle for Zendikar",
story_date: datetime(day: 29, month: 07, year: 2015),
author: "<NAME>",
doc
)
#emph[<NAME> is perhaps the most powerful necromancer in the Multiverse, but her life has been haunted by mighty entities that seek to control her. The dragon Planeswalker <NAME>, the four demons she bargained with to gain her power, and the mysterious Chain Veil have all exerted their powerful influence over her, leading her down paths of betrayal and murder. And the meddling of an even more enigmatic figure—the Raven Man—led to the death of her brother and the ignition of her Planeswalker spark. Her every effort now is directed toward seeking her freedom, with slaying her demon masters and breaking the hold of the Chain Veil at the top of her list.]
#emph[But while she focuses on these masters, the other forces pulling on her won't simply leave her alone.]
#v(0.35em)
#line(length: 100%, stroke: rgb(90%, 90%, 90%))
#v(0.35em)
<NAME> waded into the teeming streets of Ravnica's elegant Second District. She strode through the crowd, which parted like water around her. She adjusted the top of one long glove, and the croak of a nearby raven just barely touched her awareness over the din of the crowds—the crowd of people in the city and the crowd of spirits pressing at her thoughts.
#emph[Did Jace hear them?] she wondered. It was hard to imagine that he hadn't—the Onakke spirits were a constant hubbub in her mind, and Jace's telepathic abilities had surely picked up on the noise. But he'd given no indication that he had discerned their presence, or indeed that he had any idea what the Chain Veil was doing to her.
#emph[Do] I #emph[have any idea what this thing is doing to me?]
As if in response, the voices in her mind surged in volume. ". . .Vessel of destruction . . . root. . ."
"Oh, shut up," she snarled, giving her head a small, fierce shake that freed a single lock of hair from her headdress and left the strand hanging over one eye. A young vedalken's eyes widened at her outburst, and he ducked quickly out of her path. She tucked her hair back into place, and the voices subsided.
They had been strongest on Shandalar, of course. It was the Onakke's home plane. Here on Ravnica, or on Innistrad, or any of the other half dozen planes she'd visited recently, they usually remained at the level of background noise. In the context of her conversation with Jace, though, that background noise had felt more like a clattering of kitchen pots, and she couldn't quite believe he hadn't noticed the clamor.
#emph[Maybe he would have,] she thought, #emph[if we hadn't been interrupted.]
And if he had noticed? What then? #emph[Maybe he would have helped.]
Liliana had come to Jace in search of a loophole, a way out of the mess she'd landed in. The power of the Chain Veil was immeasurable. It had allowed her to kill Kothophed and Griselbrand, two of the demons to whom she owed her soul—part of the pact she'd made to regain some of the godlike magic she had lost with the Mending.
But in the process of trying to free herself from one bargain for power, she had unwittingly entered into another. The Chain Veil's magic came with a cost, a terrible toll on both her body and her mind. In desperation, she had taken it back to Shandalar and tried to leave it there, but she found that she couldn't. It was bound to her, and her to it.
#emph[There has to be a way out.]
#figure(image("005_Unkindness of Ravens/01.jpg", width: 100%), caption: [The Chain Veil | Art by Volkan Baga], supplement: none, numbering: none)
Jace was supposed to help her find it—some way for her to continue using the Chain Veil without being enslaved by it and the spirits it carried. Jace was nothing if not clever, and if the Veil had some kind of hold on her mind, she felt confident that he could help her break it.
Instead, Jace had asked #emph[her] for help, after that soldier, Gideon, showed up. She scoffed aloud at the thought, drawing startled glances from the people around her. A well-dressed merchant met her gaze, then blanched and lost himself in the crowd. A goblin found himself squarely in her path and scurried quickly away, not daring to look up at her.
And a raven, perched on a wall nearby, fixed a glossy black eye on her. She scowled at it and walked on.
Gideon had come to the restaurant, interrupted their conversation, and practically begged Jace to come with him to Zendikar, some backwoods nowhere plane he'd said was being devoured by giant monsters. Liliana had almost laughed him out of the building—as if she or Jace could bother with such a place. As the Living Guildpact, Jace had Ravnica to worry about, after all; and besides, he was going to help #emph[her.]
But he hadn't. Instead, he had agreed to help Gideon. "I know you'll do the right thing," Gideon had said—and Jace fell for it. And then he'd been ridiculous enough to ask Liliana to come with him. She scoffed again at the thought of it.
Then a sort of weight settled in her chest, and she frowned. She and Jace had shared some good times, had some fun together, and seeing him again had conjured up some surprising feelings. They had shared a house, and a bed, in one of Ravnica's poorer districts. She had helped him through a rough time, the dear boy . . . before sticking a metaphorical knife in his back and returning to <NAME>, who she thought was going to help her extricate herself from the demonic pact that he had helped broker.
#figure(image("005_Unkindness of Ravens/02.jpg", width: 100%), caption: [Demonic Pact | Art by Aleksi Briclot], supplement: none, numbering: none)
#emph[What if this time could be different? What if I went with him and helped him?]
Maybe they would have some more good times. Maybe she could enjoy his company, even if it meant putting up with Gideon's self-righteous arrogance—#emph[he's almost as bad as an angel,] she thought. #emph[I know you'll do the right thing, indeed. ] But maybe taking on some giant monsters and raising up their huge corpses to fight for her would be . . . fun?
"Ugh," she said. Fighting Gideon's monsters would mean using the Chain Veil again, and she was right back where she had started.
A flutter of black wings in her face brought her up short. Another raven—
#emph[Raven Man.]
The croak of a raven. A raven on the wall. Now a startled raven in her face. She had been oblivious, and she silently cursed herself as she looked around, finally noticing where her feet had taken her while she'd been lost in her thoughts.
She stood at the edge of a small, deserted courtyard. An old fountain, dry and crusted with lime, provided a perch for fully a dozen ravens, each cocking its head to turn an eye toward her. More of the birds hopped over the cracked cobblestones or flapped from roof to roof on the buildings surrounding the yard. One bird, stretching tall from its perch atop the fountain, uttered a short series of knocking sounds, then snapped its beak at her.
"All right, Raven Man," Liliana said. "Enough of your games."
All at once, the ravens perched on the fountain sprang into the air in a flurry of beating black wings. They formed a churning cloud of feathers and harsh calls just above the cobblestones, and then the Raven Man stepped forward from their midst—and the birds were gone.
Liliana clapped her hands slowly and drawled, "Oh, well done. Do show me another trick."
He looked no different than when she had first met him, back home among the trees of the Caligo Forest. The intervening century had left no greater mark on him than it had on her own features. Garbed in black and gold, with white hair and golden eyes, he seemed as much a vision from her past as a living man, but he reached out and placed a very solid hand on her shoulder.
#figure(image("005_Unkindness of Ravens/03.jpg", width: 100%), caption: [Art by <NAME>], supplement: none, numbering: none)
"You need help," he said.
Liliana shrugged his hand off her shoulder and moved a step farther away from him. No encounter with the Raven Man had ever ended well for her—or for those she loved.
"And I suppose you're here to offer it?" she said.
He scoffed. "Would you accept it if I did?"
"Of course not."
"I don't think you know how to accept help," he said, stepping closer again.
"I don't need it," she said. She planted a hand on his chest and pushed him two steps back. "Everything's under control."
"Ah, I see." He looked amused, and a sudden desire to blast the ridiculous smirk from his face seized her. "So what is your next move?"
"Scouring you from the earth and turning you and all your little bird friends into my zombie minions."
The Raven Man chuckled.
"Tell me why I shouldn't do it," she said.
"You make it sound so easy." He shrugged. "Maybe you should."
"It would be easy," she said, but there was no pleasure in it. It would be easy because of the Chain Veil. She could already feel its power surging up in her, as if it were anxious to be put to use. And with it, the Onakke voices grew louder in her mind. She turned away from him, shaking her head to clear them away.
She felt his breath on her ear. "Turning your back on an enemy, <NAME>?" Something pricked through her gown in the small of her back—he held a dagger.
"I don't fear you," she said, and a ring of darkness burst out around her, driving the Raven Man back.
"Of course you do," he said.
She wheeled around to face him again. "Who are you?" she demanded. "You're a Planeswalker—I met you on Dominaria, on Shandalar, and now here. You're a shapeshifter, obviously. And you spoke to me with the mouth of a corpse on Shandalar. Who—what are you?"
His lip curled into a smile more cruel than amused, but he said nothing.
#figure(image("005_Unkindness of Ravens/04.jpg", width: 100%), caption: [Art by <NAME>], supplement: none, numbering: none)
"You spoke of the Chain Veil as though the whole thing were your idea—#emph[you] cultivated the root of evil, the Veil of deceit, the vessel of destruction." As she said the words, the Onakke spirits echoed them in her mind, with hissing whispers that resounded like the inside of a mausoleum. "But Kothophed sent me to fetch the Chain Veil for him."
"Yet you did not return it to him."
"I run errands for no one. Did you somehow give the demon the idea of sending me after it? You certainly planted the seed of #emph[his] destruction if you did."
"You are the vessel for a much greater destruction than that."
His words sent a cold prickle running down her back, but she stepped closer to him with a sly smile. "Oh, yes," she said. "I bring destruction wherever I go. Which brings me back to my earlier question—why again should I not destroy you? Right now?"
"What about your own destruction?"
She scowled. "What are you talking about?" In her darkest moments, she had begun to fear that the Chain Veil did carry the seeds of her own destruction, that after fighting so long and so hard to avoid death, she had taken it into herself. But she wasn't going to admit that fear to the Raven Man—or, indeed, show him any fear at all.
"Look around you, Lili," the Raven Man said.
"Don't call me that."
He ignored her. "Death is staring at you from every side."
She did glance around, without meaning to. Ravens were everywhere, dozens of glassy black eyes fixed on her.
#figure(image("005_Unkindness of Ravens/05.jpg", width: 100%), caption: [Raven Familiar | Art by <NAME>], supplement: none, numbering: none)
"Two more demons still hold you bound by the words on your skin, and those two are mightier than the first. The Veil you wear so brazenly at your hip takes more and more of your strength every time you use it. But without it, your demons will tear your heart from your chest."
"I haven't had a heart for a very long time." An unwanted memory of Jace flitted through her mind.
"And that's not all. The beastmage you cursed is still hunting you, killing more and more Planeswalkers as he searches for signs of your passage. Even your beloved Jace is inviting you to your death."
She opened her mouth to retort—then closed it again, furrowing her brow. "Oh, so shall we add mind mage to your list of accomplishments?" she said. "Get out of my head, Raven Man. There's no room for one more."
He ignored her. "Every side," he repeated.
"Yes, well, I'm quite accustomed to the presence of death."
"You're accustomed to murder," he snapped. "You're accustomed to corpses that are bound to your will. You're accustomed to using death as a weapon. But death is coming for you, Lili. Death you can't control. It is growing inside you, and there is nothing you can do."
"There is #emph[always] —" She lifted her hands, and a blinding flare of purplish light streaked out from her—her hands, her eyes, the glowing whorls and writing engraved on her skin, and the little skull-shaped beads that adorned the Chain Veil—to engulf the Raven Man in a conflagration of magic.
"—something to do," she finished.
#figure(image("005_Unkindness of Ravens/06.jpg", width: 100%), caption: [Art by <NAME>], supplement: none, numbering: none)
Dead ravens and tattered feathers littered the cobblestones where the Raven Man had stood. A flurry of wings beat the air right behind her, and she whirled to see him emerge from another cloud of birds, his dagger bared. She grabbed his wrist and tugged at the vital energy that pulsed in his veins. The blade clattered to the ground as he dissolved again into a dozen croaking ravens, their wings battering her face and arms. Her hand gripped a single dead bird.
"Fine," she said. "I can make my own flock."
The bird in her hand squirmed and wriggled free, now a tiny zombie bound to her will. Around the courtyard, more zombie ravens lifted themselves off the stone, hopping and fluttering toward her. When another cluster of living birds began to form, her own little minions threw themselves into it, tearing with sharp claws and heavy beaks to rend the living flesh. She thought for a moment that she saw the Raven Man start to emerge from the frenzy, but he threw up his hands and was gone. A mere handful of ravens escaped the fray, fluttering high above the buildings and scattering to the winds.
Liliana felt a trickle run down her shoulder. Looking down at her skin, she saw blood welling up in all the places where the purplish lines of her demonic contract were fading from view. Just tiny pinpricks of crimson—but then, she had barely tapped the full power of the Chain Veil.
She sat down on the edge of the fountain to catch her breath and gather her thoughts. It was true—she was trapped. If she continued using the Chain Veil like this, it might drain the life out of her by the time she killed her two remaining demons. If she tried to face her demons without the power of the Chain Veil, they would tear her apart. Helping Jace fight Zendikar's giant monsters presented the same choice: death if she used the Veil, death if she didn't.
"I #emph[don't] need help," she said aloud. #emph[Jace can go solve Gideon's puzzle. I'll solve my own.]
She stood up, closed her eyes, and took a deep breath. Her stomach lurched a bit as she pulled open a door between worlds.
Just as she stepped through, she heard the mocking cry of a raven at her back.
#figure(image("005_Unkindness of Ravens/07.jpg", width: 100%), caption: [Carrion Crow | Art by <NAME>], supplement: none, numbering: none)
|
|
https://github.com/HPDell/touying-brandred-uobristol | https://raw.githubusercontent.com/HPDell/touying-brandred-uobristol/main/README.md | markdown | MIT License | # Touying slide template for University of Bristol
Inspired by the brand guidelines of University of Bristol and modified from the Metropolis theme.
## Use as Typst Template Package
Use the following command to create a new project with this theme.
```bash
typst init @preview/touying-uobristol
```
## Examples
See the [examples](./examples/example.typ) and [output](./examples/example.pdf) for more details.
Licensed under the [MIT License](LICENSE).
|
https://github.com/SWATEngineering/Docs | https://raw.githubusercontent.com/SWATEngineering/Docs/main/src/2_RTB/NormeDiProgetto/content.typ | typst | MIT License | #import "functions.typ": glossary, team
/*************************************/
/* INSERIRE SOTTO IL CONTENUTO */
/*************************************/
#show link: underline
= Introduzione
== Scopo del documento
Il presente documento ha l'obiettivo di definire le #glossary[best practices] e il #glossary[way of working] che ogni componente del team #team ha l'obbligo di rispettare durante l'intero svolgimento del progetto. In questo modo si prova a garantire un metodo di lavoro omogeneo, verificabile e migliorabile nel tempo. La formulazione delle norme avviene in modo progressivo, consentendo al team di apportare aggiornamenti continui in risposta alle esigenze sviluppatesi e alle problematiche incorse nel corso del lavoro.
== Scopo del prodotto
Il progetto "InnovaCity" si concentra sulla creazione di una #glossary[dashboard] intuitiva, ovvero facilmente comprensibile e accessibile, che permetta al personale amministrativo di monitorare e analizzare il continuo sviluppo di una #glossary[smart city]. L'applicazione comprende una #glossary[data pipeline], appositamente progettata per elaborare dati provenienti da una varietà di simulatori di sensori. Questa pipeline consente la gestione e la visualizzazione ottimale di tali dati, permettendo agli utenti di ottenere rapidamente informazioni rilevanti. L'obiettivo finale è fornire uno strumento per prendere decisioni informate riguardo alla gestione delle risorse della città.
== Glossario
Al fine di evitare possibili ambiguità relative al linguaggio utilizzato nei documenti, viene
fornito il _Glossario v1.0_, nel quale sono presenti tutte le definizioni di termini aventi un significato specifico che vuole essere disambiguato. Tali termini, sono scritti in corsivo e marcati con una #sub("G") a pedice.
L'attività di inserimento di un termine nel glossario può considerarsi completata solo quando il termine viene correttamente definito e spiegato all'interno del _Glossario_.
== Riferimenti
=== Riferimenti normativi
- *Capitolato d'appalto C6 - InnovaCity*:\
#link("https://www.math.unipd.it/~tullio/IS-1/2023/Progetto/C6.pdf")
=== Riferimenti informativi
- *#glossary[Documentazione] git*:\
#link("https://git-scm.com/docs")
- *#glossary[Documentazione] GitHub*:\
#link("https://docs.github.com/en")
- *Materiale didattico del corso Metodi e Tecnologie per lo Sviluppo Software 2022/2023*:\
#link("https://stem.elearning.unipd.it/course/view.php?id=5359")
- Lezione 4: GIT;
- Laboratorio 2: GitHub Version Control System.
- *#glossary[Documentazione] #glossary[Typst]*:\
#link("https://typst.app/docs")
= Processi primari
== Fornitura
=== Descrizione e scopo
Il processo di fornitura si propone di dettagliare le attività del fornitore per comprendere e soddisfare le richieste della Proponente.
Dopo la completa comprensione delle esigenze, il fornitore, in collaborazione con la Proponente, stabilisce tramite contratto la data di consegna del prodotto. Successivamente, si procede con la redazione del _Piano di Progetto_, per pianificare dettagliatamente le varie attività da svolgere, garantendo un chiaro processo di sviluppo del prodotto finale. L'obiettivo principale è soddisfare in modo chiaro le richieste della Proponente, evitando possibili incomprensioni attraverso una collaborazione continua.
Il processo si articola in diverse fasi:
- Definizione chiara dei requisiti soddisfatti dal prodotto finale;
- *Contrattazione*:
+ Richiesta di incontri di formazione sulle tecnologie consigliate per ottimizzare lo sviluppo;
+ Ricezione di un feedback approfondito sull'utilizzo delle tecnologie proposte.
- *Pianificazione*: individuazione preventiva di una suddivisione precisa di tutte le ore produttive disponibili, seguita da una stima dei costi per ciascun incremento di lavoro (#glossary[sprint]);
- *Esecuzione*: progettazione e sviluppo del prodotto procedono di pari passo con la stesura della #glossary[documentazione] relativa al progetto;
- Continuo controllo e verifica;
- Completamento e consegna.
=== Rapporti con la Proponente
La Proponente si è resa disponibile attraverso vari canali, come e-mail, Google Meet e Element, per stabilire una comunicazione frequente e risolvere prontamente eventuali dubbi o domande che possono emergere durante lo svolgimento del progetto. Sin dall'inizio si è concordato di organizzare incontri regolari, in particolare al termine di ciascuno #glossary[sprint], fissati per il venerdì alle 10:30. Questi incontri, che assumono la forma di sessioni di #glossary[sprint review], consentono al team di esporre quanto realizzato e di ricevere feedback sull'andamento del lavoro.
Gli incontri con la Proponente si suddividono principalmente in tre categorie:
- *Incontri di formazione*: finalizzati ad acquisire familiarità con nuove tecnologie, approfondire concetti specifici o migliorare competenze richieste dal progetto;
- *Incontri di analisi dei requisiti*: mirati a chiarire, discutere e validare i requisiti del progetto, garantendo una comprensione chiara e condivisa tra il team e la Proponente;
- *#glossary[Sprint review]*: fase conclusiva di ogni #glossary[sprint] durante la quale vengono presentati i risultati ottenuti, con l'intento di ricevere feedback dalla Proponente.
Ogni incontro con la Proponente viene sintetizzato e documentato nel verbale esterno di riferimento. Il verbale viene successivamente presentato alla Proponente per essere validato tramite firma, ottenendo così un'approvazione formale del resoconto delle discussioni avvenute all'incontro.
=== Documentazione fornita
Di seguito vengono elencati i documenti che il team #team si impegna a consegnare ai Committenti Prof. <NAME> e Prof. <NAME>, nonché alla Proponente Sync Lab.
==== Analisi dei Requisiti
L’_Analisi dei Requisiti v1.0_, redatto dagli Analisti, rappresenta un documento fondamentale per lo sviluppo del #glossary[sistema] software. Il suo obiettivo principale è definire in dettaglio le funzionalità necessarie affinché il prodotto soddisfi pienamente le richieste della Proponente. Il documento omonimo comprende una serie di elementi essenziali:
- *Definizione degli attori*: entità o persone che interagiscono con il #glossary[sistema]\;
- *Definizione dei casi d'uso*: rappresentazione narrativa di scenari specifici che descrivono come gli attori interagiscono con il #glossary[sistema]. I casi d'uso offrono una visione chiara delle azioni eseguibili all'interno del #glossary[sistema] e delle interazioni degli utenti con esso. All'interno di ciascun caso d'uso, viene fornito un elenco preciso delle azioni intraprese dall'#glossary[attore] per attivare il caso d'uso, facilitando così l'estrazione dei requisiti corrispondenti;
- *Definizione di requisiti*: individuazione dei requisiti obbligatori, desiderabili e opzionali e loro categorizzazione in:
- *Requisiti funzionali*: specificano le operazioni che il #glossary[sistema] deve essere in grado di eseguire;
- *Requisiti di qualità*: si concentrano sulla definizione degli standard e degli attributi che il software deve possedere per garantire prestazioni, affidabilità, usabilità e sicurezza ottimali;
- *Requisiti di vincolo*: delineano vincoli e limitazioni che il #glossary[sistema] deve rispettare. Possono includere restrizioni tecnologiche, normative o di risorse.
==== Piano di Progetto
Il _Piano di Progetto v1.0_, redatto dal Responsabile, offre una visione dettagliata dell'intero processo di sviluppo di un progetto. Esso fornisce al team una guida approfondita per mantenere l'allineamento con gli obiettivi, gestire le risorse in modo efficace e affrontare le sfide che possono emergere durante lo sviluppo del progetto.
Si compone delle seguenti sezioni:
- *Analisi dei rischi*: identifica, valuta e gestisce i potenziali rischi che possono influenzare il successo del progetto. Questo processo è essenziale per consentire al team di adottare misure preventive. I rischi vengono categorizzati in rischi tecnologici, di comunicazione e di pianificazione. Per ogni rischio, si compie un'analisi mirata per individuarne i segnali di manifestazione, valutarne l'occorrenza e la pericolosità e pianificare strategie di mitigazione;
- *Modello di sviluppo*: approccio metodologico scelto per guidare il processo di sviluppo del prodotto. Esso definisce la struttura di lavoro che viene seguita per l'intero ciclo di vita del progetto. Con l'adozione del modello di sviluppo agile Scrum, questa sezione descrive le pratiche e gli eventi principali del #glossary[framework], illustrando il modo in cui vengono utilizzati ed implementati dal team;
- *Pianificazione*: fornisce una roadmap dettagliata delle attività, delle risorse, e delle scadenze associate al progetto. In particolare, vengono pianificate le attività necessarie per raggiungere gli obiettivi previsti per ogni #glossary[sprint], dall'inizio sino al termine del progetto, e la loro distribuzione temporale;
- *Preventivo*: basandosi sulla pianificazione eseguita a priori, determina la ripartizione delle ore produttive a disposizione di ogni componente del team nei vari ruoli per ogni #glossary[sprint]. Questo assicura il conseguimento degli obiettivi prefissati e un utilizzo oculato delle risorse. La suddivisione delle ore determina altresì, il costo preventivato per ogni #glossary[sprint]\;
- *Consuntivo*: partendo dalla rendicontazione delle ore produttive impiegate da ciascun membro del team eseguita a posteriori, determina la ripartizione effettiva delle ore osservata durante lo #glossary[sprint] e, di conseguenza, anche il costo effettivo. Inoltre, si conduce una breve analisi retrospettiva per giustificare le scelte effettuate nel preventivo, evidenziare eventuali deviazioni e delineare i cambiamenti nella strategia utilizzata per pianificare il resto del lavoro, qualora dovessero rendersi necessari.
==== Piano di Qualifica
Il _Piano di Qualifica v1.0_, redatto dall'Amministratore, descrive le strategie e gli approcci adottati per garantire la qualità del prodotto o del servizio che si sta sviluppando. Il suo scopo principale è quello di definire le modalità di verifica e validazione, nonché gli standard e le procedure di qualità che verranno seguite durante l'intero ciclo di vita del progetto.
Si compone delle seguenti sezioni:
- *Qualità di processo*: standard e procedure adottate per garantire la qualità durante lo sviluppo del progetto. Include informazioni sulle attività di gestione della qualità, le metodologie utilizzate, e come vengono misurati e migliorati i processi stessi;
- *Qualità di prodotto*: standard, specifiche e caratteristiche che il prodotto deve soddisfare per essere considerato di qualità. Include anche le metriche e i criteri di valutazione utilizzati per misurare la qualità del prodotto;
- *Specifiche dei test*: specifiche dettagliate dei test che verranno condotti durante lo sviluppo del progetto;
- *Cruscotto delle metriche*: resoconto delle attività di valutazione effettuate durante il progetto. Le valutazioni risultano fondamentali a tracciare l'andamento del progetto rispetto agli obiettivi e alle aspettative, e a identificare prontamente eventuali azioni correttive necessarie a garantire la qualità complessiva del progetto.
==== Glossario
Il _Glossario v1.0_ funge da catalogo esaustivo che raccoglie i termini tecnici impiegati all'interno del progetto, offrendo definizioni chiare e precise. Questo documento previene fraintendimenti e promuove una comprensione condivisa della terminologia specifica del settore, migliorando così la coerenza e la qualità della #glossary[documentazione] prodotta dal team.
==== Lettera di Presentazione
La _Lettera di Presentazione_ accompagna la consegna del prodotto software e della #glossary[documentazione] pertinente, sottolineando l'impegno che il team #team si assume nel completare e consegnare il prodotto entro le scadenze concordate. Inoltre, espone un preventivo aggiornato rispetto a quello presentato in occasione dell'ultima revisione. In questo contesto, costo e data di consegna del progetto sono attentamente valutati in relazione all'andamento corrente e vengono confermati o eventualmente modificati in risposta alle dinamiche emergenti durante l'evoluzione del progetto.
=== Strumenti
Gli strumenti adottati per agevolare il processo di fornitura sono i seguenti:
==== Google Calendar
Strumento di calendario, utilizzato dal team per gestire impegni e attività in modo organizzato, oltre che per condividere eventi con la Proponente.
==== Google Slides
Servizio di creazione di presentazioni multimediali, utilizzato dal team per assemblare i diari di bordo.
==== Google Sheets
Servizio di creazione di #glossary[spreadsheet], utilizzato dal team per la rendicontazione delle ore produttive impiegate da ciascun componente nel corso di uno #glossary[sprint].
==== Google Meet
Servizio per creare e partecipare a videochiamate, utilizzato dal team per gli incontri telematici con la Proponente.
==== Online Gantt
Online software per creare diagrammi di Gantt, utilizzato dal Responsabile per delineare la distribuzione temporale delle attività pianificate per ogni #glossary[sprint] nella sezione di *Pianificazione* del _Piano di Progetto v1.0_.
==== Draw.io
Software per creare diagrammi e grafici di varia natura, utilizzato dagli Analisti per creare i diagrammi #glossary[UML] dei casi d'uso nella sezione Casi d'uso dell'_Analisi dei Requisiti v1.0_.
=== Metriche
La definizione delle metriche seguenti si può trovare nella @metriche_fornitura.
#figure(
table(
columns:(auto,auto),
align: (x, y) => (center, center).at(x),
fill:(_,row) =>if row==0 {luma(150)} else if calc.odd(row) { luma(220)} else {white},
[*Metrica*],[*Descrizione*],
[*BAC*],[Budget At Completion],
[*EV*],[Earned Value],
[*PV*],[Planned Value],
[*SV*],[Schedule Variance],
[*AC*],[Actual Cost],
[*CPI*],[Cost Performance Index],
[*EAC*],[Estimated At Completion],
[*ETC*],[Estimated To Completion],
[*VAC*],[Variance At Completion],
[*BV*],[Budget Variance]
),
caption:[Metriche di fornitura],
)
== Sviluppo
=== Descrizione e scopo
Il processo di sviluppo rappresenta la serie di attività che devono essere svolte affinché il team #team riesca nell'implementazione del prodotto software, rispettando i requisiti e le date di scadenza concordate con la Proponente. In particolare, si ha:
- *Analisi dei requisiti*;
- *Progettazione*;
- *Codifica*.
=== Analisi dei Requisiti
==== Descrizione
L'_Analisi dei Requisiti v1.0_ viene redatta dagli Analisti e contiene:
- *Introduzione*: esplicita lo scopo del documento, lo scopo del prodotto e i riferimenti utilizzati;
- *Descrizione*: esplicita le funzionalità attese del prodotto e le caratteristiche degli utenti;
- *Attori*: gli utilizzatori del prodotto finale;
- *Casi d'uso*: individua gli attori e tutte le interazioni che possono avere con il #glossary[sistema]\;
- *Requisiti*: le caratteristiche da soddisfare e le fonti da cui sono state estratte.
==== Scopo
Lo scopo dell'_Analisi dei Requisiti v1.0_ è definire in modo dettagliato e chiaro le funzionalità e le caratteristiche che il prodotto software deve soddisfare. Questo processo mira a comprendere a fondo le esigenze degli utenti, gli obiettivi del #glossary[sistema] e le condizioni in cui dovrà operare. Gli obiettivi principali dell'attività di analisi dei requisiti includono:
- Identificare e chiarire gli obiettivi e le finalità del prodotto che si intende sviluppare;
- Fornire ai Progettisti una base chiara e comprensibile per la definizione dell'#glossary[architettura] e il design del #glossary[sistema]\;
- Fornire una base per la pianificazione mediante i requisiti raccolti;
- Facilitare la comunicazione tra fornitori e Proponente;
- Fornire riferimenti per la verifica.
==== Diagrammi #glossary[UML] dei casi d'uso
Un diagramma dei casi d'uso rappresenta uno strumento di modellazione ampiamente impiegato per documentare e delineare le funzionalità di un #glossary[sistema]. La sua utilità risiede nel tracciare i flussi operativi attraverso una rappresentazione visiva, descrivendo il modo in cui un utente interagisce con il #glossary[sistema].
Gli scenari d'uso sono organizzati in sequenze di azioni, illustrando le operazioni necessarie per consentire a un utente di portare a termine una specifica attività (realizzare uno scopo), e sono interconnessi mediante linee. Questo tipo di diagramma risulta particolarmente prezioso nella progettazione di sistemi, in quanto offre un'illustrazione rapida e intuitiva delle dinamiche di lavoro e delle interazioni tra l'utente e il #glossary[sistema].
È fondamentale notare che la rappresentazione fornita dai diagrammi dei casi d'uso non si addentra nei dettagli implementativi, poiché il loro scopo principale è descrivere la funzionalità, considerandola come un elemento esterno al #glossary[sistema].
I diagrammi dei casi d'uso sono composti da:
- *#glossary[Attore]*: rappresenta un agente esterno coinvolto nelle interazioni con il #glossary[sistema]. Si tratta di una qualsiasi entità in grado di interagire con il #glossary[sistema]\; infatti ogni caso d'uso determina una funzionalità che viene messa a disposizione di tale #glossary[attore], tuttavia, senza entrare nei dettagli implementativi.
A livello di diagramma, l'#glossary[attore] è simboleggiato da un'icona umana stilizzata, identificabile mediante un'etichetta univoca e rappresentativa, posizionata sotto di essa.
#figure(
image(
"assets/imgs/Attore.png",
width: 10%
),
caption: "Figura rappresentante un attore."
)
- *Caso d'uso*: delinea le operazioni eseguibili dall'utente sul #glossary[sistema]. Un singolo caso d'uso si compone di una breve esposizione delle funzioni messe a disposizione del #glossary[sistema] per uno o più utenti nell'ambito di un software. In modo specifico, offre una descrizione dettagliata del comportamento dell'utente mentre interagisce con il software.
Generalmente, un caso d'uso è costituito da una sequenza di situazioni che esplicitano le diverse eventualità che possono manifestarsi durante l'interazione tra l'utente e il software. La sua rappresentazione comprende un'identificazione univoca, espressa come UCx.y (dove x indica il numero del caso d'uso, e y indica il fatto che si sta trattando un eventuale sotto-caso d'uso del caso d'uso UCx), seguita da una concisa ma completa descrizione della funzione stessa.
Ogni caso d'uso discute i seguenti punti:
- *#glossary[Attore] principale*: l'#glossary[attore] che intende compiere lo scopo rappresentato dal caso d'uso;
- *Precondizioni*: stato in cui il #glossary[sistema] si deve trovare prima dell'avvio della funzionalità rappresentata dal caso d'uso;
- *Postcondizioni*: stato in cui il #glossary[sistema] si troverà dopo che l'utente avrà portato a termine lo scopo rappresentato dal caso d'uso;
- *Scenario principale*: descrizione accurata della funzionalità rappresentata dal caso d'uso;
- *Specializzazioni*: nel caso di un caso d'uso generale, vengono indicati i codici dei casi d'uso che lo specializzano;
- *Inclusioni*: vengono specificati i codici dei casi d'uso che vengono inclusi nel caso d'uso trattato;
- *Estensioni*: vengono specificati i codici dei casi d'uso che rappresentano scenari secondari.
Ciascun caso d'uso è connesso, attraverso una linea continua, agli attori che hanno autorizzazioni per accedere a quella particolare funzione.
#figure(
image(
"assets/imgs/UseCase.png",
width: 70%
),
caption: "Figura rappresentante un caso d'uso."
)
In ogni diagramma dei casi d'uso possono essere definite:
- *Generalizzazioni*:
il concetto di generalizzazione può essere esteso sia agli attori che ai casi d'uso. La generalizzazione di un #glossary[attore] si verifica quando un #glossary[attore] di livello superiore, dotato di abilità più generiche, viene specializzato in comportamenti più specifici nei sottostanti attori. Ogni #glossary[attore] sottostante eredita le funzionalità dal suo #glossary[attore] padre, integrandole con ulteriori aspetti rilevanti al proprio contesto.
Per quanto riguarda i casi d'uso, i casi figli hanno la possibilità di aggiungere o modificare il comportamento dei casi d'uso ereditati dal caso padre. Tutte le funzionalità non ridefinite nei casi figlio mantengono la definizione ereditata. La generalizzazione degli attori e dei casi d'uso è simboleggiata da una freccia continua con triangolo vuoto bianco, che si estende da un elemento figlio a un elemento padre.
#figure(
image(
"assets/imgs/GeneralizzazioneAttore.png",
width: 25%
),
caption: "Figura rappresentante una generalizzazione tra attori."
)
#figure(
image(
"assets/imgs/GeneralizzazioneUseCase.png",
width: 70%
),
caption: "Figura rappresentante una generalizzazione tra casi d'uso."
)
- *Inclusioni*: supponiamo che vi sia una relazione di inclusione tra un caso d'uso A e un caso d'uso B se ogni istanza del caso d'uso A deve necessariamente eseguire le istanze del caso d'uso B. Questo assegna al caso d'uso A la responsabilità di eseguire il caso d'uso B, eliminando la duplicazione e favorendo il riutilizzo di una struttura comune. La connessione di inclusione viene simboleggiata da una freccia tratteggiata che collega il caso d'uso A a tutti i casi d'uso inclusi, come nel caso del caso d'uso B nell'esempio. Sopra la freccia verrà annotata la direttiva "include".
#figure(
image(
"assets/imgs/UseCaseInclude.png",
width: 70%
),
caption: "Figura rappresentante un' inclusione tra casi d'uso."
)
- *Estensioni*: nel contesto dei diagrammi dei casi d'uso UML, la relazione di estensione indica una connessione tra due casi d'uso, A e B, segnalando che ogni istanza del caso d'uso A può condizionalmente eseguire anche il caso d'uso B. L'esecuzione del caso d'uso B avviene soltanto in specifiche circostanze o sotto condizioni particolari durante l'esecuzione del caso d'uso A, interrompendo temporaneamente il flusso del caso d'uso A. La responsabilità dell'esecuzione del caso d'uso esteso (B) ricade su chi estende (nel caso, il caso d'uso B). Questa relazione viene visualizzata graficamente con una freccia tratteggiata dal caso d'uso esteso (B) al caso d'uso base (A), con l'etichetta "extend".
#figure(
image(
"assets/imgs/UseCaseExtend.png",
width: 70%
),
caption: "Figura rappresentante un' estensione tra casi d'uso."
)
==== Identificazione dei casi d'uso <c.uso>
Un caso d'uso rappresenta un singolo scenario o interazione tra un #glossary[attore] e il #glossary[sistema] software, focalizzandosi sulle azioni compiute dall'#glossary[attore] e sulle risposte del #glossary[sistema] a tali azioni.
I casi d'uso sono identificati nel seguente modo:
#align(center)[*UC[Numero].[Numero sottocaso] [Titolo]*]
*Legenda*:
- *Numero*: numero del caso d'uso;
- *Numero sottocaso*: numero del sottocaso del caso d'uso generale se presente;
- *Titolo*: breve titolo che descrive il contesto del caso d'uso in questione.
==== Struttura dei casi d'uso
I casi d'uso sono strutturati nel seguente modo:
- #glossary[Attore]\;
- Precondizioni;
- Postcondizioni;
- Scenario Principale;
- Scenari Secondari (ove necessario);
- Estensioni, se presenti;
- Specializzazioni, se presenti.
==== Requisiti
I requisiti trovati vengono classificati nei seguenti modi:
- *Funzionali*:
un requisito funzionale specifica una funzionalità che il #glossary[sistema] deve essere in grado di svolgere;
- *Qualità*:
un requisito di qualità stabilisce gli standard e i criteri che il #glossary[sistema] deve soddisfare per garantire prestazioni, affidabilità, sicurezza e altri aspetti correlati alla qualità;
- *Vincolo*:
un requisito di vincolo è una restrizione o una condizione imposta al progetto.
==== Identificazione dei requisiti
I requisiti trovati hanno un codice univoco con la seguente sintassi:
#align(center)[*R[Importanza][Tipo][Numero]*]
*Legenda*:
- *Importanza*:
- O: se requisito obbligatorio;
- D: se requisito desiderabile;
- P: se requisito opzionale.
- *Tipo*:
- F: se funzionale;
- Q: se di qualità;
- V: se di vincolo.
- *Numero*:
per ogni requisito aggiunto il numero viene incrementato.
==== Metriche
La definizione delle metriche seguenti si può trovare nella @metriche_qualità-prodotto.
#figure(
table(
columns:(auto,auto),
align: (x, y) => (center, center).at(x),
fill:(_,row) =>if row==0 {luma(150)} else if calc.odd(row) { luma(220)} else {white},
[*Metrica*],[*Descrizione*],
[*ROS*],[Requisiti Obbligatori Soddisfatti],
[*RDS*],[Requisiti Desiderabili Soddisfatti],
[*ROPS*],[Requisiti Opzionali Soddisfatti]
),
caption:[Metriche sui requisiti],
)
=== Progettazione
==== Descrizione e scopo
L'attività di progettazione è affidata ai Progettisti, i quali devono definire le caratteristiche del prodotto finale basandosi sui requisiti specificati nel documento _Analisi dei Requisiti v1.0_.
La fase di progettazione segue l'analisi dei requisiti, dove sono definite le necessità e le aspettative per il prodotto. I Progettisti traducono queste informazioni in una struttura architetturale definita, organizzando il #glossary[sistema] in componenti specifiche e definendo le interazioni tra di esse. In questo modo, la progettazione costituisce un passo essenziale nel percorso di sviluppo, contribuendo a trasformare i requisiti in un piano tangibile per la creazione del prodotto finale.
Si definiscono tre sottoattività:
+ *Requirements and Technology Baseline (#glossary[RTB])*: implica la selezione e la definizione delle tecnologie di base utilizzate per la realizzazione del #glossary[sistema]. Questo comprende decisioni relative a linguaggi di programmazione, librerie e #glossary[framework]. Tale processo porta alla creazione di un Proof of Concept (#glossary("PoC"));
Include:
- *Proof of Concept (#glossary[PoC])*: consiste nella creazione di una versione parziale del prodotto, includendo alcune delle funzionalità stabilite durante l'analisi dei requisiti. L'obiettivo è valutare la fattibilità del prodotto completo;
- *Scelte tecnologiche*: consiste nello stabilire quali tecnologie adottare per lo sviluppo del #glossary[PoC], anche su consiglio della Proponente.
+ *Progettazione architetturale*: definizione ad alto livello dell'#glossary[architettura] del #glossary[sistema]\; si concentra sulla suddivisione del #glossary[sistema] in componenti e moduli, definendo le relazioni tra di essi e specificando le linee guida per l'organizzazione e l'interazione delle varie parti;
+ *Product Baseline (#glossary[PB])*: segna un punto stabile nell'attività di progettazione, in cui le specifiche tecniche, le funzionalità principali e l'#glossary[architettura] del prodotto sono definite in modo dettagliato e accettate dalle parti coinvolte. Include tutti gli elementi essenziali e i requisiti chiave del prodotto che devono essere soddisfatti, fornendo una base solida per lo sviluppo continuo del prodotto. Questo processo porta infine alla realizzazione di un Minimum Viable Product (#glossary("MVP"));
Include:
- #glossary("Design Patterns")\;
- Definizione delle classi;
- Diagrammi #glossary[UML] che includono:
- Classi;
- Package;
- *Sequenze*: utilizzato per descrivere uno scenario che costituisce una determinata sequenza di azioni in cui tutte le scelte sono state già effettuate;
- *Attività*: diagramma comportamentale che illustra il flusso delle attività attraverso un #glossary[sistema].
- Test di unità su ogni componente.
==== Diagrammi #glossary[UML] delle classi
Il diagramma delle classi è una tipologia di diagramma #glossary[UML] utile a rappresentare la struttura statica di un #glossary[sistema] orientato agli oggetti. Esso visualizza le classi del #glossary[sistema], insieme ai loro attributi e metodi, e le relazioni tra di esse. Le classi sono rappresentate tramite rettangoli divisi in tre sezioni: la parte superiore contiene il nome della classe, la sezione centrale include gli attributi della classe e quella inferiore ne elenca i metodi.
- *Nome*: nome della classe in grassetto, se la classe è astratta viene scritto in corsivo oltre che in grassetto;
- *Attributi*:
#align(center)[*Visibilità* *Nome* : *Tipo* [Molteplicità] = {Default}]
*Legenda*:
- *Visibilità*: può essere di 3 tipi;
+ Privata, viene indicata con il -;
+ Protetta, viene indicata con il \#;
+ Pubblica, viene indicata con il +.
- *Nome*: il nome dell'attributo, se statico viene sottolineato;
- *Tipo*: rappresenta il tipo di dato dell'elemento;
- *Molteplicità*: quante istanze dell'elemento possono esistere in relazione ad altri elementi;
- *Default*: se configurato, indica il valore predefinito per l'elemento.
- *Metodi*:
#align(center)[*Visibilità* *Nome* *(Lista-Parametri)* : *Ritorno* ]
*Legenda*:
- *Visibilità*: segue quanto sopra;
- *Nome*: nome del metodo, se statico viene sottolineato;
- *Lista-Parametri*: se la funzione prevede più di un parametro, questi vengono separati tramite ",";
- *Ritorno*: il tipo restituito dal metodo.
Di seguito si elencano le possibili relazioni:
- *Dipendenza*: una dipendenza tra due classi è indicata da una freccia tratteggiata con la punta, che parte dalla classe dipendente A e punta alla classe da cui si origina la dipendenza B. Questa freccia simbolizza il fatto che un cambiamento nella classe B può avere un impatto o influenzare la classe A;
#figure(
image(
"assets/imgs/Dipendenza.png",
width: 70%
),
caption: "Figura rappresentante la relazione di dipendenza."
)
- *Aggregazione*: una classe A contiene un riferimento a un oggetto di tipo B, condividendo questo riferimento con altre classi. In sostanza, la classe A possiede un campo di tipo B che viene assegnato da una fonte esterna. L'oggetto di tipo B può essere utilizzato anche da altre parti del #glossary[sistema], non solo dalla classe A. Questa relazione è indicata da una freccia a rombo vuoto, in cui A rappresenta l'oggetto contenitore e B il contenuto;
#figure(
image(
"assets/imgs/Aggregazione.png",
width: 70%
),
caption: "Figura rappresentante la relazione di aggregazione."
)
- *Composizione*: una classe A contiene un oggetto di tipo B. In questa relazione, la classe A ha la responsabilità di creare e gestire l'oggetto di tipo B. È una relazione "parte-tutto", in cui l'oggetto di tipo B esiste solo all'interno dell'oggetto di tipo A e dipende strettamente da esso. Se la classe A viene eliminata, anche la classe B associata viene cancellata. Questa relazione è indicata da una freccia a rombo pieno, dove A rappresenta l'oggetto contenitore e B il contenuto;
#figure(
image(
"assets/imgs/Composizione.png",
width: 70%
),
caption: "Figura rappresentante la relazione di composizione."
)
- *Associazione*: una classe A contiene riferimenti o istanze di un'altra classe B. Questa relazione non implica una dipendenza stretta o un'inclusione di un'istanza all'interno dell'altra.
La rappresentazione grafica di un'associazione consiste in una linea tra le classi coinvolte, spesso accompagnata da molteplicità che indica quanti oggetti di una classe sono associati a quanti oggetti dell'altra classe. Questi valori di molteplicità possono essere situati agli estremi della linea che collega le classi.
Viene rappresentata con una freccia;
#figure(
image(
"assets/imgs/Associazione.png",
width: 70%
),
caption: "Figura rappresentante la relazione di associazione."
)
- *Generalizzazione*: una classe B eredita attributi, comportamenti e relazioni dalla classe genitore A. In altre parole, ogni istanza di B è anche un'istanza di A (subtyping), ma con specificità o dettagli aggiuntivi propri di B.
Nella rappresentazione grafica, si utilizza una freccia vuota che punta dalla classe figlia (Classe B) alla classe genitore (Classe A).
#figure(
image(
"assets/imgs/Generalizzazione.png",
height:38%
),
caption: "Figura rappresentante la relazione di generalizzazione."
)
=== Codifica
==== Descrizione e scopo
L'attività di codifica viene svolta dai Programmatori, i quali sono responsabili della traduzione delle decisioni progettuali nel codice sorgente.
I Programmatori operano all'interno di un contesto ben definito seguendo le linee guida stabilite durante la fase di progettazione architetturale. Questo approccio garantisce coerenza nell'implementazione del design e nell'applicazione delle #glossary[best practices], favorendo la creazione di codice robusto, manutenibile e di alta qualità.
Nel perseguire gli obiettivi di qualità, i Programmatori sono tenuti a rispettare le metriche definite nel _Piano di Qualifica v1.0_.
==== Aspettative
La fase di codifica è intrinsecamente orientata alla creazione di un prodotto software che soddisfi pienamente le esigenze e le aspettative della Proponente.
Ci si aspetta che il codice sviluppato rispetti determinate caratteristiche:
- Conformità alle specifiche;
- Chiarezza e comprensibilità;
- Ottimizzazione delle prestazioni;
- Supplemento di test per verificare la correttezza e il funzionamento.
==== Stile di codifica
Il team #team ha deciso di adottare il linguaggio di programmazione #glossary[Python] per la creazione dei simulatori di sensori.
Questa scelta tecnologica è motivata dalla familiarità che molti membri del team hanno con il linguaggio in questione, il che consente al team di concentrarsi direttamente sulla realizzazione del prodotto, risparmiando una quantità significativa risorse.
Inoltre, #glossary[Python] promuove uno stile di codifica uniforme e leggibile. La sua struttura rigida basata sull'indentazione agevola la comprensione della struttura del programma, contribuendo a una maggiore chiarezza all'interno del codice.
Il team si impegna ad utilizzare i seguenti stili di codifica:
===== Lunghezza metodi
Sono da preferire metodi di lunghezza limitata per diverse ragioni tra cui:
- Leggibilità;
- Manutenibilità;
- Riusabilità;
- Testabilità;
- Analisi statica semplificata.
===== Singola responsabilità
Ogni classe o funzione deve avere un unico obiettivo ben definito. Quando ogni entità nel codice svolge un compito specifico, ciò garantisce che ci sia un motivo chiaro e singolare per apportare modifiche. Questo approccio non solo promuove la chiarezza e la manutenibilità del codice, ma contribuisce anche a ridurre la complessità ciclomatica del software.
===== Parametri per metodo
Preferire l'uso di metodi con un numero limitato di parametri quando possibile. Questo approccio offre diversi vantaggi che contribuiscono alla chiarezza, manutenibilità e testabilità del codice.
===== Univocità dei nomi
Tutte le variabili, i metodi e le classi devono avere un nome che li distingue univocamente, per limitare la possibilità di ambiguità del codice.
===== Type hint
L'utilizzo dei type hint, ossia l'annotazione dei tipi di dati nelle firme delle funzioni o dei metodi, pratica comunemente utilizzata in #glossary[Python], contribuisce ad una migliore robustezza del codice fornendo alcuni vantaggi:
- Analisi statica avanzata;
- Riduzione errori;
- Contratto esplicito tra chiamante e funzione;
- Facilità di manutenzione.
I type hint non impongono un ritorno specifico, ma forniscono informazioni chiare sui tipi di dati attesi nei parametri e nei risultati delle funzioni.
===== Strumenti
Si è deciso di integrare il linter PEP8 come fondamentale strumento nel processo di sviluppo. Questo strumento svolge un ruolo di rilievo nel garantire la coerenza e l'adesione alle linee guida di formattazione del codice #glossary[Python], stabilite nella PEP 8, contribuendo in modo significativo a mantenere uno standard uniforme nella base di codice.
==== Metriche
La definizione delle metriche seguenti si può trovare nella @metriche_codifica.
#figure(
table(
columns:(auto,auto),
align: (x, y) => (center, center).at(x),
fill:(_,row) =>if row==0 {luma(150)} else if calc.odd(row) { luma(220)} else {white},
[*Metrica*],[*Descrizione*],
[*ATC*],[Attributi per Classe],
[*PM*],[Parametri per Metodo],
[*LCM*],[Linee di Codice per Metodo]
),
caption: [Metriche di codifica],
)
= Processi di supporto
== Documentazione
=== Descrizione e scopo
La #glossary[documentazione] è l'insieme di informazioni rappresentate sotto forma di testo scritto che accompagna un prodotto software, svolgendo un ruolo essenziale nella descrizione del prodotto per coloro che lo sviluppano, lo distribuiscono e lo utilizzano. Il suo obiettivo primario è facilitare l'attività di sviluppo ai membri del team durante l'intero ciclo di vita del progetto, garantendone la coerenza mediante il tracciamento di tutti i processi e le attività coinvolte. Ciò mira a migliorare la qualità del risultato finale e semplificare la manutenzione. L'implementazione di regole chiare e di una struttura uniforme non solo migliora la fruibilità e la comprensione, ma favorisce anche la collaborazione all'interno del team, contribuendo in modo significativo al successo complessivo del progetto software.
=== Lista documenti
I documenti che verranno prodotti sono:
- _Norme di Progetto v1.0_;
- _Piano di Progetto v1.0_;
- _Piano di Qualifica v1.0_;
- _Analisi dei Requisiti v1.0_;
- _Glossario v1.0_;
- _Verbali_:
+ _Interni_;
+ _Esterni_.
=== Ciclo di vita dei documenti
Ogni documento segue le fasi del seguente #glossary[workflow]:
+ Si crea un branch per lo sviluppo del documento nell'apposita #glossary[repository] Docs e si mette in uso;
+ Si copia dall'apposita #glossary[repository] `Templates` il template relativo al file che si deve redigere, e lo si inserisce nella cartella appropriata;
+ Si redige il documento o una sua sezione. Nel caso di documenti nuovi, in cui è necessario un elevato parallelismo di lavoro, è possibile usare Google Drive per la prima stesura e successivamente caricare il documento all'interno del branch;
+ Nel file `changelog.typ` si aggiunge una riga in coda, secondo il seguente formato: `<versione>,<data-modifica>,<descrizione-modifica>,<nome-autore>,<ruolo-autore>`; la versione segue le regole descritte nella @versionamento;
+ Si esegue la commit sul branch creato;
+ Si apre una pull request dal branch appena creato verso il branch `main`: se il documento non è pronto per la verifica, ma ha bisogno di ulteriori modifiche, si apre la pull request in modalità `draft`, altrimenti in modalità normale, spostando la issue nell'apposita #glossary[corsia] di stato "Ready to Review";
+ Per ulteriori modifiche richieste dal/dai verificatore/i si ripetono i punti, in ordine, dal punto 3 al punto 5;
+ Si elimina, solo quando la pull request viene chiusa o risolta, il branch creato.
La modifica di un documento avviene allo stesso modo, saltando il passo 2.
Ogni cambiamento di stato è accompagnato dal conseguente movimento della issue, associata allo sviluppo, attraverso le diverse corsie dell'issue tracking system.
Nel contesto della versione finale di un documento, spetta al Responsabile conferire l'approvazione definitiva, annotando opportunamente nel changelog la versione *x.0* e la sua approvazione finale.
In cui *x* può essere:
- 1 se per #glossary[RTB]\;
- 2 se per #glossary[PB]\;
- 3 se per #glossary[CA].
=== Template #glossary[Typst]
Per la stesura dei documenti viene usato un template in formato #glossary[Typst]. Il template fornisce una struttura e un formato predefinito per semplificare la creazione di documenti. Serve a garantire coerenza, risparmiare tempo, standardizzare la presentazione e contribuire a una produzione di documenti più efficiente e professionale.
Sono stati sviluppati quattro template distinti per adattarsi alle diverse esigenze di #glossary[documentazione]:
- #glossary[documentazione] ufficiale;
- lettere di presentazione;
- verbali per incontri interni ed esterni.
Ogni template è progettato per garantire coerenza e facilità d'uso, con piccole modifiche per rispecchiare le specificità di ciascun tipo di documento.
=== Nomenclatura
La consueta nomenclatura per i documenti si ottiene unendo, attraverso un underscore (`_`), il nome del file in _CamelCase_ senza spazi (`NomeDelFile`) e la sua versione (`3.5`). Ad esempio `NormeDiProgetto_2.6.pdf`.
Nel caso di documenti il cui nome contiene una data, essa si inserisce dopo il nome, ma prima della versione, sempre separandolo con gli underscores, nella forma `aammdd` senza separatori tra i singoli componenti della data: `gg` rappresenta il giorno, sempre scritto in due cifre, allo stesso modo `mm` rappresenta il mese, mentre l'anno è rappresentato da `aa`, corrispondente alle ultime due cifre dell'anno corrente.
=== Versionamento <versionamento>
Il versionamento avviene secondo il seguente formato *x.y*:
- *y*: si incrementa una volta effettuata una modifica e la sua conseguente verifica;
- *x*: si incrementa quando si effettua la modifica definitiva in vista di una verifica di avanzamento, questo comporta l'azzeramento di y.
Due modifiche, fatte in momenti diversi, differiscono l'una dall'altra solo se hanno scopi diversi. Ad esempio non è necessario incrementare la versione se viene fatta una modifica alla stessa sezione in due giorni differenti; anche se si effettua una modifica ed essa non viene approvata, non è necessario incrementare la versione con le nuove modifiche proposte dal/dai verificatore/i, dal momento che modifica e verifica "viaggiano" parallelamente.
=== Struttura
==== Prima pagina
- *Logo team*: situato in alto a destra;
- *Titolo*:
- Nome del documento, se diverso dai verbali;
- Per i verbali interni: Verbale Interno;
- Per i verbali esterni: Verbale Esterno;
- *Data*: solo se si tratta di verbali, vedere @formato;
- *Contatti*: l'email del team;
- *Versione*: l'ultima versione del documento;
- *Logo università*: in basso a destra.
==== Intestazione
Su ogni pagina del documento, eccetto la prima, si trova il titolo del documento seguito dalla sua versione e il logo del team.
==== Registro delle modifiche
Il registro delle modifiche è un elenco dettagliato che tiene traccia di tutte le modifiche apportate al documento nel corso del tempo.
È utile per tenere traccia dell'evoluzione del documento e per consentire a chiunque stia lavorando sul progetto di comprendere quali modifiche sono state apportate e quando.
Si compone di una tabella con l'intestazione:
- *Versione*: versione del documento;
- *Data*: data della modifica apportata;
- *Descrizione*: cosa è stato modificato o aggiunto al file;
- *Autore*: l'autore della modifica;
- *Ruolo*: ruolo dell'autore al momento della modifica.
==== Indice
Nella pagina successiva al registro delle modifiche deve essere presente l'indice, utile per facilitare la ricerca e la navigazione all'interno del documento.
==== Verbali
I verbali differiscono leggermente da un documento ufficiale, in quanto non evolvibili nel tempo.
Si compongono principalmente di 2 sezioni:
- *Partecipanti*: si indica data di inizio e fine incontro e il luogo in cui si è svolto. A seguire, i nomi dei partecipanti del team e la durata della presenza di ciascuno vengono rappresentati in forma tabellare. Se il verbale è esterno si indicano anche i partecipanti della Proponente;
- *Sintesi dell'incontro*: Riassunto degli argomenti trattati durante la riunione.
Il verbale esterno oltre alle sezioni sopra elencate ha una pagina per la convalida, attraverso firma, del documento.
=== Convenzioni stilistiche
- *Grassetto*:
- Titoli di sezioni/sottosezioni/paragrafi di un documento;
- Parole a cui si vuole dare enfasi;
- Definizioni di termini negli elenchi puntati.
- *Corsivo*:
- I nomi dei documenti, seguiti dalla loro versione (1.0 nel caso di documenti pronti ad essere presentati alla revisione #glossary[RTB]);
- I termini di glossario (seguiti da #sub[G]).
- *Caratteri maiuscoli*:
- Le iniziali dei nomi;
- Le lettere che compongono un acronimo e le iniziali della rispettiva definizione;
- Le iniziali dei ruoli svolti dai componenti del gruppo;
- L'iniziale del termine "Proponente";
- Prima lettera di ogni elenco puntato.
Nei verbali interni ed esterni non si usa la formattazione da glossario.
==== Elenchi puntati
Le voci di ogni elenco iniziano con lettera maiuscola e terminano con punto e virgola ';', eccetto l'ultima voce che termina con punto normale '.'.
==== Caption
Ogni immagine o tabella deve avere obbligatoriamente una caption associata, utile a fornire una breve descrizione o spiegazione del contenuto visivo.
==== Formato delle date <formato>
Viene adottato il formato "DD-MM-YYYY":
- DD: giorno con 2 cifre;
- MM: mese con 2 cifre;
- YYYY: anno con 4 cifre.
=== Strumenti
Il gruppo utilizza:
- *#glossary[Typst]*: linguaggio di markup utilizzato per la redazione di documenti, noto per la sua semplicità e flessibilità nella formattazione di testi strutturati;
- *Visual Studio Code*: un popolare ambiente di sviluppo integrato (IDE), noto per la sua leggerezza, versatilità e la vasta gamma di estensioni che permettono la personalizzazione e offrono supporto per numerosi linguaggi di programmazione;
- *GitHub*: una piattaforma di hosting per progetti di sviluppo software basati su Git. Fornisce un #glossary[sistema] di controllo delle versioni distribuito e strumenti per la gestione del codice sorgente, delle issue e delle pull request, facilitando la collaborazione all'interno di un team di sviluppo.
=== Metriche
La definizione delle metriche seguenti si può trovare nella @metriche_documentazione.
#figure(
table(
columns:(auto,auto),
align: (x, y) => (center, center).at(x),
fill:(_,row) =>if row==0 {luma(150)} else if calc.odd(row) { luma(220)} else {white},
[*Metrica*],[*Descrizione*],
[*IG*],[Indice Gulpease],
[*CO*],[Correttezza Ortografica]
),
caption:[Metriche relative alla documentazione],
)
#pagebreak()
== Gestione della configurazione
=== Descrizione e scopo
La gestione della configurazione (configuration management) è una pratica fondamentale nell'ambito dello sviluppo software, specialmente quando si tratta di gestire e controllare configurazioni complesse di prodotti. Essa riguarda il processo di identificazione e controllo delle componenti di un #glossary[sistema], così come delle relazioni tra di esse, durante tutto il ciclo di vita del prodotto. Consente di mantenere la tracciabilità, la coerenza e la comprensione chiara delle relazioni tra le varie parti del #glossary[sistema].
=== Issue Tracking System <its>
Come #glossary[ITS] si utilizza Github che, attraverso le funzioni di "Project", "Issue" e "Pull request", garantisce una struttura all'organizzazione di progetto.
Le #glossary[corsie di Stato] descrivono lo stato attuale delle attività, all'interno del Project nell'#glossary[ITS] sono presenti:
/ Backlog: attività individuate da svolgere;
/ Ready: attività individuate per il completamento durante il prossimo #glossary[sprint]\;
/ In Progress: attività che sono in corso d'opera da parte dei redattori;
/ Ready to Review: attività svolte che sono pronte per essere verificate;
/ In Review: attività in corso di verifica da parte dei Verificatori;
/ Done: attività le cui modifiche sono state verificate e accettate.
=== Strumento di condivisione
Per la condivisione veloce o la creazione di bozze si utilizza Google Drive. Uno dei suoi principali casi d'uso consiste nella collaborazione in tempo reale nella stesura di sezioni testuali ampie, da inserire successivamente nella #glossary[documentazione] (questo risulta particolarmente utile nel momento in cui il documento è alla sua prima stesura). Viene inoltre utilizzato come sistema per l'immagazzinamento di conoscenze acquisite durante lo svolgimento del progetto.
=== Controllo di versione e repository
Come sistema di controllo di versione si utilizza Git.
Vengono utilizzate le seguenti #glossary[repository]:
- #link("https://github.com/SWATEngineering/Docs"): questa #glossary[repository] viene impiegata dal team per condividere e revisionare il codice sorgente legato alla #glossary[documentazione] del progetto. Viene utilizzata per collaborare, revisionare e mantenere aggiornati i documenti di lavoro, consentendo ai membri del team di contribuire e gestire in modo efficiente la #glossary[documentazione]\;
- #link("https://github.com/SWATEngineering/SWATEngineering.github.io"): questa #glossary[repository] funge da piattaforma per i documenti compilati e approvati. Il sito web #link("https://swatengineering.github.io/") rappresenta la versione web della #glossary[documentazione] finale e approvata dal team. È utilizzata per presentare al pubblico una visione consolidata dei documenti di progetto;
- #link("https://github.com/SWATEngineering/InnovaCity"): questa #glossary[repository] è dedicata alla condivisione e revisione del codice sorgente relativo al prodotto software "InnovaCity". È qui che il team lavora e collabora sul codice del prodotto stesso, consentendo una gestione centralizzata del lavoro di sviluppo e delle modifiche apportate al software.
All'interno dei #glossary[repository] Docs e Innovacity si utilizza il #glossary[rebase workflow] come metodo di gestione, con l'utilizzo dei Feature branch per separare logicamente il lavoro da svolgere. Nel primo #glossary[repository] però, i Feature branch si derivano direttamente dal main, mentre nel secondo si derivano dal branch dev.
Questo impone quindi che, prima di andare ad effettuare la chiusura di una Pull request, si vada ad effettuare un rebase del branch di derivazione, per rendere il branch di sviluppo aggiornato rispetto alla base.
I Feature branch vengono aperti a partire dalle issue create nell'Issue Tracking System (vedi @its). Si procede poi ad associare una Pull request, a una o più issue collegate tra loro, per effettuare la verifica.
Nel caso del #glossary[repository] InnovaCity, il branch main viene utilizzato per la pubblicazione di cambiamenti major, ovvero quando sono state implementate diverse funzionalità significative che contribuiscono all'avanzamento del progetto. In questa circostanza, è compito del Responsabile eseguire l'approvazione finale.
=== Sito vetrina
Il sito vetrina consultabile al seguente link #link("https://swatengineering.github.io/") è progettato per garantire un'esperienza aggiornata e intuitiva agli utenti. Grazie all'integrazione di una GitHub Action, il sito si aggiorna automaticamente ogni volta che vengono apportate modifiche al branch principale "main" del #glossary[repository] Docs.
Lo script, realizzato in JavaScript, avvia una richiesta GET a un server esterno per ottenere la struttura aggiornata delle directory e dei file. Questa operazione consente al sito di rimanere sempre allineato con le modifiche apportate al #glossary[repository] principale.
Per garantire la coerenza e la tempestività delle informazioni, il servizio esterno esegue un aggiornamento periodico, ogni 15 minuti. Questo processo automatico consente al sito di riflettere dinamicamente qualsiasi modifica rilevante nel #glossary[repository] Docs, garantendo un'esperienza utente sempre aggiornata e completa.
=== Controllo termini glossario
È stato sviluppato uno script in #glossary[Python] per verificare la corrispondenza tra i termini presenti in un documento e quelli presenti nel _Glossario v1.0_.
Lo script, utilizzando espressioni regolari, confronta i termini indicati nei documenti, formattati secondo lo standard del glossario, con quelli presenti nel _Glossario_. In presenza di discrepanze, genera un messaggio di errore specificando i termini mancanti nel _Glossario_. In caso contrario, l'esecuzione avviene senza problemi, indicando che i termini nel documento sono in linea con quelli del _Glossario v1.0_.
Tutti i termini inclusi nel _Glossario v1.0_ devono essere formattati secondo la convenzione da glossario ogni volta che compaiono nel documento, non solo alla prima occorrenza. Questo assicura coerenza e facilita la consultazione, contribuendo a una migliore comprensione dei termini chiave nel contesto del documento.
== Verifica
=== Descrizione e scopo
Qualsiasi processo istanziato durante lo svolgimento del progetto, prima di potersi considerare completato, dev’essere sottoposto a verifica.
Lo scopo primario di questo processo è garantire la correttezza dei prodotti e la loro adesione ai vincoli di qualità individuati ed elencati all'interno del documento _Piano di Qualifica v1.0_.
Il _Piano di Qualifica v1.0_ funge da punto di riferimento per il Verificatore: in esso vengono fornite tutte le linee guida a cui il Verificatore deve aderire, garantendo uniformità, coerenza e ripetibilità al processo di verifica.
=== Strumenti
Gli strumenti adottati per agevolare il processo di verifica sono i seguenti:
==== GitHub <revisione_pull>
GitHub offre una funzionalità di review all'interno del meccanismo di pull request, permettendo al Verificatore di visualizzare facilmente le ultime modifiche apportate al prodotto. Il Verificatore inserisce commenti specifici che indicano le correzioni o le migliorie necessarie e, al termine della review, la invia richiedendo le modifiche indicate. In seguito all'intervento correttivo dell'autore, il Verificatore esegue nuovamente la revisione.
Il processo viene ripetuto fino a che la revisione non da esito positivo.
A seguito del processo di verifica il Verificatore si occupa di spostare la issue nella #glossary[corsia] di stato adeguata all'interno della Kanban Board:
- "Done": qualora la revisione abbia avuto esito positivo;
- "In progress": in caso siano richieste modifiche.
L'utilizzo delle review in GitHub non solo facilita il tracciamento del processo di verifica, ma consente anche al team di accedere e consultare facilmente l'intera cronologia del codice o del documento di interesse all'interno della #glossary[repository] del progetto. Questo approccio garantisce un processo di verifica trasparente, tracciabile e conforme alle linee guida stabilite.
Inoltre GitHub impedisce l'unione dei rami oggetto di pull request fino a quando l'ultimo commit non viene verificato e approvato.
Ciò garantisce che ogni prodotto che viene integrato nel ramo principale, sia stato effettivamente revisionato da almeno un membro del team, riducendo il rischio di introdurre errori.
Il Verificatore, a seguito di una revisione positiva, accetta la pull request con la metodologia "squash and merge". Nell'eventualità in cui il branch presenti dei conflitti, è responsabilità dell'autore risolverli prima di procedere con l'unione del branch. Una volta effettuato il merge, il Verificatore si occupa dell'eliminazione sicura del branch.
===== Elementi esterni al #glossary[repository]
Potrebbero esservi delle issue aperte all'interno dell'#glossary("ITS") che non hanno un corrispondente documento o prodotto in generale, all'interno del #glossary[repository]. Per queste, il ciclo di vita segue il normale flusso attraverso i diversi stati elencati nella @its. La verifica viene effettuata attraverso i commenti della issue stessa, che avranno la seguente forma:
- richiesta cambiamenti:
```
[REV]
- richiesta 1;
- richiesta 2;
```
- approvazione:
```
[REV] done
```
=== Analisi statica
L'analisi statica rappresenta un'esplorazione approfondita del codice o della #glossary[documentazione] associata al prodotto. Questa metodologia mira a individuare potenziali problemi o irregolarità, senza mai eseguire effettivamente il #glossary[sistema] software. Nel caso della #glossary[documentazione], l'analisi statica si concentra sulla struttura, sulla coerenza, sulla completezza e sulla chiarezza del testo. In particolare, verifica la presenza di errori grammaticali, di formattazione e concettuali, garantendo un livello ottimale di qualità nel materiale consegnato.
Il Verificatore, nel contesto della #glossary[documentazione] o del codice, può condurre l'analisi statica tramite due metodologie: #glossary[walkthrough] o #glossary[inspection]. La metodologia preferita dal team, e utilizzata con maggior frequenza, è l'#glossary[inspection].
==== #glossary[Inspection]
In questo processo, il Verificatore adotta un approccio strutturato, seguendo una sequenza di passaggi ben definiti. Utilizza liste di controllo per esaminare in dettaglio il documento o il codice. Per dettagli specifici sulle checklist usate, si rimanda al documento _Piano di Qualifica v1.0_.
==== #glossary[Walkthrough]
Contrariamente all'#glossary[inspection], il #glossary[walkthrough] è un approccio più esplorativo e che lascia maggiore spazio alla collaborazione tra l’autore e il Verificatore. Questa metodologia prevede una lettura a pettine del prodotto con l'obiettivo di analizzare struttura e contenuto nel loro insieme.
La decisione del team di preferire il metodo #glossary[inspection] è giustificata dall'alto grado di rigore che questo approccio offre e dalla conseguente maggiore efficacia nell' individuazione di tutte le inconsistenze. L'#glossary[inspection] fornisce una revisione più strutturata e dettagliata, guidata da liste di controllo specifiche, contribuendo a garantire una maggiore completezza e coerenza.
Tuttavia, il metodo #glossary[walkthrough] conserva la sua rilevanza e rimane una valida alternativa di cui ci si può avvalere specialmente nelle fasi iniziali e finali del lavoro su un determinato prodotto: l’approccio pragmatico del metodo risulta infatti adeguato a rilevare criticità e peculiarità che potrebbero non essere rilevate da metodi più formali.
=== Analisi dinamica
L'analisi dinamica nel contesto dello sviluppo software si concentra sull'osservazione e valutazione del comportamento del #glossary[sistema] durante l'esecuzione. Questa metodologia è specificamente rivolta al prodotto software risultante dall'attività di codifica.
Nel processo di sviluppo, l'analisi dinamica è attuata attraverso varie categorie di test. I test, derivati dai requisiti, siano essi funzionali o non funzionali, rendono l'attività di analisi dinamica ripetibile. Questo significa che è possibile eseguire i test più volte con gli stessi input e condizioni, ottenendo risultati coerenti e affidabili. La ripetibilità dei test è fondamentale per confermare la coerenza delle funzionalità del software in diverse situazioni e sotto diverse condizioni operative. La definizione e l'esecuzione dei test seguono i principi del #glossary[Modello a V].
Il Verificatore si impegna a elaborare casi di test per ciascuna delle seguenti categorie, garantendo una copertura completa e dettagliata del software:
- Test di unità;
- Test di integrazione;
- Test di sistema;
- Test di accettazione.
La totalità dei test individuati viene riportata all'interno del documento _Piano di Qualifica v1.0_.
In sede di verifica, sulla base del dominio esaminato, il Verificatore è tenuto ad eseguire tali test in maniera rigorosa e a riportarne gli esiti all'interno del _Piano di Qualifica v1.0_.
==== Test di unità
Il test di unità è una fase del processo di software testing che si concentra sulla verifica delle singole unità o componenti del software. Un'unità è la più piccola parte di un'applicazione che può essere testata isolatamente.
Gli obiettivi principali:
- Testare ogni unità in modo separato, isolando le influenze esterne e garantendo che ciascuna parte del software funzioni correttamente da sola;
- Accertarsi che ciascuna unità esegua le operazioni specificate nel suo design;
- Identificare precocemente i possibili errori.
I test di unità si dividono principalmente in due categorie:
- *Test Funzionali*: verificano che ciascuna unità esegua le funzioni specificate nel design, concentrandosi sulla logica interna dell'unità e testando i casi in cui la funzione produce i risultati desiderati;
- *Test Strutturali*: verificano la struttura interna dell'unità, compresa la logica di controllo e il flusso dei dati, esaminando il codice sorgente dell'unità.
==== Test di integrazione
I test di integrazione sono cruciali per valutare il comportamento delle unità software quando vengono combinate. Una volta confermato il corretto funzionamento delle singole unità in isolamento, i test di integrazione mirano a identificare possibili problemi nelle interazioni tra le unità integrate. Questi test, automatizzati il più possibile, verificano se le componenti del software collaborano efficacemente e se il sistema integrato soddisfa le specifiche di progetto. L'obiettivo è garantire che, quando le unità sono combinate, il software funzioni senza intoppi e risponda alle esigenze dell'applicazione in modo coerente.
==== Test di #glossary[sistema]
I test di #glossary[sistema] vengono definiti durante la fase di analisi dei requisiti con l'obiettivo di misurare la copertura dei requisiti derivati dal capitolato d'appalto. Questa fase del processo di software testing mira a verificare l'intero #glossary[sistema] come entità unificata. Durante il test di #glossary[sistema], il software viene valutato nella sua completezza, con l'obiettivo di accertare che tutte le componenti integrate funzionino insieme in modo coerente per soddisfare gli obiettivi e i requisiti del #glossary[sistema].
Per la definizione dei test si rimanda al _Piano di Qualifica v1.0_.
==== Test di accettazione
Il superamento dei test di accettazione è fondamentale poiché dimostra il soddisfacimento della Proponente rispetto al prodotto software. L'esito positivo di questi test fornisce l'approvazione finale e la conferma che il software è conforme alle aspettative. Solo dopo il superamento dei test di accettazione il team #team potrà procedere con il rilascio ufficiale del prodotto, garantendo che sia pronto all'utilizzo nell'ambiente operativo previsto.
Per la definizione dei test si rimanda al _Piano di Qualifica v1.0_.
=== Classificazione dei test
I test vengono identificati in base alla loro tipologia e tramite un codice numerico.
Nello specifico devono avere la seguente forma: *T[Tipologia Test] [Codice]*
Tipologia:
- *U*: unità;
- *I*: integrazione;
- *S*: sistema;
- *A*: accettazione.
Il codice numerico è seriale all'interno della categoria.
=== Stato dei test
Nella sezione relativa ai test nel _Piano di Qualifica v1.0_ a ogni test viene affiancato il suo stato:
- *N-A*: il test non è applicabile al contesto attuale o alle funzionalità correnti;
- *N-I*: il test non è stato implementato;
- *Passato*: il test ha dato esito positivo;
- *Non Passato*: il test ha dato esito negativo.
== Gestione della qualità
=== Descrizione
La gestione della qualità è un insieme di processi e attività volte a garantire che un prodotto soddisfi gli standard di qualità definiti, assicurando che il prodotto sviluppato sia affidabile ed efficiente. È fondamentale garantire che il prodotto soddisfi a pieno i requisiti funzionali e non, stabiliti durante la fase di progettazione.
=== Obiettivi
La gestione della qualità si propone di raggiungere i seguenti obiettivi:
- Controllo continuo della qualità del prodotto, verificando che rispetti le aspettative della Proponente;
- Minimizzare la presenza di errori o anomalie nel prodotto;
- Riduzione dei rischi che potrebbero influenzare la qualità;
- Consegna del progetto rispettando il budget preventivato inizialmente e i requisiti individuati assieme alla Proponente.
Per la valutazione della qualità viene fornito il documento _Piano di Qualifica v1.0_, in cui sono presenti varie metriche con le relative soglie di valori accettabili ed ideali.
=== Denominazione metriche
Per identificare le metriche si usa la seguente formattazione:
#align(center)[*M[Tipo]-[Nome]*]
*Legenda*:
- *Tipo*: specifica la tipologia di metrica:
+ *PC* se si tratta di qualità di processo;
+ *PD* se si tratta di qualità di prodotto.
- *Nome*: abbreviazione del nome della metrica.
=== Struttura metriche
Nel _Piano di Qualifica v1.0_ le varie metriche sono descritte mediante delle tabelle organizzate secondo la seguente struttura:
- *Metrica*: il codice della metrica seguendo il codice identificativo;
- *Descrizione*: il nome della metrica;
- *Valore di accettazione*: valore considerato accettabile;
- *Valore ideale*: valore ideale che dovrebbe essere assunto dalla metrica.
=== Grafici metriche
Per realizzare i grafici relativi alle metriche e all'andamento del progetto, si usa Google Sheets.
La descrizione delle metriche usate si trova nella @metriche.
=== Metriche
La definizione delle seguenti metriche si può trovare nella @metriche_gestione_qualità.
#figure(
table(
columns:(auto,auto),
align: (x, y) => (center, center).at(x),
fill:(_,row) =>if row==0 {luma(150)} else if calc.odd(row) { luma(220)} else {white},
[*Metrica*],[*Descrizione*],
[*MNS*],[Metriche Non Soddisfatte]
),
caption:[Metriche relative alla gestione della qualità],
)
= Processi organizzativi
== Gestione organizzativa
=== Decisioni
Per poter prendere una qualsiasi decisione è necessario vi siano due condizioni:
+ Si deve raggiungere il #glossary[quorum] di quattro persone su sei;
+ La decisione deve essere verbalizzata e motivata.
=== Pianificazione
==== Descrizione e scopo
Il Responsabile assume il ruolo cruciale di pianificare dettagliatamente gli obiettivi per ciascuno #glossary[sprint] fino alla conclusione del progetto. Questo implica una distribuzione coerente del lavoro in linea con le scadenze fissate per le revisioni #glossary[RTB], #glossary[PB] e #glossary[CA]. Il suo compito principale consiste nel delineare chiaramente come il team dovrebbe gestire e completare le attività relative allo sviluppo del software e alla redazione della #glossary[documentazione] in periodi di tempo specifici.
Oltre a definire gli obiettivi per ogni #glossary[sprint], il Responsabile si occupa di stimare accuratamente il tempo necessario per ciascuna attività e di pianificare la distribuzione dei ruoli all'interno del team. Questa pianificazione deve sempre rimanere aggiornata e sensata rispetto all'andamento generale del progetto e agli obiettivi imminenti. Queste previsioni vengono formalizzate nel _Piano di Progetto v1.0_, che diventa un punto di riferimento durante l'evento di #glossary[sprint planning] per definire gli obiettivi del successivo #glossary[sprint].
Eventuali variazioni nella distribuzione dei ruoli, rispetto alla pianificazione iniziale, vengono documentate e giustificate nel *Consuntivo* del _Piano di Progetto v1.0_. Questo approccio consente al team di adattarsi in modo flessibile alle esigenze emergenti, mantenendo costantemente un quadro chiaro delle variazioni e delle ragioni che sottendono a tali modifiche.
==== #glossary[Documentazione] fine #glossary[sprint]
Il Responsabile è incaricato di sviluppare un preventivo dettagliato per le successive due settimane subito dopo la conclusione dello #glossary[sprint] attuale, fornendo una guida chiara al team su aspettative e obiettivi.
Nel contesto della gestione dello #glossary[sprint], il Responsabile si impegna anche a compilare un consuntivo dettagliato dello sprint appena concluso.
Per garantire un monitoraggio efficace delle prestazioni, il Responsabile utilizza e calcola le metriche, presenti nel documento _Piano di Qualifica v1.0_, rispetto allo #glossary[sprint] appena concluso, valutando l'efficacia del processo e apportando eventuali correzioni o miglioramenti per il successo continuo del progetto.
==== Preventivo
Per utilizzare efficacemente lo script per il calcolo preventivo, si procede nel seguente modo:
- Eseguire lo script init_preventivo.py, seguendo attentamente le istruzioni fornite. Questo script guida la creazione dei file CSV necessari, che sono utilizzati per inserire i dati relativi a due preventivi successivi;
- Accedere al file preventivonumerosprint.csv situato nella directory preventivi/preventivi_csv/. In questo file, si inserisce, con precisione, i dati riguardanti le ore dedicate da ciascun membro del team, specificando le risorse allocate per i due preventivi successivi;
- Eseguire lo script auto_preventivo.py, indicando lo #glossary[sprint] per il quale si desidera generare il preventivo. L'esecuzione di questo script applica automaticamente i dati inseriti, producendo un preventivo accurato per lo #glossary[sprint] selezionato;
- All'interno del file typst, dove si intende inserire il preventivo, utilizzare le funzioni prospettoOrario e prospettoEconomico fornite nel modulo functions.typ. Queste funzioni consentono di integrare facilmente i dati di prospetto orario ed economico nel documento, facilitando la visualizzazione e la gestione delle informazioni relative al preventivo.
==== Consuntivo
Si analizzano le attività svolte, i tempi impiegati rispetto alle stime previste e qualsiasi deviazione dai piani originali. Tale consuntivo rappresenta una preziosa fonte di apprendimento per il team, consentendo di identificare aree di miglioramento e di ottimizzare la pianificazione futura.
È stato sviluppato uno script in #glossary[Python] (timeresource_sheets_downloader.py), integrato con #glossary[Typst], per semplificare la generazione automatica di tabelle e grafici relativi al consuntivo di ogni singolo #glossary[sprint] del progetto. L'automazione coinvolge l'estrazione dei dati dal foglio di calcolo condiviso, dove vengono registrate le ore produttive del team. I dati vengono successivamente organizzati per #glossary[sprint] e archiviati in file CSV.
L'elaborazione comprende la creazione di un DataFrame consolidato che rappresenta le ore lavorate per ogni ruolo e membro del team durante uno #glossary[sprint], includendo anche i costi associati. I risultati di questa analisi vengono salvati in un file CSV.
Per visualizzare i dati aggiornati relativi a ciascuno #glossary[sprint], è possibile utilizzare le seguenti funzioni all'interno del file:
\#rendicontazioneOreAPosteriori(sprintNumber: "number")
\#rendicontazioneCostiAPosteriori(sprintNumber: "number")
Dove "number" rappresenta il numero a 2 cifre, specifico dello #glossary[sprint] di interesse. Queste funzioni consentono di ottenere report aggiornati sulla distribuzione delle ore per ruolo e persona, nonché sui costi associati, semplificando la gestione.
=== Ruoli progetto
Durante il periodo di sviluppo del progetto, ciascun membro assume sei ruoli distinti, con compiti diversificati, al fine di garantire una gestione completa ed efficace delle diverse fasi e aspetti del lavoro. Questi ruoli contribuiscono a promuovere la collaborazione sinergica e l'ottimizzazione delle risorse all'interno del team.
I ruoli assunti sono i seguenti:
==== Responsabile
Figura chiave che supervisiona, coordina e gestisce le attività del team. Si occupa di garantire l'allineamento tra gli obiettivi del progetto e le azioni intraprese, gestisce le risorse disponibili, stabilisce e mantiene le relazioni esterne con la Proponente e assicura il flusso efficace delle informazioni all'interno del team e al di fuori di esso.
I suoi compiti sono:
- Gestione della comunicazione con la Proponente (si fa uso della piattaforma Element);
- Preparazione dell'#glossary[ordine del giorno] per la successiva riunione, anche sulla base
dei punti individuati dagli altri componenti;
- Redazione dei verbali interni ed esterni;
- Stesura e e avanzamento del documento “_Piano di progetto_”;
- Creazione dei diari di bordo;
- Upload dei verbali esterni convalidati, tramite firma, dalla Proponente in una cartella apposita su Google Drive.
==== Amministratore
Figura professionale con la responsabilità della creazione, manutenzione e ottimizzazione degli strumenti, delle risorse e dei processi necessari per il corretto svolgimento del progetto.
I suoi compiti sono:
- Configurazione e gestione gli ambienti di sviluppo;
- Implementazione delle procedure operative;
- Assicurare la disponibilità degli strumenti necessari per la collaborazione e la comunicazione all'interno del team;
- Creazione e assegnazione delle issue ai membri del team;
- Stesura e avanzamento del documento _Norme di Progetto_;
- Implementazione di script dedicati per automatizzare processi nell'ambiente di lavoro;
- Gestione del versionamento dei documenti;
- Stesura e avanzamento del documento _Piano di Qualifica_.
==== Analista
Figura professionale che si occupa di analizzare, comprendere e definire i requisiti e le specifiche di un #glossary[sistema] software prima che venga sviluppato. Questa figura svolge un ruolo fondamentale nel processo di sviluppo del software, contribuendo a garantire che il prodotto finale soddisfi le esigenze e le aspettative degli utenti e della Proponente.
I suoi compiti:
- Studio del contesto applicativo e relativa complessità;
- Specifica dei casi d'uso per comprendere in dettaglio i requisiti funzionali del #glossary[sistema]\;
- Raccolta dei requisiti per definire le necessità e le funzionalità richieste;
- Stesura del documento _Analisi dei Requisiti_;
- Creazione diagrammi #glossary[UML]\;
==== Progettista
Figura professionale specializzata nella progettazione architetturale e strutturale di sistemi. La sua responsabilità principale è definire la configurazione, la disposizione e l'organizzazione dei vari componenti del #glossary[sistema], concentrandosi su come questi elementi interagiscono tra loro per raggiungere determinati obiettivi di funzionalità, prestazioni e scalabilità.
I suoi compiti sono:
- Scelta degli aspetti tecnici e tecnologici;
- Progettazione architetturale che miri all'economicità e alla manutenibilità del #glossary[sistema]\;
- Ottimizzazione delle prestazioni usando algoritmi efficienti e gestione memoria;
- Gestione dei rischi: cerca di mitigare problemi che possono sorgere durante lo sviluppo;
- Redazione del documento _Specifiche Tecniche_.
==== Programmatore
Figura professionale incaricata di trasformare le specifiche tecniche in codice eseguibile, garantendo un'implementazione efficiente e accurata delle funzionalità richieste dal progetto.
I suoi compiti:
- Traduzione delle specifiche tecniche in codice funzionante;
- Scrittura di codice chiaro, leggibile e manutenibile;
- Creazione di test per la verifica del software;
- Ampliamento delle _Specifiche Tecniche_ conforme alle esigenze del progetto;
- Risoluzione di #glossary[bug] e problemi di performance;
- Realizzazione del _Manuale Utente_;
- Collaborazione con il team per l'integrazione del codice e il mantenimento della coerenza del progetto.
==== Verificatore
Figura professionale che si occupa di esaminare il lavoro prodotto dagli altri membri del team.
I suoi compiti:
- Revisione e valutazione della #glossary[documentazione] prodotta dal team;
- Analisi critica del codice per individuare errori, discrepanze o possibili miglioramenti;
- Identificazione e segnalazione di problemi;
- Collaborazione con il team per garantire che il lavoro sia conforme alle linee guida e agli standard richiesti.
=== Cambio dei ruoli
Per garantire che ogni membro svolga tutti i ruoli menzionati per un periodo di tempo consono, il team si impegna a cambiarli ogni settimana.
=== Tracciamento del tempo speso
Al fine di tracciare il tempo speso nel corso del progetto, nei diversi ruoli, si utilizza uno #glossary[spreadsheet] appositamente creato, disponibile all'interno di Google Drive. A fine giornata, ogni membro del team inserisce le proprie ore *produttive* svolte quel giorno, secondo la sua miglior stima del rapporto tra ore di orologio e ore produttive. Si inserisce una sola riga per ogni giornata e nella descrizione si aggiungono brevi titoli rappresentativi delle attività svolte.
=== Gestione strumenti coordinamento
==== Ticketing
L'Amministratore crea, durante gli incontri interni, e gestisce le varie task in modo tale ogni membro del team sia informato su ciò che ci si propone di fare durante lo #glossary[sprint] e sia in grado di verificare il progresso effettuato in qualsiasi momento.
Si segue il seguente metodo:
+ L'Amministratore crea la issue su Github;
+ Assegna il task al membro, con la relativa priorità e grandezza;
+ Imposta una data di inizio e fine del task e lo sposta nella #glossary[corsia] Ready;
+ Assegna l'issue alla #glossary[milestone] dello #glossary[sprint] attuale;
+ Il membro incaricato della issue la sposta nella #glossary[corsia] "In Progress" nel momento in cui inizia a lavorarci;
+ Una volta concluso il task, la issue viene spostata nella #glossary[corsia] "Ready To Review";
+ Successivamente il Verificatore segue i passi definiti nella @revisione_pull;
+ La issue viene chiusa in automatico, se linkata ad una pull request che viene mergiata nel ramo principale main, altrimenti si procede manualmente.
Ogni issue è composta da:
- *Titolo*: titolo significativo;
- *Descrizione*: una breve descrizione o checklist delle cose da fare;
- *Assignee*: membro/membri incaricati;
- *Priority*: la priorità, può essere:
+ Low;
+ Medium;
+ High;
+ Urgent.
- *Size*: la grandezza del lavoro da svolgere:
+ Tiny;
+ Small;
+ Medium;
+ High;
+ Large.
- *Intervallo temporale*: una data di inizio e una di fine;
- *#glossary[Milestone]*: #glossary[milestone] associata alla issue, se il completamento non è possibile entro lo #glossary[sprint] attuale, è necessario spostare l'issue nella #glossary[milestone] successiva.
=== Gestione dei rischi
La gestione dei rischi è un approccio sistematico finalizzato a individuare, valutare e affrontare le possibili minacce o opportunità che possono influenzare il successo di un progetto. Questo processo coinvolge l'identificazione dei rischi, la valutazione della loro probabilità e impatto, la pianificazione di strategie di mitigazione o sfruttamento e il monitoraggio continuo durante l'intero ciclo di vita del progetto.
==== Struttura dei rischi
I rischi vengono suddivisi in tre categorie:
- Rischi tecnologici;
- Rischi comunicativi;
- Rischi pianificazione.
Ogni rischio viene identificato da un codice univoco avente la seguente struttura:
#align(center)[*R[Tipologia][Numero] - [Nome]*]
*Legenda*:
- *Tipologia*: il tipo del rischio, può essere:
- T se tecnologico;
- C se comunicativo;
- P se di pianificazione.
- *Numero*: è un numero progressivo univoco per ogni rischio della sua tipologia;
- *Nome*: nome del rischio.
#pagebreak()
=== Procedure comunicative
==== Gestione delle comunicazioni
===== Comunicazioni interne
Riguardano esclusivamente i membri del team e si svolgono tramite:
- *Whatsapp*: utilizzato per messaggistica istantanea e una comunicazione veloce;
- *Discord*: piattaforma utilizzata per:
+ Creare server suddivisibili in vari canali testuali o vocali, dove verranno svolte le riunioni;
+ Supplementare la comunicazione all'interno della piattaforma con funzionalità offerte da servizi esterni quali GitHub.
===== Comunicazioni esterne
Le comunicazioni esterne vengono affidate al Responsabile attraverso i seguenti mezzi:
- Email: si usa l'email di gruppo <EMAIL>;
- Element: si usa il canale creato appositamente dalla Proponente per avere una comunicazione diretta.
==== Gestione degli incontri
===== Incontri interni
Negli incontri interni possono partecipare solamente i membri del gruppo. Si svolgono principalmente una volta a settimana, il giorno può variare in caso di imprevisti, ma solitamente si tiene il venerdì mattina in modalità sincrona.
Le linee guida per le riunioni:
+ Prima dell'incontro avere un ordine del giorno, ovvero i punti eventuali da discutere;
+ Discussione dei punti;
+ Pianificazione attività per la settimana (valutate rispetto a quanto pianificato nel _Piano di Progetto_) e assegnazione issue.
Alla fine dell'incontro il Responsabile ha il compito della stesura del verbale interno, fornendo una sintesi dei punti salienti dell'incontro.
Gli incontri hanno due modalità:
- *Fisici*: per gli #glossary[stand-up meeting] quotidiani (#glossary("Daily Scrum")) di 15 minuti in cui si discutono brevemente le attività completate il giorno precedente e si espongono le attività pianificate per il futuro;
- *Virtuali*: si svolgono chiamate o video di gruppo in cui si discutono eventuali dubbi o difficoltà riscontrate. Lo strumento adatto per questo scopo è Discord.
Dopo la sessione invernale degli esami, gli #glossary[stand-up meeting] quotidiani si svolgono virtualmente.
===== Incontri esterni
Negli incontri esterni i partecipanti includono i membri del team e i referenti della Proponente. Questi incontri sono pianificati in concomitanza con l'inizio e la fine dello #glossary[sprint]. Durante queste sessioni, i partecipanti del team hanno l'opportunità di presentare gli sviluppi recenti, condividere i progressi raggiunti e discutere eventuali sfide o questioni emerse nel corso del lavoro.
In aggiunta, è possibile richiedere sessioni di formazione mirate su tecnologie specifiche, offrendo al team l'opportunità di approfondire la comprensione di una particolare tecnologia, imparare le #glossary[best practices] e acquisire competenze più avanzate.
Il Responsabile ha il compito della stesura del verbale esterno, che viene successivamente convalidato, con firma, dalla Proponente.
#pagebreak()
== Formazione
=== Scopo e aspettative
Il processo è progettato per normare il modo in cui il team #team acquisisce conoscenze relative alle tecnologie richieste per la produzione dei documenti e del prodotto.
L'attività di formazione è progettata per garantire che ogni membro del team raggiunga una competenza sufficiente nell'utilizzo consapevole delle tecnologie selezionate per la realizzazione del progetto.
=== Formazione individuale dei membri
Ciascun membro del gruppo assume la responsabilità di approfondire individualmente le diverse tecnologie necessarie per lo sviluppo del prodotto. Per facilitare il processo di apprendimento collettivo, si promuove attivamente la condivisione di conoscenze tra i membri, permettendo a coloro che possiedono una maggiore competenza di condividere le proprie nozioni con i colleghi meno esperti.
=== Guide e documentazione
Si riporta la lista delle guide e documentazione da prendere come riferimento:
- *#glossary[Typst]*: #link("https://typst.app/docs/");
- *Github*: #link("https://docs.github.com/en");
- *#glossary[Python]*: #link("https://docs.python.org/3/");
- *#glossary[Grafana]*: #link("https://grafana.com/docs/grafana/latest/");
- *Apache #glossary[Kafka]*: #link("https://kafka.apache.org/20/documentation.html");
- *#glossary[Clickhouse]*: #link("https://clickhouse.com/docs").
Questa lista non intende essere forzata, ciascun membro è libero di approfondire le proprie conoscenze utilizzando materiale aggiuntivo.
Qualora lo ritenesse utile ed esaustivo è pregato di condividerlo con gli altri membri.
= Metriche per la qualità <metriche>
== Metriche per la qualità di processo <metriche_qualità-processo>
=== Fornitura <metriche_fornitura>
- *BAC*: Budget At Completion - indica il budget totale pianificato per il completamento del progetto;
- *EV*: Earned Value - rappresenta il valore prodotto dal progetto ossia il valore dei #glossary("deliverable") rilasciati fino al momento della misurazione in seguito alle attività svolte
Formula: $"EV" = "Percentuale di completamento del lavoro" dot "BAC"$
in cui la percentuale di completamento del lavoro è misurata con le ore produttive effettive degli #glossary[sprint]\; in particolare la percentuale è costituita dal rapporto tra le ore effettive e le ore produttive totali a disposizione (570)
- *PV*: Planned Value - il valore del lavoro pianificato fino a un dato momento
Formula: $"PV" = "Percentuale di pianificazione del lavoro" dot "BAC"$
in cui la percentuale di pianificazione del lavoro è misurata con le ore preventivate per gli #glossary[sprint]\; in particolare la percentuale è costituita dal rapporto tra le ore preventivate e le ore produttive totali a disposizione (570)
- *AC*: Actual Cost - il costo effettivo sostenuto fino a un dato momento;
- *CPI*: Cost Performance Index - misura l'efficienza del costo del lavoro svolto fino a un dato momento
Formula: $"CPI" = "EV" / "AC"$;
- *EAC*: Estimated At Completion - revisione del valore stimato per la realizzazione del progetto, ossia il BAC rivisto allo stato corrente del progetto
Formula: $"EAC" = "BAC" / "CPI"$;
- *ETC*: Estimated To Completion - stima del costo aggiuntivo necessario per completare il progetto
Formula: $"ETC" = "EAC" - "AC"$;
- *VAC*: Variance At Completion - la differenza tra il budget previsto e il budget attuale alla fine del progetto
Formula: $"VAC" = "BAC" - "EAC"$;
- *SV*: Schedule Variance - indica se si è in linea, in anticipo o in ritardo rispetto alla schedulazione delle attività di progetto pianificate
Formula: $"SV" = "EV" - "PV"$;
- *BV*: Budget Variance - indica se alla data corrente si è speso di più o di meno rispetto a quanto inizialmente previsto nel budget
Formula: $"BV" = "PV" - "AC"$.
=== Codifica <metriche_codifica>
- *ATC*: Attributi per Classe - rappresenta il numero di attributi appartenenti ad una classe;
- *PM*: Parametri per Metodo - rappresenta il numero di parametri appartenenti ad un metodo;
- *LCM*: Linee di Codice per Metodo - rappresenta il numero di linee di codice che costituiscono un metodo.
=== Documentazione <metriche_documentazione>
- *IG*: Indice Gulpease - metrica utilizzata per valutare la leggibilità di un testo in lingua italiana.
L'Indice Gulpease tiene conto di due variabili linguistiche: la lunghezza delle parole e la lunghezza delle frasi. La formula per calcolare l'indice è la seguente:
$ "IG" = 89 + (300 dot "Nf" - "Nl")/"Np"$, con:
- *Nf*: indica il numero delle frasi;
- *Nl*: indica il numero delle lettere;
- *Np*: indica il numero delle parole.
L'indice fornisce un punteggio che varia da 0 a 100. Di seguito le possibili interpretazioni:
- 0-29: Testo difficile da leggere;
- 30-49: Testo leggibile con sforzo;
- 50-59: Testo abbastanza leggibile;
- 60-69: Testo leggibile;
- 70-79: Testo facile da leggere;
- 80-89: Testo molto facile da leggere;
- 90-100: Testo estremamente facile da leggere.
Per calcolarlo si usa uno strumento online: #link("https://farfalla-project.org/readability_static/");
- *CO*: Correttezza Ortografica - numero errori grammaticali ed ortografici in un documento.
=== Gestione della qualità <metriche_gestione_qualità>
- *MNS*: Metriche Non Soddisfatte - Numero delle metriche che il progetto non riesce a raggiungere o mantenere.
== Metriche per la qualità di prodotto
=== Funzionalità <metriche_qualità-prodotto>
- *ROS*: Requisiti Obbligatori Soddisfatti - la percentuale di requisiti obbligatori soddisfatti dal prodotto
Formula: $"ROS" = "requisiti obbligatori soddisfatti" / "requisiti obbligatori totali" dot 100$;
- *RDS*: Requisiti Desiderabili Soddisfatti - la percentuale di requisiti desiderabili soddisfatti dal prodotto
Formula: $"RDS" = "requisiti desiderabili soddisfatti" / "requisiti desiderabili totali" dot 100$;
- *ROPS*: Requisiti Opzionali Soddisfatti - la percentuale di requisiti opzionali soddisfatti dal prodotto
Formula: $"ROPS" = "requisiti opzionali soddisfatti" / "requisiti opzionali totali" dot 100$;
=== Usabilità
- *FU*: Facilità di Utilizzo - quantità di click che l'utente deve effettuare per raggiungere un obiettivo desiderato;
- *TA*: Tempo di Apprendimento - il tempo richiesto da una persona per comprendere e padroneggiare l'uso del #glossary[sistema].
=== Affidabilità
- *PTCP*: Passed Test Cases Percentage - rappresenta la percentuale di casi di test che sono stati eseguiti con successo rispetto al totale dei casi di test previsti
Formula: $"PTCP" = "test superati" / "test totali" dot 100$;
- *CC*: Code Coverage - numero di linee di codice convalidate con successo nell'ambito di una procedura di test
Formula: $"CC" = "linee di codice percorse" / "linee di codice totali" dot 100$;
- *BC*: Branch Coverage - valuta quanti rami condizionali nel codice sorgente sono stati eseguiti durante l'esecuzione dei test.
Formula: $"BC"= "Numero di rami condizionali eseguiti" / "numero totale dei rami condizionali" dot 100$;
- *SC*: Statement Coverage - valuta quanti statement o istruzioni del codice sorgente sono stati eseguiti durante l'esecuzione dei test.
Formula: $"SC"="numero statement eseguiti"/"numero totale statement" dot 100$.
=== Manutenibilità
- *SFIN*: Structure Fan In - rappresenta il numero di moduli o componenti direttamente collegati o dipendenti da un modulo o una funzione specifica; un fan-in elevato indica che molte parti del #glossary[sistema] dipendono da un particolare modulo;
- *SFOUT*: Structure Fan Out - rappresenta il numero di dipendenze o connessioni che un componente o modulo particolare ha con altri componenti o moduli. Misura quanti altri elementi dipendono o interagiscono con un dato elemento all'interno di un #glossary[sistema]\; un fan-out elevato può indicare che un modulo ha molte dipendenze da altri moduli;
- *CCM*: Complessità Ciclomatica per Metodo - quantifica la complessità del codice misurando il numero di percorsi linearmente indipendenti attraverso il grafo di controllo di flusso del metodo. Più è alta la complessità ciclomatica, maggiore è la complessità del codice.
Formula: $"CCM" = "e" − "n" + 2$, con:
- e: numero di archi del grafo del flusso di esecuzione del metodo;
- n: numero di vertici del grafo del flusso di esecuzione del metodo.
=== Efficienza
- *CPUU*: Maximum CPU usage - indica il picco massimo di utilizzo della CPU durante un determinato periodo di tempo. Utilizzata per valutare il carico massimo di lavoro che il #glossary[sistema] può gestire e per identificare possibili problemi di performance;
- *RAMU*: Maximum RAM usage - indica il picco massimo di utilizzo della memoria RAM durante un determinato periodo di tempo.Importante per valutare l'efficienza nell'uso della memoria del sistema e per identificare eventuali situazioni di sovrautilizzo della memoria che potrebbero causare rallentamenti o crash;
- *TDE*: Tempo Di Elaborazione - rappresenta il tempo trascorso tra il momento in cui i dati sono generati e il momento in cui vengono visualizzati nella #glossary[dashboard] di #glossary[Grafana].
|
https://github.com/davystrong/umbra | https://raw.githubusercontent.com/davystrong/umbra/main/src/shadow-path.typ | typst | MIT License | // Gets the length of an arbitrary vector
#let _norm(p) = calc.sqrt(p.map(x => calc.pow(x.pt(), 2)).sum()) * 1pt
// Adds any number of arbitrary vectors
#let _add(..ps) = ps.pos().fold(
none,
(acc, x) => if acc == none { x } else { acc.zip(x).map(((y, z)) => y + z) },
)
// Takes the first vector and subtracts all subsequent vectors from it
#let _sub(..ps) = ps.pos().fold(
none,
(acc, x) => if acc == none { x } else { acc.zip(x).map(((y, z)) => y - z) },
)
// Rotates a 2D vector by the given angle
#let _rot(p, angle) = (
p.first() * calc.cos(angle) - p.last() * calc.sin(angle),
p.first() * calc.sin(angle) + p.last() * calc.cos(angle),
)
// Multiply (scale) a vector by some number
#let _mult(p, x) = p.map(y => x * y)
// Roll a vector by count positions, moving the overflow at the end back to the start
#let _roll(arr, count) = (arr.slice(count) + arr).slice(0, arr.len())
#let shadow-path(
fill: none,
stroke: none,
closed: false,
shadow-radius: 0.5cm,
shadow-stops: (gray, white),
// A small correction is required otherwise there is a white line between shadow sections
correction: 5deg,
..vertices,
) = {
let vertices = vertices.pos()
assert(
vertices.all(x => x.len() == 2 and x.all(y => type(y) != array)),
message: "paths with Bezier control points not supported",
)
layout(
size => {
let vertices = vertices.map(((x, y)) => (
if type(x) == ratio { x * size.width } else { x },
if type(y) == ratio { y * size.height } else { y },
))
let groups = vertices.zip(_roll(vertices, 1), _roll(vertices, 2), _roll(vertices, 3))
if not closed {
groups = _roll(groups, -1).slice(0, -1)
}
// Setup edge shadows
for (p0, p1, p2, p3) in groups {
let angle0 = calc.atan2(.._sub(p1, p0).map(x => x.pt()))
angle0 += if angle0 > 0deg { 0deg } else { 360deg }
let angle1 = calc.atan2(.._sub(p2, p1).map(x => x.pt()))
angle1 += if angle1 > 0deg { 0deg } else { 360deg }
let angle2 = calc.atan2(.._sub(p3, p2).map(x => x.pt()))
angle2 += if angle2 > 0deg { 0deg } else { 360deg }
let width = shadow-radius
let height = _norm(_sub(p1, p2))
let d0 = 0pt
let d1 = 0pt
let da0 = angle1 - angle0
let da1 = angle2 - angle1
if da0 < 0deg or da0 > 180deg {
da0 = 0
}
if da1 < 0deg or da1 > 180deg {
da1 = 0
}
place(top + left, dx: p2.first(), dy: p2.last(), rotate(
calc.atan2(.._sub(p1, p2).map(x => x.pt())) + 90deg + 180deg,
origin: top + left,
polygon(
fill: gradient.linear(..shadow-stops),
(0pt, 0pt),
_rot((width, 0pt), da1 / 2),
_add((0pt, height), _rot((width, 0pt), -da0 / 2)),
(0pt, height),
),
))
}
// Setup corner shadows
if not closed {
groups = groups.slice(1)
}
for (p0, p1, p2, p3) in groups {
let angle0 = calc.atan2(.._sub(p1, p0).map(x => x.pt()))
angle0 += if angle0 > 0deg { 0deg } else { 360deg }
let angle1 = calc.atan2(.._sub(p2, p1).map(x => x.pt()))
angle1 += if angle1 > 0deg { 0deg } else { 360deg }
let da = angle1 - angle0
if da < 0deg or da > 180deg {
da = calc.abs(da)
let d0 = _rot((shadow-radius, 0pt), angle0 + 90deg + correction)
let d1 = _rot((shadow-radius, 0pt), angle1 + 90deg - correction)
// Must be placed in the correct location, otherwise the gradient is based on the size of the whole box
place(
top + left,
dx: p1.first() - shadow-radius,
dy: p1.last() - shadow-radius,
box(
// A fixed size box is required to make radial gradient work. For PDF, the gradient doesn't actually have to be contained by the box, but this breaks with PNG, hence the extra complexity
width: 2 * shadow-radius,
height: 2 * shadow-radius,
place(
top + left,
dx: 50%,
dy: 50%,
path(
closed: true,
fill: gradient.radial(..shadow-stops, center: (50%, 50%), radius: 50%, relative: "parent"),
(d0, _mult(_rot(d0, -90deg), calc.sin(da / 2)), (0pt, 0pt)),
(0pt, 0pt),
((d1), (0pt, 0pt), _mult(_rot(d1, 90deg), calc.sin(da / 2)),),
),
),
),
)
}
}
if fill != none or stroke != none {
path(fill: fill, stroke: stroke, closed: closed, ..vertices)
}
},
)
}
#let shadow-circle(
radius: 0pt,
width: auto,
height: auto,
fill: none,
stroke: none,
inset: 5pt,
outset: (:),
shadow-radius: 0.5cm,
shadow-stops: (gray, white),
// A small correction factor to avoid a line between the shadow and the fill
correction: 0.00001%,
..body,
) = {
assert(
(radius, width, height).filter(it => it == 0pt or it == auto or it == none).len() >= 2,
message: "radius, width and height are mutually exclusive",
)
layout(
size => {
// Replicate the built in optional positional body argument
assert(
body.named().len() == 0 and body.pos().len() <= 1,
message: "unexpected argument",
)
let body = if body.pos().len() == 1 { body.pos().first() } else { none }
// Width and height seem to only be to allow for sizing relative to parent
let radius = radius
if not (width == 0pt or width == auto or width == none) {
if type(width) == ratio {
radius = width * size.width
} else {
radius = width
}
} else if not (height == 0pt or height == auto or height == none) {
if type(height) == ratio {
radius = height * size.height
} else {
radius = height
}
}
// Avoid an unnecessary place
let inner = circle(
radius: radius + shadow-radius,
fill: gradient.radial(
// Making it transparent doesn't actually do anything yet since gradients
// can't handle transparency
(shadow-stops.last().transparentize(100%), 0%),
(
shadow-stops.last().transparentize(100%),
radius / (radius + shadow-radius) * 100% - correction,
),
..shadow-stops.enumerate().map(
((i, stop)) => (
stop,
(radius + shadow-radius * i / (shadow-stops.len() - 1)) / (radius + shadow-radius) * 100%,
),
),
),
stroke: none,
inset: inset,
outset: outset,
)
if fill != none or stroke != none or body != none {
place(inner)
place(dx: shadow-radius, dy: shadow-radius, circle(
radius: radius,
fill: fill,
stroke: stroke,
inset: inset,
outset: outset,
body,
))
} else {
inner
}
},
)
}
|
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/math/op_02.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Test scripts vs limits.
#set page(width: auto)
#set text(font: "New Computer Modern")
Discuss $lim_(n->oo) 1/n$ now.
$ lim_(n->infinity) 1/n = 0 $
|
https://github.com/dantevi-other/kththesis-typst | https://raw.githubusercontent.com/dantevi-other/kththesis-typst/main/utils/values.typ | typst | MIT License | //-- Font sizes
#let font-size-0 = 24pt
#let font-size-1 = 18pt
#let font-size-2 = 16pt
#let font-size-3 = 14pt
#let font-size-base = 12pt |
https://github.com/jbirnick/typst-rich-counters | https://raw.githubusercontent.com/jbirnick/typst-rich-counters/main/lib.typ | typst | MIT License | #let rich-counter(identifier: none, inherited_levels: 0, inherited_from: heading) = {
// this can equip `headings` and similar objects with the rich-counter functions
// that are needed for recursive evaluation
let rich-wrapper(key) = {
let at(loc) = {
let cntr = counter(key)
if (loc == none) { cntr.final() }
else { cntr.at(loc) }
}
let last_update_location(level, before_key) = {
if key == heading {
let occurrences = if before_key == none { query(selector(key)) } else { query(selector(key).before(before_key)) }
for occurrence in occurrences.rev() {
if occurrence.level <= level {
return occurrence.location()
}
}
} else {
// best guess: just take the last occurrence of the element
// WARNING: this can be wrong for certain elements, especially if Typst introduces more queryable/locatable elements
let occurrences = if before_key == none { query(selector(key)) } else { query(selector(key).before(before_key)) }
if occurrences.len() == 0 {
return none
} else {
return occurrences.last().location()
}
}
}
return (at: at, inherited_levels: 0, last_update_location: last_update_location)
}
// get the parent rich-counter
let parent_rhcntr = if type(inherited_from) == dictionary {
if inherited_levels == 0 { inherited_levels = inherited_from.inherited_levels + 1 }
inherited_from
} else {
rich-wrapper(inherited_from)
}
// `step` method for this rich-counter
let step(depth: 1) = [
#metadata(depth)
#label("rich-counter:step:" + identifier)
]
// find updates of own partial (!) counter in certain range
let updates_during(after_key, before_key) = {
let query_for = selector(label("rich-counter:step:" + identifier))
if after_key == none and before_key == none {
return query(query_for)
} else if after_key == none {
return query(query_for.before(before_key))
} else if before_key == none {
return query(query_for.after(after_key))
} else {
return query(query_for.after(after_key).before(before_key))
}
}
// find last update of this total (!) counter up to a certain level and before a certain location
let last_update_location(level, before_key) = {
let parent_last_update_location = (parent_rhcntr.last_update_location)(inherited_levels, before_key)
let updates = updates_during(parent_last_update_location, before_key)
for update in updates.rev() {
if update.value <= level - inherited_levels {
return update.location()
}
}
return parent_last_update_location
}
// compute value of the counter after the given updates, starting from 0
let compute_counter(updates) = {
let value = (0,)
for update in updates {
let level = update.value
while value.len() < level { value.push(0) }
while value.len() > level { value.pop() }
value.at(level - 1) += 1
}
return value
}
// `at` method for this rich-counter
let at(key) = {
// get inherited numbers
let num_parent = (parent_rhcntr.at)(key)
while num_parent.len() < inherited_levels { num_parent.push(0) }
while num_parent.len() > inherited_levels { num_parent.pop() }
// get numbers of own partial counter
let updates = updates_during((parent_rhcntr.last_update_location)(inherited_levels, key), key)
let num_self = compute_counter(updates)
return num_parent + num_self
}
// `get` method for this rich-counter
let get() = { at(here()) }
// `final` method for this rich-counter
let final() = { at(none) }
// `display` method for this rich-counter
let display(..args) = {
if args.pos().len() == 0 {
numbering("1.1", ..get())
} else {
numbering(args.pos().first(), ..get())
}
}
return (step: step, at: at, get: get, final: final, display: display, inherited_levels: inherited_levels, last_update_location: last_update_location)
}
|
https://github.com/AxiomOfChoices/Typst | https://raw.githubusercontent.com/AxiomOfChoices/Typst/master/Research/Summer%202024/Geometry%20School/Ancient%20Mean%20Curvature%20Flow.typ | typst | #import "/Templates/generic.typ": latex
#import "/Templates/notes.typ": chapter_heading
#import "@preview/ctheorems:1.1.0": *
#import "/Templates/math.typ": *
#show: latex
#show: chapter_heading
#show: thmrules
#show: symbol_replacing
#show: equation_references
#set pagebreak(weak: true)
#set page(margin: (x: 2cm, top: 2cm, bottom: 2cm), numbering: "1")
#set enum(numbering: "(1)", indent: 1em)
#show heading: it => {
if (it.numbering == none or it.level > 1) {
return it
}
let numbers = counter(heading).at(it.location())
let body = it.body
block([*#body*])
}
#outline()
= Lecture 1
We will start with a simpler model of mean curvature flow to get familiar with the subject.
== Ancient Curve Shortening Flow
Set $Gamma : M -> RR^2$, the mean curvature equation simplifies to
$
diff_t Gamma = diff_s diff_s Gamma
$
If $Gamma_t$ exists for $t in (-infinity, T)$ then we call $Gamma_t$ an ancient flow.
#remark[
Ancient solutions to parabolic PDEs are rigid, and thus easier to analyze.
]
#example[
Consider the heat equation $diff_t u = laplace u$ where $u : RR -> RR$, then
$
1 / 2 (d) / (d t) integral_RR u^2 dif x = integral u u_t = integral u u_(x x) = - integral u_x^2 <= - C integral u^2
$
where the last inequality is due to Poincare.
Hence we have
$
integral u^2 dif x >= C e^(- s t)
$
and so with the correct boundary conditions $u equiv 0$ is the only ancient solution to the heat flow.
]
#remark[
This is an analogue to the Louville type theory for elliptic PDEs, in the elliptic case we need the solution to be entire, in the parabolic case we need it to be ancient.
]
#example[
In the case of CSF, we do have embedded ancient solutions.
- The line is the simplest solution.
- The self-shrinking circle.
- The grim reaper curve.
The line and grim reaper are actually solutions for $t in (-infinity, infinity)$, solutions of this type are called _eternal_ solutions.
]
We can also glue solutions together, one can in fact glue two grim reaper solutions together to get another ancient solution. This is called the paperclip solution.
There are also many other ways to glue these ancient solutions together.
We also have a solution named the Yin-Yang spiral, which is a rotator, it rotates symmetrically under MCF.
#theorem("Daskolopaulus-Hamilton-Sesmin")[
A closed embedded compact CSF is a shrinking circle or a paperclip.
]
Under CSF the curvature satisfies
$
diff_t kappa = diff_s diff_s kappa + kappa^3,
$
if we instead parametrize using the Gauss map we get
$
diff_t kappa (theta, t) = kappa^2 diff_(theta) diff_theta + kappa^3.
$
Now if we set $p(theta, t) = k^2$, we call $p$ the 'pressure', and it solves
$
diff_t p = p diff_theta diff_theta p - 1 / 2 (diff_theta p)^2 + 2 p^2.
$
If $p(theta, t) = 1/(- 2t)$ then $Gamma_t$ is the shrinking circle. If $p(theta, t) = lambda (1/(1 - e^(2 lambda t)) - sin^2(theta + gamma))$ then $Gamma_t$ is a paper clip, $lambda$ is the top speed of the paper clip.
Set $alpha = p_theta$ then $alpha$ solves
$
diff_t alpha = p(diff_theta diff_theta alpha + 4 alpha)
$
and we define
$
I(alpha) = integral_0^(2 pi) (diff_theta alpha)^2 - 4 alpha^2 dif theta
$
#exercise[ Show that if $I equiv 0$ then $Gamma_t$ is a shrinking circle or a paper clip.
]
#lemma[
$I$ evolves as
$
d / (d t) I = - 2 integral.dash (diff_t alpha)^2 / p dif theta <= 0
$
]
#proof[
We compute
$
d / (d t) I = integral 2 (diff_theta alpha) (
diff_t diff_theta alpha
) - 8 alpha (diff_t alpha) = - integral (
2 diff_theta diff_theta alpha + 8 alpha
) (diff_t alpha) = - 2 integral (diff_t alpha) / p (diff_t alpha)
$
]
#theorem("Gage-Hamilton")[
Convex closed CSF converges to a round point, in the sense that under the rescaling $tilde(Gamma)_t = (Gamma_t - x_0)/sqrt(2 (t_0 - t))$ and $tau = -1/2 log(t_0 - t)$ we have $lim_(tau -> infinity) tilde(kappa) - 1 = 0$.
]<thrm-gage_hamilton>
= Lecture 2
We now want to prove that $I equiv 0$, to do this we will use the fact that $I$ is monotone, as well as the fact that $lim_(t -> T) I(alpha(t)) = 0$ and $lim_(t -> -infinity) I(alpha(t)) = 0$.
#lemma[
$lim_(t -> T) I(alpha(t)) = 0$.
]
To prove this we will consider the quantity $omega := tilde(kappa) - 1$, and find that it solves
$
diff_tau omega = L omega + E(omega)
$
where $L(omega) = omega_(theta theta) + 2 omega$ and we have bounds
$
|E(omega)| <= C|omega|||omega||_(L^2)
$
We now want to analyze this linear operator, one can easily check that
$
1, cos(k theta), sin(k theta)
$
are all eigenfunctions of eigenvalue $2$ and $2-k^2$ respectively.
Now in order for $omega -> 0$ as $tau -> + infinity$ we need to have all the 'unstable' components, those with $2-k^2$ positive, not contribute to the solution as $tau -> +infinity$.
This motivates us to define the projection of $omega$ to the positive eigenvalues,
$
P_+ omega = a_0(tau) 1 / (2 pi) + a_1(tau) cos(theta) / pi + b_1(
tau
) sin(theta) / pi
$
as well as the projection to negative eigenvalues
$
P_- omega = omega - P_+ omega
$
We can now find that
$
d / (d t) ||P_+ omega||^2_(L^2) = 2 ip(omega_tau, P_+ omega)_(L^2) = 2 ip(L omega + E, P_+ omega)_(L^2)
= 2 ip(L omega, P_+ omega)_(L^2) + 2 ip(E, P_+ omega)_(L^2)
\ >= 2 dot 1 ||P_+ omega||^2_(L^2) + 2 ip(E, P_+ omega)_(L^2)
$
and similarly
$
d / (d t) ||P_- omega||_(L^2)^2
<= 2 dot (-2) ||P_- omega||^2_(L^2) + 2 ip(E, P_- omega)_(L^2)
$
#exercise[
$|ip(E, P_(plus.minus) omega)| <= C||omega||_(C^2)||omega||_(L^2)^2$
]
We can now use the fact that
$
||omega||_(L^2)^2
=
||P_+ omega||_(L^2)^2
+
||P_- omega||_(L^2)^2
$
and by writing $omega_(plus.minus) = ||P_(plus.minus) omega||_(L^2)^2$ we get
$
omega'_+ >= 2 omega_+ - C||omega||_(C^2)(omega_+ + omega_-)
\
omega'_- <= - 4 omega_- + C||omega||_(C^2)(omega_+ + omega_-)
$
#claim[
$omega_+ <= C||omega||_(C^2)omega_-$
]
#proof[
First notice that we expect this to be true, since otherwise the $2 omega_+$ term would dominate in the equation for $omega'_+$ and it would grow exponentially, which would contradict the fact that $omega -> 0$.
Now for an actual proof we defined $f(tau) := omega_+ - G omega_-$, then we have
$
f' >= 2 omega_+ - C||omega||_(C^2)(
omega_+ + omega_-
) + 4 G omega_- - G C||omega||_(C^2)(omega_+ + omega_-)
\ = (2 - C||omega||_(C^2)) omega_+ + (4 G - C||omega||_(C^2)) omega_-
$
Now we know that in the limit, $2 - C||omega||_(C^2) > 1$ so the first coefficient here is at least $1$, hence if $4 G >= C||omega||_(C^2)$ for all $tau >= T_0$ then we have
$
f' >= omega_+ >= f
$
so $f$ would blow up to infinity as long as $f(T_0) > 0$.
Thus if we set $G(T_0) = sup_(s > T_0) C_0||omega||_(C^2)$ then this blowup would happen unless
$
f(T_0) = omega_+ - G omega_- < 0
$
so since we know it cannot happen then we must have
$
omega_+ < G omega_- = C sup_(s > T_0)||omega||_(C^2)(s)
$
]
Now we can use this result to get
$
omega'_- <= -4 omega_- + C G omega_- = - (4 - C G) omega_-
$
so for large enough $t$ we have $C G < 1$ so
$
omega'_- <=-3 omega_-
$
hence we get
$
omega_- <= C e^(- 3 tau)
$
so again by the claim
$
||omega||_(L^2)^2 = omega = (1 + o(1)) omega_- <= C e^(- 3tau)
$
and hence
$
||omega||_(L^2) <= C e^(- 3 / 2tau)
$
Then by interior Schauder estimates we get that
$
||omega||_(C^(2 alpha)) <= C||omega||_(L^infinity) <= C||omega||_(L^2)
$
= Lecture 3
Now we move on to the more interesting case of surfaces, if we set $M_t$ to be the graph of $u(dot, t)$ over $Sigma := M_0$ then under MCF this evolves as
$
u_t = L u + E(u)
$
where $L u = laplace_Sigma u + |A_sigma|^2 u + Ric(nu,nu) u$ and $|E(u)| <= C||u||_(C^2)||u||_(C^1)$
Now if we write this as
$
u_t = F(nabla^2 u, nabla u, u, x, t)
$
then we will define $v$ to be the solution of
$
0 = F(nabla^2 v, nabla v, v, x, t).
$
Now we define $w = u - v$ and note that $||omega||_(C^2) <= epsilon$ as well as
$
omega_t = L omega + E(omega)
$
|
|
https://github.com/jonatchoum/quarto-jon-thesis-template | https://raw.githubusercontent.com/jonatchoum/quarto-jon-thesis-template/main/_extensions/jon_thesis/typst-show.typ | typst | #import "typst-template.typ": template
// Your acknowledgments (Ringraziamenti) go here
#let acknowledgments = [
I would like to thank you for using my template and the team of typst for the great work they have done and the awesome tool they developed. Remember that it's best practice to thank the people you worked with before thanking your family and friends.
]
// Your abstract goes here
#let abstract = [
In this theis, we will talk about this template I made for the University of Turin, remember that the abstract should be concise and clear but should also be able to give a good idea of what the thesis is about, always ask your advisor for feedback if you are unsure.
]
#show: template.with(
// Your title goes here
title: "Utilisation de Copilot pour le développement de logiciel informatique",
// Change to the correct academic year, e.g. "2024/2025"
academic-year: [2023/2024],
// Change to the correct subtitle, i.e. "Tesi di Laurea Triennale",
// "Master's Thesis", "PhD Thesis", etc.
subtitle: "Mémoire Technique",
// Change to your name and matricola
candidate: (
name: "<NAME>",
matricola: none
),
// Change to your supervisor's name
supervisor: (
"<NAME>"
),
// Add as many co-supervisors as you need or remove the entry
// if none are needed
co-supervisor: (
"<NAME>",
),
// Customize with your own school and degree
affiliation: (
university: "Università degli Studi di Torino",
school: "Scuola di Scienze della Natura",
degree: "Corso di Laurea Triennale in Informatica",
),
// Change to "it" for the Italian template
// Change to "fr" for the French template
lang: "fr",
// University logo
logo: image("imgs/total_logo.svg", width: 40%),
// Enterprise logo
logo2: image("imgs/cesi.png", width: 40%),
// Hayagriva bibliography is the default one, if you want to use a
// BibTeX file, pass a .bib file instead (e.g. "works.bib")
bibliography: bibliography("works.yml"),
// See the `acknowledgments` and `abstract` variables above
acknowledgments: acknowledgments,
abstract: abstract,
// Add as many keywords as you need, or remove the entry if none
// are needed
keywords: [keyword1, keyword2, keyword3]
)
// I suggest adding each chapter in a separate typst file under the
// `chapters` directory, and then importing them here.
// #include "chapters/introduction.typ"
// #include "chapters/example.typ"
// #include "chapters/conclusions.typ"
|
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/hydra/0.1.0/src/default.typ | typst | Apache License 2.0 | // get the adjacent headings
#let get-adjacent(is-footer: false, sel, loc) = {
import "/src/util.typ": into-sel-filter-pair
let (sel, filter) = into-sel-filter-pair(sel)
if is-footer {
loc = query(selector(<hydra>).before(loc), loc).last().location()
}
let prev = query(sel.before(loc), loc).filter(x => filter(x, loc))
let next = query(sel.after(loc), loc).filter(x => filter(x, loc))
let prev = if prev != () { prev.last() }
let next = if next != () { next.first() }
(prev, next)
}
// check if the previous heading is numbered
#let prev-filter(element, loc) = {
import "/src/util.typ": assert-element
assert-element(element, heading)
element.numbering != none
}
// check if the next heading is on the curent page
#let next-filter(top-margin: 2.5cm, element, loc) = {
import "/src/util.typ": assert-element
assert-element(element, heading)
(element.numbering != none
and element.location().page() == loc.page()
and element.location().position().y <= top-margin)
}
// display the heading as closely as it occured at the given loc
#let display(element, loc) = {
import "/src/util.typ": assert-element
assert-element(element, heading)
if element.numbering != none {
numbering(element.numbering, ..counter(heading).at(element.location()))
[ ]
}
element.body
}
#let resolve(
sel: heading,
getter: get-adjacent,
prev-filter: prev-filter,
next-filter: next-filter,
display: display,
is-footer: false,
loc,
) = {
let (last, next) = getter(sel, is-footer: is-footer, loc)
let last-eligible = last != none and prev-filter(last, loc)
let next-eligible = next != none and next-filter(next, loc)
if last-eligible and not next-eligible {
display(last, loc)
}
}
|
https://github.com/Jollywatt/typst-fletcher | https://raw.githubusercontent.com/Jollywatt/typst-fletcher/master/tests/edge-bend/test.typ | typst | MIT License | #set page(width: auto, height: auto, margin: 1em)
#import "/src/exports.typ" as fletcher: diagram, node, edge
#diagram(
cell-size: 3cm,
node((0,0), "from"),
node((1,0), "to"),
for θ in (0deg, 20deg, -50deg) {
edge((0,0), (1,0), $#θ$, bend: θ, marks: (none, "head"), label-side: center)
}
)
#pagebreak()
#for (i, to) in ((0,1), (1,0), (calc.sqrt(1/2),-calc.sqrt(1/2))).enumerate() {
diagram(debug: 0, {
node((0,0), $A$)
node(to, $B$)
let N = 6
range(N + 1).map(x => (x/N - 0.5)*2*120deg).map(θ => edge((0,0), to, bend: θ, marks: ">->")).join()
})
}
|
https://github.com/francescoo22/masters-thesis | https://raw.githubusercontent.com/francescoo22/masters-thesis/main/chapters/2-Background.typ | typst | #import "../config/utils.typ": *
#pagebreak(to:"odd")
= Background<cap:background>
This chapter outlines the background information necessary to understand the concepts discussed in the rest of this work. Specifically, it covers relevant aspects about Kotlin, aliasing, separation logic, and Viper, providing a foundation for understanding how these topics interrelate and support the main contributions of the thesis.
== Kotlin
Developed by JetBrains, Kotlin @KotlinSpec @Kotlin is an open-source, statically typed programming language that gained popularity in recent years, particularly in the field of Android software development. It shares many similarities with Java and it can fully interoperate with it. Additionally, Kotlin introduces a range of modern features, including improved type inference, support for functional programming, null-safety, and smart-casting, making it an attractive option for developers.
The following sections will present the features of the language that are more relevant for this work.
=== Mutability vs Immutability
In programming languages, mutability refers to the capability to alter the value of a variable after it has been initialized. In Kotlin, variables and fields can be either mutable or immutable. Mutable elements are defined using the `var` keyword, while immutable elements are defined using the `val` keyword. Mutable variables or fields, once assigned, can have their values changed during the execution of the program. In contrast, immutable elements, once assigned a value, cannot be altered subsequently. For instance, `var x = 5` allows to change the value of `x` later in the program, while `val y = 5` keeps `y` consistently at the value of `5` throughout the program's execution. This clear distinction between `val` and `var` is particularly useful in a multithreaded environment since it helps to prevent race conditions and data inconsistencies.
=== Smart Casts<cap:smart-cast>
In Kotlin, when the compiler can determine that a variable's type is more specific than its declared type, it inserts a smart cast to reflect this. This means that after a type check in a conditional expression, the variable can be used with its more specific type within that block without additional casting. For example, after confirming a variable is of a certain type in an `if` condition, the variable can be used with that type within the `if` block without requiring an explicit cast. An example of smart casting is provided in @smart-cast.
#figure(
caption: "Example of smart-cast in Kotlin",
```kt
open class A()
class B : A() {
fun f() = println("B")
}
fun callIfIsB(a: A) {
if (a is B) {
a.f()
// ^^^^^
// Smart cast to B
}
}
```
)<smart-cast>
=== Null Safety
Kotlin's type system has been designed with the goal of eliminating the danger of null references. In many programming languages, including Java, accessing a member of a null reference results in a null reference exception. Kotlin avoids most of these situations because the type system distinguishes between references that can hold `null` and those that cannot, the former are called nullable references while the latter are called non-nullable references. @kt-null-safety shows how nullable references are declared by appending a question mark to the type name and it shows that trying to assign `null` to a non-nullable reference leads to a compilation error.
#figure(
caption: "Kotlin null safety example",
```kt
var nullableString: String?
nullableString = "abc" // ok
nullableString = null // ok
var nonNullableString: String
nonNullableString = "abc" // ok
nonNullableString = null // compilation error
```
)<kt-null-safety>
Accessing members of nullable reference or calling a method with a nullable reference as receiver is only allowed if the compiler can understand that the reference will never be null when one of these actions occurs. Usually, this is done with a smart cast considering that for every type `T`, its nullable counterpart `T?` is a supertype of `T`.
#figure(
caption: "Kotlin smart cast to non-nullable",
```kt
fun f(nullableString: String?) {
if (nullableString != null) {
// 'nullableString' is smart-cast from 'String?' to 'String'
println(nullableString.length) // safe
println(nullableString.isEmpty()) // safe
}
val n = nullableString.length // compilation error
}
```
)
However, there are instances in which a `NullPointerException` can be raised in Kotlin. These include explicit calls to `throw NullPointerException()`, performing unsafe (non-smart) casts, and during Java interoperation.
=== Properties
As mentioned before, properties in Kotlin can be declared as either mutable or read-only. While the initializer, getter, and setter for a property are optional, the property's type can also be omitted if it can be inferred from the initializer or the getter's return type.
Kotlin does not allow direct declaration of fields. Instead, fields are implicitly created as part of properties to store their values in memory. When a property requires a backing field, Kotlin automatically provides one. This backing field can be accessed within the property's accessors using the `field` identifier.
A backing field is generated under two conditions: if the property relies on the default implementation of at least one accessor, or if a custom accessor explicitly references the backing field via the `field` identifier.
#figure(
caption: "Kotlin properties",
```kt
class Square {
var width = 1 // initializer
set(value) { // setter
if (value > 0) field = value // accessing backing field
else throw IllegalArgumentException(
"Square width must be greater than 0"
)
}
val area
get() = width * width // getter
}
```
)
=== Contracts
Kotlin contracts @KotlinContracts are an experimental feature introduced in Kotlin 1.3 designed to provide additional guarantees about code behavior, helping the compiler in performing more precise analysis and optimizations. Contracts are defined using a special contract block within a function, describing the relationship between input parameters and the function's effects. This can include conditions such as whether a lambda is invoked or if a function returns under certain conditions. By specifying these relationships, contracts provide guarantees to the caller of a function, offering the compiler additional information that enable more advanced code analysis.
It is important to point out that currently contracts are only partially verified by the compiler. In certain cases, the compiler trusts the contracts without verification, placing the responsibility on the programmer to ensure that the contracts are correct.
In @contract-1 it is possible to see how contracts allow the initialization of immutable variables within the body of a lambda, doing this is not possible without using a contract (@contract-2).
#figure(
caption: "Example of contract declaration and usage",
```kt
public inline fun <R> run(block: () -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
fun main() {
val b: Boolean
run {
b = true
}
println(b)
}
```
)<contract-1>
#figure(
caption: "Compilation error caused by the absence of contracts",
```kt
fun <R> runWithoutContract(block: () -> R): R {
return block()
}
fun main() {
val b: Boolean
runWithoutContract { b = true }
/* ^^^^^^^^
Captured values initialization is forbidden
due to possible reassignment
*/
}
```
)<contract-2>
=== Annotations
Annotations provide a way to associate metadata with the code. To declare annotations, the `annotation` modifier should be placed before a class declaration.
It is also possible to specify additional attributes by using meta-annotations on the annotation class. For instance, `@Target` specifies the types of elements that can be annotated.
@kt-annotations-example illustrates how to declare and use a custom annotation (Lines 1-13) alongside existing annotations such as `@Deprecated` and `@SinceKotlin`.
#figure(
caption: "Example of annotations usage",
```kt
@Target(
AnnotationTarget.CLASS,
AnnotationTarget.FUNCTION,
AnnotationTarget.VALUE_PARAMETER
)
annotation class MyAnnotation
@MyAnnotation
class MyClass {
@MyAnnotation
fun myFun(@MyAnnotation foo: Int) {
}
}
@Deprecated(
message = "Use newFunction() instead",
replaceWith = ReplaceWith("newFunction()"),
)
fun oldFunction() { /* ... */ }
@SinceKotlin(version = "1.3")
fun newFunction() { /* ... */ }
```
)<kt-annotations-example>
== Aliasing and Uniqueness<cap:aliasing>
Aliasing refers to the situation where a data location in memory can be accessed through different symbolic names in the program. Thus, changing the data through one name inherently leads to a change when accessed through the other name as well. This can happen due to several reasons such as pointers, references, multiple arrays pointing to the same memory location etc.
In contrast, uniqueness @uniqueness-logic @An-Entente-Cordiale ensures that a particular data location is accessible through only one symbolic name at any point in time. This means that no two variables or references point to the same memory location, thus preventing unintended side effects when data is modified. A data location that is accessible by exactly one reference is said to be unique; similarly, the reference pointing to that data location is also termed unique.
Uniqueness can be particularly important in concurrent programming paradigms, where the goal is often to avoid mutable shared state to ensure predictability and maintainability of the code @bocchino2013alias. By enforcing uniqueness, programmers can guarantee that data modifications are localized and do not inadvertently affect other parts of the program, making reasoning about program behavior and correctness more straightforward.
@aliasing shows the concept of aliasing and uniqueness practically with a Kotlin example.
The function starts by declaring and initializing variable `y` with `x`, resulting in `x` and `y` being aliased.
Following that, variable `z` is initialized with a newly-created object in the function's second line. Therefore, at this stage in the program, `z` can be referred to as "unique", signifying that it is the only reference pointing to that particular object.
#figure(
caption: "Aliasing, an example",
```kt
class T()
fun f(x: T) {
val y = x // 'x' and 'y' are now aliased
val z = T() // here 'z' is unique
}
```
)<aliasing>
Although aliasing is essential in object-oriented programming as it allows programmers to implement designs involving sharing, as described in _the Geneva Convention on the Treatment of Object Aliasing_ @GenevaConvention, aliasing can be a problem in both formal verification and practical programming.
The example in @alias-verification illustrates how aliasing between references can complicate the formal verification process. In the given example, a class `A` is declared with a boolean field `x`, followed by the function `f` which accepts two arguments `a1` and `a2` of type `A`. The function assigns `true` to `a1.x`, `false` to `a2.x`, and finally returns `a1.x`. Despite the function being straightforward, we cannot assert that the function will always return `true`. The reason for this uncertainty is the potential aliasing of `a1` and `a2`, as the second assignment might change the value of `a1.x` as well.
Modern programming languages frequently utilize a high degree of concurrency, which can further complicate the verification process. As shown in @alias-verification-concurrent, even a simpler function than its counterpart in @alias-verification does not permit to assert that it will always return `true`. In this instance, the function only takes a single argument `a` of type `A`, assigns `true` to `a.x` and eventually returns it. However, within a concurrent context there may exist another thread with access to a variable aliasing `a` that can modify `a.x` to `false` prior to the function's return, thus challenging the verification process.
@alias-bug presents a contrived example to illustrate how aliasing can lead to mysterious bugs. Function `f` takes two lists `xs` and `ys` as arguments. If both lists are not empty, the function removes the last element from each. One might assume this function will never raise an `IndexOutOfBoundsException`. However, if `xs` and `ys` are aliased and have a size of one, this exception will occur.
Moving to a more realistic example, @alias-custom-assign shows a reasonable C++ implementation of the assignment operator overloading for a vector.
Since C++ does not have built-in mechanisms to control aliasing statically, in this implementation, the assignment operator must explicitly address the possibility of aliasing between the `this` pointer and the `&other` pointer (Lines 9-11). If these two pointers are found to be identical, indicating that the object is being assigned to itself, the operation is immediately terminated to prevent any unnecessary operations. Failing to properly manage this aliasing could lead to significant issues, such as data corruption or unintended behavior, because the operator might inadvertently delete the data before copying, thereby causing the object to lose its original state.
#figure(
caption: "Problems caused by aliasing in formal verification",
```kt
class A(var x: Boolean)
fun f(a1: A, a2: A): Boolean {
a1.x = true
a2.x = false
return a1.x
}
```
)<alias-verification>
#figure(
caption: "Problems caused by aliasing in formal verification within a concurrent context",
```kt
class A(var x: Boolean)
fun f(a: A): Boolean {
a.x = true
return a.x
}
```
)<alias-verification-concurrent>
#figure(
caption: "Problems caused by aliasing in practical programming",
```kt
fun f(xs: MutableList<Int>, ys: MutableList<Int>) {
if (xs.isNotEmpty() && ys.isNotEmpty()) {
xs.removeLast()
ys.removeLast()
}
}
fun main() {
val xs = mutableListOf(1)
f(xs, xs)
}
```
)<alias-bug>
#figure(
caption: "Aliasing handling in vector assignment operator overloading",
```cpp
class Vector {
private:
int* data;
size_t size;
public:
// other code here...
Vector& operator=(const Vector& other) {
if (this == &other) {
return *this;
}
delete[] data;
size = other.size;
data = new int[size];
std::memcpy(data, other.data, size * sizeof(int));
return *this;
}
// other code here...
}
```
)<alias-custom-assign>
== Separation Logic
Separation logic @separationLogic1 @separationLogic2 @separationLogic3 is an extension of first-order logic that can be used to reason about low-level imperative programs that manipulate pointer data structures by integrating it in Hoare's triples.
Unlike a first-order logic formula, which directly represents a truth value, a separation logic formula represents predicates on the heap. This enables separation logic to describe how memory locations are manipulated and how different locations interact with each other.
The core concept of separation logic is the separating conjunction $P ∗ Q$, which asserts that $P$ and $Q$ hold for different, non-overlapping parts of the heap. For instance, if a change to a single heap cell affects $P$ in $P ∗ Q$, it is guaranteed that it will not impact $Q$. This feature eliminates the need to check for possible aliases in $Q$. On a broader scale, the specification ${P} space C space {Q}$ for a heap modification can be expanded using a rule that allows to derive ${P ∗ R} space C space{Q ∗ R}$, indicating that additional heap cells remain untouched. This enables the initial specification ${P} space C space{Q}$ to focus solely on the cells involved in the program's footprint.
Separation logic also includes other assertions: `emp` indicates that the heap is empty, $e_1 |-> e_2$ specifies that the heap contains a cell at address $e_1$ with the value $e_2$, and $a_1 mw a_2$ asserts that extending the current heap with a disjoint part where $a_1$ holds will result in a heap where $a_2$ holds.
$
angle.l "assert" angle.r &::= \
&| "emp" &&& "empty heap" \
&| angle.l "exp" angle.r |-> angle.l "exp" angle.r &&& "singleton heap" \
&| angle.l "assert" angle.r * angle.l "assert" angle.r &&& "separating conjunction" \
&| angle.l "assert" angle.r mw angle.l "assert" angle.r #h(5em) &&& "separating implication" \
$
#example[
In separation logic, this example represents a Hoare triple, which consists of a precondition, a command, and a postcondition.
$ {(x |-> "true") * (y |-> "true")} space x := "false" space {(x |-> "false") * (y |-> "true")} $
The triple has the following meaning:
- Precondition ${(x |-> "true") * (y |-> "true")}$ describes the state of the memory before the command is executed.
- $x |-> "true"$ means that reference $x$ points to the value true.
- $y |-> "true"$ means that reference $y$ points to the value true.
- Separating conjunction $*$ indicates that $x$ and $y$ point to different locations in memory.
- Command $x := "false"$ is an assignment operation where the value referenced by $x$ is updated from true to false.
- Postcondition ${(x |-> "false") * (y |-> "true")}$ describes the state of the memory after the command is executed.
- After the assignment, $x$ now points to false, while $y$ continues to point to true, reflecting that $y$ remains unchanged.
- Again, the separating conjunction $*$ ensures that $x$ and $y$ still point to distinct memory locations.
]
#example[
The following triple is derivable in separation logic:
$ {(x |-> -) * ((x |-> 1) mw P)} space x := 1 space {P} $
]
== Viper
Viper @ViperWebSite @Viper (Verification Infrastructure for Permission-based Reasoning) is a language and suite of tools developed by ETH Zurich designed to aid in the creation of verification tools.
The Viper infrastructure (@vpr-infrastructure) consists of the Viper intermediate language and two different back-ends: one that uses symbolic execution @MuellerSchwerhoffSummers16b and another that relies on verification condition generation @HeuleKassiosMuellerSummers13.
The verification process with Viper follows several steps.
First, a higher-level programming language is translated into Viper's intermediate language, which incorporates permission-based reasoning to manage and express ownership of memory locations, similar to separation logic.
After translation, Viper uses one of its back-ends and an SMT solver to verify the conditions expressed in the Viper language @eilers2024verification. The back-ends are designed to automate the verification process as much as possible, allowing tool developers and users to focus on the verification task itself without needing to comprehend the inner behavior of the back-ends
#figure(
caption: [The Viper verification infrastructure @ViperWebSite],
image("../images/viper.png", width: 80%)
)<vpr-infrastructure>
=== Language Overview
The Viper intermediate language is a sequential, object-based language that provides simple imperative constructs along with specifications and custom statements for managing permission-based reasoning.
In Viper, methods can be seen as an abstraction over a sequence of operations. The caller of a method observes its behavior solely through the method's signature and its preconditions and postconditions. This allows Viper to perform a method-modular verification, avoiding all the complexities associated with interprocedural analysis.
#figure(
caption: "Viper method example",
```vpr
method multiply(x: Int, y: Int) returns (res: Int)
requires x >= 0 && y >= 0
ensures res == x * y
{
res := 0
var i: Int := 0
while (i < x)
invariant i <= x
invariant res == i * y
{
res := res + y
i := i + 1
}
}
```
)<ViperMultiply>
@ViperMultiply shows an example of method in Viper. It is possible to notice that the signature of the method (Line 1) declares the returned values as a list of variables. Preconditions (Line 2), postconditions (Line 3) and invariants (Lines 8-9) are the assertions subject to verification. The remaining statements are similar to most of the existing programming languages. The language is statically typed and several built-in types like `Ref`, `Bool`, `Int`, `Seq`, `Set` and others are provided.
=== Permissions
In Viper, fields are top-level declarations and, since classes do not exist in Viper, every object has all the declared fields.
Field permissions, which define the heap areas that an expression, a statement, or an assertion can access, control the reasoning of a Viper program's heap. Heap locations are only accessible if the relevant permission is under the control of the method currently being verified.
@vpr-permissions-1 shows how a method can require field permissions in its preconditions (Line 4) and ensure that these permissions will still be valid when returning to the caller (Line 5).
#figure(
caption: "Viper permissions example",
```vpr
field b: Bool
method negate(this: Ref)
requires acc(this.b)
ensures acc(this.b)
{
this.b := !this.b
}
```
)<vpr-permissions-1>
As well as being declared in preconditions and postconditions, field permissions can also be obtained within a method's body. The operation that allows to gain permissions is called inhaling and can be seen in @vpr-permissions-2 (Line 3). The opposite operation is called exhaling and enables to drop permissions.
@vpr-permissions-2 also allows to notice how access permissions that has been seen until now are exclusive. In fact, the assertion `acc(x.b) && acc(y.b)` is similar to a separating conjunction in separation logic and so inhaling that assertion implies that `x != y`. This is confirmed by the fact that the statement at Line 6 can be verified.
#figure(
caption: "Viper exclusivity example",
```vpr
field b: Bool
method exclusivity(x: Ref, y: Ref)
{
inhale acc(x.b) && acc(y.b)
assert x != y
x.b := true
y.b := true
}
```
)<vpr-permissions-2>
Sometimes, exclusive permissions can be too restrictive. Viper also allows to have fractional permissions for heap locations that can be shared but only read. Fractional permissions are declared with a permission amount between 0 and 1 or with the `wildcard` keyword.
The value represented by a `wildcard` is not constant, instead it is reselected each time an expression involving a `wildcard` is identified.
The `wildcard` permission amount provides a convenient way to implement duplicable read-only resources, which is often suitable for the representation of immutable data. The example in @vpr-fractional shows how fractional permissions can be combined to gain full permissions (Line 6-7). In the same example it is also possible to see that Viper does not allow to have a permission amount greater than 1, in fact, since `wildcard` is an amount greater than 0, a situation in which `x == y == z` is not possible and so the assertion on Line 11 can be verified.
#figure(
caption: "Viper fractional permissions example",
```vpr
field b: Bool
method fractional(x: Ref, y: Ref, z: Ref)
requires acc(x.b, 1/2)
requires acc(y.b, 1/2)
requires acc(z.b, wildcard)
{
if (x == y) {
x.b := true
if (x == z) {
assert false
}
}
}
```
)<vpr-fractional>
=== Predicates and Functions
Predicates can be seen as an abstraction tool over assertions, which can include resources like field permissions. The body of a predicate is an assertion. However, predicates are not automatically inlined. In fact, in order to substitute the predicate resource with the assertions defined by its body, it is necessary to perform an unfold operation. The opposite operation is called a fold: folding a predicate substitutes the resources determined by its core content with an instance of the predicate. Having predicates that are not automatically inlined is fundamental since it allows to represent potentially unbounded data structures as shown in @vpr-predicate (Lines 4-8) where the predicate `List` can represent a linked-list. The same example shows how unfold and fold operations can be performed to access the value of the second element of a list (Lines 22-26).
Similar to predicates, functions in Viper are used to define parameterized and potentially recursive assertions. The body of a function must be an expression, ensuring that the evaluation of a function is side-effect free, just like any other Viper expression. Unlike methods, Viper reasons about functions based on their bodies, so it is not necessary to specify postconditions when the function body is provided. In @vpr-predicate (Lines 11-15), a function is first used to represent the size of a `List`, and then is utilized in the preconditions of the `get_second` method (Line 19).
#figure(
caption: "Viper predicate and function example",
```vpr
field value: Int
field next: Ref
predicate List(this: Ref)
{
acc(this.value) &&
acc(this.next) &&
(this.next != null ==> List(this.next))
}
function size(xs: Ref): Int
requires List(xs)
{
unfolding List(xs) in xs.next == null ? 1 : 1 + size(xs.next)
}
method get_second(xs: Ref) returns(res: Int)
requires List(xs) && size(xs) > 1
ensures List(xs)
{
unfold List(xs)
unfold List(xs.next)
res := xs.next.value
fold List(xs.next)
fold List(xs)
}
```
)<vpr-predicate>
=== Domains
Domains allow the creation of custom types, mathematical functions, and axioms that define their properties.
The functions defined within a domain are accessible globally across the Viper program. These are known as domain functions, and they have more limitations compared to standard Viper functions. Domain functions cannot have preconditions and can be used in any program state. They are also always abstract, meaning that they cannot have an implemented body. To give meaning to these abstract functions, domain axioms are used.
Domain axioms are also global and define properties that are assumed to be true in all states. Typically, they are expressed as standard first-order logic assertions.
#figure(
caption: "Viper domain example",
```vpr
domain Fraction {
function nominator(f: Fraction): Int
function denominator(f: Fraction): Int
function create_fraction(n: Int, d: Int): Fraction
function multiply(f1: Fraction, f2: Fraction): Fraction
axiom axConstruction {
forall f: Fraction, n: Int, d: Int ::
f == create_fraction(n, d) ==>
nominator(f) == n && denominator(f) == d
}
axiom axMultiply {
forall f1: Fraction, f2: Fraction, res: Fraction ::
res == multiply(f1, f2) ==>
(nominator(res) == nominator(f1) * nominator(f2)) &&
(denominator(res) == denominator(f1) * denominator(f2))
}
}
method m(x: Int)
{
var f: Fraction
f := create_fraction(x, 2)
assert nominator(f) == x
assert denominator(f) == 2
var f_sq: Fraction
f_sq := multiply(f, f)
assert nominator(f_sq) == x * x
assert denominator(f_sq) == 4
}
```
) |
|
https://github.com/duskmoon314/THU_AMA | https://raw.githubusercontent.com/duskmoon314/THU_AMA/main/docs/ch2/2-内部结构.typ | typst | Creative Commons Attribution 4.0 International | #import "/book.typ": *
#show: thmrules
#show: book-page.with(title: "内部结构")
= 内部结构
== 子群与子群判则
#definition()[
设$G$是群，$H subset.eq G$为非空子集，若$H$在$G$的运算下也构成群，则称$H$是$G$的一个#strong[子群]，记为$H lt.eq G$
$H < G$：当$H$为$G$的真子群，即$H eq.not G$
]
#corollary()[
$e lt.eq G$、 $G lt.eq G$， 称为平凡子群
]
#theorem("子群判则")[
设$H subset.eq G$为群内非空子集，则
+ $H lt.eq G$
+ $forall a , b in H$，有$a b in H$且$a^(- 1) in H$ （四合二）
+ $forall a , b in H$，有$a b^(- 1) in H$ （四合一）
等价
]
#proof()[
- 1 $arrow.r$ 2
显然
- 2 $arrow.r$ 3
由2知，$b in H arrow.r.double b^(- 1) in H arrow.r.double a b^(- 1) in H$
- 3 $arrow.r$ 1
取 $a = b arrow.r.double e in H$，幺元
取 $a = e arrow.r.double b^(- 1) in H$，逆元
将$b$视为$lr((b^(- 1)))^(- 1) arrow.r.double a b = a lr((b^(- 1)))^(- 1) in H$，封闭性
结合律可由大群中继承
故 H 构成群即 $H lt.eq G$ #qedhere
]
#example()[
$lr((4 bb(Z) , +)) lt.eq lr((2 bb(Z) , +)) lt.eq lr((bb(Z) , +))$ 偶数构成子群
若$n \| m$，则$m bb(Z) lt.eq n bb(Z)$
$S O_n < S L_n lr((bb(R))) < S L_n^plus.minus lr((bb(R))) < G L_n lr((bb(R)))$
]
#theorem("子群运算律")[
+ $H lt.eq G$，则$H$中的幺元为$G$中的幺元
+ $H_1 , H_2 lt.eq G$，则$H_1 sect H_2 lt.eq G$
+ $H_1 , H_2 lt.eq G$，则$H_1 union H_2 lt.eq G arrow.l.r.double H_1 subset.eq H_2$或$H_2 subset.eq H_1$
+ $H_1 , H_2 lt.eq G$，则$H_1 H_2 lt.eq G arrow.l.r.double H_1 H_2 = H_2 H_1 eq.delta { h_1 h_2 \| h_1 in H_1 , h_2 in H_2 }$
]
#proof("验证子群运算律")[
/ 1,2: 略
/ 3:
- 设$h_1 in H_1 , h_2 in H_2 \\ H_1$，则$h_1 h_2 in.not H_1$（否则$h_1^(- 1) h_1 h_2 in H_1$，矛盾）
由$H_1 union H_2 lt.eq G$，$h_1 h_2 in H_2 arrow.r.double.long h_1 = h_1 h_2 h_1^(- 1) in H_2$
再由$h_1 h_2$的任意性，$H_1 subset.eq H_2$
- 若$H_1 subset.eq H_2$，则$H_1 union H_2 = H_2 lt.eq G$
/ 4:
- $forall a b in H_1 H_2 lr((a in H_1 b in H_2))$，由$H_1 H_2 lt.eq G$，$lr((a b))^(- 1) in H_1 H_2$
记$lr((a b))^(- 1) = a_1 b_1 lr((exists a_1 in H_1 , b_1 in H_2))$
又$a b = lr((a_1 b_1))^(- 1) = b_1^(- 1) a_1^(- 1) in H_2 H_1 arrow.r.double.long H_1 H_2 subset.eq H_2 H_1$
反之，$forall b a in H_2 H_1$，有$lr((b a))^(- 1) = a^(- 1) b^(- 1) in H_1 H_2$，则$b a = lr((lr((b a))^(- 1)))^(- 1) in H_1 H_2$
综上有$H_1 H_2 = H_2 H_1$
- $e in H_1 H_2 arrow.r.double.long H_1 H_2 eq.not nothing$，$forall a b , a_1 b_1 in H_1 H_2$，$lr((a_1 b_1)) lr((a b))^(- 1) = a_1 b_1 b^(- 1) a^(- 1) = a_1 b prime a^(- 1) = a_1 a prime b prime.double = a prime.double b prime.double in H_1 H_2 arrow.r.double.long H_1 H_2 lt.eq G$ #qedhere
]
== 元素的阶
#definition()[
设G是群，$a in G$，使$a^n = e$的最小正整数n称为$a$的#strong[阶]或#strong[周期（order, period）]，记为$o lr((a))$（允许$o lr((a)) = oo$）
]
#corollary()[
+ $o lr((e)) = 1$, $o lr((a^(- 1))) = o lr((a))$
+ $a^m = e arrow.l.r.double o lr((a)) \| m$
#proof()[
/ #sym.arrow.r.double: 若$a^m = e$，设$o lr((a)) = k$，对m与k作带余除法，$m = q k + r lr((0 lt.eq r < k))$
$e = a^m = a^(q k) a^r = e a^r = a^r$，由阶的最小性，$r = 0$
/ #sym.arrow.l.double: 显然
]
+ 有限群中所有元素的阶均有限，而无限群不一定存在无限阶元
#example()[
$W = {upright("全体复单位根")} = {
e^(frac(2 pi i k, n)) \| n in bb(N) , 0 lt.eq k < n
} lt.eq lr((bb(C)^(\*) , dot.op))$
]
+ 设$o lr((a)) = m , o lr((b)) = n$，若$lr((m , n)) = 1$且$a b = b a$，则$o lr((a b)) = m n$
#proof()[
设$o lr((a b)) = k$，则$lr((a b))^(m n) = a^(m n) b^(m n) = e^n e^m = e arrow.r.double.long k \| m n$
$e = lr((a b))^(k m) = b^(k m) arrow.r.double.long n lr(|k m arrow.r.double.long n|) k$
$e = lr((a b))^(k n) = a^(k n) arrow.r.double.long m lr(|k n arrow.r.double.long m|) k$
故 $m n \| k arrow.r.double.long k = m n$ #qedhere
]
+ $forall a in G \\ { e }$，若总有$o lr((a)) = 2$，则G为交换群（如Klein四元群）
#proof()[
$a^2 = e arrow.r.double.long a = a^(- 1) , forall a , b in G$，有$a b = lr((a b))^(- 1) = b^(- 1) a^(- 1) = b a$ #qedhere
]
]
== 循环群与生成子群
包含a的最简单的子群？设 $H lt.eq G$ 使得 $a in H$
${dots.h.c , a^(- 2) , a^(- 1) , e = a^0 , a , a^2 , dots.h.c , a^n , dots.h.c} = {
a^k \| k in bb(Z)
} = cyclicgroup(a) subset.eq H$
$a^(k_1) lr((a^(k_2)))^(-) 1 = a^(k_1 - k_2) in cyclicgroup(a)$
#definition()[
设$S subset.eq G$非空子集，G中包含S的所有子群的交称为#strong[由S生成的子群]，记为$cyclicgroup(S)$（$arrow.l.r.double cyclicgroup(S)$是包含S的最小子群）
由1个元素生成的（子）群称为#strong[循环（子）群（cyclic group）]
]
#corollary()[
设$S subset.eq G$非空子集，则$cyclicgroup(S) = { a_1^(epsilon.alt_1) a_2^(epsilon.alt_2) dots.h.c a_n^(epsilon.alt_n) \| n in bb(Z)^(+) , a_i in S , epsilon.alt_i = plus.minus 1 }$（$a_i$可重）
]
#definition()[
若$G = cyclicgroup(S)$，且任何S的真子集的生成子群均不是G，则称S为G的#strong[极小生成集]
]
#example()[
$lr((bb(Z) , +)) = < 1 > = < - 1 >$
$lr((m bb(Z) , +)) = < m > = < - m >$
$lr((bb(Z) \/ n bb(Z) , +)) = < 1^(‾) > = < a^(‾) > , lr((a , n)) = 1$（$lr((a , n)) = 1 arrow.l.r.double a x + n y = 1 arrow.l.r.double a^(‾) x^(‾) = 1^(‾) arrow.l.r.double x_0 upright("个") a^(‾) upright("相加")$
$K_4 = {e , a , b , c} = < a , b > = < a , c > = < b , c >$
]
#corollary()[
生成元集不一定是唯一的，但极小生成集包含的元素个数是唯一的
]
#property()[
+ 循环群必交换
+ #proposition()[
循环子群的阶等于生成元的阶，即$\# < a > = o lr((a))$
]
+ #theorem()[
$
< a > tilde.equiv cases(
delim: "{",
lr((bb(Z) , +)) & o lr((a)) = oo,
lr((bb(Z) \/ n bb(Z) , +)) & o lr((a)) = n < oo,
)
$ (同构 \= 双射 + 保运算)
]
#proof()[
当$o lr((a)) = oo$时，$< a > = { a^k \| k in bb(Z) } arrow.r^sigma lr((bb(Z) , +))$，$a^k arrow.r.bar k$
当$o lr((a)) = n < oo$时，$< a > = { a^k \| k in bb(Z) , 0 lt.eq k < n } arrow.r^sigma lr((bb(Z) \/ n bb(Z) , +))$，$a^k arrow.r.bar k^(‾)$
]
+ #corollary()[
阶数相同的循环群必同构
]
]
#theorem()[
+ $lr((bb(Z) , +))$的子群必为$m bb(Z) lr((m in bb(Z)))$的形式，从而无限循环群的非零子群仍为无限循环群。
+ $lr((bb(Z) \/ n bb(Z) , +))$的子群必同构于$lr((bb(Z) \/ d bb(Z) , +))$的形式，其中$d \| n$，且对n的任意因子d，$bb(Z) \/ n bb(Z)$有且仅有1个d阶子群。进而有限循环群的非零子群仍为有限循环群。
]
#proof()[
+ 容易验证 $m bb(Z) lt.eq bb(Z)$。反之，设$H lt.eq bb(Z)$，则令$H = H^(+) union { 0 } union H^(-)$，其中$H^(+) = { h in H |h > 0 }, H^(-) = { h in H | h < 0 }$，可知$H^(+) = - H^(-) , H^(+) subset.eq bb(N)$。
由自然数的良序性知，$H^(+)$中存在最小元，记作m。 于是$forall x in H^(+)$，有$x = q m_0 + r lr((0 lt.eq r < m_0))$，则$r = x - q m_0 = x - lr((m_0 + dots.h.c + m_0)) in H$
若$r > 0$，则$r in H^(+)$，但这与$m_0$的最小性矛盾。故只有$r = 0$，即$x = q m_0$，即$m_0 \| x lr((forall x in H))$。
即$H = m_0 bb(Z) = < m_0 >$
+ 容易验证：若$d \| n$，有$< d^(‾) > lt.eq lr((bb(Z) \/ n bb(Z) , +))$，$< d^(‾) > tilde.equiv lr((bb(Z) \/ n / d bb(Z) , +))$。
反之，设$H lt.eq lr((bb(Z) \/ n bb(Z) , +))$，令$tilde(H) = { k \| k^(‾) in H \\ { 0^(‾) } 1 lt.eq k lt.eq n - 1 } subset.eq bb(Z)^(+)$
则由良序性知，$tilde(H)$中存在最小元，记作d。$forall x in tilde(H)$，有$x = q d + r lr((0 lt.eq r < d)) arrow.r.double.long r^(‾) = x^(‾) - q d^(‾) in H$
若$r eq.not 0$，则$r in tilde(H)$，但这与d的最小性矛盾矛盾。故只有$r^(‾) = 0^(‾) arrow.r.double.long r = 0 arrow.r.double.long tilde(H) = { k d
|0 < k < n \/ d } arrow.r.double.long H = { k^(‾) d^(‾)| k = 0,
1, 2 dots.h.c }$
下证$d \| n$。设$lr((n , d)) = t$，则$u n + v d = t lr((exists u , v))$。$v^(‾) d^(‾) = t^(‾) in H$。由$0 < t lt.eq d$，$t in tilde(H)$。由d的最小性知$t = d$，即$d \| n$。
故有$H = { 0^(‾) , d^(‾) , overline(2 d) , dots.h.c , overline(lr((n / d - 1)) d) } = < d^(‾) > tilde.equiv lr((bb(Z) \/ n / d bb(Z) , +))$
]
#example()[
决定$D_n$的所有子群$D_n = angle.l rho , pi | o lr((rho)) = n , o lr((pi)) = 2 , rho pi = pi rho^(- 1) angle.r = { rho^i pi^j | 0 lt.eq i lt.eq n - 1 , 0 lt.eq j lt.eq 1 }$
]
#proof()[
$\# D_n = 2 n$
+ $< rho > tilde.equiv C_n lt.eq D_n$以及$< rho >$的所有子群$< rho^d > lr((forall d \| n))$
+ $< pi > tilde.equiv C_2 lt.eq D_n , < rho^k pi > tilde.equiv C_2 lt.eq D_n lr((0 lt.eq k lt.eq n - 1))$
+ $< rho^k , rho^l pi > = { rho^(i k) , rho^(i k) lr((rho^l pi)) = rho^(i k + l) pi , lr((rho^l pi)) rho^(i k) = rho^(- i k + l) pi , rho^0 = e } tilde.equiv D_(n / k)$ 只须$k \| n , 0 lt.eq l < k$
]
#remark()[
$D_n$的子群数量为$sum_(k \| n) k^0 + sum_(k \| n) k$
]
== 置换群与变换群
最简单的非交换群
#definition()[
非空集合$Omega$上所有可逆变换全体构成的群及其子群称为$Omega$的#strong[变换群]。有限集上的变换群及其子群称为#strong[置换群]（或#strong[对称群]），记为$S_n$，其中$n = lr(|Omega|)$。
]
设$sigma in S_n , sigma = mat(delim: "(", 1, 2, dots.h.c, n; i_1, i_2, dots.h.c, i_n) , \# S_n = n !$
一类特殊的置换，称为#strong[轮换]
#definition("轮换")[
$sigma in S_n$满足
+ $sigma lr((i_1)) = i_2 , sigma lr((i_2)) = i_3 , dots.h.c , sigma lr((i_l)) = i_1$
+ $forall i in { 1 , 2 , dots.h.c n } \\ { i_1 , i_2 , dots.h.c , i_l }$，有$sigma lr((i)) = i$
则称$sigma$是一个长度为$l$的#strong[轮换]或#strong[循环(cycle)]，记作$lr((i_1 i_2 dots.h i_l))$。特别，长度为2的轮换称为#strong[对换(transposition)]
]
#property()[
+ 长度为$l$的轮换$sigma$，有$o lr((sigma)) = l$
+ 轮换可从圈上任一元开始，表法不唯一。一般从最小元开始， \
如$lr((7325)) arrow.r lr((2573))$
+ 乘积就近原则，如 $ lr((1345)) lr((25)) mat(delim: "[", 1;2;3;4;5) $ $lr((25))$先作用
+ 同一轮换中无重复元（反证：这与可逆变换矛盾）
+ 若两个轮换不相交（无公共元）则乘积可交换
]
#theorem()[
$forall sigma in S_n$，有
+ $sigma$ 可分解为不相交的轮换之积，且分解唯一（#strong[标准轮换分解]）
+ 若$sigma$的标准轮换分解为$sigma = r_1 r_2 dots.h.c r_s$则 \
$o lr((sigma)) = l c m lr((o lr((r_1)) , o lr((r_2)) , dots.h.c , o lr((r_s))))$
]
#corollary()[
$S_n$中$1^(lambda_1) 2^(lambda_2) dots.h.c n^(lambda_n)$型（指$sigma$的标准轮换分解中含$lambda_i$个长度为i的轮换）的置换个数为$frac(
n !, 1^(lambda_1) 2^(lambda_2) dots.h.c n^(lambda_n) lambda_1 ! lambda_2 ! dots.h.c lambda_n !,
)$ \
其中$sum_(i = 1)^n i lambda_i = n , sum_(i = 1)^n lambda_i$为标准分解中轮换的个数
]
#theorem()[
$forall sigma in S_n , sigma$可分解为对换的乘积，即$sigma = pi_1 pi_2 dots.h.c pi_s$（$pi_i$为对换），且分解式中对换个数s的奇偶性由$sigma$决定，与分解的形式无关。（不一定不相交，不一定唯一）
]
#proof()[
存在性：只须证轮换可分解为对换乘积即可
两种常见分解方法$i_1 dots.h.c i_l = cases(
delim: "{",
lr((i_1 i_2)) lr((i_2 i_3)) dots.h.c lr((i_(l - 1) i_l)) & upright("接龙法"),
lr((i_1 i_l)) lr((i_1 i_(l - 1))) dots.h.c lr((i_1 i_2)) & upright("牵头法（逆向）"),
)$
下证$S$的奇偶性唯一：由上述两种常见分解可知均把$l$-轮换分解为$l - 1$个对换之积， \
则可令$N lr((r_i)) = l_i - 1$（其中$r_i$为$l_i$-轮换），若$sigma = r_1 dots.h.c r_k$为标准分解 \
则$N lr((sigma)) = sum_(i = 1)^k lr((l_i - 1)) = sum_(i = 1)^k l_i - k = n - k$
$forall a , b in { 1 , dots.h.c , n }$ 当 ab在$sigma$中的不同轮换中时，考虑 $ lr((a b)) sigma & = lr((a b)) lr((b b_2 dots.h.c b_(l_2))) lr((a a_2 dots.h.c a_(l_1)))\
& = lr((a b b_2 dots.h.c b_(l_2))) lr((a a_2 dots.h.c a_(l_1)))\
& = lr((b b_2 dots.h.c b_(l_2) a a_2 dots.h.c a_(l_1))) $ $N lr((lr((a b)) sigma)) = n - lr((k - 1)) = N lr((sigma)) + 1$
当 ab在同一轮换$sigma$中时，考虑 $ lr((a b)) sigma & = lr((a b)) lr((a a_2 dots.h.c a_(g_1) b b_2 dots.h.c b_(g_2)))\
& = lr((a a_2 dots.h.c a_(g_1))) lr((b b_2 dots.h.c b_(g_2))) $ $N lr((lr((a b)) sigma)) = n - lr((k + 1)) = N lr((sigma)) - 1$
设$sigma = pi_1 dots.h.c pi_s$为任一对换分解，则
+ $sigma^(- 1) sigma = lr((pi_1 dots.h.c pi_s))^(- 1) sigma = pi_s^(- 1) dots.h.c pi_1^(- 1) sigma = pi_s dots.h.c pi_1 sigma$ \
$o = N lr((lr((1)))) = N lr((pi_s dots.h.c pi_1 sigma)) equiv N lr((sigma)) + s mod med 2$ \
$S equiv N lr((sigma)) mod med 2$
]
#definition()[
若$sigma$可表为奇(偶)数个对换之积，则称$sigma$为#strong[奇(偶)置换]。其中$S_n$中全体偶置换构成的集合称为#strong[交错群]，记为$A_n$，并有$A_n lt.eq S_n$
]
进一步，$\# A_n = frac(n !, 2)$
#proof("证明思路")[
作映射$f : A_n arrow.r { upright("奇置换") } , f lr((sigma)) = lr((12)) sigma$，验证$f$单满即可
]
#corollary()[
$S_n = angle.l lr((12)) , lr((13)) , dots.h.c lr((1 n)) angle.r = angle.l lr((12)) , lr((123 dots.h.c n)) angle.r lr((n gt.eq 2))$
$A_n = angle.l lr((123)) , lr((124)) , dots.h.c lr((12 n)) angle.r lr((n gt.eq 3))$
]
#theorem("Cayley 定理")[
任一群$G$必同构于某个集合上的变换群。任一$G$有限群，若$lr(|G|) = n$，则必有$G tilde.equiv G prime lt.eq S_n$
]
#remark()[
某个集合：$G prime = { sigma_a \| a in G }$，其中$sigma_a : G arrow.r G , g arrow.r.bar a g$ 左乘变换，变换群
]
#proof()[
要证$G tilde.equiv G prime$
+ 验证$G prime$构成群（以映射的复合为运算） \
$sigma_a circle.stroked.tiny sigma_b lr((g)) = sigma_a lr((sigma_b lr((g)))) = a b g = sigma_(a b) lr((g))$ \
封 结 幺元 $sigma_e$ 逆元 $sigma_(a^(- 1))$
+ 构造群之间的映射 $f : G arrow.r G prime , f lr((a)) = sigma_a$，验证$f$单、满、保运算(由1得)
+ 当$lr(|G|) = n = lr(|G prime|)$时，验证$G prime lt.eq S_n$，不妨设 $G = { a_1 , dots.h.c a_n }$ \
$sigma_a lr((a_i)) = a a_i , sigma_a lr((G)) = {a a_1 , a a_2 , dots.h.c a a_n} = a G subset.eq G$ \
$forall a_i in G$，有$a_i = a lr((a^(- 1) a_i)) in a G arrow.r.double G subset.eq a G$ \
故$G = a G$ \
$sigma_a = mat(delim: "(", a_1, dots.h.c, a_n;a_(i_1), dots.h.c, a_(i_n))$ 视为 $mat(delim: "(", 1, 2, dots.h.c, n;i_1, i_2, dots.h.c, i_n)$ 可视为对下标的n阶置换$in S_n$
]
#example()[
$K_4 = {e , a , b , c} = angle.l a , b angle.r = angle.l a , c angle.r = angle.l b , c angle.r$
由Cayley定理，$K_4 tilde.equiv K_4 prime = { sigma_g \| g in K_4 } lt.eq S_4$
- $e arrow.r sigma_e = mat(delim: "(", e, a, b, c;e, a, b, c) arrow.r lr((1))$
- $a arrow.r sigma_a = mat(delim: "(", e, a, b, c;a, e, c, b) arrow.r lr((12)) lr((34))$
- $b arrow.r sigma_b = mat(delim: "(", e, a, b, c;b, c, e, a) arrow.r lr((13)) lr((24))$
- $c arrow.r sigma_c = mat(delim: "(", e, a, b, c;c, b, a, e) arrow.r lr((14)) lr((23))$
$K_4 prime = {lr((1)) , lr((12)) lr((34)) , lr((13)) lr((24)) , lr((14)) lr((23))} lt.eq A_4 lt.eq S_4$
]
== 陪集与 Lagrange 定理
从一个特定的子群出发，讨论其对于大群内部产生的划分效果
#definition()[
设G为群，$H lt.eq G , forall a in G$
$a H = { a h \| h in H }$称为关于$H$的一个#strong[左陪集（left coset）]
$H a = { h a \| h in H }$称为关于$H$的一个#strong[右陪集（right coset）]
]
#remark()[
当G为交换群时，左右陪集相等 $a H = H a$
]
#example()[
$G = lr((bb(Z) , +)) , H = m bb(Z)$ 故$H$的左右陪集为 $a + H = { a + k m \| k in bb(Z) } = a^(‾) in bb(Z) \/ m bb(Z)$。共有m个不同的陪集
]
#example()[
$G = S_3 , H = angle.l lr((12)) angle.r = {lr((1)) , lr((12))}$
$H$的左陪集为 $ lr((1)) H & = lr((12)) H = { lr((1)) , lr((12)) }\
lr((13)) H & = lr((123)) H { lr((13)) , lr((123)) }\
lr((23)) H & = lr((132)) H = { lr((23)) , lr((132)) } $
右陪集类似
]
#property()[
- $a H = H arrow.l.r.double a in H$
#proof()[
- $a H = H arrow.r.double forall h in H , exists h_1 in H med s . t . med a h = h_1 arrow.r.double a = h_1 h^(- 1) in H$
- $a in H arrow.r.double a H subset.eq H , a^(- 1) in H arrow.r.double a^(- 1) H subset.eq H arrow.r.double H subset.eq a H$
]
- (人人平等) $b in a H arrow.l.r.double b H = a H$
#proof()[
- $b in a H arrow.r.double b = a h arrow.r.double b H = lr((a h)) H = a H$
- $b H = a H arrow.r.double a h = b h_1 lr((forall h , exists h_1)) arrow.r.double b = a h h_1^(- 1) in a H$
]
- (陪集相等判则) $a H = b H arrow.l.r.double a^(- 1) b in H lr((H a = H b arrow.l.r.double a b^(- 1) in H))$
对比子群的四合一判则 $nothing eq.not H lt.eq arrow.l.r.double a b^(- 1) in H lr((forall a , b in H))$
- (不重不漏) $forall a , b in G$，有$a H = b H$或$a H sect.big b H = nothing$
#proof()[
若$a H eq.not b H$且$a H sect.big b H eq.not nothing$，则$a^(- 1) b in.not H$且$exists x = a h_1 = b h_2 arrow.r.double h_1 h_2^(- 1) = a^(- 1) b in H$，矛盾
]
- 陪集划分给出一种等价关系，记$tilde.op_L : a tilde.op_L b$表示$a H = b H$和$tilde.op_R : a tilde.op_R b$表示$H a = H b$
等价关系 $arrow.r.double$ 等价类（陪集） $arrow.r.double$ 商集 ${ a H \| a in G }$ $arrow.r.double$ 划分 $G = union.sq.big_(a in G) a H = union.sq.big_(a in G) H a arrow.r.double lr(|G|) = sum_(a in G) lr(|a H|) = k lr(|H|) = lr(|H|) lr(|lr((G \/ H))_L|) = lr(|H|) lr(|lr((G \/ H))_R|) eq.delta lr(|H|) lr([G : H])$
- H与aH之间（Ha之间）存在双射，特别当H有限时，有$lr(|H|) = lr(|a H|) = lr(|H a|) lr((forall a in G))$
]
#definition()[
设$H lt.eq G$，H的左右陪集的个数称为关于H的#strong[指数]，记为$lr([G : H])$
]
#theorem()[
设$H lt.eq G$，H的全体左右陪集分别记为$lr((G \/ H))_L , lr((G \/ H))_R$，则存在两者间的双射
]
#theorem("Lagrange 定理")[
设$lr(|G|) < oo$，$H lt.eq G$，则$lr(|G|) = lr(|H|) lr([G : H])$
]
#corollary()[
- $lr(|G|) < oo , H lt.eq G arrow.r.double lr(|H|) lr(||) G lr(|, lr([G : H])|) lr([G])$
- $lr(|G|) < oo , forall a in G arrow.r.double o lr((a)) lr(||) G \| , a^(lr(|G|)) = e$
- 若$lr(|G|) = p$为素数，则G为p阶循环群
#proof()[
$forall a in G , o lr((a)) = 1 upright("或") p arrow.r.double a eq.not e , o lr((a)) = p arrow.r.double angle.l a angle.r lt.eq G , lr(|angle.l a angle.r|) = lr(|G|) arrow.r.double angle.l a angle.r = G$
]
]
#example()[
确定所有的4阶群
$lr(|G|) = 4$，则G中只能有1、2、4阶元（1阶元即e）
若G中有4阶元，$a arrow.r.double angle.l a angle.r = G = C_4$
若G中无4阶元，除幺元外皆2阶元，即$G = K_4 tilde.equiv C_2 times C_2$
$arrow.r.double$ 4阶群必交换
$arrow.r.double$ 2、3、4、5阶群均为交换群，$S_3$为最小的非交换群（6阶）
]
#example()[
#theorem("Euler 定理")[
设 $lr((a , m)) = 1$，则$a^(phi lr((m))) equiv 1 med ( mod med m \)$
]
#proof()[
$lr((a , m)) = 1 arrow.l.r.double a^(‾) in lr((bb(Z) \/ m bb(Z)))^(\*)$
$lr(|lr((bb(Z) \/ m bb(Z)))^(\*)|) = phi lr((m))$，由Larange定理的推论，$a^(‾)^(phi lr((m))) = 1^(‾)$
]
]
#example()[
#theorem("Wilson 定理")[
设p为素数，则$lr((p - 1)) ! equiv - 1 med ( mod med p )$
]
#proof()[
当p\=2时，显然
当p\>2时，$p$为奇素数，在$lr((lr((bb(Z) \/ p bb(Z)))^(\*) , dot.op))$中${ 1^(‾) , 2^(‾) , dots.h.c , overline(p - 1) }$每个元均有逆元，即$exists a^(‾)^(- 1) upright(" s.t. ") a^(‾) a^(‾)^(- 1) = 1^(‾)$。
若$a^(‾) = a^(‾)^(- 1) arrow.l.r.double a^(‾)^2 = 1^(‾) arrow.r.double p \| lr((a - 1)) lr((a + 1)) lr((1 lt.eq a lt.eq p - 1)) arrow.r.double a = 1$或$p - 1 arrow.r.double a^(‾) = overline(plus.minus 1)$
除$lr((overline(plus.minus 1)))$以外，$a^(‾)$与$a^(‾)^(- 1)$均成对出现，故$overline(p - 1) ! = 1^(‾) lr((overline(- 1))) 1^(‾)^(frac(p - 3, 2)) = overline(- 1)$
]
]
#theorem()[
设G为群，A、B为G中的有限子群，则有 $ lr(|A B|) = frac(lr(|A|) lr(|B|), lr(|A sect B|)) $
]
#proof()[
$A , B lt.eq G arrow.r.double A sect B lt.eq G$，但AB不一定是子群
转化为用陪集表示$A B = union.big_(a in A) a B = union.big_(b in B) A b arrow.r.double lr(|A B|) = lr(|B|) dot.op \# { a B \| a in A }$
令$S_1 = { a B \| a in A }$关键讨论何时有$a_1 B = a_2 B$
$a_1 B = a_2 B arrow.l.r.double a_1^(- 1) a_2 in B arrow.l.r.double a_1^(- 1) a_2 in A sect B arrow.l.r.double a_1 lr((A sect B)) = a_2 lr((A sect B)) lr((\*))$
令$S_2 = { a lr((A sect B)) \| a in A }$，由$A sect B lt.eq A$，则$S_2 = lr((A \/ A sect B))_L arrow.r.double lr(|S_2|) = lr([A : lr((A sect B))]) = frac(lr(|A|) lr(|B|), lr(|A sect B|))$
故只须证明$lr(|S_1|) = lr(|S_2|)$，作对应$f : S_1 arrow.r S_2 a B arrow.r.bar a lr((A sect B))$，由$lr((\*))$知$f$为映射，且为单射
又$f$显然满射，故为双射，即$lr(|S_1|) = lr(|S_2|) arrow.r.double lr(|A B|) = lr(|B|) lr(|S_1|) = lr(|B|) lr(|S_2|) = lr(|B|) lr(|A|) \/ lr(|A sect B|)$
]
== 正规子群与商群
考虑$lr((G \/ H))_L$商集$= { a H \| a in G } , \# lr((G \/ H))_L = lr([G : H])$
当$G = lr((bb(Z) , +)) , H = m bb(Z)$时，$lr((G \/ H)) = lr((bb(Z) \/ m bb(Z) , +)) a^(‾) + b^(‾) eq.delta overline(a + b)$
一般的，是否可在左陪集之间引入运算 $lr((a H)) lr((b H)) = lr((a b)) H$?
当$b H = H b lr((forall b in G))$时，上式成立
#definition()[
设G为群，$H lt.eq G$，若$forall g in G$，有$g H = H g$，则称H为G的一个#strong[正规子群(normal subgroup)]，记为$H lt.tri.eq G$
]
特别，$H lt.tri G$表示$H < G$且正规，即H为G的正规真子群
#corollary()[
- 平凡子群均为正规子群
- 当G交换时，任何子群均正规
- 若G中不存在非平凡的正规子群，则称G为单群
]
#example()[
指数为2的子群必正规
#proof()[
设$H lt.eq G$且$lr([G : H]) = 2$，取$forall a in G \\ H$，故$a H eq.not H$，则$H union a H = G$
但$H sect a H = nothing$。同理$H union H a = G$，且$H sect H a eq.not nothing$
综上$a H = G \\ H = H a arrow.r.double H lt.tri.eq G$
]
]
由上例可知，$A_n lt.tri.eq S_n , angle.l p angle.r = C_n lt.tri.eq D_n = angle.l rho pi angle.r$
#theorem("正规子群判则")[
设G为群，$H lt.eq G$，则下述命题等价
+ $H lt.tri.eq G$
+ $forall g in G , forall h in H , g h g^(- 1) in H$
+ $forall g in G , g H g^(- 1) subset.eq H$
+ $forall g in G , g H g^(- 1) = H$
]
#proof()[
/ 1 #sym.arrow.r 2: $forall g in G , forall h in H$，由$g H = H g$，$exists h_1 in H med s . t . med g h = h_1 g arrow.r.double g h g^(- 1) = h_1 in H$
/ 2 #sym.arrow.r 3: 由h的任意性，知成立
/ 3 #sym.arrow.r 4: 在3中，用$g^(- 1)$替换$g$，得$g^(- 1) H g subset.eq H arrow.r.double H subset.eq g H g^(- 1) arrow.r.double g H g^(- 1) = H$
/ 4 #sym.arrow.r 1: $g H g^(- 1) = H arrow.r.double g H = H g arrow.r.double H lt.tri.eq G$
]
#example()[
设$K_4 = { lr((1)) , lr((12)) lr((34)) , lr((13)) lr((24)) , lr((14)) lr((23)) }$，证明$K_4 lt.tri.eq S_4$
#proof()[
易验证$K_4$是$S_4$的一个子群
下用判则$forall sigma in S_4 , forall tau in K_4$（不妨设$tau = lr((12)) lr((34))$）
$sigma tau sigma^(- 1) = sigma lr((12)) lr((34)) sigma^(- 1) = lr((sigma lr((12)) sigma^(- 1))) lr((sigma lr((34)) sigma^(- 1))) = lr((sigma lr((1)) sigma lr((2)))) lr((sigma lr((3)) sigma lr((4))))$
由于所有$2^2$型置换和$1^4$型置换均在$K_4$中，故$sigma tau sigma^(- 1) in K_4 arrow.r.double K_4 lt.tri.eq S_4$。
]
]
一般的，由$sigma lr((a_1 dots.h.c a_l)) sigma^(- 1) = lr((sigma lr((a_1)) dots.h.c sigma lr((a_l))))$
#theorem("正规子群运算律")[
+ $A lt.tri.eq G , B lt.tri.eq G arrow.r.double A sect B lt.tri.eq G , A B lt.tri.eq G$
+ $A lt.tri.eq G , B lt.eq G arrow.r.double A sect B lt.tri.eq B , A B lt.eq G$
+ $A lt.tri.eq G , B lt.tri.eq G , A sect B = {e} arrow.r.double a b = b a lr((forall a in A , forall b in B))$
]
#proof()[
+ $forall g in G , forall c in A sect B$，有$g c g^(- 1) in A , g c g^(- 1) in B arrow.r.double g c g^(- 1) in A sect B arrow.r.double A sect B lt.tri.eq G$
对$A B$，因$A lt.tri.eq G$，有$b A = A b lr((forall b in B)) arrow.r.double b A subset.eq A B$，由b的任意性知，$B A subset.eq A B$。同理可证$A B subset.eq B A arrow.r.double A B = B A arrow.l.r.double A B lt.eq G$
$forall g in G , forall a b in A B$，有$g lr((a b)) g^(- 1) = g a g^(- 1) g b g^(- 1) in A B arrow.r.double A B lt.tri.eq G$
+ 习题
+ $forall a in A , forall b in B , a b a^(- 1) b^(- 1) = lr((a b a^(- 1))) b^(- 1) = b_1 b^(- 1) in B$
同理，$a b a^(- 1) b^(- 1) = a lr((b a^(- 1) b^(- 1))) = a a_1 in A$
由$A sect B = { e }$知$a b a^(- 1) b^(- 1) = e arrow.r.double a b = b a$
]
#remark()[
$a b a^(- 1) b^(- 1)$记作$lr([a , b])$，称为$a$与$b$的#strong[换位子]
${ angle.l a b a^(- 1) b^(- 1) angle.r \| a , b in G } lt.tri.eq G$，称为#strong[换位子群]
]
#definition()[
设$H lt.tri.eq G , lr((G \/ H)) = { a H |a in G } eq.delta { a^(‾)| a in G }$
定义 $lr((a H)) dot.op lr((b H)) eq.delta lr((a b)) dot.op H$，即$a^(‾) dot.op b^(‾) eq.delta overline(a b)$
诱导运算
]
#definition()[
设G是群，$H lt.tri.eq G$，则$G \/ H$ 在子集乘法的运算下构成群，称为G关于H的#strong[商群]，且$lr(|G \/ H|) = lr([G : H]) = lr(|G|) \/ lr(|H|) lr((lr(|G|) < oo))$
- $lr((a H)) lr((b H)) = lr((a b)) H in G \/ H$
- 可由原群中的结合律诱导而来（继承）
- $e^(‾) = e H = H , H lr((a H)) = lr((e a)) H = a H , lr((a H)) H = lr((a e)) H = a H$
- $a^(‾)^(- 1) = overline(a^(- 1)) = lr((a^(- 1))) H$
二元运算的唯一性：确保运算与代表元选取无关
$a H = a_1 H , b H = b_1 H arrow.l.r.double a^(- 1) a_1 in H , b^(- 1) b_1 in H$
考虑$lr((a b))^(- 1) lr((a_1 b_1)) = b^(- 1) a^(- 1) a_1 b_1 = b^(- 1) h b_1 = b^(- 1) b_1 h_1 = h_2 h_1 in H$
故$lr((a b)) H = lr((a_1 b_1)) H$，唯一性验证
]
商群是对原群的降阶，保结构（部分），化简（模者抹也）
#theorem()[
设$G$为有限交换群，$p$素数，$p lr(||) G \|$，则$G$中必有$p$阶元
]
#proof()[
当$lr(|G|) = p$时，有$G tilde.equiv C_p = angle.l a angle.r , o lr((a)) = p$
假设结论对$lr(|G|) < n$且$p lr(||) G \|$均成立，考虑$lr(|G|) = n$且$p lr(||) G \|$的情形：
取$e eq.not a in G$，若$p \| o lr((a)) = k$，则$a^(k \/ p)$就是$G$中的$p$阶元
若$p divides.not o lr((a))$，令$H = angle.l a angle.r$，则$p divides.not lr(|H|)$，由$G$交换知$H lt.tri.eq G$。考虑$G \/ H$，有$p divides lr(|G \/ H|) = lr(|G|) \/ lr(|H|)$且$lr(|G \/ H|) < n$，由归纳假设知$G \/ H$中有$p$阶元。
设$b^(‾) = b H$，即$b^(‾)^p = e^(‾) arrow.l.r.double lr((b H))^p = b^p H = e H = H arrow.l.r.double b^p in H$
$lr((b^p))^(o lr((a))) = b^(p lr(|H|)) = lr((b^(lr(|H|))))^p = e$，从而$b^(lr(|H|)) = b^(o lr((a)))$就是$G$中的$p$阶元
$b^(lr(|H|)) eq.not e$否则$b^(lr(|H|)) = e arrow.r.double b^(‾)^(lr(|H|)) = e^(‾) arrow.r.double p lr(||) H \|$矛盾
]
== 共轭元和共轭子群
#definition()[
群$G$的#strong[中心(center)]定义为$C lr((G)) = { x in G \| x g = g x , forall g in G }$，简记为$C$
]
#property()[
+ $e in C lr((G)) arrow.r.double C lr((G)) eq.not nothing$
+ $forall a , b in C lr((G))$，由$a g = g a lr((forall g)) arrow.r.double g a^(- 1) = a^(- 1) g lr((forall g)) arrow.r.double a^(- 1) in C lr((G))$
$lr((a b)) g = a g b = g lr((a b)) arrow.r.double a b in C lr((G))$
四合二$arrow.r.double C lr((G)) lt.eq G$
+ $forall a in C lr((G)) , forall g in G , g a g^(- 1) = a g g^(- 1) = a in C lr((G)) arrow.r.double C lr((G)) lt.tri.eq G$
]
#definition()[
对$a in G$，$a$在$G$中的#strong[中心化子]为$C_G lr((a)) = { x in G \| x a = a x }$，简记为$C lr((a))$
对$A subset.eq G$，$A$在$G$中的#strong[中心化子]为$C_G lr((A)) = { x in G \| x a = a x , forall a in A }$，简记为$C lr((A))$
]
#property()[
+ $C_G lr((a)) sect C_G lr((b)) = C_G lr(({ a , b }))$
+ $angle.l a angle.r subset.eq C_G lr((a)) arrow.r.double angle.l a angle.r lt.eq C_G lr((A))$
+ ${e} lt.eq C lr((G)) lt.eq C_G lr((a)) lt.eq C_G lr((a)) lt.eq G lr((forall a in A subset.eq G))$
#proof()[
只须证$C_G lr((A)) lt.eq G , forall x , y in C_G lr((A))$有$x a = a x , y a = a y lr((forall a in A))$
$arrow.r.double a^(- 1) x = x a^(- 1) lr((forall a)) arrow.r.double x^(- 1) in C_G lr((A))$
$lr((x y)) a = x a y = a lr((x y)) lr((forall a)) arrow.r.double x y in C_G lr((A))$
$arrow.r.double C_G lr((A)) lt.eq G$
]
+ 当$a in C lr((G))$，有$C_G lr((a)) = G$
]
#example()[
设$G = { mat(delim: "(", a, b;c, d) lr(|a , b , c , d in bb(Z) ,|) a d - b c \| = 1 } = S L_2 lr((bb(Z)))$
$H = {mat(delim: "(", 1, t;0, 1) \| t in bb(Z)} quad g = mat(delim: "(", 1, 2;0, - 1) in G$
求$C lr((G)) , C_G lr((H)) , C_G lr((g))$
]
#solution()[
设$A = mat(delim: "(", a, b;c, d) in C lr((G))$，则$forall X in G$有$A X = X A$
取$X = mat(delim: "(", 1, 0;0, - 1)$，则$A X = mat(delim: "(", a, - b;c, - d) = X A = mat(delim: "(", a, b;- c, - d) arrow.r.double b = c = 0$
取$X = mat(delim: "(", 0, 1;- 1, 0)$，则$A X = mat(delim: "(", 0, a;- d, 0) = X A = mat(delim: "(", 0, d;- a, 0) arrow.r.double a = d$
$arrow.r.double C lr((G)) = {plus.minus I_2}$
$mat(delim: "(", a, b;c, d) mat(delim: "(", 1, t;0, 1) = mat(delim: "(", a, a t + b;c, c t + d) = mat(delim: "(", 1, t;0, 1) mat(delim: "(", a, b;c, d) = mat(delim: "(", a + t c, b + t d;c, d)$
$arrow.r.double c = 0 , a = d , a^2 = 1 arrow.r.double C_G lr((H)) = {
plus.minus mat(delim: "(", 1, b;0, 1) \| b in bb(Z)
}$
]
#example()[
$S_4$中求$a = lr((12))$的中心化子
]
#solution()[
$angle.l a angle.r subset.eq C_G lr((a))$且与1，2无关的置换（与a不相交）也含在$C_G lr((a))$
$arrow.r.double lr((1)) , lr((12)) , lr((34)) in C lr((a)) arrow.r.double lr((12)) lr((34)) in C lr((a))$
设$sigma in S_4$使$sigma lr((12)) = lr((12)) sigma arrow.r.double sigma lr((12)) sigma^(- 1) = lr((12)) = lr((sigma lr((1)) sigma lr((2))))$
$arrow.r.double {sigma lr((1)) = 1\
sigma lr((2)) = 2$或${sigma lr((1)) = 2\
sigma lr((2)) = 1$
验证可知满足上式的元只有以上4个，故$C lr((a)) = { lr((1)) , lr((12)) , lr((34)) , lr((12)) lr((34)) }$
]
#definition()[
设$a , b in G$，若$exists g in G$使$g a g^(- 1) = b$则称$a$与$b$#strong[共轭(conjugate)].
]
#property()[
+ 共轭是一种等价关系
+ 每一个等价类，记作$K_a = { g a g^(- 1) \| g in G }$，称为$a$的共轭类，且有划分$G = union.sq.big_(a in G) K_a$
取$lr(|G|) = sum_(a in G) lr(|K_a|)$
当$a in C lr((G))$时，有$K_a = { g a g^(- 1) \| g in G } = { a }$。故可将上述划分修改为$G = C lr((G)) union.sq.big lr((union.sq.big_(a in.not C lr((G))) K_a)) arrow.r.double lr(|G|) = lr(|C|) + sum_(a in.not C) lr(|K_a|)$
]
#theorem()[
设$lr(|K_A|) < oo$，则$lr(|K_a|) = lr([G : C_G lr((a))])$
]
#proof()[
考虑$K_a$与$lr((G \/ C_G lr((a))))_L$之间的对应关系：
$sigma : K_a arrow.r lr((G \/ C_G lr((a))))_L , g a g^(- 1) arrow.r.bar g C lr((a))$
$g a g^(- 1) = g_1 a g_1^(- 1) arrow.l.r.double g_1^(- 1) g a = a lr((g_1^(- 1) g)) arrow.l.r.double g_1^(- 1) g in C lr((a)) arrow.l.r.double g C lr((a)) = g_1 C lr((a))$
则$sigma$为映射，且为单射。另一方面，$sigma$显然为满射，故为双射。从而$lr(|K_a|) = lr(|lr((G \/ C lr((a))))_L|)$
]
#theorem("类方程")[
设$lr(|G|) < oo$，则$lr(|G|) = lr(|C|) + sum_(a in.not C) lr([G : C_G lr((a))])$，其中只对共轭类代表元求和
]
#corollary()[
设$H lt.eq G$，则$H$正规$arrow.l.r.double K_h subset.eq H lr((forall h in H))$，即$H$恰为若干个共轭类的并
]
#corollary()[
p-群有非平凡的中心，即若$p$为素数，$lr(|G|) = p^n$，则$lr(|C lr((G))|) > 1$
]
#proof()[
用类方程分析$lr(|G|) = p^n = lr(|C|) + sum_(a in.not C) lr([G : C lr((a))])$
由Lagrange定理知$lr(|C|) , lr([G : C lr((a))]) lr(|p^n arrow.r.double p|) lr([G : C lr((a))])$或$lr([G : C lr((a))]) = 1$
但$lr([G : C lr((a))]) = 1 arrow.l.r.double a in C lr((G))$，从而$forall a in.not C$有$p \| lr([G : C lr((a))])$
从而有$p lr(||) C \|$，但$e in C$即$lr(|C|) gt.eq 1 arrow.r.double lr(|C|) gt.eq p > 1$
]
#definition()[
对$H lt.eq G , H_1 = g H g^(- 1)$称为$H$的#strong[共轭子群\(conjugate)]
]
共轭子群类$K_H = { g H g^(- 1) \| g in G }$，令$cal(A) = { H \| H lt.eq G }$，共轭是$d$的一个等价关系，$K_H$为一个等价类
$arrow.r.double cal(A)$有划分，$cal(A) = union.sq.big_(H in cal(A)) K_H arrow.r.double ? lr(|cal(A)|) = sum_(H in cal(A)) lr(|K_H|)$
#definition()[
对$H lt.eq G$，$G$中所有与$H$可交换的元素构成的集合，即$N_G lr((H)) = { g in G |g H = H g } = { g in G| H = g H g^(- 1) }$称为$H$的#strong[正规化子(normalizer)]，简记为$N lr((H))$
]
#property()[
+ $H lt.tri.eq N lr((H)) lt.eq G$ (满足$H lt.tri.eq H prime lt.eq G$的最大的$H prime$)
+ 当$H lt.tri.eq G$时，有$N lr((H)) = G$；当$H lt.tri.not G$时，$N lr((H)) < G$。特别，当$H lt.tri.eq G$时，有$K_H = { g H g^(- 1) \| g in G } = { H }$，令$cal(N) = { H \| H lt.tri.eq G }$，$cal(A) = cal(N) union.sq lr((union.sq.big_(H in.not cal(N)) K_H)) arrow.r.double lr(|cal(A)|) = lr(|cal(N)|) + sum_(H in.not cal(N)) lr(|K_H|)$
]
#theorem()[
设$lr(|K_H|) < oo$，则$lr(|K_H|) = lr([G : N_G lr((H))])$
]
#theorem("类方程2")[
$lr(|cal(A)|) = lr(|cal(N)|) + sum_(H in.not cal(N)) lr([G : N lr((H))])$
]
#example()[
设$H$是$G$中唯一的n阶子群，则$H lt.tri.eq G$
]
#solution()[
$lr(|H|) =^(?) lr(|g H g^(- 1)|) arrow.r.double H = g H g^(- 1) arrow.l.r.double g H = H g arrow.l.r.double H lt.tri.eq G lr((forall g))$
只须在$H$与$g H g^(- 1)$之间建立双射
]
#theorem()[
设对称群$S_n$中，$sigma_1$与$sigma_2$共轭$arrow.l.r.double sigma_1$与$sigma_2$的类型相同
]
#proof()[
$arrow.r.double$ 习题，略
$arrow.l.double$
设$sigma_1 = lr((i_1 dots.h.c i_(l_1))) dots.h.c lr((p_1 dots.h.c p_(l_s))) , sigma_2 = lr((j_1 dots.h.c j_(l_1))) dots.h.c lr((q_1 dots.h.c q_(l_s)))$
寻找$tau in S_n$使得$tau sigma_1 tau^(- 1) = sigma_2$
只须令$tau = mat(
delim: "(",
i_1, dots.h.c, i_(l_1), dots.h.c, p_1, dots.h.c, p_(l_s);j_1, dots.h.c, j_(l_1), dots.h.c, q_1, dots.h.c, q_(l_s),
)$即可
]
#theorem()[
设$sigma in A_n$，令$K_sigma$是$A_n$中所有与$sigma$有相同类型的偶置换集合，$C_(S_n) lr((sigma))$为$sigma$在$S_n$内的中心化子，则
+ 当$C_(S_n) lr((sigma))$含有奇置换时，$K_sigma$是$A_n$的一个共轭类
+ 当$C_(S_n) lr((sigma))$不含有奇置换时，$K_sigma$在$A_n$中分裂为两个共轭类$K_sigma prime$与$K_sigma prime.double$
$K_sigma prime = {tau sigma tau^(- 1) \| tau in S_n , tau upright("为偶置换")}$
$K_sigma prime.double = {tau sigma tau^(- 1) \| tau in S_n , tau upright("为奇置换")}$
]
#theorem()[
设$n gt.eq 5$，$A_n$是单群
] |
https://github.com/michel-steuwer/typst-acmart | https://raw.githubusercontent.com/michel-steuwer/typst-acmart/main/sample-typst-acmsmall.typ | typst | MIT License | #import "template.typ": *
#show: acmart.with(
format: "acmsmall",
title: "The Name of the Title is Hope",
authors: {
let clarityInstitute = (
institution: "Institute for Clarity in Documentation",
streetaddress: "P.O. Box 1212",
city: "Dublin",
state: "Ohio",
country: "USA",
postcode: "43017-6221")
let thorvaldGroup = (
institution: "The Thørväld Group",
streetaddress: "The Thørväld Circle",
city: "Hekla",
country: "Iceland")
(
(
name: "<NAME>",
email: "<EMAIL>",
orcid: "1234-5678-9012",
affiliation: clarityInstitute),
(
name: "<NAME>",
email: "<EMAIL>",
affiliation: clarityInstitute),
(
name: "<NAME>",
email: "<EMAIL>",
affiliation: thorvaldGroup),
(
name: "<NAME>",
affiliation: (
institution: "Inria Paris-Rocquencourt",
city: "Rocquencourt",
country: "France")),
(
name: "<NAME>",
affiliation: (
institution: "Rajiv Gandhi University",
streetaddress: "Rono-Hills",
city: "Doimukh",
state: "Arunachal Pradesh",
country: "India")),
(
name: "<NAME>",
affiliation: (
institution: "Tsinghua University",
streetaddress: "30 Shuangqing Rd",
city: "Haidian Qu",
state: "Beijing Shi",
country: "China")),
(
name: "<NAME>",
email: "<EMAIL>",
affiliation: (
institution: "Palmer Research Laboratories",
streetaddress: "8600 Datapoint Drive",
city: "San Antonio",
state: "Texas",
country: "USA",
postcode: "78229")),
(
name: "<NAME>",
email: "<EMAIL>",
affiliation: thorvaldGroup),
(
name: "<NAME>",
email: "<EMAIL>",
affiliation: (
institution: "The Kumquat Consortium",
city: "New York",
country: "USA"))
)},
shortauthors: "Trovato et al.",
abstract: [
A clear and well-documented Typst document is presented as an
article formatted for publication by ACM in a conference proceedings
or journal publication. Based on the "acmart" template, this
article presents and explains many of the common variations, as well
as many of the formatting elements an author may use in the
preparation of the documentation of their work.
],
ccs: (
([Computer systems organization], (
(500, [Embedded systems]),
(300, [Redundancy]),
(0, [Robotics]))),
([Networks], (
(100, [Network reliability]),))
),
// (
// (500, ([Computer systems organization], [Embedded systems])),
// (300, ([Computer systems organization], [Redundancy])),
// (none, ([Computer systems organization], [Robotics])),
// (100, ([Networks], [Network reliability]))
// ),
keywords: ("datasets", "neural networks", "gaze detection", "text tagging"),
copyright: "acmcopyright",
acmJournal: "JACM",
acmVolume: 37,
acmNumber: 4,
acmArticle: 1,
acmMonth: 8,
acmYear: 2018,
)
= Introduction
ACM's consolidated article template, introduced in 2017, provides a
consistent Typst style for use across ACM publications, and
incorporates accessibility and metadata-extraction functionality
necessary for future Digital Library endeavors. Numerous ACM and
SIG-specific Typst templates have been examined, and their unique
features incorporated into this single new template.
If you are new to publishing with ACM, this document is a valuable
guide to the process of preparing your work for publication. If you
have published with ACM before, this document provides insight and
instruction into more recent changes to the article template.
The "`acmart`" document class can be used to prepare articles
for any ACM publication --- conference or journal, and for any stage
of publication, from review to final "camera-ready" copy, to the
author's own version, with _very_ few changes to the source.
= Template Overview
As noted in the introduction, the "`acmart`" document class can
be used to prepare many different kinds of documentation --- a
double-blind initial submission of a full-length technical paper, a
two-page SIGGRAPH Emerging Technologies abstract, a "camera-ready"
journal article, a SIGCHI Extended Abstract, and more --- all by
selecting the appropriate _template style_ and _template parameters_.
This document will explain the major features of the document
class. For further information, the _Typst User's Guide_ is
available from https://www.acm.org/publications/proceedings-template.
== Template Styles
The primary parameter given to the "`acmart`" document class is
the _template style_ which corresponds to the kind of publication
or SIG publishing the work. This parameter is enclosed in square
brackets and is a part of the `documentclass` command:
```
\documentclass[STYLE]{acmart}
```
Journals use one of three template styles. All but three ACM journals
use the `acmsmall` template style:
- `acmsmall`: The default journal template style.
- `acmlarge`: Used by JOCCH and TAP.
- `acmtog`: Used by TOG.
The majority of conference proceedings documentation will use the `acmconf` template style.
- `acmconf`: The default proceedings template style.
- `sigchi`: Used for SIGCHI conference articles.
- `sigplan`: Used for SIGPLAN conference articles.
== Template Parameters
In addition to specifying the _template style_ to be used in
formatting your work, there are a number of _template parameters_
which modify some part of the applied template style. A complete list
of these parameters can be found in the _Typst User's Guide._
Frequently-used parameters, or combinations of parameters, include:
- `anonymous,review`: Suitable for a "double-blind"
conference submission. Anonymizes the work and includes line
numbers. Use with the command to print the
submission's unique ID on each page of the work.
- `authorversion`: Produces a version of the work suitable
for posting by the author.
- `screen`: Produces colored hyperlinks.
This document uses the following string as the first command in the
source file:
```
\documentclass[acmsmall]{acmart}
```
= Modifications
Modifying the template --- including but not limited to: adjusting
margins, typeface sizes, line spacing, paragraph and list definitions,
and the use of the `\vspace` command to manually adjust the
vertical spacing between elements of your work --- is not allowed.
*Your document will be returned to you for revision if modifications are discovered.*
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/unichar/0.1.0/ucd/block-11A50.typ | typst | Apache License 2.0 | #let data = (
("SOYOMBO LETTER A", "Lo", 0),
("SOYOMBO VOWEL SIGN I", "Mn", 0),
("SOYOMBO VOWEL SIGN UE", "Mn", 0),
("SOYOMBO VOWEL SIGN U", "Mn", 0),
("SOYOMBO VOWEL SIGN E", "Mn", 0),
("SOYOMBO VOWEL SIGN O", "Mn", 0),
("SOYOMBO VOWEL SIGN OE", "Mn", 0),
("SOYOMBO VOWEL SIGN AI", "Mc", 0),
("SOYOMBO VOWEL SIGN AU", "Mc", 0),
("SOYOMBO VOWEL SIGN VOCALIC R", "Mn", 0),
("SOYOMBO VOWEL SIGN VOCALIC L", "Mn", 0),
("SOYOMBO VOWEL LENGTH MARK", "Mn", 0),
("SOYOMBO LETTER KA", "Lo", 0),
("SOYOMBO LETTER KHA", "Lo", 0),
("SOYOMBO LETTER GA", "Lo", 0),
("SOYOMBO LETTER GHA", "Lo", 0),
("SOYOMBO LETTER NGA", "Lo", 0),
("SOYOMBO LETTER CA", "Lo", 0),
("SOYOMBO LETTER CHA", "Lo", 0),
("SOYOMBO LETTER JA", "Lo", 0),
("SOYOMBO LETTER JHA", "Lo", 0),
("SOYOMBO LETTER NYA", "Lo", 0),
("SOYOMBO LETTER TTA", "Lo", 0),
("SOYOMBO LETTER TTHA", "Lo", 0),
("SOYOMBO LETTER DDA", "Lo", 0),
("SOYOMBO LETTER DDHA", "Lo", 0),
("SOYOMBO LETTER NNA", "Lo", 0),
("SOYOMBO LETTER TA", "Lo", 0),
("SOYOMBO LETTER THA", "Lo", 0),
("SOYOMBO LETTER DA", "Lo", 0),
("SOYOMBO LETTER DHA", "Lo", 0),
("SOYOMBO LETTER NA", "Lo", 0),
("SOYOMBO LETTER PA", "Lo", 0),
("SOYOMBO LETTER PHA", "Lo", 0),
("SOYOMBO LETTER BA", "Lo", 0),
("SOYOMBO LETTER BHA", "Lo", 0),
("SOYOMBO LETTER MA", "Lo", 0),
("SOYOMBO LETTER TSA", "Lo", 0),
("SOYOMBO LETTER TSHA", "Lo", 0),
("SOYOMBO LETTER DZA", "Lo", 0),
("SOYOMBO LETTER ZHA", "Lo", 0),
("SOYOMBO LETTER ZA", "Lo", 0),
("SOYOMBO LETTER -A", "Lo", 0),
("SOYOMBO LETTER YA", "Lo", 0),
("SOYOMBO LETTER RA", "Lo", 0),
("SOYOMBO LETTER LA", "Lo", 0),
("SOYOMBO LETTER VA", "Lo", 0),
("SOYOMBO LETTER SHA", "Lo", 0),
("SOYOMBO LETTER SSA", "Lo", 0),
("SOYOMBO LETTER SA", "Lo", 0),
("SOYOMBO LETTER HA", "Lo", 0),
("SOYOMBO LETTER KSSA", "Lo", 0),
("SOYOMBO SIGN JIHVAMULIYA", "Lo", 0),
("SOYOMBO SIGN UPADHMANIYA", "Lo", 0),
("SOYOMBO CLUSTER-INITIAL LETTER RA", "Lo", 0),
("SOYOMBO CLUSTER-INITIAL LETTER LA", "Lo", 0),
("SOYOMBO CLUSTER-INITIAL LETTER SHA", "Lo", 0),
("SOYOMBO CLUSTER-INITIAL LETTER SA", "Lo", 0),
("SOYOMBO FINAL CONSONANT SIGN G", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN K", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN NG", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN D", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN N", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN B", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN M", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN R", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN L", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN SH", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN S", "Mn", 0),
("SOYOMBO FINAL CONSONANT SIGN -A", "Mn", 0),
("SOYOMBO SIGN ANUSVARA", "Mn", 0),
("SOYOMBO SIGN VISARGA", "Mc", 0),
("SOYOMBO GEMINATION MARK", "Mn", 0),
("SOYOMBO SUBJOINER", "Mn", 9),
("SOYOMBO MARK TSHEG", "Po", 0),
("SOYOMBO MARK SHAD", "Po", 0),
("SOYOMBO MARK DOUBLE SHAD", "Po", 0),
("SOYOMBO MARK PLUTA", "Lo", 0),
("SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME", "Po", 0),
("SOYOMBO HEAD MARK WITH MOON AND SUN AND FLAME", "Po", 0),
("SOYOMBO HEAD MARK WITH MOON AND SUN", "Po", 0),
("SOYOMBO TERMINAL MARK-1", "Po", 0),
("SOYOMBO TERMINAL MARK-2", "Po", 0),
)
|
https://github.com/sicheng1806/typst-book-for-sicheng | https://raw.githubusercontent.com/sicheng1806/typst-book-for-sicheng/main/scr/basic_pkg/par.typ | typst | // 增加了摘要段落
#let abstact(title:[#text(14pt)[摘要]],fontsize:12pt,doc) = {
set text(fontsize)
set align(center)
par(title)
par[#h(2em)#doc]
} |
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/circuiteria/0.1.0/src/elements/block.typ | typst | Apache License 2.0 | #import "@preview/cetz:0.2.2": draw
#import "element.typ"
#let draw-shape(id, tl, tr, br, bl, fill, stroke) = {
let f = draw.rect(
radius: 0.5em,
inset: 0.5em,
fill: fill,
stroke: stroke,
name: id,
bl, tr
)
return (f, tl, tr, br, bl)
}
/// Draws a block element
///
/// #examples.block
/// For parameters description, see #doc-ref("element.elmt")
#let block(
x: none,
y: none,
w: none,
h: none,
name: none,
name-anchor: "center",
ports: (),
ports-margins: (),
fill: none,
stroke: black + 1pt,
id: "",
debug: (
ports: false
)
) = element.elmt(
draw-shape: draw-shape,
x: x,
y: y,
w: w,
h: h,
name: name,
name-anchor: name-anchor,
ports: ports,
ports-margins: ports-margins,
fill: fill,
stroke: stroke,
id: id,
debug: debug
) |
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/dashy-todo/0.0.1/lib/place-in-page-margin.typ | typst | Apache License 2.0 | #import "side-margin.typ": calc-side-margin
#let place-in-page-margin(body, cur-pos: none, position: auto) = (
box({
let side = position
if position == auto {
if cur-pos.x > page.width / 2 {
side = right
} else {
side = left
}
}
// caclulation based on https://typst.app/docs/reference/layout/page/#parameters-margin
let page-side-margin = calc-side-margin(side)
let target-x = if side == left { 0pt } else { page.width - page-side-margin }
let delta-x = target-x - cur-pos.x
place(dx: delta-x)[
#box(body, width: page-side-margin)
]
})
) |
https://github.com/polarkac/MTG-Stories | https://raw.githubusercontent.com/polarkac/MTG-Stories/master/stories/003%20-%20Gatecrash/007_The%20Guild%20of%20Deals.typ | typst | #import "@local/mtgstory:0.2.0": conf
#show: doc => conf(
"The Guild of Deals",
set_name: "Gatecrash",
story_date: datetime(day: 12, month: 02, year: 2013),
author: "<NAME>",
doc
)
#figure(image("007_The Guild of Deals/02.jpg", width: 100%), caption: [Orzhov Guildgate | Art by John Avon], supplement: none, numbering: none)
Bosco unlocked the small but thick wooden side door that granted access through the outer wall into the mansion grounds. He passed a pair of guards, paying them each a coin as he made his way to a building assigned to the janitors and groundskeepers. As he pushed open the old, wooden door, he could feel the cold of the stone walls and rubbed his hands together briskly. Bosco was short, thin-lipped, with black hair that seemed even darker against his pale skin. He was in his early twenties and had already worked for the Orzhov for years scrubbing steps, polishing brass, mopping floors. But Bosco had plans. He wouldn’t be a mopper for long. He was making connections and would soon make his mark.
#figure(image("007_The Guild of Deals/04.jpg", width: 100%), caption: [Basilica Guards | Art by Dan Scott], supplement: none, numbering: none)
He began to collect his mop and bucket when Jozica’s thrull shuffled in. Jozica was the enforcer employed by the owner of the estate. Bosco feared her. The thrull, he hated.
"Three coins." The thrull sneered behind its golden faceplate. "Mopper tax," it said, with as much high-pitched, slobbering relish as it had done on Bosco’s first day. Its little grin of satisfaction and demanding whine had, over time, turned the thrull into a mortal enemy.
For a split-second, Bosco imagined kicking the thrull across the room and driving his mop handle through its gilded faceplate, but he quickly thought the better of it. It was Jozica’s personal thrull and Bosco knew she was quite fond of it.
One lapse in reason and he’d be indebted to her for a long time—or worse.
#figure(image("007_The Guild of Deals/06.jpg", width: 100%), caption: [Dutiful Thrull | Art by Daarken], supplement: none, numbering: none)
The thrull flinched and hissed at Bosco as he dropped the three coins into the locked moneybox, as if its primal senses somehow knew of Bosco’s inner desire to crush its bones into paste. As soon as the coins clinked the thrull clutched the box tightly in its rubbery, gray arms and scurried off, snickering to itself as if it had pulled off a most ingenious heist. Bosco swallowed another urge to chase it down and feed it the moneybox. Instead, he grabbed his mop and bucket and proceeded to the large stone floor of the mansion’s main hall. The slapping sound of the thrull’s feet echoed in the distance.
#emph[Bide your time, Bosco,] he thought. #emph[Your time is coming.]
"Five centuries," Bosco said, over a mug of bumbat.
"What?" Drovo almost spit his bumbat out his nose.
"That’s how much debt I owe to the guild. Five centuries all told."
"That’s insane. How did that happen?"
"Well, I was new to the Orzhov—a joinant. For their protection, benefits, stability, and opportunities, I had to make a substantial buy-in. I wasn’t born into the guild so I haven’t had ancestors working off debt for me. So I incurred a few penalties."
"Krokt. What made you finally do it?"
"You know what it’s like being unguilded: everyone kicks us around and nobody gives us any respect. But the Orzhov, they walk the streets like kings. I mean, look!" Bosco moved his chair back off of the table to allow his friend to admire his new black-and-white mopper attire with gold threading, silver buttons and cufflinks, all emblazoned with the Orzhov guild symbol. "I’m just a mopper and I get these clothes. People give me respect and I can always get an advance from an Orzhov coiner for another year of service." Bosco plopped a fat purse of coins on the table.
Bosco’s impeccable Orzhov tailoring and sack of coins created a pang of envy in Drovo.
But five centuries?
"What happens when you… you know, die?" Drovo asked, a bit apprehensively.
"I don’t care about that," Bosco said, a little too abruptly. "It’s about getting what’s mine while I’m alive, Drovo. Who cares after I’m dead? The Orzhov encourage ambition, someone willing to do what it takes to move up." Bosco balled up his hand into a fist for emphasis. "I’m going to take every opportunity I can get. I’ll show them that they can’t do without me. I may even be able to buy off some of my after-debt. I could even live an unlife of luxury if I play my cards right. "
"Whoa. You’ve really become an Orzhov. I know the last time we met you were talking about it but I didn’t think that you’d really do it. I thought you’d join the Gateless or something."
"The Gateless. I want to be a part of something powerful. The Orzhov own Ravnica. They don’t get pushed around by the other guilds." Bosco leaned in. "I’m going to be promoted fast here Drovo. The Orzhov know how to reward ambition and I know someone who has the power to make things happen for me… and you can be a part of it too if you’re up for it."
"Sit down, Bosco," Jozica said. Bosco hated the fact that he still felt uncomfortable around the Orzhov enforcer. He could almost feel the amount of death she had handed out and how easily she had done it. He tried not to look at her.
The high prelate sat behind a black slate desk on a golden chair etched with Orzhov symbols and covered with lavish, embroidered cushions. A thrull pushed a chair toward Bosco and quickly fled behind some thick velvet curtains before reappearing at the high prelate’s elbow, purring as it offered a dish of grapes.
#figure(image("007_The Guild of Deals/08.jpg", width: 100%), caption: [High Priest of Penance | Art by <NAME>], supplement: none, numbering: none)
Bosco sat down. The high prelate was a lifeless man. A lifetime of lies, swindles, and graft had pulled his features down into an impassive mélange, where apathy and disgust were permanently fixed. The high prelate seemed to stare off into space. Bosco was beginning to feel like the old man maybe wasn’t all there. As soon as Bosco looked at Jozica, he saw the high prelate’s eyes swivel and lock on to him in an unsettling, reptile-like manner. There was a sharp mind still lurking within the folds of flesh that hung on his face. A mind that evaluated Bosco like a butcher would evaluate a side of beef.
Bosco swallowed.
Jozica produced a contract and slid it toward Bosco. Halfway across the table the high prelate interrupted its journey, placing a fat, ring-encrusted finger on it with a thud.
"This will magically bind you to your word and deed." The high prelate’s voice croaked out at him, his speech punctuated by strained wheezing. "You sign this, carry out your task, and your debt will be substantially reduced by the terms agreed to." The high prelate then pushed the document toward Bosco. It made a crispy, rasping sound. As Bosco reached for the contract, the high prelate looked at Bosco with his wet, coal-like eyes. "We may even have more work for you."
Bosco hurriedly signed the contract and felt the tingle of Orzhov magic along with the thrill of opportunity.
"Over there," Bosco whispered, pointing to a sconce on the wall. "Pull it."
"Are you sure that it won’t raise an alarm?" Drovo asked.
"No. I told you, once we got past the guards everything would be easy pickings."
"You better be sure." Drovo reached up and, with some effort, pulled the sconce. It made a grinding sound followed by a mechanical click, as a section of wainscoting popped out.
"That’s it," Bosco whispered excitedly. He took a glance down the candlelit hall, making sure no one had spotted them—especially Jozica’s thrull. "Go through there."
Drovo pulled open the oaken panel to reveal a small, stone staircase winding down into the darkness.
#figure(image("007_The Guild of Deals/10.jpg", width: 100%), caption: [Rogue’s Passage | Art by Christine Choi], supplement: none, numbering: none)
"Quickly," Bosco hissed, looking both ways as he followed Drovo down the stairs, locking the panel behind them and then striking a small torch to light with a piece of flint and steel.
"Keep moving," Bosco said, as the torch sputtered and popped. "It’s at the bottom of the stairs."
The two moved down the stairs, feeling the air grow colder as they neared the bottom. A long, narrow hallway only wide enough to pass single file stretched beyond the light of the torch. Drovo looked back nervously.
"Keep going. It has to be down here." Bosco nudged his friend forward.
They walked down the chill corridor. The air smelled of earth and must; the light of the torch animated their shadows into dancing specters. Ahead, they could see the hallway open out into a circular mausoleum, a massive Orzhov guild symbol emblazoned on the floor in onyx and ivory tile. The tip of each point of the guild symbol housed a heavy, iron-bound door. The two walked into the center of the mausoleum and looked at the doors.
"Which one is it?" Drovo asked.
Bosco pointed to the one diagonal from the entrance. "That one over there."
They walked to the big door. "It’s locked. Do you have the key?"
Bosco smiled and held up a heavy, iron key. "I told you I was prepared."
Drovo stood aside as Bosco handed him the torch and inserted the key in the lock. He gave it a turn, and the tumblers groaned a bit as the latch slide open.
Bosco pulled the door open and pulled another torch from his rucksack. "Go check it out. I’m going to make sure we weren’t followed."
Drovo stepped into the interior of the tomb, a pair of stone sarcophaguses sat before him, their lids carved with what appeared to be Orzhov nobles. There would be plenty of treasure for both of them within these tombs. Getting past the lids without making too much noise would take some careful work but it could be done. Drovo unshouldered his pack. "We’re going to have to find a way to slide these lids off carefully, Bosco. I brought a couple crowbars and some rope. We might be able to lash them to those rings in the ceiling. Hey are you…?" Drovo turned around to see the door close and the lock slide shut with an echoing clack.
He ran to door. "Hey! Bosco, what in Krokt’s name are you playing at?"
On the other side, Drovo could hear the muffled sound of his friend’s voice. "Sorry Drovo. You were right, five centuries is too long."
A hissing noise came from behind Drovo. He wheeled around to see black smoke gushing from underneath the lid of a sarcophagus. The smoke looked like ink dropped into clear water, swirling and tumbling into the air of the room and filling it with an overpowering smell of the dank bogs in the overgrown areas of the Sixth District. It was as if the smoke was being pulled directly from the foul swamp.
The black smoke had begun to form into large, hanging swaths of tattered cloth surrounded by a circle of masks that rotated around a skeletal figure. Drovo gagged on the stench as he rushed to his pack and clawed out one of his crowbars in a panic. As he wrenched it out, part of his pack ripped and sent tools scattering across the stone floor. The masks rotated around the cowled figure faster, creating a moaning sound as a grim skeletal face manifested. It dripped fetid water and focused its eyeless sockets on Drovo, who hacked at the door like a caged beast.
"What’s this?" The crypt ghast hissed amid the din of the moaning masks. Drovo’s hands bled; the crowbar slipped from his fingers and clattered on the floor.
"Blood." The apparition gasped with palpable pleasure as Drovo reached for the bar with his blood-soaked hands. "Blood."
#figure(image("007_The Guild of Deals/12.jpg", width: 100%), caption: [Crypt Ghast | Art by <NAME>ahn], supplement: none, numbering: none)
"Has he been fed?" The high prelate asked
"As you instructed, High Prelate," Bosco replied.
The high prelate slid a small, leather sack of coins across the slate desk at Bosco. "You’ve proven yourself quite useful. There will be more work for you in the future."
"Thank you, High Prelate." Bosco took the sack of coins. The weight was more than he’d ever held. As he left, he ventured a look at Jozica, who stood impassively at the high prelate’s side. Much to Bosco’s surprise, he didn’t feel afraid anymore. He turned and closed the large door behind him with a smirk on his face.
"I didn’t think he had it in him," Jozica said.
"After enough time, I’ve come to know what lies within a person’s soul. That boy has got ambition written all over him."
|
|
https://github.com/juanppalacios/typst-gvsu-egr | https://raw.githubusercontent.com/juanppalacios/typst-gvsu-egr/main/template.typ | typst | #let thesis(
title: none,
authors: (),
acknowledgements: [],
abstract: [],
bibliography-file: none,
doc,
) = {
// Set and show rules from before.
set text(
font: "Times New Roman",
size: 12pt,
)
// todo: fix typst's ieee imports
// Configure equation numbering and spacing.
set math.equation(numbering: "(1)")
show math.equation: set block(spacing: 0.65em)
// Configure lists.
set enum(indent: 10pt, body-indent: 9pt)
set list(indent: 10pt, body-indent: 9pt)
set par(
justify: true,
leading: 2em
)
set align(center)
text(12pt, title)
let count = authors.len()
let ncols = calc.min(count, 3)
grid(
columns: (1fr,) * ncols,
row-gutter: 24pt,
..authors.map(author => [
#author.name \
#v(25%, weak: true) \
A Thesis Submitted to the Graduate Faculty of \
#upper(author.affiliation) \
In \
Partial Fulfillment of the Requirements\
For the Degree of \
#author.degree \
#v(20%, weak: true) \
#author.college \
#v(5%, weak: true) \
#author.date
// #link("mailto:" + author.email)
]),
)
pagebreak()
par(justify: false)[
*Acknowledgements* \
#acknowledgements
]
pagebreak()
par(justify: false)[
*Abstract* \
#abstract
]
pagebreak()
set heading(numbering:"1.1")
show outline.entry.where(
level: 1
): it => {
v(12pt, weak: true)
strong(it)
}
outline(
title: [Table of Contents],
)
pagebreak()
outline(
title: [List of Figures],
target: figure.where(kind: image),
)
pagebreak()
outline(
title: [List of Tables],
target: figure.where(kind: table),
)
pagebreak()
// todo: math symbols
// todo: acronyms and abbreviations
set align(left)
columns(1, doc)
// Display bibliography.
pagebreak()
if bibliography-file != none {
show bibliography: set text(12pt)
bibliography(bibliography-file, title: text(12pt)[References], style: "ieee")
}
// todo: appendix
} |
|
https://github.com/daskol/typst-templates | https://raw.githubusercontent.com/daskol/typst-templates/main/neurips/neurips.typ | typst | MIT License | /**
* neurips.typ
*
* Template for The n-th Annual Conference on Neural Information Processing
* Systems (NeurIPS).
*
* [1]: https://neurips.cc/Conferences/2023
* [2]: https://neurips.cc/Conferences/2024
*/
// Re-export `neurips2023` rule as a general one.
#import "/neurips2023.typ": neurips2023 as neurips
#import "/neurips2023.typ": font, neurips2023, paragraph, url
#import "/neurips2024.typ": neurips2024
// Horizontal lines in table taken from booktabs.
#import "/neurips2024.typ": botrule, midrule, toprule
|
https://github.com/sitandr/typst-examples-book | https://raw.githubusercontent.com/sitandr/typst-examples-book/main/.github/ISSUE_TEMPLATE/new-snippet.md | markdown | MIT License | ---
name: New snippet
about: Add new snippet to the book
title: "[Snippet(s) name here]"
labels: new snippet
assignees: sitandr
---
**Location**: [where in the book should be snippet located]
**Importance**: [why should it be in the book]
**Snippet**:
```typ
[The code there]
```
<!-- If possible, attach rendered image from snippet, plese. -->
|
https://github.com/tilman151/pypst | https://raw.githubusercontent.com/tilman151/pypst/main/docs/pandas.md | markdown | MIT License | # Create a Typst Table from a Pandas Data Frame
Pypst can create Typst tables from Pandas data frames.
This allows you to use the full power of Pandas for data wrangling and then render the results in a Typst document.
Multiple levels for columns and indexes are supported.
## Basics
Create a data frame and do any data wrangling you need.
```python
df = pd.DataFrame({
"Name": ["Alice", "Bob", "Charlie"],
"Age": [25, 30, 35],
"City": ["New York", "Los Angeles", "New York"]
})
df = df.groupby("City").agg({"Name": "count", "Age": "mean"})
```
Create a Typst table from the data frame and apply styling.
Then wrap it in a figure and save it to a file.
```python
table = pypst.Table.from_dataframe(df)
table.stroke = "none"
table.align = "(x, _) => if calc.odd(x) {left} else {right}"
table.add_hline(1, stroke="1.5pt")
table.add_hline(len(df) + df.columns.nlevels, stroke="1.5pt")
figure = pypst.Figure(table, caption='"This is my table."')
with open("my-table.typ", mode="wt") as f:
f.write(figure.render())
```
The resulting file looks like this:
```typst
#figure(
table(
columns: 3,
stroke: none,
align: (x, _) => if calc.odd(x) {left} else {right},
table.hline(y: 1, stroke: 1.5pt),
table.hline(y: 3, stroke: 1.5pt),
table.header[][Name][Age],
[Los Angeles], [1], [30.0],
[New York], [2], [30.0]
),
caption: "This is my table."
)
```
Include the file in your `main.typ` Typst document.
```typst
= My Section Heading
#lorem(100)
#include("my-table.typ")
#lorem(100)
```
Compile with `typst compile main.typ` to receive a PDF file like [this](examples/table/main.pdf).
By using `typst watch main.typ`, you can automatically recompile the when your Python script runs.
## Styling individual cells
You can style individual cells by accessing the `table.row_data` attribute.
This attribute is a list of lists, where each sublist corresponds to a row in the table.
Each sublist contains the data for the cells in that row.
```python
table = pypst.Table.from_dataframe(df)
table.row_data[0][0].fill = "red"
table.row_data[1][1].fill = "blue"
```
The resulting Typst code looks like this:
```typst
#table(
columns: 3,
table.header[][Name][Age],
[#table.cell(fill: red)[Los Angeles]], [1], [30.0],
[New York], [#table.cell(fill: blue)[2]], [30.0]
)
```
## Using Third-Party Packages
If your table uses third-party packages, you can wrap the figure in a document and include the proper imports.
```python
document = pypst.Document(figure)
document.add_import("@preview/unify:0.4.3", ["num"])
```
The resulting file looks like this:
```typst
#import "@preview/unify:0.4.3": num
#figure(
table(
columns: 3,
stroke: none,
align: (x, _) => if calc.odd(x) {left} else {right},
table.hline(y: 1, stroke: 1.5pt),
table.hline(y: 3, stroke: 1.5pt),
table.header[][Name][Age],
[Los Angeles], [1], [30.0],
[New York], [2], [30.0]
),
caption: "This is my table."
)
```
## Multiple Levels for Columns and Indexes
If your data frame has multiple levels for columns, Pypst will render them correctly.
```python
df = pd.DataFrame(
[[1, 3], [2, 4]],
columns=pd.MultiIndex.from_tuples([("A", "mean"), ("A", "std")]),
index=["X", "Y"]
)
table = pypst.Table.from_dataframe(df)
```
```
#table(
columns: 3,
table.header[#table.cell(rowspan: 2)[]][#table.cell(colspan: 2)[A]][mean][std],
[X], [1], [3],
[Y], [2], [4]
)
```
Multiple levels for indexes are also supported.
```python
df = pd.DataFrame(
[[1, 3], [2, 4]],
columns=["A", "B"],
index=pd.MultiIndex.from_tuples([("X", "mean"), ("X", "std")])
)
table = Table.from_dataframe(df)
print(table.render())
```
```
#table(
columns: 4,
table.header[#table.cell(colspan: 2)[]][A][B],
[#table.cell(rowspan: 2)[X]], [mean], [1], [3],
[std], [2], [4]
)
```
The cells for the headers and row indexes are stored by level in the `table.header_data` and `table.index_data` attributes, respectively.
You can access them to style the cells individually.
|
https://github.com/noahjutz/AD | https://raw.githubusercontent.com/noahjutz/AD/main/notizen/algorithmen/mts3.typ | typst | #import "/config.typ": theme
#show table.cell: set text(size: 8pt)
#show table.cell.where(y: 0): set text(size: 11pt)
#let nums = (-13, 25, 34, 12, -3, 7, -87, 28, -77, 11)
#let rows(nums) = {
let result = ()
let start = 0
let end = 0
let sum = -1
for n in nums {
if sum + n <= n {
start = end
sum = n
} else {
sum += n
}
end += 1
let next_row = nums.enumerate().map(((i, n)) => {
table.cell(
str(n),
fill: if start <= i and i < end {theme.primary_trans}
)
})
next_row.insert(0, table.cell[
#set text(weight: "bold")
#sum
])
result.push(next_row)
}
return result
}
#let c = rows(nums)
#block(
stroke: 1pt,
table(
columns: (1fr,) * (nums.len() + 1),
align: end,
stroke: (x, y) => {
if y == 0 {(bottom: 1pt)}
if x == 0 {(right: 1pt)}
},
table.cell(align: center + horizon)[$sum$],
table.cell(colspan: nums.len(), align: start + horizon)[Liste],
..c.flatten()
)
) |
|
https://github.com/thanhdxuan/dacn-report | https://raw.githubusercontent.com/thanhdxuan/dacn-report/master/datn-week-1/contents/02-introduce.typ | typst | = Tổng quan
Báo cáo tuần 1 của nhóm tập trung vào lên kế hoạch cho giai đoạn đồ án tốt nghiệp và sửa đổi đồ án theo những góp ý của hội đồng báo cáo đồ án chuyên ngành. |
|
https://github.com/rabotaem-incorporated/probability-theory-notes | https://raw.githubusercontent.com/rabotaem-incorporated/probability-theory-notes/master/sections/02-general/05-random-sequence-convergence.typ | typst | #import "../../utils/core.typ": *
== Сходимость последовательности случайных величин
#th[
$xi_1$, $xi_2$, ... --- последовательность независимых случайных величин. Пусть $f_i: RR^(n_i) --> RR$ измеримы относительно борелевской $sigma$-алгебры. Тогда случайные величины
$f_1(xi_1, xi_2, ... xi_(n_1))$, $f_2(xi_(n_1 + 1), xi_(n_1 + 2), ..., xi_(n_1+n_2))$, ... независимы.
]
#proof[
Докажем для пары кусочков последовательностей $xi_1, xi_2, ..., xi_m$ и $eta_1, eta_2, ..., eta_n$ независимых, $f: RR^m --> RR$, $g: RR^n --> RR$. Хотим доказать, что $f(xi_1, ..., xi_m)$ и $g(eta_1, ..., eta_n)$ независимы. Пусть $A$ и $B$ --- борелевские множества. Тогда надо доказать, что
$
{f(xi_1, ..., xi_m) in A}, {g(eta_1, ..., eta_m) in B}
$
независимы. Равносильно,
$
{(xi_1, ..., xi_m) in f^(-1) (A)}, {(eta_1, ..., eta_n) in g^(-1) (B)}
$ независимы, или
$
P(arrow(xi) in f^(-1) (A)) dot P(arrow(eta) in g^(-1) (B)) = P((arrow(xi), arrow(eta)) in f^(-1) (A) times g^(-1) (B)) newline(<==>)
P_(arrow(xi)) (f_1^(-1) (A)) dot P_(arrow(eta)) (g^(-1) (B)) = P_(arrow(xi), arrow(eta)) (f^(-1) (A) times g^(-1) (B))
$
Это верно, так как
$
P_(arrow(xi)) &= P_(xi_1) times ... times P_(xi_m),\
P_(arrow(eta)) &= P_(eta_1) times ... times P_(eta_n),\
P_(arrow(xi), arrow(eta)) &= P_xi_1 times ... times P_(xi_m) times P_(eta_1) times ... times P_(eta_n).
$
]
#def[
Пусть $xi_1, xi_2, ..., xi : Omega --> RR$ случайные величины. Будем говорить, что
1. последовательность $xi_n$ _сходится к случайной величине $xi$ почти наверное_, если
$
P(lim xi_n = xi) = 1.
$
2. $xi_n$ _сходится к $xi$ в среднем порядка $r$_, если
$
E abs(xi_n - xi)^r -->_(n -> oo) 0.
$
Обозначается $xi_n -->^(L_r) xi$.
3. $xi_n$ _сходятся к $xi$ по вероятности_, если для любого $eps > 0$,
$
P(abs(xi_n - xi) > eps) -->_(n -> oo) 0.
$
Обозначается $xi_n -->^p xi$.
4. Если $xi_i: Omega_i --> RR$ (то есть каждая задана на своем вероятностном пространстве), то _$xi_n$ сходится к $xi$ по распределению_ или _$xi_n$ слабо сходится к $xi$_, если
$
F_(xi_n) (x) -->_(n -> oo) F_(xi) (x)
$
по всех точках непрерывности $F_(xi)$. Обозначается $xi_n ==> xi$.
]
#th[
#figure[
#cetz.canvas({
import cetz.draw: *
rect((0, 0.3), (4, 1.8), name: "rect1")
rect((-1, -1.8), (4, -0.3), name: "rect2")
rect((6, -0.75), (10, 0.75), name: "rect3")
rect((12, -0.75), (16, 0.75), name: "rect4")
set-style(stroke: (thickness: 2pt), fill: black)
line((to: "rect1.east", rel: (0.3, 0.0)), (to: "rect3.west", rel: (-0.3, 0.225)), mark: (end: ">"))
line((to: "rect2.east", rel: (0.3, 0.0)), (to: "rect3.west", rel: (-0.3, -0.225)), mark: (end: ">"))
line((to: "rect3.east", rel: (0.3, 0.0)), (to: "rect4.west", rel: (-0.3, 0.0)), mark: (end: ">"))
content("rect1.center", align(center)[1. Сходимость \ почти наверное])
content("rect2.center", align(center)[2. Сходимость в \ среднем порядка $r$])
content("rect3.center", align(center)[3. Сходимость по \ вероятности])
content("rect4.center", align(center)[4. Сходимость по \ распределению])
})
]
]
#proof[
- "$1==>3$": теорема Лебега из матана (вероятностная мера всегда конечна).
- "$2==>3$": рассмотрим $P(abs(xi_n - xi) >= eps) = P(abs(xi_n - xi)^r >= eps^r) <= (E abs(xi_n - xi)^r) / eps^r --> 0$.
- "$1cancel(==>)2$": (а значит и $3 cancel(==>) 2$) $Omega = [0, 1]$, $P = lambda_1$, $xi_n = n^(1/r) bb(1)_[0, 1/n]$ --- сходится почти наверное к $xi = 0$. Но $E xi_n^r = E(n bb(1)_[0, 1/n]) = 1 cancel(-->) 0$ --- значит 2 не выполняется.
- "$2cancel(==>)1$": (а значит и $3cancel(==>)1$) $Omega = [0, 1]$, $P = lambda_1$. $xi = bb(1)_[0, 1]$, $xi_1 = bb(1)_[0, 1/2)$, $xi_2 = bb(1)_[1/2, 1)$, $xi_3 = bb(1)_[0, 1/3)$, ...
и тогда 2 есть: $E bb(1)_[k/n, (k + 1)/n) = 1/n --> 0$, а 1 нет: в каждой точке сколь угодно далеко встречаются и $0$, и $1$.
- "$3==>4$": ${xi_n > x} supset {xi > x + eps} sect {abs(xi_n - xi) < eps}$. Взяв дополнения, ${xi_n <= x} subset {xi <= x + eps} union {abs(xi_n - xi) >= eps}$. Отсюда
$
P(xi_n <= x) <= P(xi <= x+eps) + P(abs(xi_n - xi) >= eps) ==> F_(xi_n) (x) <= F_xi (x + eps) + P(abs(xi_n - xi) >= eps) newline(==>)
limsup F_(xi_n) (x) <= F_xi (x + eps) + underbrace(limsup P(abs(xi_n - xi) >= eps), 0) = F_xi (x + eps).
$
С другой стороны, ${xi_n <= x} supset {xi <= x - eps} sect {abs(xi_n - xi) < eps}$, откуда ${xi_n > x} subset {xi > x + eps} union {abs(xi_n - xi) >= eps}$, и
$
P(xi_n > x) <= P(xi > x - eps) + P(abs(xi_n - xi) >= eps) ==> F_(xi_n) (x) >= F_xi (x - eps) - P(abs(xi_n - xi) >= eps) newline(==>)
liminf F_(xi_n) (x) >= F_xi (x - eps) - underbrace(limsup P(abs(xi_n - xi) >= eps), 0) = F_xi (x - eps).
$
Таким образом, $F_xi (x - eps) <= liminf F_xi_n (x) <= limsup F_xi_n (x) <= F_xi (x + eps)$. В точке непрерывности $F_xi$ это означает, что $F_xi_n --> F_xi$.
- "$4cancel(==>)3$": в прямой формулировке не имеет смысла, но даже если определить случайные величины на одном пространстве --- это все равно не верно (примера не было).
]
#th(name: "<NAME>ольших чисел")[
Пусть $xi_1$, $xi_2$, ... --- попарно некоррелированные случайные величины и $D xi_n <= M$. Тогда $ P(abs(S_n/n - E S_n/n) >= eps) --> 0, $ где $S_n = xi_1 + xi_2 + ... + xi_n$.
]
#proof[
$D S_n = sum_(k = 1)^n D_(xi_k) <= n M$, так как величины некоррелированны. По неравентсву Чебышева,
$
P(abs(S_n/n - E S_n/n) >= eps) <= (D(S_n/n)) / eps^2 <= (D S_n)/(n^2 eps^2) <= (n M)/(n^2 eps^2) = M/(eps^2 n) --> 0.
$
]
#th(name: "закон больших чисел в форме Чебышева")[
$xi_1, xi_2, ...$ независимы и одинаково распределены с конечной дисперсией. Тогда $S_n / n --> a$ по вероятности, где $a = E xi_1$.
]
#proof[
```coq
Proof.
apply big_number_law.
Qed.
```
]
#follow(name: "закон больших чисел для схемы Бернулли")[
Пусть имеется схема Бернулли с вероятностью успеха $p$. Тогда $S_n/n --> p$ по вероятности.
]
#th(name: "усиленный закон больших чисел")[
Пусть $xi_1$, $xi_2$, ... --- независимые случайные величины, и их четвертый центральный момент $E (xi_k - E xi_k)^4$ ограничен. Тогда $S_n/n --> E S_n/n $ почти наверное (где $S_n := xi_1 + ... + xi_n$).
]
#proof[
Пусть $eta_k := xi_k - E xi_k$, и $S_n - E S_n = eta_1 + eta_2 + ... + eta_n$. Надо доказать, что $ (eta_1 + eta_2 + ... + eta_n)/n --> 0 $ почти наверное, но теперь все матожидания нулевые. Давайте вообще считать, что в изначальной задаче все матожидания нулевые, и писать $xi$ вместо $eta$ как в оригинальной задаче.
Итак, имеем $E xi_k = 0$, $E xi_k^4 <= C$, и надо доказать, что $S_n/n --> 0$ почти наверное. Для некоторого $eps$ положим $A_n = {abs(S_n/n) >= eps}$. Рассмотрим $A := Sect_(n = 1)^oo Union_(k = n)^oo A_k$ --- событие "случилось бесконечное количество событий $A_n$". Докажем, что $P(A) = 0$ по лемме Бореля-Кантелли. Достаточно проверить, что $sum_(n = 1)^oo P(A_n)$ сходится, а для этого достаточно проверить $P(A_n) = O(1/n^2)$.
$
P(A_n) = P((S_n/n)^4 >= eps^4) <=^"Марков" (E (S_n/n)^4)/eps^4 = (E S_n^4)/(n^4 eps^4).
$
Достаточно доказать, что $E S_n^4 = O(n^2)$. Посчитаем:
$
E (S_n^4) = E (xi_1 + xi_2 + ... + xi_n)^4 newline(=)
sum E xi_k^4 + 6 sum_(i < k) E xi_i^2 xi_k^2 + 12 sum_(j < k \ i != j \ i != k) E xi_i^2 xi_j xi_k + 4 sum_(i != k) E xi_i^3 xi_k + 24 sum_(i < j < k < l) E xi_i xi_j xi_k xi_l newline(=)
sum E xi_k^4 + 6 sum_(i < k) E xi_i^2 E xi_k^2 + 12 sum_(j < k \ i != j \ i != k) E xi_i^2 E xi_j E xi_k + 4 sum_(i != k) E xi_i^3 E xi_k + 24 sum_(i < j < k < l) E xi_i E xi_j E xi_k E xi_l newline(=)
sum E xi_k^4 + 6 sum_(i < k) E xi_i^2 E xi_k^2.
$
Эта сумма оценивается сверху:
$
E xi_i^4 &<= C,\
E xi_i^2 xi_j^2 &<=^"Коши-Буняковский" sqrt(E xi_i^4 E xi_j^4) <= C.
$
Значит
$
sum E xi_k^4 + 6 sum_(i < k) E xi_i^2 E xi_k^2 <= n C + 6 n^2 C = O(n^2).
$
Рассмотрим событие $A(eps) = Sect_(n = 1)^oo Union_(k = n)^oo A_k$. $P(A(eps)) = 0$ для любого $eps > 0$ (то есть то $eps$, который мы раньше рассматривали произвольным теперь рассматривается как параметр для множества $A$). Рассмотрим $B := Union_(m = 1)^oo A(1/m)$ и $P(B) = 0$.
Пусть $omega in.not B$. Тогда $omega in.not A(1/m)$ для любого $m$, а значит $omega in.not A(eps)$ для любого $eps > 0$, и случилось лишь конечное число событий ${abs(S_n/n) >= eps}$, а тогда начиная с некоторого номера начинаются только обратные: $ omega in {abs(S_n/n) < eps} ==> abs((S_n (omega))/n) < eps ==> S_n/n -->_(n -> oo) 0. $
Доказали.
]
#follow(name: "Усиленный закон больших чисел для схемы Бернулли")[
Пусть $p$ --- вероятность успеха. Тогда $S_n/n --> p$ почти наверное.
]
#proof[
$E xi_k = p$, а значит $E S_n = n p$. Надо проверить конечность четвертого центрального момента. Ну да, он конечен:
$
E (xi_k - p)^4 = E xi_k^4 + ... E xi_k^3 + ... E xi_k^2 + ... E xi_k + ...,
$
где под $...$ находятся какие-то конечные коэффициенты, а $E xi_k^n$ равно $p$, так как $xi_k$ --- либо $0$, либо $1$.
]
#example(name: "метод Монте-Карло")[
Пусть $Phi$ --- тело в $RR^d$. Хотим найти его $n$-мерный объем, причем для каждой точки несложно проверить $x in Phi$ или $x in.not Phi$.
Запихиваем $Phi$ в параллелепипед $[a, b]^d$. Кидаем в его случайную точку, и проверяем, лежит ли она в $Phi$. $xi_k$ --- попали ли мы в $Phi$ или нет. Тогда $S_n/n$ сходится к вероятности успеха попасть в $Phi$, а значит $(lambda_d Phi) / (lambda_d [a, b]^d)$.
]
|
|
https://github.com/agarmu/typst-templates | https://raw.githubusercontent.com/agarmu/typst-templates/main/homework/template.typ | typst | MIT License |
#let problem_counter = counter("problem")
#let prob(question: none, body) = {
// let current_problem = problem_counter.step()
problem_counter.step()
pagebreak(weak: true)
[= Problem #problem_counter.display()]
if question != none {
v(0.25em)
[
#question
#line(length: 100%, stroke: 0.5pt)#v(0.5em)
] } else { v(0.75em) }
[#body]
}
// Initiate the document title, author...
#let assignment_class(title, author, course_id, professor_name, semester, due_time, collaborators, body) = {
set math.mat(delim: "[")
set math.vec(delim: "[")
set document(title: title, author: author)
show par: set block(above: 1em, below: 1em)
show heading: set block(above: 1.4em, below: 1em)
set par(justify: true)
set page(
paper:"us-letter",
header: locate(
loc => if (
counter(page).at(loc).first()==1) { none }
else {
let ptot = problem_counter.final(loc).last()
align(right,
[*#author* | *#course_id: #title* | *Problem
#problem_counter.display() of #ptot*]
)
}
),
footer: locate(loc => {
let page_number = counter(page).at(loc).first()
let total_pages = counter(page).final(loc).last()
align(center)[Page #page_number of #total_pages]
}))
v(0.5fr)
align(center, text(17pt)[
*#course_id: #title*])
align(center, text(10pt)[
Due on #due_time])
align(center, [_Prof. #professor_name _, #semester])
v(3fr)
align(center)[*#author*]
v(1fr)
body
}
|
https://github.com/KiranWells/hackable-typst-resume | https://raw.githubusercontent.com/KiranWells/hackable-typst-resume/main/template.typ | typst | #import "resume.typ": resume, experience, chip, linked_block, skills
#show: doc => resume(
name: "<NAME>",
contacts: (
email: "<EMAIL>",
linkedin: "john-smith-fake",
github: "JohnSmith",
website: "<EMAIL>",
),
// These are embedded into the document metadata
keywords: ("pdf", "typesetting", "typist"),
header_gradient: (
..color.map.flare,
),
paper: "us-letter",
// These should be changed to a better display font that is installed on your computer.
// If you aren't sure what is available, try using the Typst language server with
// `#text(font: "type here")` to get auto-complete for available fonts
header_font: "Liberation Serif",
body_font: "DejaVu Sans",
// This changes the default spacing between blocks
// Using em as the unit should improve scaling
spacing: 1em,
doc
)
#align(center)[
_Professional PDF maker with 20+ years of experience and a passion for clean typesetting_
]
#v(0.75em)
#grid(columns: (auto, auto), column-gutter: 1fr, row-gutter: 0.9em,
skills(label: [Programs], ("Acrobat", "Typst"),("Other",)),
skills(label: [Soft Skills], ("Time Management", "Communication"), ("Work Ethic", "Attention to Detail")),
)
= Experience
#experience(
name: "ACME Corp",
highlight: "PDF Maker",
"Remote",
"2001-2020",
)[
=== 2001-2007
- Create professional PDFs for clients in various industries, including legal, financial, and marketing
- Collaborate with clients to ensure the final product meets their specifications and requirements
=== 2007-2020
- Utilize various tools and software to optimize PDFs for print and digital distribution
- Maintain a high level of accuracy and attention to detail throughout the process
]
= Portfolio
#block(inset: (left: 2em))[
_The source code for each of these projects is available on my GitHub page at #link("https://github.com/JohnSmith")[github.com/JohnSmith]_
#v(0.5em)
#columns(2)[
#linked_block(name: "Professional Business Plan", github: "JohnSmith/bus-plan", tech: ("Microsoft Word", "HTML"))[
A comprehensive business plan for a new startup in the technology industry.
The plan includes an executive summary, market analysis, financial projections,
and a detailed marketing strategy.
]
#colbreak()
#linked_block(name: "Interactive Resume", address: "https://example.com", tech: ("CSS", "JavaScript"))[
An interactive resume that showcases the skills and experience of a professional in the marketing industry. The resume includes interactive elements such as a skill bar, portfolio links, and a contact form.
]
]
]
= Education
Efficient GPU Implementation of Stable Position-Based Dynamics for Rigid Bodies
#experience(
name: "XYZ University",
highlight: "3.6 GPA",
[Bachelor of Science in Computer Science, #chip()[Honors], Minors: Typesetting],
"May 2000",
)[
#block(inset: (left:2em), skills((), ("The Impact of Social Media on Mental Health in College Students: A Qualitative Study",), label: "Thesis"))
#block(inset: (left:2em), skills(label: "Relevant Coursework", ("PDF Basics",), ("How to use Word",)))
]
= Certifications
#block(inset: (left: 2em))[
#linked_block(
name: [*GFACT* - GIAC Foundational Cybersecurity Technologies],
address: "https://example.com/badges/badge-id",
image_file: "images/gfact.png",
)[
_Global Information Assurance Certification (GIAC)_
The GFACT certification tests knowledge of foundational
cybersecurity concepts and practical skills in computers,
technology, and security fundamentals.
]
]
= Volunteer Experience
#experience(
name: "<NAME>",
highlight: "Event Manager",
"XYZ Organization",
"April 2021",
)[
As a volunteer coordinator at XYZ organization, I was responsible for organizing and managing volunteer events for the organization. This included recruiting volunteers, scheduling events, and providing support during events.
]
|
|
https://github.com/DawnEver/mcm-icm-typst-template | https://raw.githubusercontent.com/DawnEver/mcm-icm-typst-template/main/main.typ | typst | MIT License | #import "template.typ": project
#import "appendices.typ" : appendices
#show: appendices.with()
#show: project.with(
title: "Enjoy a Cozy and Green Bath",
abstract: [
A traditional bathtub cannot be reheated by itself, so users have to add hot water from time to time. Our goal is to establish a model of the temperature of bath water in space and time. Then we are expected to propose an optimal strategy for users to keep the temperature even and close to initial temperature and decrease water consumption.
To simplify modeling process, we firstly assume there is no person in the bathtub. We regard the whole bathtub as a thermodynamic system and introduce heat transfer formulas.
We establish two sub-models: adding water constantly and discontinuously. As for the former sub-model, we define the mean temperature of bath water. Introducing Newton cooling formula, we determine the heat transfer capacity. After deriving the value of parameters, we deduce formulas to derive results and simulate the change of temperature field via CFD. As for the second sub-model, we define an iteration consisting of two process: heating and standby. According to energy conservation law, we obtain the relationship of time and total heat dissipating capacity. Then we determine the mass flow and the time of adding hot water. We also use CFD to simulate the temperature field in second sub-model.
In consideration of evaporation, we correct the results of sub-models referring to some scientists' studies. We define two evaluation criteria and compare the two sub-models. Adding water constantly is found to keep the temperature of bath water even and avoid wasting too much water, so it is recommended by us.
Then we determine the influence of some factors: radiation heat transfer, the shape and volume of the tub, the shape/volume/temperature/motions of the person, the bubbles made from bubble bath additives. We focus on the influence of those factors to heat transfer and then conduct sensitivity analysis. The results indicate smaller bathtub with less surface area, lighter personal mass, less motions and more bubbles will decrease heat transfer and save water.
Based on our model analysis and conclusions, we propose the optimal strategy for the user in a bathtub and explain the reason of uneven temperature throughout the bathtub. In addition, we make improvement for applying our model in real life.
],
keywords: ("Heat transfer", "Thermodynamic system", "CFD", "Energy conservation"),
team-number: "00000",
problem-chosen: "A",
year: "2024",
bibliography-file: "refs.bib",
)
= Introduction
== Background
Bathing in a tub is a perfect choice for those who have been worn out after a long day's working. A traditional bathtub is a simply water containment vessel without a secondary heating system or circulating jets. Thus the temperature of water in bathtub declines noticeably as time goes by, which will influent the experience of bathing. As a result, the bathing person needs to add a constant trickle of hot water from a faucet to reheat the bathing water. This way of bathing will result in waste of water because when the capacity of the bathtub is reached, excess water overflows the tub.
An optimal bathing strategy is required for the person in a bathtub to get comfortable bathing experience while reducing the waste of water.
== Literature Review
Korean physicist <NAME> analyzed heat loss through free surface of water contained in bathtub due to conduction and evaporation #cite(<example0>). He derived a relational equation based on the basic theory of heat transfer to evaluate the performance of bath tubes. The major heat loss was found to be due to evaporation. Moreover, he found out that the speed of heat loss depends more on the humidity of the bathroom than the temperature of water contained in the bathtub. So, it is best to maintain the temperature of bathtub water to be between 41 to 45 $attach(C,tl:circle)$ and the humidity of bathroom to be 95%.
When it comes to convective heat transfer in bathtub, many studies can be referred to. Newton's law of cooling states that the rate of heat loss of a body is proportional to the difference in temperatures between the body and its surroundings while under the effects of a breeze #cite(<example1>). <NAME> and <NAME> described the motion of viscous fluid substances with the Navier-Stokes equations. Those equations may be used to model the weather, ocean currents, water flow in a pipe and air flow around a wing #cite(<example2>).
In addition, some numerical simulation software are applied in solving and analyzing problems that involve fluid flows. For example, Computational Fluid Dynamics (CFD) is a common one used to perform the calculations required to simulate the interaction of liquids and gases with surfaces defined by boundary conditions #cite(<example3>).
== Restatement of the Problem
We are required to establish a model to determine the change of water temperature in space and time. Then we are expected to propose the best strategy for the person in the bathtub to keep the water temperature close to initial temperature and even throughout the tub. Reduction of waste of water is also needed. In addition, we have to consider the impact of different conditions on our model, such as different shapes and volumes of the bathtub, etc.
In order to solve those problems, we will proceed as follows:
- *Stating assumptions*. By stating our assumptions, we will narrow the focus of our approach towards the problems and provide some insight into bathtub water temperature issues.
- *Making notations*. We will give some notations which are important for us to clarify our models.
- *Presenting our model*. In order to investigate the problem deeper, we divide our model into two sub-models. One is a steady convection heat transfer sub-model in which hot water is added constantly. The other one is an unsteady convection heat transfer sub-model where hot water is added discontinuously.
- *Defining evaluation criteria and comparing sub-models*. We define two main criteria to evaluate our model: the mean temperature of bath water and the amount of inflow water.
- *Analysis of influencing factors*. In term of the impact of different factors on our model, we take those into consideration: the shape and volume of the tub, the shape/volume/temperature of the person in the bathtub, the motions made by the person in the bathtub and adding a bubble bath additive initially.
- *Model testing and sensitivity analysis*. With the criteria defined before, we evaluate the reliability of our model and do the sensitivity analysis.
- *Further discussion*. We discuss about different ways to arrange inflow faucets. Then we improve our model to apply them in reality.
- *Evaluating the model*. We discuss about the strengths and weaknesses of our model:
1. ...
2. ...
3. ...
4. ...
= Assumptions and Justification
To simplify the problem and make it convenient for us to simulate real-life conditions, we make the following basic assumptions, each of which is properly justified.
- *The bath water is incompressible Non-Newtonian fluid*. The incompressible Non-Newtonian fluid is the basis of Navier–Stokes equations which are introduced to simulate the flow of bath water.
- *All the physical properties of bath water, bathtub and air are assumed to be stable*. The change of those properties like specific heat, thermal conductivity and density is rather small according to some studies #cite(<example4>). It is complicated and unnecessary to consider these little change so we ignore them.
- *There is no internal heat source in the system consisting of bathtub, hot water and air*. Before the person lies in the bathtub, no internal heat source exist except the system components. The circumstance where the person is in the bathtub will be investigated in our later discussion.
- *We ignore radiative thermal exchange*. According to Stefan-Boltzmann’s law, the radiative thermal exchange can be ignored when the temperature is low. Refer to industrial standard #cite(<example4>), the temperature in bathroom is lower than 100 $attach(C,tl:circle)$, so it is reasonable for us to make this assumption.
- *The temperature of the adding hot water from the faucet is stable*. This hypothesis can be easily achieved in reality and will simplify our process of solving the problem.
= Notations
// \begin{center}
// \begin{tabular}{clc}
// {\bf Symbols} & {\bf Description} & \quad {\bf Unit} \\[0.25cm]
// $h$ & Convection heat transfer coefficient & \quad W/(m$^2 \cdot$ K)
// \\[0.2cm]
// $k$ & Thermal conductivity & \quad W/(m $\cdot$ K) \\[0.2cm]
// $c_p$ & Specific heat & \quad J/(kg $\cdot$ K) \\[0.2cm]
// $\rho$ & Density & \quad kg/m$^2$ \\[0.2cm]
// $\delta$ & Thickness & \quad m \\[0.2cm]
// $t$ & Temperature & \quad $attach(C,tl:circle)$, K \\[0.2cm]
// $\tau$ & Time & \quad s, min, h \\[0.2cm]
// $q_m$ & Mass flow & \quad kg/s \\[0.2cm]
// $\Phi$ & Heat transfer power & \quad W \\[0.2cm]
// $T$ & A period of time & \quad s, min, h \\[0.2cm]
// $V$ & Volume & \quad m$^3$, L \\[0.2cm]
// $M,\,m$ & Mass & \quad kg \\[0.2cm]
// $A$ & Aera & \quad m$^2$ \\[0.2cm]
// $a,\,b,\,c$ & The size of a bathtub & \quad m$^3$
// \end{tabular}
// \end{center}
#figure(
table(
columns: (2fr, 5fr, 2fr),
inset: 3pt,
stroke:none,
align: (center,left,center),
[*Symbol*], [*Description*], [*Unit*],
[$h$],[Convection heat transfer coefficient],[$W"/"(m^2 dot K )$],
[$k$],[Thermal conductivity],[$W"/"(m dot K )$],
[$M,m$],[Mass],[$"kg"$],
),
caption: none,
)<tab1>\
where we define the main parameters while specific value of those parameters will be given later.
= Model Overview
In our basic model, we aim at three goals: keeping the temperature as even as possible, making it close to the initial temperature and decreasing the water consumption.
We start with the simple sub-model where hot water is added constantly.
At first we introduce convection heat transfer control equations in rectangular coordinate system. Then we define the mean temperature of bath water.
Afterwards, we introduce Newton cooling formula to determine heat transfer
capacity. After deriving the value of parameters, we get calculating results via formula deduction and simulating results via CFD.
Secondly, we present the complicated sub-model in which hot water is
added discontinuously. We define an iteration consisting of two process:
heating and standby. As for heating process, we derive control equations and boundary conditions. As for standby process, considering energy conservation law, we deduce the relationship of total heat dissipating capacity and time.
Then we determine the time and amount of added hot water. After deriving the value of parameters, we get calculating results via formula deduction and simulating results via CFD.
At last, we define two criteria to evaluate those two ways of adding hot water. Then we propose optimal strategy for the user in a bathtub.
The whole modeling process can be shown as follows@fig1.
#figure(
image("./img/fig1.jpg",width: 60%),
caption: [Modeling process],
)<fig1>
Citation example of Fig.@a,@b.
#grid(
columns: (auto, auto),
rows: (auto, auto),
gutter: 1pt,
[ #figure(
image("./img/image.png"),
caption: [1biudwi8d10do12h-1dj],
)<a> ],
[ #figure(
image("./img/image.png"),
caption: [1biudwi8d10do12h-1dj],
)<b> ],
[ #figure(
image("./img/image.png"),
caption: [1biudwi8d10do12h-1dj],
)<c> ],
[ #figure(
image("./img/image.png"),
caption: [1biudwi8d10do12h-1dj],
)<d> ],
)\
= Sub-model I : Adding Water Continuously
We first establish the sub-model based on the condition that a person add water continuously to reheat the bathing water. Then we use Computational Fluid Dynamics (CFD) to simulate the change of water temperature in the bathtub. At last, we evaluate the model with the criteria which have been defined before.
== Model Establishment
Since we try to keep the temperature of the hot water in bathtub to be even, we have to derive the amount of inflow water and the energy dissipated by the hot water into the air.
We derive the basic convection heat transfer control equations based on the former scientists’ achievement. Then, we define the mean temperature of bath water. Afterwards, we determine two types of heat transfer: the boundary heat transfer and the evaporation heat transfer. Combining thermodynamic formulas, we derive calculating results. Via Fluent software, we get simulation results.
=== Control Equations and Boundary Conditions
According to thermodynamics knowledge, we recall on basic convection
heat transfer control equations in rectangular coordinate system. Those
equations show the relationship of the temperature of the bathtub water in space.
We assume the hot water in the bathtub as a cube. Then we put it into a
rectangular coordinate system. The length, width, and height of it is $a, b$ and $c$.
#figure(
image("./img/fig2.jpg",width: 60%),
caption: [Modeling process],
)<fig2>
In the basis of this, we introduce the following equations \cite{5}:
- *Continuity equation:*
$
rho c_p ( u (diff t)/ (diff x) + u (diff t)/ (diff y) + u (diff t)/ (diff z)) =
lambda ( (diff^2 t)/ (diff x^2) + (diff^2 t)/ (diff y^2) + (diff^2 t)/ (diff z^2))
$<eq1>
where the first component is the change of fluid mass along the $X$-ray. The second component is the change of fluid mass along the $Y$-ray. And the third component is the change of fluid mass along the $Z$-ray. The sum of the change in mass along those three directions is zero.
- *Moment differential equation (N-S equations):*
$
rho c_p ( u (diff t)/ (diff x) + u (diff t)/ (diff y) + u (diff t)/ (diff z)) =
lambda ( (diff^2 t)/ (diff x^2) + (diff^2 t)/ (diff y^2) + (diff^2 t)/ (diff z^2))
$<eq2>
- *Energy differential equation*
$
rho c_p ( u (diff t)/ (diff x) + u (diff t)/ (diff y) + u (diff t)/ (diff z)) =
lambda ( (diff^2 t)/ (diff x^2) + (diff^2 t)/ (diff y^2) + (diff^2 t)/ (diff z^2))
$<eq3>
where the left three components are convection terms while the right three components are conduction terms.
By Equation @eq3, we have ......
......
On the right surface in Fig.@fig2, the water also transfers heat firstly with bathtub inner surfaces and then the heat comes into air. The boundary condition here is ......
=== Definition of the Mean Temperature
......
=== Determination of Heat Transfer Capacity
......
= Sub-model II: Adding Water Discontinuously
In order to establish the unsteady sub-model, we recall on the working principle of air conditioners. The heating performance of air conditions consist of two processes: heating and standby. After the user set a temperature, the air conditioner will begin to heat until the expected temperature is reached. Then it will go standby. When the temperature get below the expected temperature, the air conditioner begin to work again. As it works in this circle, the temperature remains the expected one.
Inspired by this, we divide the bathtub working into two processes: adding
hot water until the expected temperature is reached, then keeping this
condition for a while unless the temperature is lower than a specific value. Iterating this circle ceaselessly will ensure the temperature kept relatively stable.
== Heating Model
=== Control Equations and Boundary Conditions
=== Determination of Inflow Time and Amount
== Standby Model
== Results
We first give the value of parameters based on others’ studies. Then we get the calculation results and simulating results via those data.
=== Determination of Parameters
After establishing the model, we have to determine the value of some
important parameters.
As scholar <NAME> points out, the optimal temperature for bath is
between 41 and 45$attach(C,tl:circle)$ #cite(<example1>). Meanwhile, according to Shimodozono's study, 41$attach(C,tl:circle)$ warm water bath is the perfect choice for individual health [2]. So it is reasonable for us to focus on 41$attach(C,tl:circle)$ 45 $attach(C,tl:circle)$. Because adding hot water continuously is a steady process, so the mean temperature of bath water is supposed to be constant. We value the temperature of inflow and outflow water with the maximum and minimum temperature respectively.
The values of all parameters needed are shown as follows:
.....
=== Calculating Results
Putting the above value of parameters into the equations we derived before, we can get the some data as follows:
#figure(
table(
columns: (auto, auto, auto),
inset: 3pt,
align: horizon,
[*Parameter*], [*Value*], [*Unit*],
[$A_1$],[1.05],[$m^2$],
[$A_2$],[2.24],[$m^2$],
[$Phi_1$],[189.00],[$W$],
[$Phi_2$],[43.47],[$W$],
[$Phi$],[232.47],[$W$],
[$q_m$],[0.014],[$"g/s"$],
),
caption: [The calculating results],
)<tab2>\
From Table @tab2, ......
......
= Correction and Contrast of Sub-Models
After establishing two basic sub-models, we have to correct them in consideration of evaporation heat transfer. Then we define two evaluation criteria to compare the two sub-models in order to determine the optimal bath strategy.
== Correction with Evaporation Heat Transfer
Someone may confuse about the above results: why the mass flow in the first sub-model is so small? Why the standby time is so long? Actually, the above two sub-models are based on ideal conditions without consideration of the change of boundary conditions, the motions made by the person in bathtub and the evaporation of bath water, etc. The influence of personal motions will be discussed later. Here we introducing the evaporation of bath water to correct sub-models.
== Contrast of Two Sub-Models
Firstly we define two evaluation criteria. Then we contrast the two submodels via these two criteria. Thus we can derive the best strategy for the person in the bathtub to adopt.
= Model Analysis and Sensitivity Analysis
== The Influence of Different Bathtubs
Definitely, the difference in shape and volume of the tub affects the
convection heat transfer. Examining the relationship between them can help
people choose optimal bathtubs.
=== Different Volumes of Bathtubs
In reality, a cup of water will be cooled down rapidly. However, it takes quite long time for a bucket of water to become cool. That is because their volume is different and the specific heat of water is very large. So that the decrease of temperature is not obvious if the volume of water is huge. That also explains why it takes 45 min for 320 L water to be cooled by 1$attach(C,tl:circle)$.
In order to examine the influence of volume, we analyze our sub-models
by conducting sensitivity Analysis to them.
= Strength and Weakness
== Strength
- We analyze the problem based on thermodynamic formulas and laws, so that the model we established is of great validity.
- Our model is fairly robust due to our careful corrections in consideration of real-life situations and detailed sensitivity analysis.
- Via Fluent software, we simulate the time field of different areas throughout the bathtub. The outcome is vivid for us to understand the changing process.
- We come up with various criteria to compare different situations, like water consumption and the time of adding hot water. Hence an overall comparison can be made according to these criteria.
- Besides common factors, we still consider other factors, such as evaporation and radiation heat transfer. The evaporation turns out to be the main reason of heat loss, which corresponds with other scientist’s experimental outcome.
== Weakness
- Having knowing the range of some parameters from others’ essays, we choose a value from them to apply in our model. Those values may not be reasonable in reality.
- Although we investigate a lot in the influence of personal motions, they are so complicated that need to be studied further.
- Limited to time, we do not conduct sensitivity analysis for the influence of personal surface area.
= Further Discussion
In this part, we will focus on different distribution of inflow faucets. Then we discuss about the real-life application of our model.
== Different Distribution of Inflow Faucets
In our before discussion, we assume there being just one entrance of inflow.
From the simulating outcome, we find the temperature of bath water is hardly even. So we come up with the idea of adding more entrances.
The simulation turns out to be as follows:
#figure(
image("./img/fig24.jpg",width: 60%),
caption: [The simulation results of different ways of arranging entrances],
)<fig24>
From the above figure, the more the entrances are, the evener the temperature will be. Recalling on the before simulation outcome, when there is only one entrance for inflow, the temperature of corners is quietly lower than the middle area.
In conclusion, if we design more entrances, it will be easier to realize the goal to keep temperature even throughout the bathtub.
== Model Application
Before discussion is based on ideal assumptions. In reality, we have to make some corrections and improvement.
1. Adding hot water continually with the mass flow of 0.16 kg/s. This way can ensure even mean temperature throughout the bathtub and waste less water.
2. The manufacturers can design an intelligent control system to monitor the temperature so that users can get more enjoyable bath experience.
3. We recommend users to add bubble additives to slow down the water being cooler and help cleanse. The additives with lower thermal conductivity are optimal.
4. The study method of our establishing model can be applied in other area relative to convection heat transfer, such as air conditioners.
|
https://github.com/schang412/typst-whalogen | https://raw.githubusercontent.com/schang412/typst-whalogen/master/manual.typ | typst | Apache License 2.0 | #import "@local/whalogen:0.2.0": ce
#let pkg_name = "whalogen"
#let pkg_version = "v0.2.0"
#let author = (
name: "<NAME>",
email: "<EMAIL>",
)
#set document(author: author.name, title: pkg_name + " " + pkg_version)
#set page(numbering: "1", number-align: center)
#show raw.where(block: true): rect.with(
fill: luma(240),
width: 100%,
inset: 3pt,
radius: 2pt,
)
#let display_wide(..content) = {
rect(
width: 100%,
fill: luma(240),
inset: 1em,
radius: 2pt,
rect(
width: 100%,
fill: luma(255),
radius: 2pt,
stroke: (
right: 2pt + luma(230),
bottom: 2pt + luma(230),
),
..content
)
)
}
#let display(res, s) = {
grid(columns: (1fr, 2fr),
res,
eval("[```typ\n" + s + "\n```]")
)
}
// Title page.
#v(10.2fr)
#text(1.1em, datetime.today().display())
#text(2em, weight: 700, pkg_name + " " + pkg_version)\
#v(0.3em)
*#author.name* \
#author.email
#v(2.4fr)
#pagebreak()
#outline()
#pagebreak()
= Quick Start Guide
```typst
#import "@preview/whalogen:0.2.0": ce
This is the formula for water: #ce("H2O")
This is a chemical reaction:
#ce("CO2 + C -> 2CO")
It can be placed inside an equation: $#ce("CO2 + C -> 2CO")$
It can be placed on its own line:
$
#ce("CO2 + C -> 2CO")
$
```
#display_wide[
This is the formula for water: #ce("H2O")
This is a chemical reaction:
#ce("CO2 + C -> 2CO")
It can be placed inside an equation: $#ce("CO2 + C -> 2CO")$
It can be placed on its own line:
$
#ce("CO2 + C -> 2CO")
$
]
#pagebreak()
= Introduction
This package is designed to facillitate the typesetting of chemical formulas in Typst. It mainly aims to
replicate the functionality and operation of LaTeX's `mhchem` package. However, there are naturally some differences in the implementation of some features.
All of the features of this package are designed to function in both text and math mode.
#show heading: it => {
v(1em)
it
v(0.4em)
}
= Chemical Equations
#display(ce("CO2 + C -> 2CO"), "#ce(\"CO2 + C -> 2CO\")")
= Chemical Formulae
#display(ce("H2O"), "#ce(\"H2O\")")
#display(ce("Sb2O3"), "#ce(\"Sb2O3\")")
= Charges
#display(ce("H+"), "#ce(\"H+\")")
#display(ce("CrO4^2-"), "#ce(\"CrO4^2-\")")
#display(ce("[AgCl2]-"), "#ce(\"[AgCl2]-\")")
#display(ce("Y^99+"), "#ce(\"Y^99+\")")
The en-dash (#sym.dash.en) will be used for minus.
= Oxidation States
#display(ce("Fe^II Fe^III_2O4"), "#ce(\"Fe^II Fe^III_2O4\")")
A caret (^) will imply that subsequent characters should be in the superscript unless interrupted by certain characters (i.e. whitespace and underscore).
= Unpaired Electrons and Radical Dots
#display(ce("OCO^.-"), "#ce(\"OCO^.-\")")
#display(ce("NO^2.-"), "#ce(\"NO^2.-\")")
#pagebreak()
= Stoichiometric Numbers
#display(ce("2H2O"), "#ce(\"2H2O\")")
#display(ce("2 H2O"), "#ce(\"2 H2O\")")
#display(ce("0.5H2O"), "#ce(\"0.5H2O\")")
#display(ce("1/2H2O"), "#ce(\"1/2H2O\")")
The behavior of the fraction line is inherited from Typst's default behavior and generally obeys the rules
for grouping numbers and automatically removing parenthesis.
When whitespace is inserted between the stoichiometric number and a compound with a subscript, the whitespace is automatically trimmed. If there is no subscript, the whitespace is not trimmed. This is a characteristic of Typst.
#display(ce("2 CO"), "#ce(\"2 CO\")")
= Nuclides, Isotopes
#display(ce("@Th,227,90@^+"), "#ce(\"@Th,227,90@^+\")")
#display(ce("@n,0,-1@^-"), "#ce(\"@n,0,-1@^-\")")
#display(ce("@Tc,99m,@"), "#ce(\"@Tc,99m,@\")")
To simplify implementation of the parser, this string pattern is introduced to specify nuclides and isotopes.
This is different from `mhchem`.
= Parenthesis, Brackets, Braces
#display(ce("(NH4)2S"), "#ce(\"(NH4)2S\")")
The parenthesis, brackets, and braces will automatically size to match the inner content.
#display(ce("[{(X2)3}2]^3+"), "#ce(\"[{(X2)3}2]^3+\")")
#pagebreak()
= Reaction Arrows
#display(ce("A -> B"), "#ce(\"A -> B\")")
#display(ce("A <- B"), "#ce(\"A <- B\")")
#display(ce("A <-> B"), "#ce(\"A <-> B\")")
#display(ce("A <--> B"), "#ce(\"A <--> B\")")
#display(ce("A <=> B"), "#ce(\"A <=> B\")")
These reaction arrows come from the built-in `sym` module.
It is also possible to include text above the arrow. The backend uses the `xarrow` package to resize the arrows and place respective text.
#display(ce("A ->[H2O] B"), "#ce(\"A ->[H2O] B\")")
#display(ce("A ->[some text] B"), "#ce(\"A ->[some text] B\")")
#display(ce("A ->[some text][other text] B"), "#ce(\"A ->[some text][other text] B\")")
= States of Aggregation
#display(ce("H2(aq)"), "#ce(\"H2(aq)\")")
#display(ce("NaOH(aq, #sym.infinity)"), "#ce(\"NaOH(aq, #sym.infinity)\")")
In Typst, when parenthesis and similar follow a subscript, it is also included in the subscript. This results in seemingly different behavior for very similar input as seen above. The #ce("H2") has an implied underscore whereas the #ce("NaOH") does not.
To achieve the opposite behavior as shown above, insert whitespace or underscore respectively.
#display(ce("H2 (aq)"), "#ce(\"H2 (aq)\")")
#display(ce("NaOH_(aq, #sym.infinity)"), "#ce(\"NaOH_(aq, #sym.infinity)\")")
#pagebreak()
= Further Examples
`ce` is a function that takes string input and returns a content block. As such, it can interact with the same rules as other content blocks in math mode.
```typ
Example to calculate $K_a$:
$
K_a = (#h(1.3em) [#ce("H+")] overbrace(#ce("[A-]"), "conjugate acid"))/ underbrace(#ce("[HA]"), "acid")
$
Using `ce` in limit text:
$
lim_#ce("[H+]->#sym.infinity") K_a = #sym.infinity
$
Aligning multiple equations:
$
#ce("H2SO4 (aq) &<-> H+ (aq) + HSO4^- (aq)")\
#ce("H+ (aq) + HSO4^- (aq) &<-> H2SO4 (aq)")
$
```
#display_wide[
Example to calculate $K_a$:
$
K_a = (#h(1.3em) [#ce("H+")] overbrace(#ce("[A-]"), "conjugate acid"))/ underbrace(#ce("[HA]"), "acid")
$
Using `ce` in limit text:
$
lim_#ce("[H+]->#sym.infinity") K_a = #sym.infinity
$
Aligning multiple equations:
$
#ce("H2SO4 (aq) &<-> H+ (aq) + HSO4^- (aq)")\
#ce("H+ (aq) + HSO4^- (aq) &<-> H2SO4 (aq)")
$
]
#pagebreak()
= Appendix
== Under the Hood
This package works by parsing the provided simple text input and converting it into Typst
equation input. In general, inserting whitespace will reset the parser's state machine.
If there is still some strange behavior, the underlying Typst output can be inspected
by setting the debug flag:
#display(ce("H2(aq)", debug: true), "#ce(\"H2(aq)\", debug: true)")
|
https://github.com/AU-Master-Thesis/thesis | https://raw.githubusercontent.com/AU-Master-Thesis/thesis/main/lib/text-case.typ | typst | MIT License | #let stringify(text) = {
let string = if type(text) == "string" {
text
} else if type(text) == "content" {
repr(text).slice(1, -1) // remove square brackets
} else {
panic("Invalid type for text. Valid types are 'string' | 'content'")
}
return string
}
#let tokenize(string) = {
stringify(string).trim().split(" ")
}
#let titlecase(string) = {
let tokens = tokenize(stringify(string))
tokens.map(
word => {
let chars = word.split("")
(upper(chars.at(1)), ..chars.slice(2, -1)).join("") // join into a word again
},
).join(" ") // join into a sentence again
}
#let camelcase(string) = {
let tokens = tokenize(stringify(string))
let first = tokens.first()
let rest = tokens.slice(2, -1)
.map(
word => {
let chars = word.split("")
(upper(chars.at(1)), ..chars.slice(2, -1)).join("") // join into a word again
},
).join("")
first + rest
}
#let pascalcase(string) = titlecase(string).replace(" ", "")
#let joinwith(string, separator: " ") = {
let tokens = tokenize(stringify(string))
tokens.map(lower).join(separator)
}
#let snakecase = joinwith.with(separator: "_")
#let kebabcase = joinwith.with(separator: "-")
#let dotcase = joinwith.with(separator: ".")
#let slashcase = joinwith.with(separator: "/")
#let screaming-snakecase(string) = upper(snakecase(string))
#let screaming-kebabcase(string) = upper(kebabcase(string))
|
https://github.com/The-Notebookinator/notebookinator | https://raw.githubusercontent.com/The-Notebookinator/notebookinator/main/themes/radial/radial.typ | typst | The Unlicense | #import "./rules.typ": rules
#import "./entries.typ": cover, frontmatter-entry, body-entry, appendix-entry
#import "./components/components.typ"
#import "./colors.typ"
#let radial-theme = (
// Global show and set rules
rules: rules,
cover: cover,
// Entry pages
frontmatter-entry: frontmatter-entry,
body-entry: body-entry,
appendix-entry: appendix-entry,
)
|
https://github.com/andreasKroepelin/lovelace | https://raw.githubusercontent.com/andreasKroepelin/lovelace/main/examples/roman.typ | typst | MIT License | #import "../lib.typ": *
#set page(width: auto, height: auto, margin: 1em)
#set text(font: "Cinzel")
#pseudocode-list(line-numbering: "I:")[
+ explore European tribes
+ *while* not all tribes conquered
+ *for each* tribe *in* unconquered tribes
+ try to conquer tribe
+ *end*
+ *end*
]
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/scholarly-tauthesis/0.4.0/template/content/tiivistelmä.typ | typst | Apache License 2.0 | /** tiivistelmä.typ
*
* Fill in the Finnish abstract of your thesis in this file. The
* preamble is imported, in case you wish to use commands defined
* there.
*
***/
#import "../preamble.typ": *
Tiivistelmä on suppea, yhden sivun mittainen itsenäinen esitys työstä: mikä oli
ongelma, mitä tehtiin ja mitä saatiin tulokseksi. Kuvia, kaavioita ja
taulukoita ei käytetä tiivistelmässä. Laita työn pääkielellä kirjoitettu
tiivistelmä ensin ja käännös sen jälkeen. Suomenkieliselle kandidaatintyölle
pitää olla myös englanninkielinen nimi arkistointia varten.
|
https://github.com/loreanvictor/master-thesis | https://raw.githubusercontent.com/loreanvictor/master-thesis/main/common/titlepage.typ | typst | MIT License | #let titlepage(
title: "",
titleGerman: "",
degree: "",
program: "",
supervisor: "",
advisors: (),
author: "",
startDate: none,
submissionDate: none,
) = {
// set document(title: title, author: author)
set page(
margin: (left: 30mm, right: 30mm, top: 40mm, bottom: 40mm),
numbering: none,
number-align: center,
)
let body-font = "New Computer Modern"
let sans-font = "New Computer Modern Sans"
set text(
font: body-font,
size: 12pt,
lang: "en"
)
set par(leading: 1em)
// --- Title Page ---
v(1cm)
align(center, image("../figures/logo.png", width: 26%))
v(5mm)
align(center, text(font: sans-font, 2em, weight: 700, "Technical University of Munich"))
v(5mm)
align(center, text(font: sans-font, 1.5em, weight: 100, "School of Computation, Information and Technology \n -- Informatics --"))
v(15mm)
align(center, text(font: sans-font, 1.3em, weight: 100, degree + "’s Thesis in " + program))
v(8mm)
align(center, text(font: sans-font, 2em, weight: 700, title))
align(center, text(font: sans-font, 2em, weight: 500, titleGerman))
pad(
top: 3em,
right: 15%,
left: 15%,
grid(
columns: 2,
gutter: 1em,
strong("Author: "), author,
strong("Supervisor: "), supervisor,
// strong("Advisors: "), advisors.join(", "),
strong("Start Date: "), startDate,
strong("Submission Date: "), submissionDate,
)
)
pagebreak()
} |
https://github.com/protohaven/printed_materials | https://raw.githubusercontent.com/protohaven/printed_materials/main/class-handouts/class-welding_101-basic_welding_skills.typ | typst |
#import "/meta-environment/env-protohaven-class_handouts.typ": *
#import "./glossary/glossary_terms.typ": *
#show: doc => class_handout(
title: "Basic Welding Skills",
category: "Welding",
number: "101",
clearances: ("MIG Welder", "Plasma Cutter"),
instructors: ("Someone",),
authors: ("<NAME> <<EMAIL>>"),
draft: true,
doc
)
// Content goes here
= Welcome
Welcome to the Basic Welding Skills class at Protohaven!
#set heading(offset:1)
#include "/common-policy/shop_rules.typ"
#include "/common-policy/tool_status_tags.typ"
#include "/common-policy/filing_a_tool_report.typ"
#set heading(offset:0)
#pagebreak()
= Safety
// Important safety notes for this particular class
== PPE
Always wear proper protective gear when welding.
*Gloves*
*Jacket*
*Mask*
If you feel unsure of something, feel free to ask!
= Introduction
== Learning Objectives
- Clearance to use our MIG welder.
- The ability to safely operate the welder and weld different types of metals.
- Begin to understand how to adjust the machine to work best for the type of welding you are performing.
== Terminology
#stick_welding_term
= Tools
#set heading(offset:1)
// #include "/common-tools/TOOLNAME.typ"
#include "/common-tools/mig_welder.typ"
#set heading(offset:0)
= Resources
(add resources here)
// == Acknowledgments |
|
https://github.com/thehydrogen/typst-gh-action | https://raw.githubusercontent.com/thehydrogen/typst-gh-action/main/README.md | markdown | # typst-gh-action
Example for a GitHub workflow to automatically build your [Typst](https://github.com/typst/typst) files.
Fetches the latest stable version from GitHub releases automatically!
|
|
https://github.com/crd2333/crd2333.github.io | https://raw.githubusercontent.com/crd2333/crd2333.github.io/main/src/docs/Reading/跟李沐学AI（论文）/对比学习串讲.typ | typst | // ---
// order: 12
// ---
#import "/src/components/TypstTemplate/lib.typ": *
#show: project.with(
title: "d2l_paper",
lang: "zh",
)
= 对比学习串讲
#info(caption: "大致阶段划分")[
+ 百花齐放（18 年到 19 年中）：在这个阶段中，方法、模型、目标函数、代理任务都还没有统一
- InstDisc(instance discrimination)
- CPC
- CMC
+ CV 双雄（19 年到 20 年中）：这个阶段发展非常迅速，这些工作有的间隔一两个月，有的间隔甚至不到一个月，ImageNet 上的成绩基本上每个月都在被刷新
- MoCo v1
- SimCLR v1
- MoCo v2
- SimCLR v2
- CPC、CMC 的延伸工作
- SwAV
+ 不用负样本（20年）
- BYOL
- BYOL 后续的一些改进
- 最后 SimSiam 将所有的方法都归纳总结了一下，融入到它的框架中，基本上是用 CNN 做对比学习的一个总结性工作
+ Transformer（21年）：对于自监督学习，无论是对比学习还是最新的掩码学习，都是用 Vision Transformer 做的
- MoCo v3
- DINO
- 这里只是把最有联系的一些工作串到一起，比较他们的异同，不一定全面（主要是 CV 领域会多一些）
]
== 百花齐放
=== Unsupervised Feature Learning via Non-Parametric Instance Discrimination
- 时间：2018.5
- 取标题后两个词命名为 InstDisc，提出了个体判别任务以及memory bank
- 本文的方法受到有监督学习的启发，让某些待分类图片聚集在一起的原因并不是因为它们有相似的语义标签，而是因为这些照片就是在某一种特征上类似。作者根据这个观察提出了个体判别任务：一种无监督的学习方式，将按照类别走的有监督信号推到了极致，把每一个 instance 都看成是一个类别，目标是学一种特征把每一个图片都区分开来
- 模型总览图
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-04-12-03-49.png")
- 通过一个卷积神经网络把所有图片都编码成一个特征，使得在最后的特征空间里尽可能分开。
- 使用对比学习训练这个 CNN，对于个体判别这个任务，正样本就是这个图片本身（可能经过一些数据增强），负样本就是数据集里所有其它的图片。大量特征存在 memory bank 里，要求每个样本纬度不能太高(128)
- 前向过程
- 假如 batch size 是 $256$（$256$ 个正样本），通过一个 Res-50，得到特征维度是 $2048$ 维，把它降维降到 $128$ 维，即为每个图片的特征大小
- 从 memory bank 里随机抽取 $4096$ 个图片作为负样本。有了正负样本，就可以用 NCE loss 计算对比学习的目标函数
- 一旦更新完这个网络，就把 mini batch 里的数据样本所对应的 memory bank 中的特征进行更新。
- 最后不断重复上述过程，使学到的特征尽可能有区分性
- 这篇论文还有一些细节设计得很巧妙，比如 proximal regularization 给模型训练加了一个约束，从而能 memory bank 里的特征进行动量式的更新。超参数的设置，也被后来的 MoCo 严格遵守，可见 Inst Disc 是一个里程碑式的工作
=== Unsupervised Embedding Learning via Invariant and Spreading Instance Feature
- 时间：2019.4
- 本篇论文影响力相对不大，之所以提一下这篇论文，是因为它可以被理解成是 SimCLR 的一个前身。它没有使用额外的数据结构去存储大量的负样本，它负样本就是来自于同一个 minibatch，而且只用一个编码器进行端到端的学习
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-04-12-11-19.png")
- 前向过程
- 如果 batch size 是 $256$，也就是说一共有 $256$ 个图片，经过数据增强，又得到了 $256$ 张图。对某一张 $x_1$ 来说，$hat(x)_1$ 就是它的正样本；剩下 $(256-1)*2$ 就是负样本
- 这样负样本比 Inst Disc 少得多，但是可以只用一个 encoder 做端到端的训练
- 本文因为比较贫穷，没有 TPU，所以结果没那么炸裂，事实上它可以理解成 SimCLR 的前身
=== Representation Learning with Contrastive Predictive Coding(CPC)
- 时间：2018.7
- 一般机器学习分为*判别式*模型和*生成式*模型，前两篇论文的个体判别显然是属于判别式范畴的，而常见的预测型任务就属于生成式代理任务
- CPC 这篇论文比较厉害，是一个很通用的结构，可以处理音频、图片、文字以及用于强化学习，这里以音频为例
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-04-12-22-05.png")
- 一个序列输入 $x$，用 $t$ 表示当前时刻，$t-i$ 表示过去，$t+i$ 表示未来。把过去输入全都扔给一个 encoder，返回一些特征，把这些特征喂给一个自回归的模型($g_"ar"$, auto regressive, e.g. RNN, LSTM)，得到上下文特征($c_t$, context representation)。如果上下文特征表示足够好，那它应该可以做出一些合理的未来预测
- 对比学习在哪里体现的呢？正样本其实就是未来输入通过 encoder 以后得到的特征输出（参考答案）；负样本的定义很广泛，比如任意选取输入通过 encoder 得到的特征，都应该跟预测结果不相似
- 这套思想是很朴实且普适的，把输入序列换成一个句子，用前面的单词来预测后面的单词的特征输出；把这个序列换成一个图片从左上到右下的 patch，用上半部分的图片特征去预测后半部分的图片特征。总之非常灵活
=== Contrastive Multiview Coding(CMC)
- 时间：2019.6
- CMC 的摘要写的非常好：
- 人观察这个世界是通过很多个传感器（眼睛、耳朵给大脑提供信号），每一个视角都是带有噪声的且可能不完整的，但最重要的那些信息其实在所有的视角中间共享（基础的物理定律、几何形状、语音信息）
- 基于此提出：学一个非常强大的特征，具有视角的不变性（不管看哪个视角，到底是看到了一只狗，还是听到了狗叫声，都能判断出这是个狗）
- CMC 工作的目的就是去增大视角之间的互信息，如果能学到一种特征能够抓住所有视角下的关键的因素，那这个特征就很好了，至少解决分类问题不在话下
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-04-14-48-20.png")
- 具体方法：采用 NYU RGBD 这个数据集，对同一个图片有四种视角 —— 正常视角、深度图、表面法向、物体分割。同一图片的视角互为正样本，与其它图片的视角为负样本
- CMC 这篇论文是第一个或者比较早的用多视角去做对比学习的工作，证明了对比学习的灵活性，某种程度上启发了后来 CLIP 多模态的思想。CMC 的原班人马后来又做了一篇关于蒸馏的对比学习工作，teacher 和 student 的结果构成正样本对，属于是大开脑洞
- 另外就是一个局限性，多个视角如果是多模态的，那就可能需要多个 encoder，加大计算复杂度。但话又说回来，一些论文显示 Transformer 具备同时处理多模态信息的能力
== CV 双雄
- 双雄主要指的是 MoCo 和 SimCLR
=== Momentum Contrast for Unsupervised Visual Representation Learning
- 时间：2019.11
- MoCo-v1 见之前的文章（#link("https://crd2333.github.io/note/Reading/%E8%B7%9F%E6%9D%8E%E6%B2%90%E5%AD%A6AI%EF%BC%88%E8%AE%BA%E6%96%87%EF%BC%89/MoCo")[链接]），不再赘述
=== A Simple Framework for Contrastive Learning of Visual Representations
- 时间：2020.2
- SimCLR 概念上容易理解，方法上也容易解释，因此很多博客在介绍对比学习的时候都用 SimCLR 当例子，只不过 batch size 太大，一般人不好上手
- 方法
#grid(
columns: (65%, 35%),
[
- 如果有一个 minibatch 的图片，记为 $x$，做不同的数据增强得 $x_i$ 和 $x_j$，同一个图片延伸得到的两个图片就是正样本，不同图片得到就是负样本
- 正负样本通过同一个 encoder $f(dot)$ 编码，如果具体化为一个 Res-50，得到的特征表示 $h$ 就是 $2048$ 维
- 然后经过一个 projector MLP 层 $g(dot)$ 降维到 $128$ 维
- 这个 MLP 层在降维的同时转化语义到对比学习特征空间，效果出奇得好（在 ImageNet 上提了 $10$ 个点），在有监督里很难观测的现象
- 这个 projector 只在训练的时候用，做下游任务的时候不用
- 损失函数采用的是 normalized temperature-scaled 的 cross entropy loss。进行 L2 归一化，温度 $tau$ 则跟 infoNCE loss 一样
],
fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-00-22-26.png")
)
- 其实是非常简单直接的一个思路，主要不同点就四个：更多的数据增强、MLP 层、更大的 batch size、更久的训练时间
=== Improved Baselines with Momentum Contrastive Learning
- 时间：2020.3
- MoCo-v2 在 MoCo-v1 的基础上把 SimCLR 的即插即用的方法拿过来，加了 projection head 和更多的数据增强
- 又刷了一波榜，然后称赞了一下自己的工作不用太多卡也能跑起来
=== Big Self-Supervised Models are Strong Semi-Supervised Learners
- 时间：2020.6
- 其实 SimCLR-v2 只是这篇论文一个很小的部分，就是一个模型上的改进，而主要在讲如何去做半监督学习
- 这篇文章分了三个部分
+ 第一部分就是 SimCLR，怎样自监督或者说自监督的对比学习去训练一个大的模型出来
+ 第二部分是说，有了这么好的一个模型后，只需要一小部分有标签的数据就可以做有监督的微调，得到一个 teacher 模型，然后就可以用这个 teacher 模型去生成伪标签，在更多无标签数据上去做自监督学习
+ 第三部分没讲，跟对比学习关系不大
- 具体从 SimCLR-v1 到 SimCLR-v2 的改进
- 使用了更大的模型
- 更深的 projection head，两层就够了
- 引入了动量编码器，提升不算特别多（因为 batch-size 已经很大了）
=== 其它
- 不细展开
- CPC 的延伸工作
- CPC-v2 也是融合了很多的技巧，用了更大的模型、更大的图像块、更多的数据增强，把 batch norm 换成了 layer norm，做了更多方向上的预测任务，一系列操作下来，把 CPC-v1 在 ImageNet 上 $40$ 多的准确率一下拔到 $70$ 多
- CMC 的延伸工作
- informing 其实是 CMC 作者做的一个分析型的延伸性工作，它论文本身的名字叫 What Makes for Good Views for Contrastive Learning（我们到底选什么样的视角才能对对比学习最好？）
- 它主要是提出了一个 InfoMin 的原则，就是最小化互信息 minimi mutual information。乍一听觉得可能有点奇怪，之前大家做的都是两个视角之间的互信息达到最大，为什么作者这里就想让它达到最小呢？作者想表达的其实是适量，因为互信息过大可能也是一种浪费且可能泛化性不好
- 按照 InfoMin 的原则选择合适的数据增强，使用合适的对比学习视角，作者发现对于很多的方法都有提升，它们最后在 ImageNet 上也有 $73$，也是相当不错的
=== 总结
- 其实到了第二阶段很多细节都趋于统一了，比如说
+ 目标函数都是用 infoNCE 或者类似的目标函数去算
+ 模型最后也都归一到用一个 encoder 后面加一个 projection head
+ 都采用了更强的数据增强
+ 都想用这个动量编码器
+ 都尝试着训练的更久
+ 最后在 ImageNet 上的准确度也逐渐逼近于有监督的 baseline
== 不用负样本
=== Unsupervised Learning of Visual Features by Contrasting Cluster Assignment
- 时间：2020.6
- SwAV: #strong[Sw]ap, #strong[A]ssignment, #strong[V]iews
- Views 是什么意思呢？其实跟之前的 CMC 差不多。给定同样一张图片生成不同的 views，希望可以用一个视角得到的特征去预测另外一个视角得到的特征
- 具体做法上，是把对比学习和之前的聚类方法合在了一起
- 当然这么想也不是偶然，因为聚类方法也是一种无监督的特征表示学习方式，跟对比学习的目标和做法都比较接近；另外，这篇文章的一作之前一直也是做聚类的
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-10-45-12.png", width: 90%)
- 左图就是之前的对比学习方法，例如 MoCo 取了 $6$ 万个负样本（还只是部分近似），每个图片都要跟大量负样本比。SwAV 就想，能不能借助一些先验信息去跟更简洁的东西比，也就是跟聚类中心比（语义含义更明确）
- 右图的 $C in RR^(K times D)$ 就是聚类中心，$K$ 为聚类数目，$D$ 为特征维度。如果 $x_1, x_2$ 是正样本的话，那 $z_1$ 和 $z_2$ 的特征就应该很相似，跟聚类中心算相似度应该很高，二者互为 ground truth 进行预测
- 另外一个性能提升点来自于一个叫 multi crop 的 trick，也被后来很多工作所借鉴
- 之前的工作是在 $256^2$ 的图片里 crop 出 $224^2$ 的图片，这么大的 crop 重叠区域也很多所以应该代表一个正样本。这样做明显抓住的是整个场景的特征，如果想学习局部物体的特征，最好能多做一些小的 crop
- 但出于计算复杂度考虑，采样二者折中的办法，比如 $2 * 160^2$ 的大 crop，再加上 $4 * 96^2$ 的小 crop，争取同时学习全局和局部的特征
- SwAV 的结果非常好，它不仅比我们之前讲过的方法效果好，其实比之后要讲的 BYOL、SimSiam 这些都好，算是卷积神经网络里用 Res-50 分刷的最高的一篇工作，达到了 $75.3%$
=== Bootstrap Your Own Latent, A New Approach to Self-Supervised Learning
- 时间：2020.6
- 标题
- Bootstrap：在一定基础上改造
- Latent / hidden / feature / embedding：都是指特征，不同叫法
- BYOL 的特点在于自己跟自己学，不用负样本，类似于左脚踩右脚上天
- 不用负样本新奇在何处？因为它相当于一个约束，否则如果没有负样本，模型只要对所有正样本的特征都输出零，即可让 loss 为零，这显然是一个 shortcut，也叫模型坍塌(model / learning collapse)
- 模型前向过程
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-14-17-16.png")
- 输入是一个 minibatch 的图片 $x$；经过两次数据增强得到 $v$ 和 $v'$；通过 encoder 得到特征，两个 encoder 使用同样的架构但参数不同，上侧的 $f_theta$ 参数正常更新，下侧的 $f_xi$ 为动量编码器（动量更新）；随后分别通过 projection head $g_theta$ 和 $g_xi$得到 $z$ 和 $z'$，同样是上面的参数正常更新，下面的参数动量更新
- BYOL 在上侧加了一个层 MLP 得到一个新的特征，让这个新的特征和下侧特征尽可能一致，把一个匹配问题变成了一个预测问题
- 和 SwAV 有点像，但后者借助了聚类中心去帮助做预测任务
- 目标函数：MSE(mean square error) loss，跟之前的方法都不一样
- BYOL 摈弃了负样本的成功训练非常令人震惊，作者自己给出的解释比较中规中矩，转战一篇复现 BYOL 的#link("https://imbue.com/research/2020-08-24-understanding-self-supervised-contrastive-learning/")[博客]。这篇博客复现了一下发现失败了，于是检查了细节，发现与 BatchNorm 有关
- SimCLR 里面的 projection head 用了两层 BN，MoCo-v2 里面没有用 BN，而 BYOL 里面用了 BN
- 博客借鉴了写得非常漂亮的 MoCo-v2 代码，MLP 中少了 BN，模型就坍塌了。于是做了实验，验证 BN 的影响
#tbl(
columns: 6,
[Name], [Projection MLP Norm], [Prediction MLP Norm], [Loss Function], [Contrastive], [Performances],
[Contrastive Loss], [None], [None], [Cross Entropy], [Explicit], [44.1],
[BYOL], [Batch Norm], [Batch Norm], [L2], [Implicit], [57.7],
[Projection BN Only], [Batch Norm], [None], [L2], [Implicit], [55.3],
[Prediction BN Only], [None], [Batch Norm], [L2], [Implicit], [48],
[No Normalization], [None], [None], [L2], [None], [28.3],
[Layer Norm], [Layer Norm], [Layer Norm], [L2], [None], [29.4],
[Random], [—], [—], [—], [None], [28.8]
)
- BN 是什么？就是把一个 batch 里所有样本的特征拿来算均值和方差，从而做归一化。这样在算某个样本 loss 的时候，其实也看到了其他样本的特征，有一定信息泄露。像 MoCo 中就做了一个 shuffle BN 以防止信息泄露。
- 于是博客作者认为，因为 BN 中有信息泄露，所以可以把 batch 里的其他样本想成隐式的负样本。换句话说，BYOL 其实并不仅是正样本在自己和自己学，它的实际对比任务是：当前正样本的图片，和 BN 产生的平均图片的差别（这和 SwAV 的不用负样本而是聚类中心去对比是相似的）
- 这时候 BYOL 作者就急了（因为这样他们的工作就没有那么开创了），于是做了一系列实验，把 SimCLR 也拉下水
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-14-47-46.png")
- 大部分结果显示，BN 确实比较关键，没有 BN 的 BYOL 确实就不学了，但 SimCLR 还在学
- 但有一组实验显示，即使 Projector 有 BN，BYOL 还是训练失败了，这就不能说明 BN 关键了（因为如果 BN 能提供隐式负样本的话，这里就不应该失败）
- 更进一步，当 encoder 和 Projector 都没有 BN 的时候，SimCLR 也失败了（SimCLR 是有显式负样本的，没有 Projector 理应不会坍缩而只是降点）
- 于是 BYOL 作者和博客作者达成一致：BN 跟它原来的设计初衷一样，主要的作用是帮助模型稳定训练，提高模型训练的稳健性，让模型不会坍塌。更进一步，BYOL 在回应论文的 3.3 中给出解释：如果一开始就能让模型初始化的比较好(+WS)，那么后面的训练即使离开了 BN 也没问题(+GN)
- Weight Standardization 和 Group Norm 分别是一种模型初始化方式和一种归一化的方式
=== Exploring Simple Siamese Representation Learning
- 时间：2020.11
- KaiMing 团队出手，SimSiam 对对比学习进行分析，化繁为简
+ 不用负样本，基本上和 BYOL 很相似
+ 不需要大的 batchsize
+ 不需要动量编码器
- 不仅不会模型坍塌，而且效果还很好
#algo(
// stroke: none,
title: [*Algorithm 1:* 伪代码]
)[
- \# f: backbone + projection mlp
- \# h: prediction mlp
#no-number
+ for x in loader: #comment[load a minibatch x with n samples]
+ x1, x2 = aug(x), aug(x) #comment[random augmentation]
+ z1, z2 = f(x1), f(x2) #comment[projections, n-by-d]
+ p1, p2 = h(z1), h(z2) #comment[predictions, n-by-d]
#no-number
+ L = D(p1, z2)/2 + D(p2, z1)/2 #comment[loss]
#no-number
+ L.backward() #comment[back-propagate]
+ update(f, h) #comment[SGD update]
#no-number
+ def D(p, z): #comment[negative cosine similarity]
+ z = z.detach() #comment[stop gradient]
#no-number
+ p = normalize(p, dim=1) #comment[l2-normalize]
+ z = normalize(z, dim=1) #comment[l2-normalize]
+ return -(p*z).sum(dim=1).mean() #comment[MSE loss]
]
- 前向过程：得到两个视角之后先过孪生 encoder 得到特征，然后通过 predictor 去进行预测。注意是一个对称型的任务，右下角图上只画了一边
- 结论：之所以 SimSiam 可以训练，不会模型坍塌，主要就是因为有 stop gradient 这个操作
- 所以可以把 SimSiam 认为是一个 EM 算法，这一个训练过程或者说这一套模型参数其实就被人为的劈成了两份，相当于在解决两个子问题，模型的更新也是在交替进行的
- 可以理解成一个 Kmeans 的聚类问题，Kmeans 就是分两步走的，每次先把所有点分配给一些聚类中心，再去更新聚类中心。从这个角度说，SimSiam 和 SwAV 就有异曲同工之妙。如图归纳总结了所有孪生网络的做法
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-15-14-38.png")
- 前面基本没看实验结果，现在在 SimSiam 这个总结性工作上看一下
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-15-23-27.png")
- 只有 MoCo-v2 和 SimSiam 能用 $256$ 的 batchsize，其他的工作都要更大；SimCLR 和 MoCo-v2 都要用负样本，BYOL 完全没用，SwAV 用的聚类中心
- $100$ epoch 的时候 SimSiam 学的最好，但是随着训练推进涨幅就小了，后面是 BYOL 更强。说明动量编码器很好用，很好提点。但是本文主要是把这些 trick 都拿掉，证明没有这些 trick 也能训练
- 针对下游任务的 transfer 来说，MoCo-v2 和 SimSiam 是表现最好的。如果尝试一些对比学习的工作，用 MoCo-v2 作为基线模型比较好，因为训练快、稳而且下游任务迁移好
- 这个阶段还有一篇论文叫 <NAME>（时间：2021.2，已经是 ViT 的时代了），方法差不多但是把目标函数换掉了（感觉跟 CLIP 很像的目标函数？），不细细展开
== Transformer
=== An Empirical Study of Training Self-Supervised Vision Transformers
- 时间：2021.4
- MoCo-v3 的论文，但大部分篇幅在讲自监督的 ViT 怎么做，另外 MoCo-v3 只是一种架构，卷积神经网络也可以用，ViT 也可以用。文章贡献在于做了一个很直接、很小的改动，让自监督的 ViT 训练变得更稳定了
- MoCo-v3 其实相当于 MoCo-v2 和 SimSiam 的合体，是一个很自然的延伸工作
- 整体框架：query 编码器(backbone + projection + prediction , i.e. BYOL/SimSiam)和 key 编码器(momentum)
- 对称型目标函数：既算 $q_2$ 到 $k_1$，也算 $q_1$ 到 $k_2$
- 把 backbone 的 ResNet 换成 ViT，试验了不同 batchsize 的结果，发现问题
#grid(
columns: (50%, 50%),
[
+ 当 batchsize 比较小的时候，曲线比较平滑，效果也还行
+ 当 batchsize 变大之后，准确度会突然掉下来又恢复，但是不如其它方法高了
+ 按道理大 batchsize 应该会有更好的结果，如果能解决这个问题，就能用更大的 batchsize，训练更大的 ViT
],
fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-15-48-57.png")
)
- 针对这个普遍出现的问题，提出一个普适的小 trick
- 如何想到的？观察训练的时候每一层梯度回传的情况。作者发现每次 loss 有大幅的震动时，梯度也会有一个波峰，发生在第一层也就是做 patch projection 时
- 即 ViT 论文中的第一步，属于 tokenization 阶段，把一个图片打成 patch 的做法就是一个可训练的全连接层
- 如果这个可训练的全连接层每次梯度都不正常，那还不如不训练。所以作者就尝试把这个 MLP 随机初始化然后冻住，问题就解决了
- 这个 trick 具有普适性，不仅对 MoCo-v3 有用，对 BYOL 也有用（用 BYOL 的框架，把残差网络换成 ViT）；因为 Transformer 又简单扩展性又好，不大改它就只能改开始的 tokenization 阶段和结尾的目标函数
=== Emerging Properties in Self-Supervised Vision Transformers
- 时间：2021.4
- DINO 的论文，也是一个自监督的 ViT，但是主要卖点在于 ViT 在自监督训练的情况下出现的有趣特性
- 名字来源于 Self-#strong[DI]stillation with #strong[NO] labels
- 一个完全不用标签信息训练出来的 ViT，如果把自注意力图进行可视化，能非常准确的抓住每个物体的轮廓，效果甚至能媲美直接对物体做分割的有监督工作
- 具体做法
- 延续了 BYOL 和 MoCo-v3 的框架，只不过换了个名字，用蒸馏的叫法成为 student, teacher
- self-distillation：和 BYOL 一样自己和自己学，用 student 去预测 teacher
- 加了个 centering 的操作，其实就是半步 BN，减掉 batch 的均值，避免模型坍塌
- 从方法和模型角度上讲，和第三阶段一模一样，主要是融合了 Transformer
== 总结
在这之后，对比学习应该就是 CLIP 的天下了，可以看 CLIP 及其相关工作（#link("https://crd2333.github.io/note/Reading/%E8%B7%9F%E6%9D%8E%E6%B2%90%E5%AD%A6AI%EF%BC%88%E8%AE%BA%E6%96%87%EF%BC%89/CLIP")[链接]）。而随着 MAE 的火爆，对比学习的热潮逐渐冷却了一些，转而向掩码学习而去。再然后就不知道了，可能是多模态大模型？
最后再自己画一张图总结一下 CV 领域对比学习的发展
#fig("/public/assets/Reading/limu_paper/对比学习串讲/2024-10-05-16-30-12.png")
|
|
https://github.com/MatheSchool/typst-g-exam | https://raw.githubusercontent.com/MatheSchool/typst-g-exam/develop/examples/exam-points-position.typ | typst | MIT License | #import "../src/lib.typ": *
#import "@preview/cetz:0.2.1"
#show: g-exam.with()
#g-question(points: 2, points-position: right)[Question 1]
#v(5cm)
#g-question[
Given the graphs of the following systems of linear equations,
Determines by the position of the lines the type of system according to the number of solutions. \
#columns(2, gutter: 2cm)[
#g-subquestion(points: 0.5, points-position: left)[
#align(center,
cetz.canvas(length: 0.7cm, {
cetz.plot.plot(
size: (10, 10),
axis-style: "school-book",
fill: "o" ,
fill-below: true,
x-domain: (-5.2, 5.2),
y-domain: (-5.2, 5.2),
x-max: 5.2,
x-min:-5.2,
y-max: 5.2,
y-min:-5.2,
x-grid: "both",
y-grid: "both",
x-tick-step: 1,
y-tick-step: 1,
{
cetz.plot.add(((0,0),), mark-size: 0,)
cetz.plot.add(
style: (stroke: blue + 2pt),
domain: (-5.2, 5.2),
x=>x + 3
)
cetz.plot.add(
style: (stroke: olive + 2pt),
domain: (-5.2, 5.2),
x=>x
)
}
)
}
)
)
]
#colbreak()
#g-subquestion(points: 0.5, points-position: right)[
#align(center,
cetz.canvas(length: 0.7cm, {
cetz.plot.plot(
size: (10, 10),
axis-style: "school-book",
fill: "o" ,
fill-below: true,
x-domain: (-5.2, 5.2),
y-domain: (-5.2, 5.2),
x-max: 5.2,
x-min:-5.2,
y-max: 5.2,
y-min:-5.2,
x-grid: "both",
y-grid: "both",
x-tick-step: 1,
y-tick-step: 1,
{
cetz.plot.add(((0,0),), mark-size: 0,)
cetz.plot.add(
style: (stroke: blue + 2pt),
domain: (-5.2, 5.2),
x=>-x - 4
)
cetz.plot.add(
style: (stroke: olive + 2pt),
domain: (-5.2, 5.2),
x=>3
)
}
)
}
)
)
]
]
]
#pagebreak()
#g-question(points: 1)[Question 2]
#g-question(points: 1.6, points-position: right)[Question 3]
#g-question()[Question 4] |
https://github.com/eneoli/kit-thesis-template | https://raw.githubusercontent.com/eneoli/kit-thesis-template/main/abstract.typ | typst | = Abstract
English version.
#pagebreak(to: "odd")
= Zusammenfassung
Deutsche Version. |
|
https://github.com/SnowManKeepsOnForgeting/NoteofModernControlTheory | https://raw.githubusercontent.com/SnowManKeepsOnForgeting/NoteofModernControlTheory/main/Homework/Homework_3.typ | typst | #import "@preview/physica:0.9.3":*
#import "@preview/i-figured:0.2.4"
+ Given representation of state equations and initial condition of a system.
$
accent(bold(x),dot) = mat(delim: "[",1,0,0;0,1,0;0,1,2)bold(x) , bold(x)(0) = mat(delim: "[",1;0;1)
$
(1)Try to find its state transition matrix by using Laplace transformation.
(2)Try to find its state transition matrix by using diagonal canonical form.
(3)Try to find its state transition matrix by finite terms.
(4)Find the solution of the homogeneous state equation based on the given initial condition.
Solution:
(1)Let $bold(A) = mat(delim: "[",1,0,0;0,1,0;0,1,2)$
$
(s bold(I) - bold(A)) = mat(delim: "[",s-1,0,0;0,s-1,0;0,-1,s-2)\
(s bold(I) - bold(A))^(-1) = mat(delim: "[",1/(s-1),0,0;0,1/(s-1),0;0,1/(s-2) - 1/(s-1),1/(s-2))
$
Thus the state transition matrix is:
$
e^(bold(A)t) = cal(L)^(-1)(s bold(I) - bold(A))^(-1) = mat(delim: "[",e^t,0,0;0,e^t,0;0,e^(2t) - e^t,e^(2t))
$
(2)Let us find the eigenvalues vectors of $bold(A)$
$
|lambda bold(I) - bold(A)| = mat(delim: "|",lambda-1,0,0;0,lambda-1,0;0,-1,lambda-2) = (lambda - 1)^2 (lambda -2) \
lambda_1 = 1,lambda_2 = 1,lambda_3 = 2\
$
And the eigenvalues vectors are:
$
bold(v_1) = vec(delim: "[",1,0,0),bold(v_2) = vec(delim: "[",0,-1,1),bold(v_3) = vec(delim: "[",0,0,1)
$
Thus we have transformation matrix:
$
bold(P) = mat(delim: "[",1,0,0;0,-1,0;0,1,1) "and" bold(P)^(-1) = mat(delim: "[",1,0,0;0,-1,0;0,1,1)
$
So the state transition matrix is:
$
e^(bold(A)t) = bold(P) mat(delim: "[",e^t,0,0;0,e^t,0;0,0,e^(2t)) bold(P)^(-1) = mat(delim: "[",e^t,0,0;0,e^t,0;0,e^(2t) - e^t,e^(2t))
$
(3)We have:
$
cases(
a_0(t) = -2t e^t + e^(2t)\
a_1(t) = 2 e^t +3 e^(t) - 2 e^(2t)\
a_2(t) = -e^t - t e^(t) + e^(2t)
)
$
Thus the state transition matrix is:
$
e^(bold(A)t) = a_0(t) bold(I) + a_1(t) bold(A) + a_2(t) bold(A)^2 = mat(delim: "[",e^t,0,0;0,e^t,0;0,e^(2t) - e^t,e^(2t))
$
(4)
$
bold(x)(t) = e^(bold(A)t) bold(x)(0) = mat(delim: "[",e^t,0,0;0,e^t,0;0,e^(2t) - e^t,e^(2t)) mat(delim: "[",1;0;1) = mat(delim: "[",e^t;0;e^(2t))
$
+ Given a second order differential equation below:
$
accent(y,dot.double) + omega^2 y = 0
$
Choose state variables as $x_1 = y,x_2 = accent(y,dot)$.The state equation is:
$
accent(bold(x),dot) = mat(delim: "[",0,omega;-omega,0)bold(x)
$
Prove that the transformation matrix of the system is:
$
bold(Phi)(t,0) = mat(delim: "[",cos(omega t),sin(omega t);-sin(omega t),cos(omega t))
$
Solution:
$
(s bold(I) - bold(A)) = mat(delim: "[",s,omega;-omega,s)\
(s bold(I) - bold(A))^(-1) = mat(delim: "[",s/(s^2 + omega^2),-omega/(s^2 + omega^2);omega/(s^2 + omega^2),s/(s^2 + omega^2))\
$
Thus we have the state transition matrix:
$
e^(bold(A)t) = cal(L)^(-1)(s bold(I) - bold(A))^(-1) = mat(delim: "[",cos(omega t),sin(omega t);-sin(omega t),cos(omega t))
$
+ Try to find transition matrix of the system by using if $bold(A) bold(B) = bold(B) bold(A)$,then $e^((bold(A) + bold(B))t) = e^(bold(A)t) e^(bold(B)t)$.
$
accent(bold(x),dot) = mat(delim: "[",sigma,omega;-omega,sigma)bold(x)
$
Solution:We have
$
mat(delim: "[",sigma,0;0,sigma) mat(delim: "[",0,omega;-omega,0) = mat(delim: "[",0,omega;-omega,0)mat(delim: "[",sigma,0;0,sigma)
$
Let
$
bold(A) = mat(delim: "[",sigma,0;0,sigma),bold(B)= mat(delim: "[",0,omega;-omega,0)
$
So the state transition matrix is:
$
e^((bold(A) + bold(B))t) = e^(bold(A)t) e^(bold(B)t) = mat(delim: "[",cos(omega t)e^(sigma t),sin(omega t)e^(sigma t);-sin(omega t)e^(sigma t),cos(omega t)e^(sigma t))
$
+ Given a transition matrix of a system $accent(bold(x),dot) = bold(A) bold(x)$,try to find the matrix $bold(A)$.
$
bold(Phi)(t,0) = mat(delim: "[",2e^(-t)-e^(-2t),2(e^(-2t) - e^(-t));e^(-t) - e^(-2t),2e^(-2t) - e^(-t))
$
Solution:
$
cal(L)[bold(Phi)(t,0)] = mat(delim: "[",2/(s+1) - 1/(s+2),2/(s+2) - 2/(s+1);1/(s+1) - 1/(s+2),2/(s+2) - 1/(s+1)) = (s bold(I) - bold(A))^(-1) \
(s bold(I) - bold(A)) = mat(delim: "[",2/(s+1) - 1/(s+2),2/(s+2) - 2/(s+1);1/(s+1) - 1/(s+2),2/(s+2) - 1/(s+1))^(-1) = mat(delim: "[",s,2;-1,s+3)
$
Thus we have the matrix $bold(A)$:
$
bold(A) = mat(delim: "[",0,2;1,-3)
$
+ Given a representation of state equation of a system:
$
accent(bold(x),dot) = mat(delim: "[",0,1;-3,4)bold(x) + mat(delim: "[",1;1)u\
y = mat(delim: "[",1,1)bold(x)
$
(1)Try to find the Unit step response of the system.
Solution:We have:
$
Phi(t) = e^(bold(A)t) =cal(L)^(-1)(s bold(I) - A)= mat(delim: "[",3/2 e^t-1/2 e^(3t),-1/2 e^(t) + 1/2 e^(3t);3/2 e^t - 3/2 e^(3t),-1/2e^t + 3/2 e^(3t))\
bold(x)(t) = e^(bold(A)t) bold(x)(0) = Phi(t)bold(x)(0) + integral_0^t Phi(t-tau)bold(B) bold(u)(tau) dd(tau)
$
Let $bold(x)(0) = 0$
$
x(t) = 1/2 integral_0^t mat(delim: "[",3/2 e^(t-tau) - 1/2 e^(3(t-tau)),-1/2 e^(t - tau) + 1/2 e^(3(t-tau));3/2 e^(t-tau) - 3/2 e^(3(t-tau)),-1/2e^(t-tau) + 3/2 e^(3(t-tau))) mat(delim: "[",1;1) dd(tau) = mat(delim: "[",e^t -1;e^t -1)\
y = mat(delim: "[",1,1) mat(delim: "[",e^t -1;e^t -1) = 2e^t - 2
$
|
|
https://github.com/Isaac-Fate/booxtyp | https://raw.githubusercontent.com/Isaac-Fate/booxtyp/master/src/reference.typ | typst | Apache License 2.0 | #import "counters.typ": theorem-counter, definition-counter, example-counter, exercise-counter, equation-counter
#let reference(body) = {
show ref: it => {
// let eq = math.equation
let numbering-style = "1.1"
let element = it.element
if element == none {
return it
}
if element.func() == math.equation {
// Override equation references
return numbering(element.numbering, ..equation-counter.at(element.location()))
}
if element.func() == figure and element.kind == "Theorem" {
// Override theorem references
return [
#element.supplement
#numbering(numbering-style, ..theorem-counter.at(element.location()))
]
}
if element.func() == figure and element.kind == "Proposition" {
// Override proposition references
return [
#element.supplement
#numbering(numbering-style, ..theorem-counter.at(element.location()))
]
}
if element.func() == figure and element.kind == "Lemma" {
// Override lemma references
return [
#element.supplement
#numbering(numbering-style, ..theorem-counter.at(element.location()))
]
}
if element.func() == figure and element.kind == "Corollary" {
// Override corollary references
return [
#element.supplement
#numbering(numbering-style, ..theorem-counter.at(element.location()))
]
}
if element.func() == figure and element.kind == "Definition" {
// Override definition references
return [
#element.supplement
#numbering(numbering-style, ..definition-counter.at(element.location()))
]
}
if element.func() == figure and element.kind == "Example" {
// Override example references
return [
#element.supplement
#numbering(numbering-style, ..example-counter.at(element.location()))
]
}
if element.func() == figure and element.kind == "Exercise" {
// Override exercise references
return [
#element.supplement
#numbering(numbering-style, ..exercise-counter.at(element.location()))
]
}
it
}
// The rest of the document
body
} |
https://github.com/Myriad-Dreamin/typst.ts | https://raw.githubusercontent.com/Myriad-Dreamin/typst.ts/main/fuzzers/corpora/layout/page-style_02.typ | typst | Apache License 2.0 |
#import "/contrib/templates/std-tests/preset.typ": *
#show: test-page
// Empty with multiple page styles.
// Should result in a small white page.
#set page("a4")
#set page("a5")
#set page(width: 1cm, height: 1cm)
|
https://github.com/SkiFire13/master-thesis | https://raw.githubusercontent.com/SkiFire13/master-thesis/master/chapters/background/5-parity-games.typ | typst | #import "../../config/common.typ": *
#import "@preview/cetz:0.2.2": canvas, draw
== Parity games
Parity games @pg_ermeson @pg_zielonka are games with two players, typically denoted by 0 and 1 and referred as the existential and universal players, performed on directed graphs. A token is placed in a position, represented by nodes, and the two players move it along the edges of the graph. The set of nodes is partitioned in two sets and the player that chooses the move is determined by the subset in which the node for the current position is in. Each node is also associated with a _priority_, usually represented by a natural number. A maximal sequence of positions visited in a game is called a _play_. A play can be finite or infinite, depending on whether a position with no moves is reached or not. In case of a finite play the player who cannot move loses, otherwise if the play is infinite the priorities of the positions that are visited infinitely many times are considered: if the largest one is even then player 0 wins, otherwise player 1 is the winner. Players are also sometimes called $exists$ and $forall$ or $lozenge$ and $square$ due to their meaning when using parity games in relation to $mu$-calculus or fixpoint equations.
#let parity_game_example(withstrategy) = canvas({
import draw: *
set-style(content: (padding: .2), stroke: black)
let node(pos, name, p, label) = {
if p == 0 {
circle(pos, name: name, radius: .65, stroke: black)
} else {
let (x, y) = pos
rect((x - .65, y + .65), (x + .65, y - .65), name: name, radius: 0.05)
}
content(pos, label)
}
node((0, 0), "v0", 0, $v_0: 0$)
node((0, -3.5), "v1", 1, $v_1: 2$)
node((3.5, 0), "v2", 1, $v_2: 3$)
node((3.5, -3.5), "v3", 0, $v_3: 5$)
node((6.5, -1.75), "v4", 0, $v_4: 4$)
let edge(ni, ai, nf, af, a, w) = {
let pi = (name: ni, anchor: ai)
let pf = (name: nf, anchor: af)
let c = if withstrategy and not w { (dash: "dotted") } else { black }
bezier(pi, pf, (pi, 50%, a, pf), fill: none, stroke: c, mark: (end: ">"))
}
edge("v0", 235deg, "v1", 125deg, -20deg, true)
edge("v1", 55deg, "v0", 305deg, -20deg, false)
edge("v0", 0deg, "v2", 180deg, 0deg, false)
edge("v2", 230deg, "v1", 20deg, 10deg, false)
edge("v2", 270deg, "v3", 90deg, 0deg, true)
edge("v3", -10deg, "v4", 260deg, -20deg, false)
edge("v4", 190deg, "v3", 55deg, -20deg, false)
edge("v4", 120deg, "v2", -5deg, -20deg, false)
rect((-1, 1), (1, -4.5), radius: .5, stroke: .5pt)
rect((2.5, 1), (7.5, -4.5), radius: .5, stroke: .5pt)
})
#example("parity game")[
In @parity-example we can see an example of a parity game with 5 vertices. Circles represent vertices controlled by player 0 while squares represent vertices controlled by player 1. Each vertex is shown with its name and its priority. The vertices have been divided in two groups based on the winner on the vertices in them. The left one is winning for player 0 because from $v_0$ it can always go downwards to $v_1$, from which the only possible response possible for player 1 is to go back to $v_0$. Player 0 can thus force such play in which the higher infinitely visited priority is 2, hence the vertices are winning for player 0. In the right group a similar situation happens where player 1 can force any play to go through vertex $v_3$ infinitely often and thus winning the game. Notice that the edges from $v_0$ to $v_2$ and from $v_2$ to $v_1$ are never a good choice for the players, since they lead from a vertex that is winning for the player to one that is losing.
#figure(
parity_game_example(false),
caption: [Example of a parity game],
) <parity-example>
]
We will now introduce graphs and some convenient notation for them. Moreover we will also need a formal notion for infinitely recurring elements in a sequence in order to describe the winner of a parity game.
#notation("graph, successors and predecessors")[
A simple graph is a pair $(V, E)$ where $V$ is the set of vertices and $E subset.eq V times V without {(v, v) | v in V}$ is the set of edges. It is called finite if $V$ is finite.
Given $u, v in V$ we write $u E v$ if $(u, v) in E$, that is if the graph contains an edge from $u$ to $v$.
We also write $u E$ to denote the set of successors of $v$ in $G$, i.e. ${ v in V | u E v }$, and $E v$ to denote the set of predecessors of $v$, i.e. ${ u in V | u E v }$.
]
#definition("sink vertices")[
Let $G = (V, E)$ be a graph. The set of sink vertices is $S_G = {v E = varempty}$, that is the set of vertices without successors.
]
#definition("infinitely recurring elements")[
Let $pi = v_0 v_1 v_2 ...$ an infinite sequence of elements. We define $inf(pi)$ as the set of infinitely recurring elements of $pi$, that is $inf(pi) = { v | forall n. exists i >= n. v_i = v }$.
]
We can now introduce parity games, which consist of a graph partitioned into two set of vertices, representing the positions controlled by each player, along with a priority function.
#definition("parity graph, parity game")[
A parity graph is a triple $G = (V, E, p)$ where $(V, E)$ is a finite graph and $p: V -> bb(N)$ is a so called priority function. A parity graph is a triple $G = (V, E, p)$.
Let $V$ be partitioned into two sets $V_0$ and $V_1$. The tuple $G = (V_0, V_1, E, p)$ is a parity game.
]
A particular game played on a parity game is called a _play_. Each play starts with the token on a given vertex and proceeds by moving the token to one of the successors of the current vertex, as chosen by the player controlling it. A play can eventually reach a vertex which has no successors, in which case the player controlling that vertex loses the play. Otherwise, the play can be infinite, in which case the winner of the play is determined by the highest priority of the vertices that are visited infinitely often: if that is even the winner is player 0, otherwise it is player 1.
#definition("play")[
Let $G = (V_0, V_1, E, p)$ be a parity game. A play in $G$ from a vertex $v_0 in V_0 union V_1$ is a potentially infinite sequence $pi = v_0 v_1 ...$ such that $forall i. v_i E v_(i+1)$. If the play is finite, that is $pi = v_0 v_1 ... v_n$, then $v_n in S_G$ is required.
]
#definition("winner of a play")[
Let $G = (V_0, V_1, E, p)$ be a parity game and let $pi = v_0 v_1 ...$ be a play. The winner of $pi$ is:
- if $pi$ is finite, that is $pi = v_0 v_1 ... v_n$ with $v_n in V_i$ then the winner is player $1-i$;
- if $pi$ is infinite then consider $max inf(p(v_0) p(v_1) ...)$: if it is even the winner is player 0, otherwise it is player 1.
]
From now on we will focus on a subclass of parity games, which for convenience we will call _bipartite parity games_ and _total parity games_.
Bipartite parity games are games whose graph is bipartite, forcing players to perfectly alternate their moves.
Total parity games instead require every vertex to have at least one successor, thus forcing every play to be infinite.
The parity games we will generate will be bipartite by construction, though not necessarily total. We will however mostly deal with total parity games since, as we will show, we can convert any parity game to a "compatible" total parity game.
#definition("bipartite parity game")[
Let $G = (V_0, V_1, E, p)$ be a parity game. It is called bipartite if the graph $(V_0, V_1, E)$ is bipartite, that is $forall v in V_i. v E sect V_i = varempty$.
]
#definition("total parity game")[
Let $G = (V_0, V_1, E, p)$ be a parity game. It is called total if $forall v in V_0 union V_1. v in.not S_G$, that is there is no sink vertex.
]
=== Strategies
By the well-known determinacy of parity games @pg_ermeson @pg_zielonka we know that each vertex is winning for exactly one of the two players, that is that player can force every play to be winning for them. Moreover it is known that the winning player also has a so-called memoryless winning strategy, that is a way to choose the next vertex in the play without considering the previous ones such that any resulting play is winning for them. From now on we will focus only on strategies and plays induced by strategies, as they are finite and easier to reason about.
#definition("strategy")[
Let $G = (V_0, V_1, E, p)$ be a parity game. A (memoryless) strategy for player $i$ is a function $sigma : V_i without S_G -> V$ such that $forall v. sigma(v) in v E$.
]
Strategies for player 0 will usually be denoted by $sigma$ while those for player 1 by $tau$.
It is also worth mentioning that the domain of a strategy for player $i$ on a total parity game will be exactly $V_i$, since the set of sink vertices $S_G$ will be empty.
#definition("strategy induced instance")[
Let $G = (V_0, V_1, E, p)$ be a parity game, $sigma$ be a strategy for player 0 and $tau$ be a strategy for player 1. An instance of the game $G$ induced by the strategies $sigma$ and $tau$ is a tuple $(G, sigma, tau)$.
Given a starting vertex $v_0 in V_0 union V_1$, an instance also uniquely defines a play, called an induced play, where if $v_i in S_G$ then the play is finite and stops at $v_i$, otherwise $v_(i+1) = sigma(v_i)$ if $v_i in V_0$ and $v_(i+1) = tau(v_i)$ if $v_i in V_1$.
]
It can be proven that if an induced play is infinite then it will eventually reach a cycle and repeatedly visit those vertices in the same order, that is the play will be of the kind $v_0 ... v_k v_(k+1) ... v_n v_(k+1) ... v_n ...$.
#definition("winning strategy")[
Let $G = (V_0, V_1, E, p)$ be a parity game. A strategy $sigma_i$ for player $i$ is called winning on vertex $v$ if for any strategy $sigma_(1-i)$ for the opposing player, the induced play starting from vertex $v$ in the instance $(G, sigma_0, sigma_1)$ is winning for player $i$.
]
#lemma("determinacy of parity games")[
Given a parity game $G = (V_0, V_1, E, p)$, for every vertex $v in V_0 union V_1$ one and only one of the players can force a winning play from $v$. The set of vertices $V$ can thus be partitioned in two *winning sets* $W_0$ and $W_1$ of the vertices where player 0 (resp. player 1) has a winning strategy starting from vertices in that set.
]
#example("strategy")[
For example in the parity game in @parity-strategy-example the winning strategy, represented as whole lines, for player 0 on vertex $v_0$ would be going to the vertex $v_1$, while for player 1 on vertex $v_2$ it would be going to the vertex $v_3$. For all the other vertices the strategy is not relevant, since it will always be losing for their controlling player, so it has not been displayed.
#figure(
parity_game_example(true),
caption: [Example of a parity game along with its winning strategies],
) <parity-strategy-example>
]
|
|
https://github.com/LugsoIn2/typst-htwg-thesis-template | https://raw.githubusercontent.com/LugsoIn2/typst-htwg-thesis-template/main/abstract/abstract.typ | typst | MIT License | #import "../lib/utils.typ": todo
Abstract here!
#lorem(100)
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/math/content-02.typ | typst | Other | // Test non-equation math directly in content.
#math.attach($a$, t: [b])
|
https://github.com/xkevio/parcio-typst | https://raw.githubusercontent.com/xkevio/parcio-typst/main/parcio-report/template/template.typ | typst | MIT License | #import "tablex.typ": *
#let ovgu-blue = rgb("#0068B4")
#let ovgu-darkgray = rgb("#606060")
#let ovgu-lightgray = rgb("#C0C0C0")
#let ovgu-orange = rgb("#F39100")
#let ovgu-purple = rgb("#7A003F")
#let ovgu-red = rgb("#D13F58")
#let large = 14.4pt
#let Large = 17.28pt
#let LARGE = 20.74pt
#let huge = 24.88pt
// Typst has its own `#lorem()` function but I wanted to make this comparable
// to the LaTeX template which uses a different variant of this placeholder text.
#let ipsum = [
#h(1em)Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut purus elit, vestibu-
lum ut, placerat ac, adipiscing vitae, felis. Curabitur dictum gravida mauris. Nam
arcu libero, nonummy eget, consectetuer id, vulputate a, magna. Donec vehic-
ula augue eu neque. Pellentesque habitant morbi tristique senectus et netus et
malesuada fames ac turpis egestas. Mauris ut leo. Cras viverra metus rhoncus
sem. Nulla et lectus vestibulum urna fringilla ultrices. Phasellus eu tellus sit amet
tortor gravida placerat. Integer sapien est, iaculis in, pretium quis, viverra ac, nunc.
Praesent eget sem vel leo ultrices bibendum. Aenean faucibus. Morbi dolor nulla,
malesuada eu, pulvinar at, mollis ac, nulla. Curabitur auctor semper nulla. Donec
varius orci eget risus. Duis nibh mi, congue eu, accumsan eleifend, sagittis quis,
diam. Duis eget orci sit amet orci dignissim rutrum.
]
// ----------------------
// Custom outline function
// since outline customization
// is still limited
// ----------------------
#let parcio-outline(title: [Contents]) = {
locate(loc => {
heading(outlined: false, numbering: none)[#title]
let headings = query(heading, loc)
let h-counter = counter("h")
let toc = ()
// remove "Contents" heading from ToC
let _ = headings.remove(0)
for h in headings {
let formatted-heading = if h.level > 1 {
text(font: "Libertinus Serif")[#h.body]
} else {
text(font: "Libertinus Sans")[*#h.body*]
}
let page = counter(page).at(h.location()).join()
let formatted-page = if h.level == 1 {
set text(font: "Libertinus Sans")
strong[#page]
} else {
page
}
let formatted-counter = if h.level == 1 {
if h.body != [References] {
set text(font: "Libertinus Sans")
box[#pad(right: 0.75em)[
#strong[#h-counter.display("1.1.")]
]]
}
} else {
box[#pad(right: 0.75em)[
#h-counter.display("1.1.")
]]
}
let h-pad = if h.level == 1 {
0em
} else {
h.level * 0.75em
}
let v-pad = if h.level == 1 [
#if headings.first() != h [
#v(0.5em)
]
] else [
#v(-0.5em)
]
let linked-heading = box[#pad(left: h-pad)[
#h-counter.step(level: h.level)
#link(h.location())[#formatted-counter#formatted-heading]
]]
toc.push(
v-pad +
linked-heading +
box(width: 1fr)[
#if h.level != 1 [
#repeat[~~.]
]
] +
[~~#formatted-page]
)
}
stack(dir: ttb, spacing: 1em, ..toc)
})
}
// ----------------------
// TODO BOX UTILITY
// ----------------------
#let todo(content) = [
#rect(fill: ovgu-orange, stroke: 0.75pt, radius: 0.35em, width: 100%)[#content]
]
#let inline-todo(content) = locate(l => {
let offset = 21cm - l.position().x - 2.5cm * 0.9
box(width: 0pt, {
place(dy: 0.25em, line(stroke: ovgu-orange, length: offset))
place(dx: offset, dy: -1em,
rect(fill: ovgu-orange, stroke: 0.75pt, radius: 0.35em, width: 0.8 * 2.5cm)[
#text(black, content)
]
)
})
})
// ----------------------
// CUSTOM PARCIO TABLE
// (uses tablex & nested tables)
// ----------------------
#let parcio-table(columns, rows, ..tablec) = {
let header-data = tablec.pos().slice(0, columns)
let rest = tablec.pos().slice(columns)
table(columns: 1, stroke: none,
style(styles => {
let header = table(columns: columns, rows: 1, stroke: 0.5pt, align: center,
..header-data
)
let hw = measure(header, styles).width / columns
header
v(-1em)
tablex(columns: (hw,) * columns, rows: rows - 1, stroke: 0.5pt, align: (x, y) =>
(left, center, right).at(x),
auto-hlines: false,
hlinex(),
..rest,
hlinex()
)
})
)
}
// ----------------------
// ACTUAL TEMPLATE
// ----------------------
#let project(title, subtitle, authors: (), abstract, body) = {
set document(title: title, author: authors.map(a => a.name))
set page("a4", margin: 2.5cm, numbering: "1") // todo: footskip
set text(font: "Libertinus Serif", 12pt, lang: "en")
set heading(numbering: "1.1.")
set par(justify: true)
set math.equation(numbering: "(1)")
// not a lot of customization regarding syntax yet
show raw: set text(font: "Inconsolata")
// custom line numbering, not native yet
show raw.where(block: true): r => [
#grid(columns: 2, column-gutter: -1em)[
#v(1em)
#set text(fill: ovgu-darkgray, font: "Inconsolata", 0.95 * 12pt)
#set par(leading: 0.65em)
#move(dx: -1.35em)[
#for (i, l) in r.text.split("\n").enumerate() [
#box[#align(right)[#{i + 1}]]
#linebreak()
]
]
][
#block(stroke: 0.5pt + gray, inset: 1em, width: 100%)[
#align(left)[#r]
]
]
]
// custom subfigure counter ((a), (b), ...)
show figure.where(kind: "sub"): f => {
f.body
v(-0.65em)
counter(figure.where(kind: "sub")).display("(a)") + " " + f.caption
}
show heading: set text(font: "Libertinus Sans", Large)
show heading: it => it + v(1em)
set footnote.entry(separator: line(length: 40%, stroke: 0.5pt))
// can't import pdf yet (svg mostly works)
align(center)[
#image(alt: "Blue OVGU logo", width: 66%, "ovgu.jpg")
]
v(3.2em)
align(center)[
#text(huge, font: "Libertinus Sans")[*#title*]\
#text(large, font: "Libertinus Sans")[*#subtitle*]
#v(0.5em)
#grid(columns: 2, column-gutter: 3.25em)[
#set text(Large)
#show raw: set text(large * 0.95)
#align(center)[
#authors.at(0).name\
#v(0.75em, weak: true)#link("mailto:" + authors.at(0).mail)[#raw(authors.at(0).mail)]
]
][
#set text(Large)
#show raw: set text(large * 0.95)
#align(center)[
#authors.at(1).name\
#v(0.75em, weak: true)#link("mailto:" + authors.at(1).mail)[#raw(authors.at(1).mail)]
]
]
#v(0.5em)
#text(Large)[January 17, 2023] // date function in next release (0.5.0)
#v(-0.5em)
]
show raw: set text(0.95 * 12pt)
box(inset: 1cm)[
#set par(leading: 0.55em)
#abstract
]
pagebreak()
body
} |
https://github.com/francescoo22/masters-thesis | https://raw.githubusercontent.com/francescoo22/masters-thesis/main/config/variables.typ | typst | // All reusable variables here
#let myLang = "en"
#let myName = "<NAME>"
#let myMatricola = "2079466"
#let myTitle = "Verifying Kotlin Code with Viper\nby Controlling Aliasing"
#let myDegree = "Master's Thesis"
#let myUni = "Università degli studi di Padova"
#let myDepartment = "Department of Mathematics “Tullio Levi-Civita”"
#let myFaculty = "Master's degree in Computer Science"
#let profTitle = "Prof. "
#let myProf = "<NAME>"
#let myCompany = "Nome azienda"
#let myTutor = "<NAME>"
#let myLocation = "Padua"
#let myAA = "2023-2024"
#let myTime = "September 2024" |
|
https://github.com/mem-courses/calculus | https://raw.githubusercontent.com/mem-courses/calculus/main/homework-2/homework14.typ | typst | #import "../template.typ": *
#show: project.with(
course: "Calculus II",
course_fullname: "Calculus (A) II",
course_code: "821T0160",
title: "Homework #14: 高斯公式 & Stocks 公式",
authors: (
(
name: "<NAME>",
email: "<EMAIL>",
id: "#198",
),
),
semester: "Spring-Summer 2024",
date: "June 4th, 2024",
)
= 习题10-2
== P224 1(2)
#prob[
计算第二类曲面积分：
$
iintb(Sigma) y z dz dx + 2 dx dy
$
其中 $Sigma$ 是球面 $x^2 + y^2 + z^2 = 4$ 外侧在 $z>=0$ 的部分。
]
== P224 1(3)
#prob[
计算第二类曲面积分：
$
iintb(S) (y-z) dy dz + (z-x) dz dx + (x-y) dx dy
$
其中 $S$ 为圆锥曲面 $x^2 + y^2= z^2 space (0<=z<=h)$ 的外侧面。
]
== P224 2(2)
#prob[
利用高斯公式计算第二类曲面积分：
$
iintcb(S) 2 x z dy dz + y z dz dx - z^2 dx dy
$
其中 $S$ 是由曲面 $z=sqrt(x^2 + y^2)$ 与 $z=sqrt(2-x^2-y^2)$ 所围立体的表面外侧。
]
== P224 2(4)
#prob[
利用高斯公式计算第二类曲面积分：
$
iintb(S) - y dz dx + (z + 1) dx dy
$
其中 $S$ 是圆柱面 $x^2 + y^2 = 4$ 被平面 $x+z=2$ 和 $z=0$ 所截出部分的外侧。
]
== P224 3
#prob[
证明：曲面 $S$ 所包围的体积等于
$
V = 1 / 3 iintb(S) (x cos alpha + y cos beta + z cos gamma) dif S
$
式中 $cos alpha$，$cos beta$，$cos gamma$ 为曲面 $S$ 的外法线的方向余弦。
]
= 习题10-3
== P233 1
#prob[
利用 Stocks 公式计算第二类曲面积分：
$
intc_C (y+z) dx + (z + x) dy + (x + y) dz
$
式中 $C$ 为依据参数 $t$ 增大方向通过的椭圆：
$
x = a sin^2 t; quad
y = 2a sin t cos t; quad
z = a cos^2 t quad
(0 <= t <= pi)
$
]
== P233 2
#prob[
设 $C$ 为位于平面 $x cos alpha + y cos beta + z cos gamma - p = 0$（$cos alpha$，$cos beta$，$cos gamma$ 为平面之法线的方向余弦）上并包围面积为 $S$ 的封闭曲线，其中围线 $C$ 是依正方向进行的。证明：
$
intc_C (z cos beta - y cos gamma) dx + (x cos gamma - z cos alpha) dy + (y cos alpha - x cos beta) dz = 2 S
$
]
== P233 3(1)
#prob[
计算第二类曲面积分：
$
int_((1,2,3))^((6,1,1)) y z dx + x z dy + x y dz
$
]
== P233 5(1)
#prob[
求函数的原函数：
$
dif u = (x^2 - 2 y z) dx + (y^2 - 2 x z) dy + (z^2 - 2 x y) dz
$
]
== P234 6
#prob[
当单位质量从点 $M_1 (x_1, y_1, z_1)$ 移动到点 $M_2 (x_2, y_2, z_2)$ 时，作用于单位质量的引力 $bold(F)$ 的大小为 $abs(bold(F)) = display(G/(r^2)) space (r = sqrt(x^2 + y^2 + z^2))$，方向指向原点 $O$，求引力所做的功。
] |
|
https://github.com/cwreed/cv | https://raw.githubusercontent.com/cwreed/cv/main/src/modules/professional.typ | typst | #import "../template.typ": cvEntry
#let aquabyte-resume = cvEntry(
title: [Machine Learning Engineer],
institution: [Aquabyte],
date: [June 2022 -- present],
location: [New York, NY],
description: list(
[Developed, optimized, and deployed custom small-object detector model to detect
sea lice on salmon with quantified uncertainty, yielding a 75% reduction in
annotation COGS while enabling more effective treatment and regulation],
[Developed, optimized, and deployed model to detect body wounds on salmon],
[Built system to integrate model servers into production pipeline, scaling inferences from tens to hundreds of thousands per day],
[Built internal service to automatically curate important training/evaluation samples from production pipeline for human review],
[Built ML dataset registry and Python library with common computer vision preprocessing and annotation methods to support model reproducibility and fast dataset curation],
[Conduct live and simulation experiments to estimate effects of new models and research proposals on company
objectives],
[Serve on company's ESG committee; wrote report for investor on the company's impact, responsibilities, and plans to advance sustainable aquaculture in the wider industry, establishing internal ESG objectives],
),
)
#let indigo-resume = cvEntry(
title: [Soil Data Research Intern, Carbon Experimentation],
institution: [Indigo],
date: [June -- August 2021],
location: [Boston, MA],
description: list(
[Crafted quantitative framework, analysis, and data visualizations used by the CEO to evaluate risk-reward tradeoffs of key
agricultural carbon market opportunities],
[Developed generative Bayesian models to create synthetic soil data combining information from published and proprietary data],
[Created pipeline to automatically clean, map, and interpret soil sample data for
customers],
),
)
|
|
https://github.com/typst/packages | https://raw.githubusercontent.com/typst/packages/main/packages/preview/crossregex/0.1.0/src/crossregex.typ | typst | Apache License 2.0 | #import "regex.typ": regex-match
#let r3 = calc.sqrt(3)
#let hexagon = rotate(30deg, polygon.regular(size: 2em, vertices: 6, stroke: 0.5pt))
#let char-box(ch) = box(
width: r3 * 1em,
height: 1.5em,
align(center + horizon)[
#set text(
size: 1.2em,
fill: if ch.match(regex("[A-Z]")) != none {
blue
} else {
purple
},
)
#ch
],
)
/// Make a wonderful crossregex game.
///
/// - size (int): the size of the grids, namely the number of cells on the edge.
/// - constraints (array): All constraint regular expressions, given in clockwise order.
/// - answer (none, array, content): Your answers, either a multi-line raw block or an array of strings. The character in one cell is represented as a char in the string.
/// - show-whole (bool): Whether to show all constraints in one page.
/// - show-views (bool): Whether to show three views separately.
#let crossregex(size, constraints: (), answer: none, show-whole: true, show-views: true) = {
let n1 = size - 1
let n2 = size * 2 - 1
let total = 3 * size * (size - 1) + 1
let filled = 0
// transform constraints
if constraints.len() != n2 * 3 {
panic("Wrong constraint size. Expected " + str(n2 * 3) + ", received " + str(constraints.len()))
}
constraints = constraints.map(t => if type(t) == content {
t.text
} else {
t
})
let max-len = calc.max(..constraints.map(t => t.len()))
constraints = constraints.chunks(n2)
// get the answer strings, and pad them
let a = if answer == none {
()
} else if type(answer) == array {
answer
} else {
answer.text.split("\n")
}
if a.len() < n2 {
a += ("",) * (n2 - a.len())
}
for i in range(n2) {
let len = n2 - calc.abs(i - n1)
if a.at(i).len() < len {
a.at(i) += " " * (len - a.at(i).len())
}
a.at(i) = a.at(i).slice(0, len)
// count letters
for c in a.at(i) {
if c.match(regex("[A-Z]")) != none {
filled += 1
}
}
}
// build other views
let b = for i in range(n2) {
(
for j in range(n2 - calc.abs(i - n1)) {
(a.at(n2 - 1 - j - calc.max(i - n1, 0)).at(calc.min(calc.min(i + n1, n2 - 1) - j, i)),)
}.join(),
)
}
let c = for i in range(n2) {
(
for j in range(n2 - calc.abs(i - n1)) {
(a.at(calc.max(n1 - i, 0) + j).at(calc.min(n2 - 1 - calc.max(i - n1, 0) - j, n2 - i - 1)),)
}.join(),
)
}
let large-hexagon = for i in range(n2) {
for j in range(n2 - calc.abs(i - n1)) {
place(dx: (j + calc.abs(i - n1) * 0.5) * r3 * 1em - 0.1em, dy: i * 1.5em + 0.15em, hexagon)
}
}
let make-decorates(constraints, a) = {
// place constraint expressions
show raw.where(block: false): box.with(fill: gray.transparentize(90%), outset: (x: 0.1em, y: 0.2em), radius: 0.2em)
for (i, cons) in constraints.enumerate() {
let check-result = if regex-match("^" + cons + "$", a.at(i).replace(regex("[^A-Z]"), " ")) {
if a.at(i).contains(" ") {
yellow
} else {
green
}
} else {
red
}
place(
dx: (n1 + 0.5 - calc.abs(i - n1) * 0.5) * r3 * 1em + 0.5em,
dy: (i - n1) * 1.5em,
move(dx: -0.2em, dy: -0.2em, circle(fill: check-result, radius: 0.2em)),
)
place(
dx: (n1 + 0.5 - calc.abs(i - n1) * 0.5) * r3 * 1em + 1.0em,
dy: (i - n1 - 0.3) * 1.5em,
box(height: 1em, align(horizon, raw(cons, lang: "re"))),
)
}
}
let make-grid-texts(a) = {
// place cell texts
for i in range(n2) {
for j in range(n2 - calc.abs(i - n1)) {
place(
dx: (j + calc.abs(i - n1) * 0.5) * r3 * 1em,
dy: i * 1.5em + 0.3em,
char-box(a.at(i).at(j)),
)
}
}
}
let puzzle-view(constraints, a) = {
large-hexagon
place(dx: (n1 + 0.5) * r3 * 1em, dy: n1 * 1.5em + 1em, make-decorates(constraints, a))
make-grid-texts(a)
if answer != none {
place(left + bottom, text(orange)[#filled/#total])
}
}
let aa = (a, b, c)
// compose pages
if show-whole {
let margin-x = max-len * 0.5em + 1em
let margin-y = max-len * r3 * 0.25em + 1em
set page(
height: (n2 + 0.33) * 1.5em + margin-y * 2,
width: (n2 + 1) * r3 * 1em + margin-x * 1.5,
margin: (y: margin-y, left: margin-x * 0.66, right: margin-x),
)
large-hexagon
place(
dx: (n1 + 0.5) * r3 * 1em,
dy: n1 * 1.5em + 1em,
make-decorates(constraints.at(0), a),
)
place(
dx: (n1 + 0.5) * r3 * 1em,
dy: n1 * 1.5em + 1em,
rotate(120deg, make-decorates(constraints.at(1), b)),
)
place(
dx: (n1 + 0.5) * r3 * 1em,
dy: n1 * 1.5em + 1em,
rotate(240deg, make-decorates(constraints.at(2), c)),
)
make-grid-texts(a)
if answer != none {
place(
left + bottom,
dx: -margin-x * 0.66 + 0.5em,
dy: margin-y - 0.5em,
text(orange)[#filled/#total],
)
}
pagebreak(weak: true)
}
if show-views {
let margin = 0.5em
set page(
height: (n2 + 0.33) * 1.5em + margin * 2,
width: (n2 + 1) * r3 * 1em + max-len * 0.5em + 1em,
margin: margin,
)
for k in range(3) {
puzzle-view(constraints.at(k), aa.at(k))
pagebreak(weak: true)
}
}
}
|
https://github.com/a-dixon/typst-template-ieee | https://raw.githubusercontent.com/a-dixon/typst-template-ieee/main/chapters/approach.typ | typst | #import "../template.typ": *
= Approach
// explain your approach here
|
|
https://github.com/Jollywatt/typst-fletcher | https://raw.githubusercontent.com/Jollywatt/typst-fletcher/master/README.template.md | markdown | MIT License | # fletcher
[](docs/manual.pdf?raw=true)
```python
f"}-green)"
```
[](https://github.com/Jollywatt/typst-fletcher/tree/dev)
[](https://github.com/Jollywatt/typst-fletcher)
_**fletcher** (noun) a maker of arrows_
A [Typst](https://typst.app/) package for drawing diagrams with arrows,
built on top of [CeTZ](https://github.com/johannes-wolf/cetz).
See the [manual](docs/manual.pdf?raw=true) for documentation.
````python
f"""
```typ
#import "@preview/fletcher:{get_version()}" as fletcher: diagram, node, edge
```
"""
````
```python
# These are examples in `docs/example-gallery/*.typ`
'\n'.join(insert_example_block(name) for name in [
"first-isomorphism-theorem",
"flowchart-trap",
"state-machine",
"feynman-diagram",
])
```
# More examples
Pull requests are most welcome!
```python
# These are examples in `docs/gallery/*.typ`
insert_example_table([
"commutative",
"algebra-cube",
"ml-architecture",
"io-flowchart",
"digraph",
"node-groups",
"uml-diagram",
])
```
## Change log
### 0.5.1
- Fix nodes which `enclose` absolute coordinates.
- Allow CeTZ-style coordinate expressions in node `enclose` option.
- Fix crash with polar coordinates.
- Fix edges which bend at 0deg or 180deg (e.g., `edge("r,r")` or `edge("r,l")`) and enhance the way the corner radius adapts to the bend angle. **Note:** This may change diagram layout from previous versions.
- Improve error messages.
- Add marks for crow's foot notation: `n` (many), `n?` (zero or more), `n!` (one or more), `1` (one), `1?` (zero or one), `1!` (exactly one).
- Add `node-shape` option to `diagram()`.
### 0.5.0
- Greatly enhance coordinate system.
- Support CeTZ-style coordinate expressions (relative, polar, interpolating, named coordinates, etc).
- Absolute coordinates (physical lengths) can be used alongside "elastic" coordinates (row/column positions).
- Add `label-angle` option to `edge()`.
- Add `label-wrapper` option to allow changing the label inset, outline stroke, and so on (#26).
- Add `label-size` option to control default edge label text size (#35)
- Add `trapezium` node shape.
- Disallow string labels to be passed as positional arguments to `edge()` (to eliminate ambiguity). Used named argument or pass content instead.
### 0.4.5
- Add isosceles triangle node shape (#31).
- Add `fit` and `dir` options to various node shapes to adjust sizing and orientation.
- Allow more than one consecutive edge to have an implicit end vertex.
- Allow `snap-to` to be `none` to disable edge snapping (#32).
### 0.4.4
- Support fully customisable marks/arrowheads!
- Added new mark styles and tweaked some existing defaults. **Note.** This may change the micro-typography of diagrams from previous versions.
- Add node groups via the `enclose` option of `node()`.
- Node labels can be aligned inside the node with `align()`.
- Node labels wrap naturally when label text is wider than the node. **Note:** This may change diagram layout from previous versions.
- Add a `layer` option to nodes and edges to control drawing order.
- Add node shapes: `ellipse`, `octagon`.
### 0.4.3
- Fixed edge crossing backgrounds being drawn above nodes (#14).
- Add `fletcher.hide()` to hide elements with/without affecting layout, useful for incremental diagrams in slides (#15).
- Support `shift`ing edges by coordinate deltas as well as absolute lengths (#13).
- Support node names (#8).
### 0.4.2
- Improve edge-to-node snapping. Edges can terminate anywhere near a node (not just at its center) and will automatically snap to the node outline. Added `snap-to` option to `edge()`.
- Fix node `inset` being half the amount specified. If upgrading from previous version, you will need to divide node `inset` values by two to preserve diagram layout.
- Add `decorations` option to `edge()` for CeTZ path decorations (`"wave"`, `"zigzag"`, and `"coil"`, also accepted as positional string arguments).
### 0.4.1
- Support custom node shapes! Edges connect to node outlines automatically.
- New `shapes` submodule, containing `diamond`, `pill`, `parallelogram`, `hexagon`, and other node shapes.
- Allow edges to have multiple segments.
- Add `vertices` an `corner-radius` options to `edge()`.
- Relative coordinate shorthands may be comma separated to signify multiple segments, e.g., `"r,u,ll"`.
- Add `dodge` option to `edge()` to adjust end points.
- Support `cetz:0.2.0`.
### 0.4.0
- Add ability to specify diagrams in math-mode, using `&` to separate nodes.
- Allow implicit and relative edge coordinates, e.g., `edge("d")` becomes `edge(prev-node, (0, 1))`.
- Add ability to place marks anywhere along an edge. Shorthands now accept an optional middle mark, for example `|->-|` and `hook-/->>`.
- Add “hanging tail” correction to marks on curved edges. Marks now rotate a bit to fit more comfortably along tightly curving arcs.
- Add more arrowheads for the sake of it: `}>`, `<{`, `/`, `\`, `x`, `X`, `*` (solid dot), `@` (solid circle).
- Add `axes` option to `diagram()` to control the direction of each axis in the diagram's coordinate system.
- Add `width`, `height` and `radius` options to `node()` for explicit control over size.
- Add `corner-radius` option to `node()`.
- Add `stroke` option to `edge()` replacing `thickness` and `paint` options.
- Add `edge-stroke` option to `diagram()` replacing `edge-thickness`.
### 0.3.0
- Make round-style arrow heads better approximate the default math font.
- Add solid arrow heads with shorthand `<|-`, `-|>` and double-bar `||-`, `-||`.
- Add an `extrude` option to `node()` which duplicates and extrudes the node's stroke, enabling double stroke effects.
### 0.2.0
- Experimental support for customising arrowheads.
- Add right-angled edges with `edge(..., corner: left/right)`.
## Star History
<a href="https://star-history.com/#jollywatt/typst-fletcher&Date">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=jollywatt/typst-fletcher&type=Date&theme=dark" />
<source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=jollywatt/typst-fletcher&type=Date" />
<img alt="Star History Chart" src="https://api.star-history.com/svg?repos=jollywatt/typst-fletcher&type=Date" />
</picture>
</a>
|
https://github.com/tingerrr/chiral-thesis-fhe | https://raw.githubusercontent.com/tingerrr/chiral-thesis-fhe/main/src/packages.typ | typst | #import "@preview/lovelace:0.3.0"
#import "@preview/oxifmt:0.2.1"
#import "@preview/subpar:0.1.1"
#import "@preview/glossarium:0.4.1"
|
|
https://github.com/kdog3682/mathematical | https://raw.githubusercontent.com/kdog3682/mathematical/main/0.1.0/src/draw/brace.typ | typst | #import "@preview/cetz:0.2.2"
#import "@local/typkit:0.1.0": *
#import "../utils.typ": *
// these are not drawing utils
#import "shapes.typ"
#let segment-decoration(
p1, p2, c, fill: none,
side: "outside"
) = {
let (x1, y1) = p1
let (x2, y2) = p2
let k = 0.1
let stroke = 0.5pt
let end1 = shapes.vline(y1 - k, y1 + k, x1, stroke: stroke)
let end2 = shapes.vline(y1 - k, y1 + k, x2, stroke: stroke)
let segment = shapes.hline(x1, x2, y1, name: "segment", stroke: stroke)
end1
end2
segment
if c != none {
let pos = (rel: (0, 0.35), to: "segment.mid")
cetz.draw.content(pos, resolve-content(c))
}
}
// - fill: the decoration and content (if present) are colored to the fill
// - style: (todo ... determines the type of brace-decoration)
// - rotate-content: make the content be at same angle as the decoration
// - offset: how far off the decoration should be from the shape
#let brace(
p1, p2, offset: 0.3, fill: none, side: "outside", style: "default", rotate-content: true, ..sink,
) = {
let get-brace-content-angle(p1, p2) = {
let angle = get-angle-between-points(p1, p2) - 90deg
if angle < -180deg {
angle += 180deg
}
return angle
}
let flip = side == "outside" or side == "above"
let k = if flip { 1 } else { -1 }
let m1 = get-offset-point(p1, p2, -k * offset)
let m2 = get-offset-point(p2, p1, k * offset)
let base = (stroke: strokes.soft)
let styles = colored(resolve-sink-attrs(sink, base), fill, key: "stroke")
let c = resolve-sink-content(sink)
if style == "default" or style == "brace" {
cetz.decorations.brace(m1, m2, flip: flip, name: "brace", ..styles)
} else if style == "segment" {
return segment-decoration(m1, m2, c)
}
if c != none {
if rotate-content == true {
let angle = get-brace-content-angle(m1, m2)
c = typst.rotate(c, angle)
}
cetz.draw.content("brace.k", colored(c, fill))
}
}
|
|
https://github.com/TeddyHuang-00/typpuccino | https://raw.githubusercontent.com/TeddyHuang-00/typpuccino/main/src/mocha.typ | typst | MIT License | #let rosewater = rgb(245, 224, 220)
#let flamingo = rgb(242, 205, 205)
#let pink = rgb(245, 194, 231)
#let mauve = rgb(203, 166, 247)
#let red = rgb(243, 139, 168)
#let maroon = rgb(235, 160, 172)
#let peach = rgb(250, 179, 135)
#let yellow = rgb(249, 226, 175)
#let green = rgb(166, 227, 161)
#let teal = rgb(148, 226, 213)
#let sky = rgb(137, 220, 235)
#let sapphire = rgb(116, 199, 236)
#let blue = rgb(137, 180, 250)
#let lavender = rgb(180, 190, 254)
#let text = rgb(205, 214, 244)
#let subtext1 = rgb(186, 194, 222)
#let subtext0 = rgb(166, 173, 200)
#let overlay2 = rgb(147, 153, 178)
#let overlay1 = rgb(127, 132, 156)
#let overlay0 = rgb(108, 112, 134)
#let surface2 = rgb(88, 91, 112)
#let surface1 = rgb(69, 71, 90)
#let surface0 = rgb(49, 50, 68)
#let base = rgb(30, 30, 46)
#let mantle = rgb(24, 24, 37)
#let crust = rgb(17, 17, 27)
#let color-entries = (
"rosewater": rosewater,
"flamingo": flamingo,
"pink": pink,
"mauve": mauve,
"red": red,
"maroon": maroon,
"peach": peach,
"yellow": yellow,
"green": green,
"teal": teal,
"sky": sky,
"sapphire": sapphire,
"blue": blue,
"lavender": lavender,
"text": text,
"subtext1": subtext1,
"subtext0": subtext0,
"overlay2": overlay2,
"overlay1": overlay1,
"overlay0": overlay0,
"surface2": surface2,
"surface1": surface1,
"surface0": surface0,
"base": base,
"mantle": mantle,
"crust": crust,
)
|
https://github.com/jgm/typst-hs | https://raw.githubusercontent.com/jgm/typst-hs/main/test/typ/visualize/path-01.typ | typst | Other | // Error: 7-9 path vertex must have 1, 2, or 3 points
#path(())
|