Gerade mit Referenz-Steigung in einen doppelt logarithmischen Plot in R eintragen

Ich stelle viele meiner Daten in Plots mit zwei logarithmischen Achsen dar. Oftmals kommt es in solchen Plots auf die Steigung der Kurve an, also den Exponenten eines Power laws. In solchen Fällen zeichne ich, zusätzlich zu den Daten, eine oder mehrere Geraden mit einer Referenz-Steigung ein. Dadurch kann der Betrachter abschätzen, in welchen Bereichen die Daten eher zu der einen oder der anderen Steigung tendieren. Ich fand es allerdings immer sehr mühsam diese Steigungen einzuzeichnen. Grund: Ein Teil der Anfangs- oder Endkoordinaten musste im logarithmischen Raum berechnet werden. Daher habe ich mir eine Funktion geschrieben, die mir anhand einer Anfangs-Koordinate, der Steigung, sowie einem Teil der Endkoordinate, den fehlenden Wert berechnet und die Referenz-Gerade in den Plot einzeichnet.

  1. Zunächst generiere ich Daten, die im doppelt-logarithmischen Plot eine Gerade ergeben:
    x = 1:1000
    y = x^-1.5
  2. Diese werden dann mit schön formatierten Achsen geplottet, wie im Artikel „Logarithmische Achsen in R-Plots formatieren“ beschrieben.
    library(package = "sfsmisc")
    #png("log-gerade.png", width=480, height=360)
    #par(cex =1.5, mar=c(4,4,0,0)+.01)
     
    plot(x, y, log="xy", xaxt="n", yaxt="n")
    sfsmisc::eaxis(side=1, at=10^c(0:3))
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))
     
    #dev.off()
    Darstellung einer Potenz-Funktion in einem Plot mit zwei logarithmischen Achsen.
    Darstellung einer Potenz-Funktion in einem Plot mit zwei logarithmischen Achsen.
  3. Der Exponent der von mir verwendeten Potenzfunktion ist -1.5. Daher ist auch die Steigung der Geraden m = -1.5. Nun möchte ich zusätzlich eine Gerade mit der Steigung m = -1 in den Plot eintragen. Diese soll bei am Punkt (x1 = 101, y1 = 10-1) beginnen. Enden soll die Gerade bei x2 = 2*102. Gesucht ist also die Y-Koordinate des Endpunktes (y2).

    Nun kann man:

    1. Alle vorhandenen x- und y-Werte logarithmieren (da beide Achsen logarithmisch sind).
    2. Diese Werte können in die Gleichung für die Berechnung der Steigung eingesetzt werden.
    3. Nun muss die Gleichung nach x2 aufgelöst werden (oder: die Gleichung auflösen lassen).
    4. Im Anschluss muss der x2-Wert in den Exponenten genommen werden.
    5. Über den Plot-Befehl kann nun eine Gerade zwischen den beiden Punkten (x1, y1) und (x2, y2) eingezeichnet werden.

    Diese Vorgehensweise habe ich in der Funktion refline() zusammengefasst:

    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
    37
    38
    39
    40
    41
    42
    43
    44
    
    refline <- function(x1=NA, y1=NA, x2=NA, y2=NA, m=1, add=T, ...) {
      # Welchen Achsen (des letzten plots) sind logarithmisch?
      logX = par("xlog")
      logY = par("ylog")
     
      # Werte der logarithmischen Achsen umrechnen
      if(!is.na(x1) && logX) {x1 = log(x1)}
      if(!is.na(x2) && logX) {x2 = log(x2)}
      if(!is.na(y1) && logY) {y1 = log(y1)}
      if(!is.na(y2) && logY) {y2 = log(y2)}
     
      # Bestimmung der fehlenden Variablen
      if(is.na(x1)) {
        x1 = (y1 - y2 + m * x2) / m
        print("X1 wird berechnet")
      } else if(is.na(x2)) {
        x2 = (y2 - y1 + m * x1) / m
        print("X2 wird berechnet")
      } else if(is.na(y1)) {
        y1 = y2 + m * (x1 - x2)
        print("Y1 wird berechnet")
      } else if(is.na(y2)) {
        y2 = y1 + m * (x2 - x1)
        print(paste("Y2 wird berechnet", y2))
      }
     
      # Werte der logarithmischen Achsen umrechnen
      if(!is.na(x1) && logX) {x1 = exp(x1)}
      if(!is.na(x2) && logX) {x2 = exp(x2)}
      if(!is.na(y1) && logY) {y1 = exp(y1)}
      if(!is.na(y2) && logY) {y2 = exp(y2)}
     
      # Einzeichnen
      if(add) {
        lines(x=c(x1, x2), y=c(y1, y2), ...)
      }
     
      # Ausgabe
      data.frame(
        x1, y1, x2, y2, m
        , xmin=min(x1, x2), xmax=max(x1, x2)
        , ymin=min(y1, y2), ymax=max(y1, y2)
      )
    }

    Die Besonderheiten der Funktion refline() sind:

    • Es wird automatisch die fehlende Koordinate bestimmt.
    • Es wird erkannt, welche der Achsen logarithmisch sind.
    • Wichtige Werte der Geraden werden bei Aufruf zurückgegeben. Im Anschluss können sie verwendet werden, z.B. um Texte an die Enden der Geraden zu schreiben.
    • Die Gerade wird (auf Wunsch: add=T) in den vorigen Plot eingetragen.
    • Grafik-Parameter werden an den Plot-Befehl weitergeleitet (...).

    Nun kann refline() genutzt werden, um die oben genannte Gerade (sowie eine weitere Gerade) in den Plot einzuzeichnen. Die Variablen rl1 und rl2 dienen dazu, die Anfangs- und End-Punkte zu speichern. Mit den gespeicherten Werten werden Anschluss die Texte positioniert.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    
    #png("log-gerade_2.png", width=480, height=360)
    #par(cex =1.5, mar=c(4,4,0,0)+.01)
     
    plot(x, y, log="xy", xaxt="n", yaxt="n")
    sfsmisc::eaxis(side=1, at=10^c(0:3))
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))
     
    rl1 = refline(x1=1e1, y1=1e-1, x2=2e2, m=-1, col="red")
    text(x=rl1$x2, y=rl1$y2, labels=paste0(" Slope: ", rl1$m), adj=0, col="red")
     
    rl2 = refline(x1=8e0, y1=1e-2, x2=1e2, m=-2, col="blue")
    text(x=rl2$x2, y=rl2$y2, labels=paste0(" Slope: ", rl2$m), adj=0, col="blue")
     
    #dev.off()
    Darstellung einer Potenzfunktion mit einer Steigung von -1.5. Zusätzlich wurden Referenz-Steigungen von -1 und -2 eingezeichnet.
    Darstellung einer Potenzfunktion mit einer Steigung von -1.5. Zusätzlich wurden Referenz-Steigungen von -1 und -2 eingezeichnet.
  4. Hinweis: Als Parameter für die Funktion refline() muss ein vollständiges und ein unvollständiges Koordinaten-Tupel, sowie die gewünschte Steigung angegeben werden. Der Punkt (x2, y2) muss dabei nicht immer rechts vom Punkt (x1, y1) liegen. Vielmehr hängt es von den gewählten Werten ab, wie die Punkte zueinander liegen. Die Werte x1 und y1 bestimmen gemeinsam immer den einen Punkt und die Werte x2 und y2 gemeinsam den anderen Punkt.
  5. Wie ich oben bereits erwähnt habe, funktioniert die Berechnung des fehlenden Punktes der Gerade auch in Plots mit zwei linearen, oder nur einer logarithmischen Achse:
    Im Falle z.B. einer logarirhmischen Y-Achse werden dann nur die Y-Koordinaten logarithmiert. Hier einige Beispiele:

    # Linear
    plot(x, y)
    r1 = refline(x1=0, x2=500, y1=1, m=-0.0005, col="blue")
    text(x=r1$xmax, y=r1$ymin, labels=paste0(" Steigung: ", r1$m), adj=0)
     
    # Y-logarithmisch
    plot(x, y, log="y", yaxt="n")
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))
    r2 = refline(x1=10, x2=500, y1=1, m=-0.002, col="red")
    text(x=r2$xmax, y=r2$ymin, labels=paste0(" Steigung: ", r2$m), adj=0)

