Eine große Datei in viele kleine Dateien zerlegen

Ich hatte gerade eine sehr große Datei (3.3GB), die ich über eine langsame Internetverbindung auf einen Server verschieben wollte. Der Vorgang würde mehrere Stunden dauern. Die Wahrscheinlichkeit, dass der Upload unterbrochen würde, wäre relativ groß. In dem Falle müßte ich nochmal von vorne beginnen. Daher habe ich die Dateien in einzelne Dateien zerlegt. In diesem Artikel erkläre ich, wie man eine große Datei aufteilt und im Anschluss wieder zusammenfügt.

Ich habe eine Datei ergebnisse.zip, die ich in 10 MB große Stücke zerteilen möchte.

  1. Um den Erfolg überprüfen zu können, ermittle ich zunächst eine Prüfsumme (Hier: MD5-String) der Ausgangsdatei:
    md5sum ergebnisse.zip > ergebnisse.zip.md5
  2. Mit Hilfe des Programms split teile ich die Datei in 10MB große Stücke:
    split -b 10M ergebnisse.zip ergebnisse_split.zip.

    Dadurch werden viele Dateien erzeugt, die folgenden Aufbau haben:

    ergebnisse_split.zip.aa
    ergebnisse_split.zip.ab
    ergebnisse_split.zip.ac
    ergebnisse_split.zip.ad
    ...
    ergebnisse_split.zip.zy
    ergebnisse_split.zip.zz
    
  3. Nun kann man diese Dateien z.B. per SSH auf einem Server laden:
    scp ergebnisse_split.zip.* user@server.domain:~/zielordner

    Sollte nun der Vorgang unterbrochen werden, kann man im Anschluss einfach bei der Datei beginnen, bei der der Upload unterbrochen wurde.

  4. Nach erfolgtem Upload fügt man die Dateien mit Hilfe von cat einfach wieder zusammen:
    cat ergebnisse_split.zip.* > ergebnisse_cat.zip
  5. Nun muss nur noch geprüft werden, ob die zusammengefügte Datei den gleichen Inhalt wie die Ausgangsdatei hat. Dazu berechnet man erstmal die MD5-Summe:
    md5sum ergebnisse_cat.zip > ergebnisse_cat.zip.md5

    Wenn alles geklappt hat, stehen in ergebnisse.zip.md5 und ergebnisse_cat.zip.md5 die gleichen MD5-Summen.

  6. Weitere Möglichkeiten findest Du im Wiki von UbuntuUsers.

Mathematische Formeln in Glossar-Einträgen verwenden

Ein Glossar hilft dem Leser, auf schnellem Wege eine kurze Erkläung für verwendete Fachbegriffe zu finden. In LaTeX ist es möglich, automatisch ein Glossar erzeugen zu lassen. Dazu erstellt man in der Präambel mit dem Befehl \newglossaryentry{LABEL}{} einen neuen Eintrag, und bindet ihn dann mit dem Befehl \gls{LABEL}, \Gls{LABEL}, \plspl{LABEL} oder \Glspl{LABEL} in den Text ein. Verwendet man allerdings mathematische Formeln im Namen des Glossar-Eintrags, so wird diese Formel in der Überschrift im Glossar nicht fett geschrieben. In diesem Artikel beschreibe ich, wie man Glossar-Einträge mit mathematischen Formeln korrekt formatieren kann.

Zunächst muss in der Präambel das Paket glossaries eingebunden werden.

% Glossaries-Paket sollte nach dem hyperref-Paket geladen werden.
% \usepackage[nonumberlist,acronym,toc,section]{glossaries}
\usepackage[toc]{glossaries}
\makeglossaries

Das Problem

Im Anschluss kann man einen Glossar-Eintrag hinzufügen (Hier z.B. zum Fixations-Index (Fst) aus der F-Statistik):

\newglossaryentry{Fst}{
  name        = {$F_{st}$-Wert},
  description = {Fixations-Index,...},
  sort        = {fst-wert}
}

Nun kann man den Eintrag im Text einbinden:

Ein Text, der den Begriff \gls{Fst} enthält.

Im Text selbst wird der Eintrag korrekt angezeigt:

