Autor: sven

Funktion aus einem bestimmten R-Paket laden

Die Programmiersprache R kann durch Funktionen erweitert werden, die von anderen Nutzern erstellt wurden. Oftmals sind diese Erweiterungen in Paketen zusammengefasst. Ein Problem tritt allerdings dann auf, wenn in unterschiedlichen Paketen Funktionen enthalten sind, die den gleichen Namen tragen (siehe: Stackoverflow).

Ich nutze z.B. folgende Pakete sehr häufig:

  • sfsmisc – Mit der Funktion eaxis() lassen sich schöne logarithmische Achsen erstellen. Die Beschriftung wird dabei von der Funktion pretty10exp() übernommen.
  • Hmisc– Mit der Funktion errbar() lassen sich sehr leicht Fehlerbalken in Plots eintragen.
  • TeachingDemos – Mit der Funktion subplot() lassen sich sehr einfach Insets zu Plots hinzufügen.

Lädt man allerdings die Pakete,

## Installation der Pakete
install.packages("sfsmisc", dependencies=T)
install.packages("Hmisc", dependencies=T)
install.packages("TeachingDemos", dependencies=T)
 
## Laden der Pakete
library(package = "sfsmisc")
library(package = "Hmisc")
library(package = "TeachingDemos")

dann erhält man folgende Fehlermeldungen:

Attache Paket: ‘Hmisc’

Das folgende Objekt ist maskiert from ‘package:survival’:
    untangle.specials

Das folgende Objekt ist maskiert from ‘package:sfsmisc’:
    errbar

Das folgende Objekt ist maskiert from ‘package:base’:
    format.pval, round.POSIXt, trunc.POSIXt, units

Man kann erkennen, dass sowohl Hmisc als auch sfsmisc eine Funktion namens errbar() enthalten.

Attache Paket: ‘TeachingDemos’

Das folgende Objekt ist maskiert from ‘package:Hmisc’:
    cnvrt.coords, subplot

Man kann erkennen, dass sowohl TeachingDemos als auch Hmisc eine Funktion mit Namen subplot() enthalten.

Um nun die Funktion aus einem bestimmten Paket zu verwenden, kann man R dies mit Hilfe von zwei Doppelpunkten :: mitteilen:

# Verwende die Funktion subplot() aus dem Paket TeachingDemos
TeachingDemos::subplot(...)
 
# Verwende die Funktion errbar() aus dem Paket Hmisc
Hmisc::errbar(...)

Meine Empfehlung: Wenn man Funktionen aus einem Paket verwendet, sollte man beim Aufruf der Funktion immer diese Notation verwenden. Zum einen hilft es dem Leser zu erkennen, woher diese Funktion stammt. Zum anderen verhindert man unnötige Verwirrung, wenn man zu einem späteren Zeitpunkt Pakete einbindet, die Funktionen mit gleichem Namen enthalten.

Webseite komplett herunterladen

Informationen im Internet sind kurzlebig und können nur abgerufen werden, sofern ein Internet-Anschluss verfügbar ist. Problematisch wird es also, wenn Websites gelöscht werden, oder man gerade keinen Zugriff auf das Internet hat (z.B. auf Reisen).

Gelöschte oder ältere Versionen von Websites findet man in Internet Archiven wie der WayBackMachine. Man kann sich die Webseiten allerdings auch selbst zum offline lesen herunterladen.

Ein beliebtes Programm dafür ist wget:

wget -r -k -E -l 8 http://de.wikipedia.org

Mit diesem Befehl würde man die deutsche Version der Wikipedia herunterladen. Die verwendeten Optionen haben folgende Bedeutungen:

-r Websites zum Herunterladen rekursiv durchlaufen.
-l 8 Bei der Rekursion maximal 8 Ebenen („Ordner“) tief vordringen (Standard ist 5)
-k Konvertiere Links, damit sie lokal funktionieren.
-E Erzwinge die Dateiendung „.html“; Das ist besonders dann nützlich, wenn man „.php“ oder „.asp“-Dateien herunterlädt.

Weietere Optionen und Informationen findest Du im Wiki von UbuntuUsers.

Falls Du diesen Befehl häufiger verwenden, Du Dir aber die ganzen Optionen nicht merken möchtest, kannst Du Dir einen Alias anlegen. Solltest Du die bash als Standard-Terminal (Shell) verwenden, musst Du dazu lediglich folgende Zeile in die Datei .bashrc in Deinem Home-Verzeichnis eintragen:

alias wdown='wget -r -k -E -l 8'

Im Anschluss steht Dir der Terminal-Befehl wdown zur Verfügung und Du könntest Dir die deutsche Wikipedia folgendermaßen herunterladen:

wdown http://de.wikipedia.org

Bevor Du allerdings Seite herunterlädst, solltest Du Dich mit den Urheberrechten auseinander setzen.