Schreibhilfen für Abschlussarbeiten

Ich schreibe gerade eine Abschlussarbeit in englischer Sprache. Da ich kein Muttersprachler bin, fällt es mir das ein oder andere Mal schwer, eine alternative Formulierung oder die englische Übersetzung für ein Wort zu finden. Daher nutze ich Online-Wörterbücher und Thesaurus-Seiten zur Unterstützung:

Thesaurus-Seiten

  • thesaurus.com: Listet nicht nur Synonyme, sondern auch Antonyme für Wörter der englischen Sprache auf. Die einzelnen Begriffe werden entsprechend ihrer Relevanz engefärbt. Es gibt weitere Auswahlkriterien wie „Wort-Komplexität“, „Wortlänge“, „Verwendung im Alltag“.
  • openthesaurus.de: OpenThesaurus.de ist Mitmach-Wörterbuch für Synonyme und Assoziationen der deutschen Sprache. Es gibt weitere Projekte in Griechisch, Polnisch, Portugiesisch, Slowenisch und Spanisch.

Wörterbücher

  • dict.cc: Dict.cc ist ein Mitmach-Wörterbuch, das Übersetzungen für mehr als 20 Sprachen bereitstellt (Wikipedia). Die Wörterbücher können für eigene Software heruntergeladen werden.
  • leo.org: LEO.org ist ein Wörterbuch, dass aus einem studentischen Projekt heraus entstanden ist. Derzeit umfasst es acht Sprachen (Wikipedia).