Link zum Glossar-Eintrag, der in normaler Schriftgröße in den Text eingefügt wurde.
Link zum Glossar-Eintrag, der in normaler Schriftgröße in den Text eingefügt wurde.

In Glossar ist die Formel allerdings nicht Fett geschrieben:

Standardmäßig werden mathematische Formeln in den Überschriften der Glossareinträge nicht fett geschrieben.
Standardmäßig werden mathematische Formeln in den Überschriften der Glossareinträge nicht fett geschrieben.

Ein erster Lösungsversuch

Um nun auch die Formel fett zu schreiben, kann man den Befehl \bm aus dem gleichnamigen Paket (bm) verwenden (siehe auch Stackoverflow):

\usepackage{bm}
 
\newglossaryentry{Fst}{
  name        = {$\bm{F_{st}}$-Wert},
  description = {Fixations-Index,...},
  sort        = {fst-wert}
}

Nun wird auch der Begriff Fst aus der Mathe-Umgebung in der Überschrift des Glossar-Eintrags fett geschrieben:

In der Glossar-Überschrift wird mit Hilfe des Befehls \bm die Formel fett geschrieben.
In der Glossar-Überschrift wird mit Hilfe des Befehls \bm die Formel fett geschrieben.

Allerdings wird Fst nun auch innerhalb des laufenden Textes fett geschrieben:

Unter Umständen wird nach der Formatierung der Formel, die Formel auch im Text fett geschrieben.
Unter Umständen wird nach der Formatierung der Formel, die Formel auch im Text fett geschrieben.

Die Lösung

Nun soll die Formel nur in der Glossar-Überschrift, aber nicht im Text fett geschreiben werden. Dazu fügt man zusätzlich den text-key hinzu, ohne diesen mit \bm zu formatieren (siehe Stackoverflow):

\newglossaryentry{Fst}{
  text        = {$F_{st}$-Wert},
  name        = {$\bm{F_{st}}$-Wert},
  description = {Fixations-Index,...},
  sort        = {fst-wert}
}

Schlussbemerkungen

  • Wenn die Formel am Anfang steht, funktionieren die Befehle für die Großschreibung nicht mehr. \gls und \glspl können problemlos verwendet werden. Verwendet man allerdings \Gls oder \Glspl bekommt man folgende Fehlermeldung:

    ! Extra }, or forgotten $.

  • Wenn man Formeln im Namen des Glossar-Eintrags verwendet, muss man auf jedenfall darauf achten, dass ein Wert für die Sortierung angegeben ist. Das geht mit Hilfe des sort-Schlüssels.

Kleinsten und größten Wert einer ArrayList ermitteln

Manche Zahlen und Objekte speichere ich in einer ArrayList. Hier kann man relativ leicht Objekte hinzufügen (.add()) oder entfernen (.remove()). In diesem Artikel beschreibe ich, wie man den größten und den kleinsten Wert (Minumum und Maximum) einer ArrayList bestimmt.

Für eine ArrayList<Integer>

Am einfachsten ist die Bestimmung des Minimums und des Maximums bei einer Liste von Objekten mit einer natürlichen Reihenfolge, wie z.B. Integer-Zahlen. In dem Falle kann man die statischen Methoden max() und min() der Collections-Klasse verwenden. Je nachdem wie die Liste aufgebaut ist, kann es allerdings auch effizientere Wege geben (siehe Stackoverflow und Zparacha-Blog).

ArrayList<Integer> liste = new ArrayList<Integer>();
liste.add(100);
liste.add(200);
liste.add(110);
liste.add(99);
 
System.out.println("Maximum: " + Collections.max(liste));
System.out.println("Minimum: " + Collections.min(liste));

Vollständiges Beispiel:

package de.fenon.test;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
 
/**
 * Beispiel: Kleinsten und größten Wert in einer ArrayList finden.
 * @author fenon.de
 */
public final class HauptProgramm {
  /** Zahl der Messungen. */
  static final Integer STICHPROBE = 10;
  /** Maximalwert. */
  static final Integer MAXIMUM = 10;
  /** Seed des Zufallszahlen-Generators. */
  static final Integer SEED = 1234567891;
 
  /**
   * Privater Konstruktor.
   * Dadurch kann kein Objekt der Klasse "Hauptprogramm" erzeugt werden.
   */
  private HauptProgramm() {}
 