Plot-Funktion in R erweitern

Manchmal möchte man eine bestehende Funktion in der Programmiersprache R um einen eigenen Parameter erweitern. Die Parameter der Ausgangsfunktion sollen dabei einfach übernommen werden, ohne sie innerhalb der eigenen Funktion definieren und einzeln übergeben zu müssen. Die Weiterleitung von Parametern kann in R durch ... realisiert werden.

Im folgenden Beispiel erweitere ich die R-Funktion plot(). In der neuen Funktion plot.mein() kann zusätzlich eine rote horizontale und/oder vertikale Linie eingezeichnet werden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Definition der neuen Funktion
plot.mein <- function(..., hline=NULL, vline=NULL) {
  # Plote die Daten
  # Leite die Grafik-Parameter direkt an die Funktion plot() weiter
  plot(...)
 
  # Füge eventuell eine horizontale rote Linie hinzu
  if(!is.null(hline)) {
    abline(h=hline, col="#ff0000")
  }
 
  # Füge eventuell eine vertikale rote Linie hinzu
  if(!is.null(vline)) {
    abline(v=vline, col="#ff0000")
  }
}
# Die Parameter x, y und type werden direkt an die Funktion plot weitergeleitet
plot.mein(c(1:6), c(16:11), hline=3, vline=2, type="b")
 
# Wenn die Namen der Parameter angegeben werden,
# dann spielt auch die Reihenfolge beim Aufruf keine Rolle
plot.mein(hline=3, x=c(1:6), vline=2, y=c(16:11), type="b")

Man kann auch die Standard-Parameter der Ausgangsfunktion ändern. Dazu muss der Parameter in der Definition der eigenen Funktion mit dem gewünschten Wert eingetragen werden (hier: type="o"). Der Parameter muss zusätzlich explizit an die Ausgangsfunktion übergeben werden (hier: type=type).

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Ändere den Standardwert für type
plot.mein <- function(..., hline=NULL, vline=NULL, type="o") {
  # type muss explizit übergben werden
  plot(..., type=type)
 
  # [...]
 
}
 
# Der in plot.mein() festgelegte Standadwert für type ("o") wird verwendet
plot.mein(c(1:6), c(16:11), hline=3, vline=2)
 
# Hier wird der beim Aufruf angegebene Wert für type ("b") verwendet
plot.mein(c(1:6), c(16:11), hline=3, vline=2, type="b")

Rezept für überbackene Waffeln („Irinas Waffeln“)

Ich bin ein Freund außergewöhnlicher und vor allem schneller Rezepte. Als mir meine Frau (Irina) allerdings von ihrer Idee zu „überbackenen süßen Waffeln“ erzählte, war ich skeptisch. Zu unrecht, denn ihre Idee stelle sich als äußerst schmackhaft heraus.

  1. Waffeln auf Mikrowellen geeigneten Teller legen.
    Fertige, süße Waffeln auf einen für die Mikrowelle geeigneten Teller legen.
  2. Die Waffeln mit Käse belegen (hier: Tilsiter).
    Die Waffeln mit Käse belegen (hier: Tilsiter).
  3. Die belegten Waffeln für 45 Sekunden bei 800 Watt in der Mikrowelle erhitzen.
    Die belegten Waffeln für 45 Sekunden bei 800 Watt in der Mikrowelle erhitzen.
  4. Fertig.
    Fertig.
  5. Die Waffeln sollten möglichst schnell gegessen werden. Auf jeden Fall sollte das Kondenswasser (zwischen Waffeln und Teller) entweichen können. Ansonsten werden die Waffeln unangenehm weich.

Ich finde man sollte die Waffeln nach Irina benennen. Wenn Dir die Waffeln ebenfalls schmecken, dann schreib einen Kommentar und empfiehl „Irinas Waffeln“ weiter.

Grafik-Parameter in R zeitweise verändern

R ist eine Programmiersprache, mit deren Hilfe man Statistiken berechnen und die Ergebnisse grafisch darstellen kann. Dabei kann man auch mehrere solcher Grafiken in eine einzige Datei (z.B. PDF-Datei) speichern.

Die Ausgabegeräte („output device“, z.B. PDF-Datei) haben voreingestellte Werte für z.B. die Rahmenbreite, Textfarben, Textgrößen, usw.. Manchmal möchte man dabei für einen einzigen Plot die Standard-Parameter des Ausgabegerätes verändern(sie auch: Dokumentation zu par() und WikiBooks-Artikel zu par()). Für weitere Plots sollen dann wiederum die Standard-Parameter verwendet werden. Dazu kann man die Parameter vor der Veränderung zwischenspeichern und im Anschluss wieder einsetzen.