Abkürzungen

Zeichenketten in R zusammenfügen

Das Zusammenfügen von Zeichenketten (Konkatenieren von Strings) ist eine Standard-Aufgabe in allen Programmiersprachen. Auch bei der Programmierung in R wird die Funktion benötigt, wenn man z.B. Text dynamisch erzeugen lassen, oder den Wert einer Variablen an einen Text anfügen möchte. Die Funktion, die diese Aufgabe in R übernimmt, ist meiner Meinung nach etwas außergewöhnlich benannt. Mit diesem Artikel möchte ich mich selbst daran erinnern, dass sie paste() heißt.

Hier ein paar Beispiele, wie Zeichenketten (Strings) in verschiedenen Programmiersprachen zusammengefügt werden:

R
Die Funktion, mit der in R Strings zusammengefügt werden, heißt paste() (vom englischen „paste“ für „zusammenkleben“). Beispiel:

daten = c(1:10)
plot(daten, main=paste("Plot von",length(daten),"Werten."))

Mit der Funktion paste() werden durch Kommata getrennte Werte zusammengefügt. Dabei wird jedesmal ein Leerzeichen eingefügt. Wenn man die Zeichenketten ohne Leerzeichen zusammenfügen möchte, kann man entweder den Parameter sep="" setzen, oder die Funktion paste0() verwenden:

paste(sep="", "eins", "zwei") == paste0("eins", "zwei")
Java
In Java können Zeichenketten mit dem +-Operator verkettet werden:

String var = "eins";
var = var + "zwei" + "drei";
System.out.println(var);

oder mit dem +=-Operator:

String text = "Anfang";
text += "Ende";
System.out.println(text);

Sollte man sehr häufig Strings zusammenfügen, so empfiehlt sich die Verwendung eines StringBuffer-Objektes mit der Methode append() (siehe auch ChuckAndWayne-Blog):

StringBuffer b = new StringBuffer();
for (int i = 0; i<1000000; i++) {
	b.append("langer Text\n");
}
System.out.println(b);
bash
In der Bash können Variablen und Strings einfach direkt nacheinander geschrieben werden, um sie zusammenzufügen.

a="A"
b=$a"b"
echo $b
 
c="${b}c"
echo $c
 
echo $c "Bei echo können" "Leerzeichen zwischen" "den Strings sein."
 
d=$a$b
echo $d

Die bash unterstützt auch den +=-Operator:

c="Vorne"
c+=Hinten
echo $c

Für weitere Details siehe StackOverflow.

Um ganze Dateien zusammenzufügen, kann man den Befehl cat verwenden:

echo -e "Zeile 1, Datei 1\nZeile 2, Datei 1" > datei1.txt
echo -e "Zeile 1, Datei 2\nZeile 2, Datei 2" > datei2.txt
cat datei1.txt datei2.txt
PHP
In PHP können Strings mit Hilfe von . oder .= zusammengefügt werden:

<?php
$text = "Mein Text ";
$text .= "wird immer" . " " . "länger!";
echo $text;
?>
JavaScript
In JavaScript können Strings, ähnlich wie in Java, mit Hilfe des + und des +=-Operators aneinander gehängt werden:

<script>
var msg = "Nachricht";
msg += " wird";
msg = msg + " immer" + " länger";
alert(msg + "!");
</script>
C#
In C# können Strings mit Hilfe der Funktionen string.concat and string.join zusammengefügt werden. Siehe dazu den Blog von Alex James Brown.

