Eines der dringenden Probleme zu jeder Zeit ist das Problem der Erstellung von Berichten. Da Julia eine Sprache ist, deren Benutzer direkt mit den Aufgaben der Datenanalyse, der Vorbereitung von Artikeln und schönen Präsentationen mit den Ergebnissen von Berechnungen und Berichten verbunden sind, kann dieses Thema einfach nicht ignoriert werden.
Ursprünglich plante dieser Artikel eine Reihe von Rezepten zum Generieren von Berichten, aber neben den Berichten befindet sich das Thema der Dokumentation, mit dem Berichtsgeneratoren viele Schnittpunkte haben. Daher umfasst dies Tools für das Kriterium der Möglichkeit, ausführbaren Julia-Code in eine Vorlage mit einem gewissen Markup einzubetten. Schließlich stellen wir fest, dass die Überprüfung Berichtsgeneratoren umfasste, die sowohl auf Julia selbst implementiert waren, als auch Tools, die in anderen Programmiersprachen geschrieben wurden. Nun, natürlich wurden einige Schlüsselpunkte der Julia-Sprache selbst nicht ohne Aufmerksamkeit gelassen, ohne die möglicherweise nicht klar ist, in welchen Fällen und mit welchen Mitteln sie eingesetzt werden sollten.
Jupyter Notizbuch
Dieses Tool sollte möglicherweise dem beliebtesten unter den an der Datenanalyse Beteiligten zugeschrieben werden. Aufgrund der Möglichkeit, verschiedene Rechenkerne miteinander zu verbinden, ist es bei Forschern und Mathematikern beliebt, die an ihre spezifischen Programmiersprachen gewöhnt sind, darunter Julia. Die entsprechenden Module für die Julia-Sprache sind für das Jupyter-Notebook vollständig implementiert. Und deshalb wird hier das Notebook erwähnt.
Der Installationsvorgang fĂĽr Jupyter Notebook ist nicht kompliziert. Die Bestellung finden Sie unter https://github.com/JuliaLang/IJulia.jl. Wenn Jupyter Notebook bereits installiert ist, mĂĽssen Sie nur das Ijulia-Paket installieren und den entsprechenden Computerkern registrieren.
Da das Jupyter Notebook-Produkt bekannt genug ist, um es nicht im Detail zu schreiben, werden wir nur einige Punkte erwähnen. Notepad (wir werden die Notepad-Terminologie verwenden) in einem Jupyter-Notizbuch besteht aus Blöcken, von denen jeder entweder Code oder Markup in seinen verschiedenen Formen enthalten kann (z. B. Markdown). Das Ergebnis der Verarbeitung ist entweder die Visualisierung des Markups (Text, Formeln usw.) oder das Ergebnis der letzten Operation. Wenn am Ende der Zeile mit dem Code ein Semikolon steht, wird das Ergebnis nicht angezeigt.
Beispiele. Das Notizbuch vor der AusfĂĽhrung ist in der folgenden Abbildung dargestellt:
Das Ergebnis seiner Implementierung ist in der folgenden Abbildung dargestellt.
Der Editor enthält Grafiken und Text. Beachten Sie, dass zur Ausgabe der Matrix der DataFrame Typ verwendet werden kann, für den das Ergebnis in Form einer HTML-Tabelle mit expliziten Rahmen und ggf. eines Scrollers angezeigt wird.
Jupyter Notebook kann das aktuelle Notebook in eine HTML-Datei exportieren. Wenn Konvertierungstools installiert sind, kann diese in PDF konvertiert werden.
Um Berichte gemäß einigen Vorschriften zu erstellen, können Sie das Modul nbconvert und den folgenden Befehl verwenden, der gemäß dem Zeitplan im Hintergrund aufgerufen wird:
jupyter nbconvert --to html --execute julia_filename.ipynb
Bei längeren Berechnungen ist es ratsam, eine Option hinzuzufügen, die das Zeitlimit --ExecutePreprocessor.timeout=180 - --ExecutePreprocessor.timeout=180
Ein aus dieser Datei generierter HTML-Bericht wird im aktuellen Verzeichnis angezeigt. Die Option --execute bedeutet hier, dass die Nachzählung zum Starten gezwungen wird.
Einen vollständigen Satz von nbconvert Sie unter
https://nbconvert.readthedocs.io/en/latest/usage.html
Das Ergebnis der Konvertierung in HTML stimmt fast vollständig mit der vorherigen Abbildung überein, außer dass es keine Menüleiste oder Schaltflächen gibt.
Jupytext
Ein ziemlich interessantes Dienstprogramm, mit dem Sie zuvor erstellte ipynb-Notizen in Markdown-Text oder Julia-Code konvertieren können.
Wir können das zuvor betrachtete Beispiel mit dem Befehl transformieren
jupytext --to julia julia_filename.ipynb
Als Ergebnis erhalten wir die Datei julia_filename.jl mit Julia-Code und speziellem Markup in Form von Kommentaren.
# --- # jupyter: # jupytext: # text_representation: # extension: .jl # format_name: light # format_version: '1.3' # jupytext_version: 0.8.6 # kernelspec: # display_name: Julia 1.0.3 # language: julia # name: julia-1.0 # --- # # Report example using Plots, DataFrames # ### Drawing # Good time to show some plot plot(rand(5,5), linewidth=2, title="My Plot", size = (500, 200)) # ## Some computational results rand(2, 3) DataFrame(rand(2, 3))
Beachten Sie, dass Blocktrennzeichen nur doppelte ZeilenvorschĂĽbe sind.
Wir können die inverse Transformation mit dem folgenden Befehl durchführen:
jupytext --to notebook julia_filename.jl
Als Ergebnis wird eine ipynb-Datei generiert, die wiederum verarbeitet und in PDF oder HTML konvertiert werden kann.
Siehe Details https://github.com/mwouts/jupytext
Der allgemeine Nachteil von Jupytext und Jupiter-Notizbüchern besteht darin, dass die „Schönheit“ des Berichts durch die Funktionen dieser Tools eingeschränkt wird.
Selbst generiertes HTML
Wenn wir aus irgendeinem Grund der Meinung sind, dass das Jupyter Notebook ein zu schweres Produkt ist und die Installation zahlreicher Pakete von Drittanbietern erfordert, die für Julia nicht erforderlich sind oder nicht flexibel genug sind, um das von uns benötigte Berichtsformular zu erstellen, besteht eine alternative Möglichkeit darin, eine HTML-Seite manuell zu generieren. Hier müssen Sie sich jedoch ein wenig mit den Funktionen der Bildgebung befassen.
Für Julia besteht eine typische Möglichkeit, etwas in den Ausgabestream auszugeben, darin, die Base.write Funktion zu verwenden und zum Dekorieren Base.show(io, mime, x) . Darüber hinaus kann es für die verschiedenen angeforderten MIME-Ausgabemethoden verschiedene Anzeigeoptionen geben. Beispielsweise wird ein DataFrame wenn er als Text angezeigt wird, von einer DataFrame Tabelle angezeigt.
julia> show(stdout, MIME"text/plain"(), DataFrame(rand(3, 2))) 3×2 DataFrame │ Row │ x1 │ x2 │ │ │ Float64 │ Float64 │ ├─────┼──────────┼───────────┤ │ 1 │ 0.321698 │ 0.939474 │ │ 2 │ 0.933878 │ 0.0745969 │ │ 3 │ 0.497315 │ 0.0167594 │
Wenn mime als text/html , ist das Ergebnis HTML-Markup.
julia> show(stdout, MIME"text/html"(), DataFrame(rand(3, 2))) <table class="data-frame"> <thead> <tr><th></th><th>x1</th><th>x2</th></tr> <tr><th></th><th>Float64</th><th>Float64</th></tr> </thead> <tbody><p>3 rows Ă— 2 columns</p> <tr><th>1</th><td>0.640151</td><td>0.219299</td></tr> <tr><th>2</th><td>0.463402</td><td>0.764952</td></tr> <tr><th>3</th><td>0.806543</td><td>0.300902</td></tr> </tbody> </table>
Das heiĂźt, mit den Methoden der show Funktion, die fĂĽr den entsprechenden Datentyp (drittes Argument) und das entsprechende Ausgabeformat definiert sind, kann die Bildung einer Datei in einem beliebigen Datenformat sichergestellt werden.
Die Situation mit Bildern ist komplizierter. Wenn wir eine einzelne HTML-Datei erstellen mĂĽssen, sollte das Bild in den Seitencode eingebettet werden.
Betrachten Sie das Beispiel, in dem dies implementiert ist. Die Ausgabe in die Datei erfolgt ĂĽber die Funktion Base.write , fĂĽr die wir die entsprechenden Methoden definieren. Also der Code:
#!/usr/bin/env julia using Plots using Base64 using DataFrames # p = plot(rand(5,5), linewidth=2, title="My Plot", size = (500, 200)) # , , @show typeof(p) # => typeof(p) = Plots.Plot{Plots.GRBackend} # , 3 # abstract type Png end abstract type Svg end abstract type Svg2 end # Base.write # # — , # Base64-. # HTML img src="data:image/png;base64,..." function Base.write(file::IO, ::Type{Png}, p::Plots.Plot) local io = IOBuffer() local iob64_encode = Base64EncodePipe(io); show(iob64_encode, MIME"image/png"(), p) close(iob64_encode); write(file, string("<img src=\"data:image/png;base64, ", String(take!(io)), "\" alt=\"fig.png\"/>\n")) end # Svg function Base.write(file::IO, ::Type{Svg}, p::Plots.Plot) local io = IOBuffer() show(io, MIME"image/svg+xml"(), p) write(file, replace(String(take!(io)), r"<\?xml.*\?>" => "" )) end # XML- , SVG Base.write(file::IO, ::Type{Svg2}, p::Plots.Plot) = show(file, MIME"image/svg+xml"(), p) # DataFrame Base.write(file::IO, df::DataFrame) = show(file, MIME"text/html"(), df) # out.html HTML open("out.html", "w") do file write(file, """ <!DOCTYPE html> <html> <head><title>Test report</title></head> <body> <h1>Test html</h1> """) write(file, Png, p) write(file, "<br/>") write(file, Svg, p) write(file, "<br/>") write(file, Svg2, p) write(file, DataFrame(rand(2, 3))) write(file, """ </body> </html> """) end
Zum Erstellen von Bildern wird standardmäßig die Plots.GRBackend Engine verwendet, die eine Raster- oder Vektorbildausgabe durchführen kann. Abhängig davon, welcher Typ im mime Argument der show Funktion angegeben ist, wird das entsprechende Ergebnis generiert. MIME"image/png"() bildet ein Bild im png Format. MIME"image/svg+xml"() generiert ein SVG-Bild. Im zweiten Fall sollten Sie jedoch darauf achten, dass ein völlig unabhängiges XML-Dokument erstellt wird, das als separate Datei geschrieben werden kann. Gleichzeitig ist es unser Ziel, ein Bild in eine HTML-Seite einzubetten. Dies kann in HTML5 durch einfaches Einfügen eines SVG-Markups erfolgen. Aus diesem Grund Base.write(file::IO, ::Type{Svg}, p::Plots.Plot) die Base.write(file::IO, ::Type{Svg}, p::Plots.Plot) Methode Base.write(file::IO, ::Type{Svg}, p::Plots.Plot) den XML-Header aus, wodurch andernfalls die Struktur des HTML-Dokuments verletzt wird. Obwohl die meisten Browser das Bild auch in diesem Fall korrekt anzeigen können.
In Bezug auf die Methode für Base.write(file::IO, ::Type{Png}, p::Plots.Plot) besteht die Implementierungsfunktion hier darin, dass wir nur Binärdaten im Base64-Format in HTML einfügen können. Wir tun dies mit dem Konstrukt <img src="data:image/png;base64,"/> . Und für die Transcodierung verwenden wir Base64EncodePipe .
Die Base.write(file::IO, df::DataFrame) Methode Base.write(file::IO, df::DataFrame) liefert die Ausgabe im HTML-Tabellenformat des DataFrame Objekts.
Die resultierende Seite lautet wie folgt:
Im Bild sehen alle drei Bilder ungefähr gleich aus. Beachten Sie jedoch, dass eines davon aus HTML-Sicht falsch eingefügt wurde (zusätzlicher XML-Header). Eines ist Raster, was bedeutet, dass es nicht ohne Detailverlust erhöht werden kann. Und nur eines davon wird als korrektes SVG-Fragment in das HTML-Markup eingefügt. Und es kann leicht ohne Detailverlust skaliert werden.
Natürlich war die Seite sehr einfach. Mit CSS sind jedoch alle visuellen Verbesserungen möglich.
Diese Methode zum Generieren von Berichten ist beispielsweise nützlich, wenn die Anzahl der angezeigten Tabellen durch reale Daten und nicht durch eine Vorlage bestimmt wird. Beispielsweise müssen Sie Daten nach einem Feld gruppieren. Und für jede Gruppe separate Blöcke zu bilden. Da beim Base.write einer Seite das Ergebnis durch die Anzahl der Aufrufe von Base.write , ist es offensichtlich, dass es kein Problem gibt, den gewünschten Block in eine Schleife zu Base.write , wodurch die Ausgabe von Daten usw. abhängig wird.
Codebeispiel:
using DataFrames # ptable = DataFrame( Symbol = ["H", "He", "C", "O", "Fe" ], Room = [:Gas, :Gas, :Solid, :Gas, :Solid] ) res = groupby(ptable, [:Room]) # open("out2.html", "w") do f for df in (groupby(ptable, [:Room])) write(f, "<h2>$(df[1, :Room])</h2>\n") show(f, MIME"text/html"(), DataFrame(df)) write(f, "\n") end end
Das Ergebnis dieses Skripts ist ein Fragment der HTML-Seite.
Bitte beachten Sie, dass alles, was keine Dekoration / Formatkonvertierung erfordert, direkt ĂĽber die Base.write Funktion angezeigt wird. Gleichzeitig wird alles, was konvertiert werden muss, ĂĽber Base.show .
Weave.jl
Weave ist ein wissenschaftlicher Berichtsgenerator, der von Julia implementiert wurde. Verwendet die Ideen der Generatoren Pweave, Knitr, rmarkdown, Sweave. Die Hauptaufgabe besteht darin, das Quell-Markup in einer der vorgeschlagenen Sprachen (Noweb, Markdown, Skriptformat) in die Formate LaTex, Pandoc, Github Markdown, MultiMarkdown, Asciidoc und reStructuredText zu exportieren. Und sogar in IJulia-Notizbüchern und umgekehrt. Im letzten Teil ähnelt es Jupytext.
Das heißt, Weave ist ein Tool, mit dem Sie Vorlagen schreiben können, die Julia-Code in verschiedenen Markup-Sprachen enthalten, und am Ausgang Markup in einer anderen Sprache haben können (jedoch mit den Ergebnissen der Julia-Code-Ausführung). Und dies ist ein sehr nützliches Werkzeug speziell für Forscher. Sie können beispielsweise einen Artikel über Latex vorbereiten, der Einfügungen zu Julia mit automatischer Berechnung des Ergebnisses und seiner Ersetzung enthält. Weave generiert eine Datei für den endgültigen Artikel.
Der Atom-Editor wird über das entsprechende Plugin https://atom.io/packages/language-weave unterstützt . Auf diese Weise können Sie im Markup eingebettete Julia-Skripte entwickeln und debuggen und anschließend die Zieldatei generieren.
Wie bereits erwähnt, besteht das Grundprinzip von Weave darin, eine Vorlage mit Markup mit Text (Formeln usw.) zu analysieren und den Code in Julia einzufügen. Das Ergebnis der Codeausführung kann im Abschlussbericht angezeigt werden. Die Ausgabe von Text, Code, die Ausgabe von Ergebnissen, die Ausgabe von Grafiken - all dies kann individuell konfiguriert werden.
Um die Vorlagen zu verarbeiten, mĂĽssen Sie ein externes Skript ausfĂĽhren, das alles in einem einzigen Dokument sammelt und in das gewĂĽnschte Ausgabeformat konvertiert. Das heiĂźt, Vorlagen separat, Handler separat.
Ein Beispiel fĂĽr ein solches Verarbeitungsskript:
# : # Markdown weave("w_example.jmd", doctype="pandoc" out_path=:pwd) # HTML weave("w_example.jmd", out_path=:pwd, doctype = "md2html") # pdf weave("w_example.jmd", out_path=:pwd, doctype = "md2pdf")
jmd in den Dateinamen ist Julia Markdown.
Nehmen Sie das gleiche Beispiel, das wir in frĂĽheren Tools verwendet haben. Wir werden jedoch eine Ăśberschrift mit Informationen ĂĽber den Autor einfĂĽgen, die Weave versteht.
--- title : Intro to Weave.jl with Plots author : Anonymous date : 06th Feb 2019 --- # Intro ## Plot ` ``{julia;} using Plots, DataFrames plot(rand(5,5), linewidth=2, title="My Plot", size = (500, 200)) ` `` ## Some computational results ` ``julia rand(2, 3) ` `` ` ``julia DataFrame(rand(2, 3)) ` ``
Dieses Fragment, das in PDF konvertiert wird, sieht ungefähr so ​​aus:
Schriftarten und Layout werden von Latexbenutzern gut erkannt.
Für jeden eingebetteten Code können Sie festlegen, wie dieser Code verarbeitet und was am Ende angezeigt wird.
Zum Beispiel:
- echo = true - der Code wird angezeigt
- eval = true - Das Ergebnis der CodeausfĂĽhrung wird angezeigt
- label - fĂĽge ein label hinzu. Wenn Latex verwendet wird, wird es als Abb. Etikett verwendet
- fig_width, fig_height - Bildgrößen
- und so weiter
Weitere Informationen zu Noweb- und Skriptformaten sowie zu diesem Tool finden Sie unter http://weavejl.mpastell.com/stable/.
Literate.jl
Wenn die Autoren dieses Pakets gefragt werden, warum Literate, beziehen sie sich auf Donald Knutt's Paradigma der Literate-Programmierung. Die Aufgabe dieses Tools besteht darin, Dokumente basierend auf Julia-Code zu generieren, die Kommentare im Markdown-Format enthalten. Im Gegensatz zum zuvor untersuchten Webwerkzeug kann er keine Dokumente mit den Ergebnissen der Ausführung erstellen. Das Tool ist jedoch leichtgewichtig und konzentriert sich hauptsächlich auf die Dokumentation von Code. Helfen Sie beispielsweise beim Schreiben schöner Beispiele, die auf jeder Markdown-Plattform platziert werden können. Wird häufig in einer Kette anderer Dokumentationstools verwendet, z. B. zusammen mit Documenter.jl .
Für das Ausgabeformat gibt es drei mögliche Optionen: Markdown, Notizbuch und Skript (reiner Julia-Code). Keiner von ihnen führt den implementierten Code aus.
Beispielquelldatei mit Markdown-Kommentaren (nach dem ersten Zeichen #):
#!/usr/bin/env julia using Literate Literate.markdown(@__FILE__, pwd()) # documenter=true # # Intro # ## Plot using Plots, DataFrames plot(rand(5,5), linewidth=2, title="My Plot", size = (500, 200)) # ## Some computational results rand(2, 3) DataFrame(rand(2, 3))
Das Ergebnis seiner Arbeit wird ein Markdown-Dokument und Anweisungen fĂĽr Documenter , wenn deren Generierung nicht explizit deaktiviert wurde.
` ``@meta EditURL = "https://github.com/TRAVIS_REPO_SLUG/blob/master/" ` `` ` ``@example literate_example #!/usr/bin/env julia using Literate Literate.markdown(@__FILE__, pwd(), documenter=true) ` `` # Intro ## Plot ` ``@example literate_example using Plots, DataFrames plot(rand(5,5), linewidth=2, title="My Plot", size = (500, 200)) ` `` ## Some computational results ` ``@example literate_example rand(2, 3) DataFrame(rand(2, 3)) ` `` *This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*
Die Code-Einfügungen innerhalb des Markdowns werden absichtlich mit einem Leerzeichen zwischen dem ersten und den nachfolgenden Apostrophen versehen, um bei der Veröffentlichung des Artikels nicht durcheinander zu kommen.
Weitere Details finden Sie unter https://fredrikekre.imtqy.com/Literate.jl/stable/
Documenter.jl
Dokumentationsgenerator. Sein Hauptzweck ist es, eine lesbare Dokumentation fĂĽr in Julia geschriebene Pakete zu erstellen. Documenter konvertiert sowohl HTML- als auch PDF-Beispiele mit Markdown-Markup und eingebettetem Julia-Code sowie Modulquelldateien und extrahiert Julia-Docstrings (Julias eigene Kommentare).
Ein Beispiel fĂĽr eine typische Dokumentation:
In diesem Artikel werden wir nicht auf die Prinzipien der Dokumentation eingehen, da dies in guter Weise als Teil eines separaten Artikels ĂĽber die Entwicklung von Modulen erfolgen sollte. Wir werden uns hier jedoch mit einigen Aspekten von Documenter befassen.
Zuallererst ist darauf zu achten, dass der Bildschirm in zwei Teile unterteilt ist - die linke Seite enthält ein interaktives Inhaltsverzeichnis. Die rechte Seite ist in der Tat der Text der Dokumentation.
Eine typische Verzeichnisstruktur mit Beispielen und Dokumentation lautet wie folgt:
docs/ src/ make.jl src/ Example.jl ...
Das Verzeichnis docs/src ist die Markdown-Dokumentation. Beispiele finden Sie irgendwo im freigegebenen Quellverzeichnis von src .
Die SchlĂĽsseldatei fĂĽr Docuementer lautet docs/make.jl Der Inhalt dieser Datei fĂĽr den Documenter selbst:
using Documenter, DocumenterTools makedocs( modules = [Documenter, DocumenterTools], format = Documenter.HTML( # Use clean URLs, unless built as a "local" build prettyurls = !("local" in ARGS), canonical = "https://juliadocs.imtqy.com/Documenter.jl/stable/", ), clean = false, assets = ["assets/favicon.ico"], sitename = "Documenter.jl", authors = "Michael Hatherly, Morten Piibeleht, and contributors.", analytics = "UA-89508993-1", linkcheck = !("skiplinks" in ARGS), pages = [ "Home" => "index.md", "Manual" => Any[ "Guide" => "man/guide.md", "man/examples.md", "man/syntax.md", "man/doctests.md", "man/latex.md", hide("man/hosting.md", [ "man/hosting/walkthrough.md" ]), "man/other-formats.md", ], "Library" => Any[ "Public" => "lib/public.md", hide("Internals" => "lib/internals.md", Any[ "lib/internals/anchors.md", "lib/internals/builder.md", "lib/internals/cross-references.md", "lib/internals/docchecks.md", "lib/internals/docsystem.md", "lib/internals/doctests.md", "lib/internals/documenter.md", "lib/internals/documentertools.md", "lib/internals/documents.md", "lib/internals/dom.md", "lib/internals/expanders.md", "lib/internals/mdflatten.md", "lib/internals/selectors.md", "lib/internals/textdiff.md", "lib/internals/utilities.md", "lib/internals/writers.md", ]) ], "contributing.md", ], ) deploydocs( repo = "github.com/JuliaDocs/Documenter.jl.git", target = "build", )
Wie Sie sehen können, sind die wichtigsten Methoden hier makedocs und deploydocs , die die Struktur der zukünftigen Dokumentation und den Ort für ihre Platzierung bestimmen. makedocs bietet die Bildung von Markdown- makedocs aus allen angegebenen Dateien, die sowohl die Ausführung von eingebettetem Code als auch das Extrahieren von Docstrings-Kommentaren umfassen.
Documenter unterstĂĽtzt eine Reihe von Anweisungen zum EinfĂĽgen von Code. Ihr Format ist `` @something
@docs , @autodocs - Links zu Dokumentationsdokumentationen, die aus Julia-Dateien extrahiert wurden.@ref , @meta , @index , @contents - Links, Angaben zu Indexseiten usw.@example , @repl , @eval - AusfĂĽhrungsmodi des eingebetteten Julia-Codes.- ...
Das Vorhandensein der Anweisungen @example, @repl, @eval bestimmte tatsächlich, ob Documenter in diese Übersicht aufgenommen werden sollte oder nicht. Darüber hinaus kann die zuvor erwähnte Literate.jl automatisch ein solches Markup erzeugen, wie zuvor gezeigt wurde. Das heißt, es gibt keine grundlegenden Einschränkungen für die Verwendung des Dokumentationsgenerators als Berichtsgenerator.
Weitere Informationen zu Documenter.jl finden Sie unter https://juliadocs.imtqy.com/Documenter.jl/stable/.
Fazit
Trotz der Jugend der Julia-Sprache ermöglichen uns die bereits dafür entwickelten Pakete und Tools, über die volle Nutzung in hoch ausgelasteten Diensten zu sprechen und nicht nur über die Implementierung von Testprojekten. Wie Sie sehen, ist die Möglichkeit, verschiedene Dokumente und Berichte zu generieren, einschließlich der Ergebnisse der Codeausführung sowohl in Textform als auch in grafischer Form, bereits verfügbar. Darüber hinaus können wir je nach Komplexität des Berichts zwischen der einfachen Erstellung einer Vorlage und der Flexibilität bei der Erstellung von Berichten wählen.
Der Artikel berĂĽcksichtigt nicht den Flachsgenerator aus dem Paket Genie.jl. Genie.jl ist ein Versuch, Julia on Rails zu implementieren, und Flax ist eine Art Analogon von eRubis mit CodeeinfĂĽgungen fĂĽr Julia. Flachs wird jedoch nicht als separates Paket bereitgestellt, und Genie ist nicht im Hauptpaket-Repository enthalten, sodass es in dieser ĂśberprĂĽfung nicht enthalten war.
Separat möchte ich die Pakete Makie.jl und Luxor.jl erwähnen, die die Bildung komplexer Vektorvisualisierungen ermöglichen . Das Ergebnis ihrer Arbeit kann auch als Teil von Berichten verwendet werden, es sollte jedoch auch ein separater Artikel darüber geschrieben werden.
Referenzen