Im folgenden Beispiel werden drei einfache Grafiken in eine gemeinsame PDF-Datei geplottet. Im zweiten Plot werden die Ränder, sowie die Ausrichtung der Beschriftungen verändert. Im dritten Plot werden dann wieder die Standard-Parameter verwendet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# Ausgabegerät setzen (hier: PDF-Datei)
pdf("plots.pdf")
 
# Plot mit Standard-Parametern
plot(
    x = 1, y = 1
    , xlab = "X-Achsenbeschriftung"
    , ylab = "Y-Achsenbeschriftung"
    , main = "Plot mit Standard-Parametern"
)
 
# Alle änderbaren Standardparameter speichern
original_parameter = par(no.readonly=TRUE)
 
# Plot mit geändertem Rahmen und linksbündigen Beschriftungen
par( mar = c(4,4,1,0) + 0.1 , adj = 0)
plot(
    x = 1, y = 1
    , xlab = "X-Achsenbeschriftung"
    , ylab = "Y-Achsenbeschriftung"
    , main = "Plot mit eigenen Parametern"
)
 
# Standard-Parameter einsetzen
par(original_parameter)
 
# Erneut mit Standard-Parametern plotten
plot(
    x = 1, y = 1
    , xlab = "X-Achsenbeschriftung"
    , ylab = "Y-Achsenbeschriftung"
    , main = "Plot mit Standard-Parametern"
)
 
# Ausgabegerät schließen (hier: Daten in PDF-Datei speichern)
dev.off()

Im oben stehenden Beispiel wurden all diejenigen Parameter zwischengespeichert, die auch tatsächlich geändert werden können. Parameter wie z.B. cin oder csi können zwar gelesen, aber nicht geändert werden. Um nur änderbare Parameter auszulesen, muss in der Funktion par() die Option no.readonly auf TRUE gesetzt werden. Ansonsten bekommt man folgende Fehlermeldung:

Warnmeldungen:
1: In par(original_parameter) : graphical parameter "cin" cannot be set
2: In par(original_parameter) : graphical parameter "cra" cannot be set
3: In par(original_parameter) : graphical parameter "csi" cannot be set
4: In par(original_parameter) : graphical parameter "cxy" cannot be set
5: In par(original_parameter) : graphical parameter "din" cannot be set

Anstatt alle änderbaren Parameter zwischen zu speichern, kann man sich auch nur eine Auswahl an Parametern merken:

12
13

# Auswahl an änderbaren Standardparametern speichern
original_parameter = par(c("mar", "adj"))

Abkürzungen in gnuplot

Das Programm gnuplot dient dazu, Daten in einem Koordinatensystem graphisch darzustellen. Gnuplot kann über den Befehl

gnuplot

im interaktiven Modus gestartet werden. Um die Eingabe der Befehle zu beschleunigen, gibt es für häufig verwendete Befehle Kurzschreibweisen. Einige davon sind in der folgenden Tabelle aufgelistet:

Befehl Abkürzung Beispiel
using u, usi plot "file.dat" u 1:2
title t plot 1 t "Linie 1"
with w plot 2 w lines
lines l plot 2 with l
linespoints lp, linesp plot 2 with linesp
linetype lt plot 2 w l lt 3
linecolor lc plot 2 w l lc rgb "#cccccc"
linewidth lw plot 2 w l lw 5
points p plot 2 with p
pointtype pt plot 2 w p pt 6
pointsize ps plot 2 w p ps .5
pointinterval pi ?pointinterval
xrange xr set xr [-5:5]
yrange yr set yr [1:2]
terminal term set term pdf
postscript post set terminal post
output out set out "filename.dat"
replot rep

Weitere Details findest Du in der gnuplot-Dokumentation.

Screenshot einer kompletten Webseite machen.

Manchmal möchte man einen Screenshot (Bildschirmfoto) von einer kompletten Webseite erstellen. Oftmals sind Webseiten aber größer als der im Browserfenster dargestellte Bereich. Dadurch kann man die Homepage nicht mit dem im Betreibssystem integrierten Screenshot-Programm „ablichten“ und speichern, da diese nur den aktuell dargestellten Bereich abfotografieren.

Bildschirmfoto vom 2013-08-23 02:09:18
Oftmals sind Webseiten größer als der aktuell im Browser dargestellte Bereich. Daher kann man nicht ohne Weiteres ein Foto der gesamten Seite erstellen (hier ist der untere Bereich abgeschnitten).
Browser Add-ons ermöglichen es, eine Webseite in ihrer vollen Größe "abzulichten".
Browser Add-ons ermöglichen es, eine Webseite in ihrer vollen Größe „abzulichten“.

Für den Browser Firefox gibt es diverse Add-Ons, die in der Lage sind komplette Webseiten abzulichten. Awesome Screenshot Plus und Fireshot (Fireshot ist nicht für Linux verfügbar) bieten darüber hinaus die Möglichkeit, das erstellte Bildschirmfoto vor dem Speichern zu bearbeiten.