Tabelle mit ASCII-Codes

Hin und wieder benötigt man beim Programmieren ASCII-Codes (z.B. für die Angabe von Symbolen in R-Plots). Daher zeige ich hier eine Liste der 128 ASCII-Zeichen, sowie deren Kodierung im Dezimalsystem, Hexadezimalsystem, Oktalsystem und Dualsystem. Die 128 ASCII-Zeichen umfassen 95 druckbare Zeichen und 33 Kontrollzeichen.

Weitere verwandte/ähnliche Zeichenkodierungen sind:

Zeichen/Abkürzung Dezimal Hexadezimal Oktal Binär Beschreibung
NUL 0 00 000 000 0000 Null character
SOH 1 01 001 000 0001 Start of Header
STX 2 02 002 000 0010 Start of Text
ETX 3 03 003 000 0011 End of Text
EOT 4 04 004 000 0100 End of Transmission
ENQ 5 05 005 000 0101 Enquiry
ACK 6 06 006 000 0110 Acknowledgment
BEL 7 07 007 000 0111 Bell
BS 8 08 010 000 1000 Backspace
HT 9 09 011 000 1001 Horizontal Tab
LF 10 0A 012 000 1010 Line feed
VT 11 0B 013 000 1011 Vertical Tab
FF 12 0C 014 000 1100 Form feed
CR 13 0D 015 000 1101 Carriage return
SO 14 0E 016 000 1110 Shift Out
SI 15 0F 017 000 1111 Shift In
DLE 16 10 020 001 0000 Data Link Escape
DC1 17 11 021 001 0001 Device Control 1 (often XON)
DC2 18 12 022 001 0010 Device Control 2
DC3 19 13 023 001 0011 Device Control 3 (often XOFF)
DC4 20 14 024 001 0100 Device Control 4
NAK 21 15 025 001 0101 Negative Acknowledgement
SYN 22 16 026 001 0110 Synchronous Idle
ETB 23 17 027 001 0111 End of Trans. Block
CAN 24 18 030 001 1000 Cancel
EM 25 19 031 001 1001 End of Medium
SUB 26 1A 032 001 1010 Substitute
ESC 27 1B 033 001 1011 Escape
FS 28 1C 034 001 1100 File Separator
GS 29 1D 035 001 1101 Group Separator
RS 30 1E 036 001 1110 Record Separator
US 31 1F 037 001 1111 Unit Separator
SP 32 20 040 010 0000
! 33 21 041 010 0001
34 22 042 010 0010
# 35 23 043 010 0011
$ 36 24 044 010 0100
% 37 25 045 010 0101
& 38 26 046 010 0110
39 27 047 010 0111
( 40 28 050 010 1000
) 41 29 051 010 1001
* 42 2A 052 010 1010
+ 43 2B 053 010 1011
, 44 2C 054 010 1100
45 2D 055 010 1101
. 46 2E 056 010 1110
/ 47 2F 057 010 1111
0 48 30 060 011 0000
1 49 31 061 011 0001
2 50 32 062 011 0010
3 51 33 063 011 0011
4 52 34 064 011 0100
5 53 35 065 011 0101
6 54 36 066 011 0110
7 55 37 067 011 0111
8 56 38 070 011 1000
9 57 39 071 011 1001
: 58 3A 072 011 1010
; 59 3B 073 011 1011
< 60 3C 074 011 1100
= 61 3D 075 011 1101
> 62 3E 076 011 1110
? 63 3F 077 011 1111
@ 64 40 100 100 0000
A 65 41 101 100 0001
B 66 42 102 100 0010
C 67 43 103 100 0011
D 68 44 104 100 0100
E 69 45 105 100 0101
F 70 46 106 100 0110
G 71 47 107 100 0111
H 72 48 110 100 1000
I 73 49 111 100 1001
J 74 4A 112 100 1010
K 75 4B 113 100 1011
L 76 4C 114 100 1100
M 77 4D 115 100 1101
N 78 4E 116 100 1110
O 79 4F 117 100 1111
P 80 50 120 101 0000
Q 81 51 121 101 0001
R 82 52 122 101 0010
S 83 53 123 101 0011
T 84 54 124 101 0100
U 85 55 125 101 0101
V 86 56 126 101 0110
W 87 57 127 101 0111
X 88 58 130 101 1000
Y 89 59 131 101 1001
Z 90 5A 132 101 1010
[ 91 5B 133 101 1011
\ 92 5C 134 101 1100
] 93 5D 135 101 1101
^ 94 5E 136 101 1110
_ 95 5F 137 101 1111
` 96 60 140 110 0000
a 97 61 141 110 0001
b 98 62 142 110 0010
c 99 63 143 110 0011
d 100 64 144 110 0100
e 101 65 145 110 0101
f 102 66 146 110 0110
g 103 67 147 110 0111
h 104 68 150 110 1000
i 105 69 151 110 1001
j 106 6A 152 110 1010
k 107 6B 153 110 1011
l 108 6C 154 110 1100
m 109 6D 155 110 1101
n 110 6E 156 110 1110
o 111 6F 157 110 1111
p 112 70 160 111 0000
q 113 71 161 111 0001
r 114 72 162 111 0010
s 115 73 163 111 0011
t 116 74 164 111 0100
u 117 75 165 111 0101
v 118 76 166 111 0110
w 119 77 167 111 0111
x 120 78 170 111 1000
y 121 79 171 111 1001
z 122 7A 172 111 1010
{ 123 7B 173 111 1011
| 124 7C 174 111 1100
} 125 7D 175 111 1101
~ 126 7E 176 111 1110
DEL 127 7F 177 111 1111 Delete

Quellen:

Linientypen, Symbole und Farben in R-Plots

R bietet verschiedene Möglichkeiten, seine Datenreihen in Plots unterscheidbar zu machen. Dazu gibt man in den Plot-Befehlen den zu ändernden Parameter, sowie einen Zahlenwert an. Ich vergesse allerdings immer, welche Zahl zu welcher Farbe oder zu welchem Linientyp gehört. Daher liste ich in diesem Artikel Zahlenwerte für folgende Parameter auf:

  1. Typen von Linien (lty).
    Beispiel: plot(c(1:10), type="o", lty=3).
  2. Farben (col).
    Beispiel: plot(c(1:10), type="o", col=4).
  3. Typen von Punkten / Sybole (pch; point character).
    Beispiel: plot(c(1:10), type="o", pch=5).

Linientypen

In R gibt es sechs verschiedene Typen von Linien. Die Zahlen für die Linientypen werden mit einer Periode von sechs „recycled“. Dadurch entspricht der Typ sieben (7) wieder dem Typen eins (1), eine Linie vom Typ acht (8) sieht aus wie eine Linie vom Typen zwei (2) und so weiter. Für jeden der Linien-Typen gibt es auch einen Namen (siehe auch Beschreibung des Parameters lty in der R-Hilfe zu par(): ?par):

  • 0: „blank“; unsichtbare Linie (=> wird nicht gezeichnet)
  • 1: „solid“
  • 2: „dashed“
  • 3: „dotted“
  • 4: „dotdash“
  • 5: „longdash“
  • 6: „twodash“
In R gibt es sechs verschiedene Typen von Linien, hier abwechselnd in rot und grün dargestellt. Jeder der Linientypen ist in 3 verschiedenen Größen (lwd=1-3) dargestellt. Die Werte für die Linientypen wiederholen sich in einer Periode von sechs. Daher entspricht die Angabe lty=7 der Angabe lty=1, die Angabe lty=8 entspricht der Angabe lty=2, und so weiter.
In R gibt es sechs verschiedene Typen von Linien, hier abwechselnd in rot und grün dargestellt. Jeder der Linientypen ist in 3 verschiedenen Größen (lwd=1-3) dargestellt. Die Werte für die Linientypen wiederholen sich in einer Periode von sechs. Daher entspricht die Angabe lty=7 der Angabe lty=1, die Angabe lty=8 entspricht der Angabe lty=2, und so weiter.

Das oben stehende Bild habe ich mit folgendem Code erzeugt:

1
2
3
4
5
6
7
8
# 6 Linientypen
png("linientypen.png")
par(mar=c(0,4,0,0)+.1, cex=1.5)
plot(1,1, type="n", ylim=c(0, 7), xaxt="n", xlab="", ylab="Linentyp (lty)", las=1)
abline(h=c(0:7),     lty=c(0:7), lwd=3, col=c(2,3))
abline(h=c(0:7)-0.2, lty=c(0:7), lwd=2, col=c(2,3))
abline(h=c(0:7)-0.4, lty=c(0:7), lwd=1, col=c(2,3))
dev.off()

Farben

In der Standard-Palette von R befinden sich acht verschiedene Farben. Dazu kommt noch der Wert 0, bei dem die Hintergrundfarbe als Farbe verwendet wird. Die Farben werden mit einer Periode von acht „recycled“. Durch diese fortlaufende Wiederholung, entspricht die Farbe neun (9) der Farbe eins (1), die Farbe zehn (10) wieder der Farbe zwei (2) und so weiter. Anstatt einer Zahl kann man auch direkt den RGB-Farbwert angeben (z.B. plot(1, 1, col="#000000") anstatt plot(1, 1, col=1) ). Weitere Details gibt es im Bereich „Color Specification“ in der R-Hilfe zu den Grafik-Parametern (?par).

In R gibt es acht verschiedene Farben. Hinzu kommt der Wert 0, bei dem die Hintergrundfarbe als Farbe verwendet wird (siehe diagonale Linie). Mit einer Periodenlänge von 8, werden die Farben wiederholt (wiederholte Farben sind mit einer dünnen Linie dargestellt).
In R gibt es acht verschiedene Farben. Hinzu kommt der Wert 0, bei dem die Hintergrundfarbe (hier: #eeeeee) als Farbe verwendet wird (siehe diagonale Linie). Mit einer Periodenlänge von 8, werden die Farben wiederholt (wiederholte Farben sind mit einer dünnen Linie dargestellt).

Für das vorangegangene Bild habe ich folgenden Code verwendet:

1
2
3
4
5
6
7
# 8 LinienFarben
png("linienfarben.png")
par(mar=c(0,4,0,0)+.1, cex=1.5, bg="#eeeeee")
plot(1,1, type="n", ylim=c(0, 11), xlim=c(0, 11), xaxt="n", xlab="", ylab="Linenfarbe (col)", las=1, lab=c(1,11,0))
abline(h=c(0:11), lty=1, lwd=c(rep(10,9), rep(1,9)), col=c(0:11))
abline(a=0, b=1, lwd=10, col=0)
dev.off()

Punkttypen / Symbole

Um den Punkttyp zu definieren, kann entweder ein einzelnes Zeichen oder eine Zahl angeben werden. In der Hilfe zum Befehl par() (?par oder ?graphics::par) steht dazu:

Note that only integers and single-character strings can be set as a graphics parameter (and not NA nor NULL)

Eine detaillierte Liste gibt es in der R-Hilfe zur Funktion points() (?points; Bereich „‚pch‘ values“). Hier eine kurze Zusammenfassung:

  • Zeichen 018: S-kompatible Vektor Symbole
  • Zeichen 1925: Weitere R Vektor Symbole. Die Zeichen 2125 können mit Hilfe von bg innerhalb des plot-Befehls (hier: points()) eingefärbt werden. Achtung: Die Angabe von bg innerhalb von points() hat hier eine andere Auswirkung als die Angabe von bg innerhalb von par() (z.B. par(bg="#ff00ff")). Durch letzteres setzt man die Hintergrundfarbe der gesamten Plot-Fläche.
  • Zeichen 2631: Werden ignoriert
  • Zeichen 32127: ASCII Zeichen

In der folgenden Grafik werden die die ersten 26 Zeichen dargestellt (+ zwei negative Werte).

Punkt-Typen für "pch"-Werte von -2 bis +25. Der Innernraum der Zeichen 21 bis 25 wurde durch die Angabe " bg='red' " innerhalb des Befehls "points()" rot eingefärbt.
Punkt-Typen für „pch“-Werte von -2 bis +25. Der Innernraum der Zeichen 21 bis 25 wurde durch die Angabe “ bg=’red‘ “ innerhalb des Befehls „points()“ rot eingefärbt.

Das oben stehende Bild wurde mit folgenden Befehlen erzeugt:

1
2
3
4
5
6
7
8
9
# 25 Punkt-Typen
png("punkttypen.png")
par(mar=c(0,4,0,0)+.25, cex=1.5)
plot(1, 1, type="n", ylim=c(-2, 25), xlim=c(0, 10), xaxt="n", xlab="", ylab="Punkttyp (pch)", las=1, lab=c(2,15,0))
abline(h=c(-2:25), lty=3, lwd=1, col="#cccccc")
for (typ in -2:25) {
  points(x=c(0:10), y=c(rep(typ,11)), pch=typ, bg="red")
}
dev.off()