  /**
   * main()-Methode.
   * @param args - Parameter der Kommandozeile.
   */
  public static void main(final String[] args) {
    ArrayList<Integer> liste = new ArrayList<Integer>();
    // Erzeuge zufällige Messwerte
    Random generator = new Random(SEED);
    for (int i = 0; i < STICHPROBE; i++) {
      liste.add(generator.nextInt(MAXIMUM));
    }
    // Gib die Messwerte aus
    for (Integer element:liste) {
      System.out.println(element);
    }
    // Gib Kleinsten und Größten Wert aus
    System.out.println("Maximum: " + Collections.max(liste));
    System.out.println("Minimum: " + Collections.min(liste));
 
  } // ENDE: main()
 
} // ENDE: HauptProgramm

Für eine ArrayList mit komplexeren Objekten

Man kann allerdings auch den minimalen und maximalen Wert eigener/komplexerer Objekte bestimmen. Im folgenden Beispiel habe ich eine Liste von Objekten des eigenen Typs Website. Mit Hilfe eines Comparators (hier: VergleicheHits) kann festgelegt werden, wie die Objekte verglichen werden sollen. Im Beispiel werden die Website-Objekte dann anhand ihrer Zugriffzahlen verglichen.

Klasse: Website

package de.fenon.Website;
 
/**
 * Informationen über Webseite.
 * @author fenon.de
 */
public class Website {
  /** Zahl der Besucher der Website. */
  private Integer hits;
 
  /**
   * Konstruktor.
   * @param besuche - Zahl der Besucher.
   */
  public Website(final Integer besuche) {
    this.setHits(besuche);
  } // ENDE: Konstruktor
 
  /**
   * Gibt die Besucherzahl der Webseite aus.
   * @return Zahl der Besucher der Website.
   */
  public final Integer getHits() {
    return hits;
  } // ENDE: getHits()
 
  /**
   * Setze die Besucherzahl der Webseite.
   * @param besuche - Zahl der Besucher.
   */
  public final void setHits(final Integer besuche) {
    this.hits = besuche;
  } // ENDE: setHits()
 
} // ENDE: Website

Comparator: VergleicheHits

package de.fenon.Website;
 
import java.util.Comparator;
 
/**
 * Vergleiche Website-Objekte anhand ihrer Hits.
 * @author fenon.de
 */
public class VergleicheHits implements Comparator<Website> {
  /** Konstruktor. */
  public VergleicheHits() {}
 
  @Override
  public final int compare(final Website a, final Website b) {
    if (a.getHits() < b.getHits()) {
      return -1;
    } else if (a.getHits().equals(b.getHits())) {
      return 0;
    } else {
      return 1;
    }
  } // ENDE: compare()
 
} // ENDE: VergleicheHits

Das Beispiel

package de.fenon.test;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
 
import de.fenon.Website.VergleicheHits;
import de.fenon.Website.Website;
 
/**
 * Beispiel: Kleinsten und größten Wert in einer Liste finden.
 * @author fenon.de
 */
public final class HauptProgramm {
  /** Zahl der Messungen. */
  static final Integer STICHPROBE = 10;
  /** Maximalwert. */
  static final Integer MAXIMUM = 10;
  /** Seed des Zufallszahlen-Generators. */
  static final Integer SEED = 1234567891;
 
  /**
   * Privater Konstruktor.
   * Dadurch kann kein Objekt der Klasse "Hauptprogramm" erzeugt werden.
   */
  private HauptProgramm() {}
 
  /**
   * main()-Methode.
   * @param args - Parameter der Kommandozeile.
   */
  public static void main(final String[] args) {
    ArrayList<Website> seiten = new ArrayList<Website>();
    // Erzeuge zufällige Messwerte
    Random generator = new Random(SEED);
    for (int i = 0; i < STICHPROBE; i++) {
      seiten.add(new Website(generator.nextInt(MAXIMUM)));
    }
    // Gib die Messwerte aus
    for (Website element:seiten) {
      System.out.println("Hits: " + element.getHits());
    }
    // Gib Kleinsten und Größten Wert aus.
    // Mit einem anderen Getter könnte man z.B. den Namen der Website ausgeben.
    System.out.println(
      "Maximum: "
      + Collections.max(seiten, new VergleicheHits()).getHits()
      );
    System.out.println(
      "Minimum: "
      + Collections.min(seiten, new VergleicheHits()).getHits()
      );
  } // ENDE: main()
 
} // ENDE: HauptProgramm