Das Firefox Add-On "Awesome Screenshot Plus" ermöglicht es auch unter Linux ein Bildschirmfoto eine kompleten Webseite (oder auch Teilen davon) zu erstellen. Im Anschluss kann das Foto direkt bearbeitet werden
Das Firefox Add-On „Awesome Screenshot Plus“ ermöglicht es (auch unter Linux!) ein Bildschirmfoto einer kompletten Webseite (oder auch Teilen davon) zu erstellen. Im Anschluss kann das Foto direkt bearbeitet werden.

 

Passwörter im Mozilla Firefox werden nicht gespeichert?

Viele Seiten im Internet erfordern eine Anmeldung mit einem Nutzernamen und einem Passwort. Im Optimalfall hat man für jede Seite ein eigenes (und sicheres) Passwort. Dadurch sammeln sich über die Zeit viele Passwörter an, die man nicht jedes mal neu eingeben möchte (oder kann, weil man sie vergessen hat).

Mozilla Firefox bietet daher die Möglichkit Passwörter zu speichern. Wie auf der deutschsprachigen Hilfeseite von Firefox beschrieben, macht Firefox dies bereits standardmäßg. Man sollte allerdings zusätzlich ein Master-Passwort vergeben, um unberechtigten Personen den Zugriff auf die Passwörter zu erschweren.

Unter Umständen kann es passieren, dass man nicht gefragt wird, ob man ein neues Passwort speichern möchte. Zudem kann man in den Sicherheitseinstellungen das Feld „Passwörter speichern“ nicht aktivieren.

Screen shot 2013-08-21 at 12.23.14_cut
Wenn man in den Datenschutzeinstellungen „immer den privaten Modus verwenden“ aktiviert hat, kann man in den Sicherheitseinstellungen das Feld „Passwörter speichern“ nicht aktivieren.

Die Ursache hierfür kann sein, dass man in den Datenschutz-Einstellungen „immer den privaten Modus verwenden“ aktiviert hat. In dem Falle ist es nicht möglich, das Feld „Passwörter speichern“ zu aktivieren. Dieser und andere Gründe für nicht gespeicherte Passwörter, werden auf der englischsprachigen Mozilla Hilfeseite diskutiert.

Um dennoch ein Passwort zu speichern, kann man den privaten Modus in den Datenschutzeinstellungen kurzzeitig deaktivieren (das erfordert einen Neustart des Browsers) und nach der erfolgreichen Speicherung des neuen Passwortes den Modus wieder aktivieren.

 

 

Bildschirmfoto (Screenshot) unter MacOSX aufnehmen

Manchmal kann es hilfreich sein, ein Foto vom aktuellen Bildshirm-Inhalt zu machen.
Um ein solches Bildschirmfoto (englisch: Screenshot) unter MacOSX zu machen, gibt es zwei mögliche Tasten-Kombinationen:

Tastenkombination Funktion
⌘ + Shift + 3 Ein Foto vom gesamten Bildschirminhalt aufnehmen.
⌘ + Shift + 4 Eine Region auswählen die photographiert werden soll.

Im Anschluss werden die Bilder automatisch als PNG-Datei auf dem Desktop abgelegt.
Die Namen der Dateien können z.B. folgendermaßen aussehen:

  • „Picture#.png“ (Mac OSX Leopard, englische Version)
  • „Screen shot YYYY-MM-DD at hh.mm.ss.png“ (Mac OSX Snow Leopard, englische Version)

Rar-Archive unter MacOSX entpacken

Manchmal findet man ein altes RAR-Archiv auf der Festplatte oder lädt ein solches aus dem Internet herunter. Standardmäßig ist unter MacOSX kein Programm vorhanden, mit dem man diese Archive entpacken kann. Allerdings findet sich in den MacPorts das Programm unrar, mit dem man diese Archive entpacken kann. Installieren kannst Du unrar über die folgenden Terminal-Befehle:

# Erstmal die Paketquellen aktualisieren:
sudo port selfupdate
 
# Schauen, ob unrar (noch) in den Quellen zu finden ist:
port search unrar
 
# unrar installieren
sudo port install unrar

Falls Du MacPorts nicht verwendest, kannst Du Dir auch die entsprechenden Dateien aus dem Internet herunterladen: UnRar (Terminal-Version), UnRarX (mit grafischer Benutzer-Oberfläche)

Danach steht Dir im Terminal der Befehl unrar zur Verfügung. Wenn Du diesen Befehl ohne Parameter eingibst, erscheint die Hilfe zu unrar.

# Hilfe zu unrar anzeigen
unrar

Zum einfachen entpacken eines Archivs kannst Du folgenden Befehl verwenden:

# Archiv names "datei.rar" entpacken
unrar e datei.rar