Vervollständigung für eigene LaTeX-Befehle in TeXstudio realisieren

Für einige Aufgaben kann man sich in LaTeX eigene Befehle definieren. So habe ich mir z.B. Befehle für die Referenzierung von Bildern, Tabellen, etc. innerhalb meines Dokumentes definiert. Im Gegensatz zum TeX-eigenen Befehl \ref, wird einem in TeXstudio für den eigenen Befehl standardmäßig keine Liste der vorhandenen Labels angezeigt. In diesem Artikel beschreibe ich, wie man diese erweiterte Code-Vervollständigung für eigene Befehle in TeXstudio aktivieren kann.

Beim tippen des LaTeX-Befehls \ref stellt TeXstudio standardmäßig eine Liste  der vorhandenen labels zur Verfügung (hier: Fig:test). In wenigen Schritten kann man diese Liste auch beim tippen von eigenen Befehlen anzeigen lassen.
Beim tippen des LaTeX-Befehls \ref stellt TeXstudio standardmäßig eine Liste der vorhandenen labels zur Verfügung (hier: Fig:test). In wenigen Schritten kann man diese Liste auch beim tippen von eigenen Befehlen anzeigen lassen.
  1. Ich nutze z.B. für Referenzen auf Bilder einen eigenen Befehl (\fig). Dieser Befehl schreibt mir bei der Referenzierung nicht nur die Nummer, sondern auch gleich ein „Fig. “ vor diese Nummer (siehe auch LaTeX: Labels and Cross-referencing). Dazu verwende ich in der Präambel folgende Zeilen:

    \newcommand{\tab}[1]{{\sc Table~\ref{#1}}}
    \newcommand{\eq}[1]{{\sc Equation~\ref{#1}}}
    \newcommand{\fig}[1]{{\sc Figure~\ref{#1}}}	% z.B. für Fig. 2
    \newcommand{\figE}[2]{{\sc Figure~\ref{#1}#2}}	% z.B. für Fig. 2A
     
    \newcommand{\chap}[1]{{\sc Chapter~\ref{#1}}}
    \newcommand{\sect}[1]{{\sc Section~\ref{#1}}}
    \newcommand{\subsect}[1]{{\sc Subsection~\ref{#1}}}
    \newcommand{\lst}[1]{{\sc Listing~\ref{#1}}}
    \newcommand{\itm}[1]{{\sc Item~\ref{#1}}}
  2. Um nun beim tippen des Befehls \fig oder \tab ebenfalls eine Liste der labels angezeigt zu bekommen, kann man Befehle in sogenannten CWL-Dateien anlegen. Eine sehr gute Beschreibung des CWL-Formates findet man in der TeXstudio-Dokumentation (lokal).

    Ich habe mir eine Datei sven.cwl mit folgendem Inhalt angelegt:

    # Kommentarzeile
    \tab{key}#r
    \eq{key}#r
    \fig{key}#r
    \figE{key}{teil}#r
    
    \tab{key}#r
    \chap{key}#r
    \sect{key}#r
    \subsect{key}#r
    \lst{key}#r
    \itm{key}#r
    
  3. Im Anschluss habe ich die Datei in mein lokales Konfigurationsverzeichnis für TeXstudio kopiert. Unter Ubuntu Linux ist das standardmäßig: /home/username/.config/textstudio (bzw. ~/.config/textstudio)
  4. Die CWL-Datei habe ich dann in den Einstellungen von TeXstudio aktiviert:
    Die eigenen CWL-Dateien müssen noch in den Einstellungen von TeXstudio aktiviert werden.
    Die eigenen CWL-Dateien müssen noch in den Einstellungen von TeXstudio aktiviert werden.
  5. Im Anschluss wird auch für eigene Befehle (hier: \fig, \figE, \eq und \tab) eine Liste von verfügbaren labels angezeigt.

    Mit Hilfe von CWL-Dateien kann auch für eigene Befehle z.B. eine Liste bekannter labels in der Autovervollständigung angezeigt werden.
    Mit Hilfe von CWL-Dateien kann auch für eigene Befehle z.B. eine Liste bekannter labels in der Autovervollständigung angezeigt werden.

JavaScript-Datei im Theme-Editor sichtbar machen

Wer JavaScript-Dateien in seinem WordPress-Blog verwenden möchte, der möchte diese Dateien eventuell auch über den eingebauten Theme-Editor bearbeiten. Das Problem ist allerdings, dass der Theme-Editor solche Dateien nicht auflistet die in Unterverzeichnissen liegen oder deren Dateinamen nicht auf .css oder .php enden. In diesem Artikel zeige ich eine Möglichkeit, dieses Problem in drei Schritten zu umgehen.

  1. Verschiebe die Datei aus dem Unterverzeichnis direkt in das Wurzelverzeichnis deines Themes oder Child-Themes.
  2. Ändere die Endung der Datei auf .php.
  3. Schreibe zu Beginn der Datei folgenden PHP-Befehl:
    <?php
    header("Content-type: text/javascript; charset=UTF-8");
    ?>

    Mit diesem Befehl sendet PHP an den Browser, dass es sich um eine JavaScript-Datei handelt. Wenn vom Server keine (oder falsche) Informationen über den Inhalt der Datei gesendet würden, dann würde insbesondere Firefox diese Datei ignorieren. Solltest Du beim Erstellen der JavaScript-Datei einen anderen Zeichensatz als UTF-8 verwendet haben, musst Du die Angabe das charset entsprechend ändern.

JavaScript und jQuery in einem WordPress-Blog verwenden

Wie man JavaScript in einem WordPress-Blog einbindet, erschließt sich dem Anfängen nicht ohne weiteres. Insbesondere dann, wenn man die Bibliothek jQuery für seine Skripte verwenden möchte. In diesem Artikel werde ich zunächst zeigen, wie man JavaScript direkt in den Quelltext einfügt. Im zweiten Teil zeige ich, wie man JavaScript-Dateien in einen WordPress-Blog einbaut.

Direkter Einbau in den Quelltext

Es wird oftmals davon abgeraten, Skripte direkt in den Quelltext einzubauen. Dennoch werde ich diese Methode kurz vorstellen, um einen Fallstrick beim Einbau von jQuery in WordPress-Blogs zu zeigen.

Das folgende JavaScript kann direkt in den Quelltext einen Artikels oder einer Seite kopiert werden. Beim neu laden der Seite wird dann ein Fenster mit der Nachricht „JavaScript funktioniert!“ angezeigt.

<script>
alert('JavaScript funktioniert!');
</script>

In WordPress-Blogs wird jQuery im No Conflict Mode gestartet (siehe auch Blog von Matthew Ruddy). Daher funktioniert das $-Zeichen als Alias für jQuery() nicht mehr. An den entsprechenden Stellen muss man jQuery() verwenden.

Im folgenden Beispiel wird beim Klicken auf den Text jedes Mal das Wort „neu“ vor den eigentlichen Text gestellt:

<p id="meinTest">Klicke auf diesen Text.</p>
<script>
  jQuery("#meinTest").click(function(){
    jQuery(this).before("neu ");
  });
</script>

Um das Dollarzeichen wieder als Alias für jQuery() in den eigenen Skripten verwenden zu können, muss man beim registrieren seiner Funktionen (mittels jQuery(document).ready) der ersten Funktion das Dollarzeichen als Parameter mitliefern.

<p id="meinTest">Klick auf diesen Text</p>
<script>
jQuery(document).ready(function($) {
  $("#meinTest").click(function(){
    $(this).before("neu ");
  });
})
</script>

Einbinden von Skript-Dateien

Wenn man eigene JavaScript-Dateien einbauen möchte, sollte man die von WordPress zur Verfügung gestellten Funktionen nutzen. Mit ihnen kann man relativ leicht seine Skripte hinzuladen und aktivieren. Zudem stellt man sicher, dass alle benötigten Skript-Dateien (z.B. jQuery) rechtzeitig und in der richtigen Reihenfolge geladen werden.

  1. Zunächst erstellt man sich eine JavaScript-Datei (z.B. meinScript.js) mit der gewünschten Funktion. Durch das folgende Skript werden die H1-Überschriften versteckt, sobald man auf sie klickt.
    jQuery(document).ready(function($) {
      $("h1").click(function(){
        $(this).hide();
      });
    });

    Die Datei meinScript.js habe ich in den Ordner js/ meines eigenen Child-Themes gelegt (siehe auch StackOverflow).

  2. Im Anschluss kann man die Datei zu WordPress hinzufügen, indem man folgenden Quelltext in seine functions.php-Datei schreibt:
    function mein_script_laden() {
    wp_enqueue_script(
      // Name des Scripts (benötigt man z.B. zum Entfernen, etc.)
        'handlerMeinesScripts',
      // Ort der Script-Datei
        get_stylesheet_directory_uri() . '/js/meinScript.js',
      // Liste der Scripts, welche von der Script-Datei benötigt werden.
      // In diesem Falle das von Wordpress geladene jqeury
        array('jquery')
    );
    }
     
    add_action( 'wp_enqueue_scripts', 'mein_script_laden' );

    Da ich ein Child-Theme verwende, habe ich zur Ermittlung des Theme-Pfades die Funktion get_stylesheet_directory_uri() verwendet. Erstellt man ein komplett eigenes Theme, sollte man die Funktion get_template_directory_uri() verwenden.

  3. In Deinem Blog kannst Du auch andere Versionen von jQuery einbinden. Siehe hierzu: Die netzialisten.de und den Blog von Wlad Leirich.
  4. Du kannst auch die JavaScript-Datei im Theme-Editor sichtbar machen. Danach hast Du die Möglichkeit, die JavaScript-Datei direkt aus WordPress heraus zu editieren.

LaTeX: Im PDF anzeigen, dass ein Eintrag zum Index hinzugefügt wurde

Wenn man einen langen Text schreibt, vergisst man gelegentlich (an der richtigen Stelle) einen Eintrag zum Glossar hinzuzufügen. Bei der späteren Durchsicht des PDF-Dokumentes kann man leider nicht erkennen, an welchen Stellen Einträge zum Glossar hinzugefügt wurden. Das kann man dadurch ändern, dass man den Befehl \index neu definiert (siehe auch StackExchange).

Durch Änderung des Befehls \index kann im Text angezeigt werden, an welchen Stellen ein Eintrag zum Index hinzugefügt wurde.
Durch Änderung des Befehls \index kann im Text angezeigt werden, an welchen Stellen ein Eintrag zum Index hinzugefügt wurde.
  1. Am Aufruf des Befehls \index innerhalb des Textes muss nichts geändert werden:

    Der Begriff Allel\index{allel} wird zum Index hinzugefügt.
  2. Zunächst muss der ursprüngliche \index-Befehl zwischengespeichert werden (hier in \indexAlt):

    \let\indexAlt\index
  3. Im Anschluss kann mit Hilfe des gespeicherten alten Index-Befehls der Index-Befehl neu definiert werden. In diesem Falle wird im Text ein schwarzes Quadrat an jeder Stelle angezeigt, an der ein Eintrag zum Index hinzugefügt wird:

    \def\index{$\blacksquare$\indexAlt}

    Der Befehl \blacksquare stammt aus dem Paket amssymb und kann über folgenden Befehl in der Präambel verfügbar gemacht werden:

    \usepackage{amssymb}

Transluzente Polygone in R-Plots einzeichnen

Manchmal möchte man Bereiche einer Grafik (z.B. einen Meßbereich) farblich hervorheben. Das kann man z.B. durch Polygone erreichen. Wichtig ist dabei, dass keiner der Datenpunkte vollständig überdeckt wird. Entweder zeichnet man die Polygone vor dem plotten der Datenpunkte ein, oder man verwendet teilweise durchsichtige Polygone (transluzente Polygone), durch die die Datenpunkte immer noch zu sehen sind.

nerv_test

Diese Transluzenz erreicht man in R dadurch, dass man einen achtstelligen hexadezimalen RGB-Farbwert verwendet. Die ersten 6 Stellen sind wie gewohnt für die drei Farben Rot, Grün und Blau reserviert. Die letzten beiden Stellen bestimmen die Deckfraft der zuvor angegebenen Farbe. Der Wert „00“ steht dabei für „vollständig durchsichtig (Farbe unsichtbar)“ und „ff“ steht für „100% deckend (undurchsichtig)“.

Im folgenden Beispiel werden Daten (x, y) geplottet.

x = 1:100
y = x + runif(n=length(x), min=-5, max=+5)
# Simulierte Standardabweichung:
sd = 10 + runif(n=length(x), min=-1, max=+1)
plot(x,y, las=1)

Die Standardabweichung (sd) soll in diesem Beispiel nicht als Fehlerbalken, sondern als farbiger Bereich um die Kurve geplottet werden. Das ist besonders dann hilfreich, wenn man eine hohe Dichte an Meßpunkten hat. Dazu werden der Funktion polygon() die x und y-Koordinaten übergeben. Für den Bereich „zuzüglich Standardabweichung“ (oberhalb der Messwerte; y+sd) gehen wir vom kleinsten zum größten x-Wert (x); für den Bereich „abzüglich Standardabweichung“ (unterhalb der Messwerte; y-sd) gehen wir vom größten zum kleinsten x-Wert (rv(x), und damit auch rev(y-sd)). Wird beschreiben das Polygon also in einer Rechtskurve.

# Bereiche der simulierten Standardabweichung einzeichnen
polygon(
  x = c(x, rev(x))
  , y = c(y+sd, rev(y-sd))
  , col = "#cc000033"
)

Auf diese Weise kann man auch einfache Formen, wie z.B. ein Rechteck, einfügen:

# Rechteck einzeichnen
polygon(
  x = c(40, 40, 60, 60)
  , y = c(-10, 200, 200, -10)
  , col = "#0000cc33"
)

Regressionsgerade in einen doppelt-logarithmischen Plot eintragen

Wer Potenzgesetze (PowerLaws) in Daten entdecken möchte, bestimmt die Steigung in einem Graphen mit logarithmischen Achsen (log-log-Plot). In der Regel möchte man diese Steigung dann in der Graphik als Regressionsgerade darstellen. In R ist genau diese Darstellung nicht ganz einfach, da die Funktion abline() hier versagt. Im folgenden Artikel möchte ich zeigen, wie man die Schätzung seines Modells dennoch in den Plot eintragen kann.

Wir haben Daten, die einem Potenzgesetz folgen (mit etwas statistischer Schwankung).

x = c(1:150)
y = x^-.5 * 155 + (runif(length(x), min=-3, max=3))

Diese Daten plotten wir in einer Graphik mit zwei logarithmischen Achsen.

plot(x, y, log="xy", cex=.5)

Da wir ein Potenzgesetz vermuten, berechnen wir die Parameter (Steigung und Y-Achsenabschnitt) des linearen Modells (lm()) der logarithmierten Daten (siehe auch Stackoverflow):

model = lm(log(y) ~ log(x))
model

In einem doppelt-logarithmischen Plot gibt es natürlich keinen Y-Achsenabschnitt (die Null wird nie erreicht). Beim Aufruf der Funktion abline(model) wird die Regressionsgerade (besonders bei verschobenen Funktionen) an der falschen Stelle dargestellt. Daher muss man für sein lineares Modell Werte vorhersagen (mit predict() bzw. predict.lm), die man im Anschluss in den Exponenten nimmt und als Linie (lines()) zum Plot hinzufügt (siehe auch Stackoverflow: Beitrag 1 und Beitrag 2).

# Schätzung für 2 Punkte machen
neuX=c(1e-10,1e10)
lines(neuX, exp(predict(model, newdata=list(x=neuX))) ,col="blue", type="o", pch=2)
 
# Schätzung für Datenpunkte machen
lines(x, exp(predict(model, newdata=list(x=x))), col="red", type="o", pch=4)

nerv_test

Hinweise: Der Variablenname in der Liste von newdata muss genau der selbe sein, wie der Name der Variablen, die beim Aufruf des linearen Modells verwendet wurde.

  1. Hat man seine Daten z.B. in einem data.frame gespeichert, sollte man das lineare Modell mittels with() aufrufen, anstatt die Bereiche mit Hilfe des $-Selektors auszuwählen.
  2. Wenn man das lineare Modell nur für einen Teil seiner Daten verwenden möchte, so sollte man die Option subset= von lm() verwenden, anstatt Teile des Vectors mit Hilfe der eckigen Klammern auszuwählen.

Die folgenden Beispiele zeigen zwei Mögliche Schreibweisen, eine lineare Regression für die die Datensätze 40 bis 80 einzuzeichnen. Die Daten dafür sind:

1
2
3
4
x = c(1:150)
y = x^-.5 * 155 + (runif(length(x), min=-3, max=3))
daten = data.frame(x,y)
range = c(40:80)

Beispiel 1: with() wird nur für den Aufruf des lm() verwendet. die Ergebnisse der Regression werden in model gespeichert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
plot(daten$x, daten$y, log="xy", cex=.5)
model = with(
  data = daten,
  expr = { model = lm(log(y) ~ log(x), subset=range); model }
)
model
 
lines(
  x[range]
  , exp(predict(model, newdata=list(x=x[range])))
  , col="red"
  , type="o"
  , pch=4
)

Beispiel 2: with() wird für die gesamte Behandlung der Daten verwendet (plot(), lm(), lines()).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
with(
  data = daten,
  expr = {
    plot(x, y, log="xy", cex=.5)
    model = lm(log(y) ~ log(x), subset=range)
    lines(
      x[range]
      , exp(predict(model, newdata=list(x=x[range])))
      , col="red"
      , type="o"
      , pch=4
    )
  }
)

Dateien in ein komprimiertes Archiv verschieben

In meinen Simulationen werden oftmals viele Dateien erzeugt. Damit bin ich schon das ein oder andere Mal an die Grenzen für die Zahl der erlaubten Dateien und den verfügbaren Speicherplatz (quota) gestoßen. Abgesehen davon dauert es länger, wenn man anstatt einer großen Datei viele kleine Dateien herunterlädt.

Daher verschiebe ich die Dateien regelmäßig in ein gepacktes tar-Archiv. Im folgenden Befehl werden alle Dateien mit der Endung .plot in ein neu erstelltes Archiv plot.tar.gz verschoben.

tar --remove-files -czf plot.tar.gz *.plot
–remove-files
Diese Option sorgt dafür, dass die Orginal-Dateien gelöscht werden, sobald sie ins Archiv kopiert wurden.
-c
Diese Option sorgt dafür, dass ein neues Archiv erzeugt wird. Der Name des Archivs wird mit der Option -f angegeben.
Alternativ können mit der Option -r Dateien zu einem bestehenden Archiv hinzugefügt werden:

tar --remove-files -rf plot.tar *.plot

Archive, an die man Dateien anhängen möchte, dürfen allerdings nicht gepackt sein (siehe -z). Ansonsten bekommt man folgende Fehlermeldung:

tar: Cannot update compressed archives
tar: Error is not recoverable: exiting now
-z
Diese Option sorgt dafür, dass das Archiv mit Hilfe von gzip komprimiert wird.
-f
Diese Option legt den Namen des zu behandelnden Archivs fest. Der Name muss (mit einem Leerzeichen getrennt) direkt nach -f stehen.

Generell ist die Reihenfolge der Optionen egal. Allerdings sollte man darauf achten, dass bei Optionen die einen Wert erwarten (z.B. -f), der Wert weiterhin hinter der Option zu finden ist. Zudem müssen die hinzugefügten Dateien ganz am Ende stehen. Hier einige Beispiele für gültige und ungültige Befehle:

# Korrekt:
tar --remove-files -czf plot.tar.gz *.plot
tar --remove-files -c -z -f plot.tar.gz *.plot
tar -f plot.tar.gz --remove-files -zc *.plot
 
# Fehlerhaft:
# Die Namen der zu archivierenden Dateien stehen nicht am Ende
tar *.plot --remove-files -czf plot.tar.gz
# Der Name des Archivs steht nicht hinter -f
tar --remove-files -cfz plot.tar.gz *.plot

Hinweis: Auf Mac OS X-Systemen (oder FreeBSD) ist meistens BSDtar installiert (tar --version ergibt z.B. „bsdtar 2.6.2 – libarchive 2.6.2“). Im Gegensatz zu GNU tar gibt es bei BSDtar die Option --remove-files nicht.