Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung
Dieses Buch gibt eine umfassende, didaktisch erprobte Einführung in die statistische Programmiersprache R. Es vermittelt fundierte Kenntnisse zum sicheren und effizienten Einsatz von R zur Datenaufbereitung, Datenanalyse, Visualisierung, Berichterstellung und Simulation.Sein didaktisches Konzept wur...
Gespeichert in:
| Hauptverfasser: | , |
|---|---|
| Format: | Buch |
| Sprache: | German |
| Veröffentlicht: |
Wiesbaden
Springer Vieweg
[2020]
|
| Schriftenreihe: | Lehrbuch
|
| Schlagworte: | |
| Online-Zugang: | Inhaltsverzeichnis |
| Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
MARC
| LEADER | 00000nam a22000008c 4500 | ||
|---|---|---|---|
| 001 | BV046808040 | ||
| 003 | DE-604 | ||
| 005 | 20231101 | ||
| 007 | t| | ||
| 008 | 200715s2020 gw a||| |||| 00||| ger d | ||
| 015 | |a 19,N48 |2 dnb | ||
| 016 | 7 | |a 1200042514 |2 DE-101 | |
| 020 | |a 9783658288419 |c Festeinband : EUR 44,99 |9 978-3-658-28841-9 | ||
| 024 | 8 | |a Bestellnummer: 86954723 | |
| 024 | 3 | |a 9783658288419 | |
| 035 | |a (OCoLC)1129048370 | ||
| 035 | |a (DE-599)DNB1200042514 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 0 | |a ger | |
| 044 | |a gw |c XA-DE-HE | ||
| 049 | |a DE-1102 |a DE-92 |a DE-Aug4 |a DE-739 |a DE-188 |a DE-473 |a DE-521 |a DE-83 | ||
| 084 | |a ST 601 |0 (DE-625)143682: |2 rvk | ||
| 084 | |a ST 250 |0 (DE-625)143626: |2 rvk | ||
| 084 | |a 68-01 |2 msc/2020 | ||
| 084 | |a 62-04 |2 msc/2020 | ||
| 084 | |a 004 |2 sdnb | ||
| 084 | |a 68N15 |2 msc/2020 | ||
| 100 | 1 | |a Obszelka, Daniel |d 19XX- |0 (DE-588)1228123489 |4 aut | |
| 245 | 1 | 0 | |a Statistisches Programmieren mit R |b eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung |c Daniel Obszelka ; Andreas Baierl |
| 264 | 1 | |a Wiesbaden |b Springer Vieweg |c [2020] | |
| 264 | 4 | |c © 2020 | |
| 300 | |a XXVIII, 673 Seiten |b Illustrationen, Diagramme |c 24 cm x 16.8 cm | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b n |2 rdamedia | ||
| 338 | |b nc |2 rdacarrier | ||
| 490 | 0 | |a Lehrbuch | |
| 520 | 3 | |a Dieses Buch gibt eine umfassende, didaktisch erprobte Einführung in die statistische Programmiersprache R. Es vermittelt fundierte Kenntnisse zum sicheren und effizienten Einsatz von R zur Datenaufbereitung, Datenanalyse, Visualisierung, Berichterstellung und Simulation.Sein didaktisches Konzept wurde im Rahmen der mit dem Teaching Award der Universität Wien ausgezeichneten Lehrveranstaltung "Statistisches Programmieren" entwickelt. Das Buch ist somit sowohl als Lehrbuch in Lehrveranstaltungen als auch zum Selbststudium und als Nachschlagewerk für R-Profis bestens geeignet. | |
| 650 | 0 | 7 | |a R |g Programm |0 (DE-588)4705956-4 |2 gnd |9 rswk-swf |
| 653 | |a Data Science | ||
| 653 | |a Datenauswertung | ||
| 653 | |a Programmieren | ||
| 653 | |a Programmiersprache R | ||
| 653 | |a Statistik | ||
| 653 | |a Statistik Software | ||
| 653 | |a Statistisches Programmieren Buch | ||
| 653 | |a Visualisierung | ||
| 689 | 0 | 0 | |a R |g Programm |0 (DE-588)4705956-4 |D s |
| 689 | 0 | |5 DE-604 | |
| 700 | 1 | |a Baierl, Andreas |d 1973- |0 (DE-588)1111514496 |4 aut | |
| 710 | 2 | |a Springer Fachmedien Wiesbaden |0 (DE-588)1043386068 |4 pbl | |
| 776 | 0 | 8 | |i Erscheint auch als |n Online-Ausgabe |z 978-3-658-28842-6 |
| 856 | 4 | 2 | |m Digitalisierung UB Passau - ADAM Catalogue Enrichment |q application/pdf |u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032216653&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |3 Inhaltsverzeichnis |
| 943 | 1 | |a oai:aleph.bib-bvb.de:BVB01-032216653 | |
Datensatz im Suchindex
| _version_ | 1819582572712165376 |
|---|---|
| adam_text | XII Inhaltsverzeichnis Inhaltsverzeichnis A Erste Schritte mit R 1 1 R startklar machen............................................................................................. 1.1 /^-Homepage ............................................................................................. 1.2 R herunterladen und installieren ........................................................... 1.3 Onlinematerialien zum Buch.................................................................... 2 2 3 3 2 Los geht’s............................................................................................................ 2.1 RGui: die Oberfläche von R.................................................................... 2.1.1 RGui und Prompts - , + ...................................... 5 2.1.2 Das Skriptfenster: Skripte öffnen, speichern und laden .... 2.2 Aus der guten Programmierpraxis ........................................................ 2.2.1 Fallbeispiel: Lösung einer quadratischen Gleichung....... 6 2.2.2 Programmierstil: Gliederung, Lesbarkeit und Kommentierung 2.3 Kommentare und Zuweisungen........................................ 2.4 R als Taschenrechner - + , / , ( ) , sqrtO .... 2.5 Nützliche Tastenkombinationen.............................................................. 2.6 R beenden: Workspace und Skripte sichern ........................................ 2.7 Pakete installieren und laden ֊ install.packages!), library() . . 2.8 Abschluss................................................................................................... 2.8.1 Zusammenfassende
Kontrollfragen................................... 12 2.8.2 Ausblick................................................................................. 13 2.8.3 Übungen ....................................................................................... 4 4 3 Vektoren und logische Abfragen....................................................................... 3.1 Vektoren generieren ................................................................................ 3.1.1 Elemente zu Vektoren verketten ֊ c()............................. 15 3.1.2 Indizierung und Länge eines Vektors ֊ lengthO.......... 15 3.1.3 Einfache Sequenzen - : .................................................. 15 3.2 Elemente selektieren: Subsetting ֊ [ ] ............................................... 3.2.1 Subsetting mit Indizes und Indizes ausschließen .... 3.2.2 Subsetting mit Wahrheitswerten - TRUE und FALSE, ! ... 3.3 Recycling................................................................................................... 3.4 Logische Bedingungen und Operatoren.................................................. 3.4.1 Elemente vergleichen = , , = 3.4.2 Bedingungen verknüpfen I ........................................ 6 6 8 9 9 11 11 12 12 13 14 15 16 16 19 20 21 21 23
Inhaltsverzeichnis XIII 3.5 Rechnen mit Wahrheitswerten.............................................................. 24 3.5.1 Absolute und relative Häufigkeiten - sum(), meanO............ 24 3.5.2 Indexwerte bestimmen - which() 25 3.6 Ersetzen und Tauschen von Werten..................................................... 27 3.7 Aus der guten Programmierpraxis ..................................................... 30 3.7.1 Programmierstil: Sprechende Objektnamen und Sonderzeichen 30 3.7.2 Programmierstil: Allgemein und automatisiert programmieren 31 3.8 Abschluss............................................................................................... 34 3.8.1 Zusammenfassende Kontrollfragen.......................................... 34 3.8.2 Ausblick...................................................................................... 35 3.8.3 Übungen ................................................................................... 35 В Vektorfunktionen für Data Science und Statistik 37 4 Funktionsaufrufe, R-Hilfe und nützliche Funktionen.................................... 4.1 R-Hilfe help() .......................................................................... 4.2 Sequenzen generieren - seq().............................................................. 4.3 Regelwerk für Funktionsaufrufe........................................................... 4.3.1 Objektübergabe und Parameterzuordnung.............................. 4.3.2 Dynamische und statische Defaultwerte................................. 4.3.3 Dreipunkteargument und fehlende Werte - . . NA, na.rm . . 4.4
Objekte und Elemente replizieren - rep О.......................................... 4.5 Ganzzahlige Division, Rest und Teilbarkeit - ’UV , 4.6 Komponentenweises Rechnen.............................................................. 4.7 Nützliche Funktionen............................................................................. 4.7.1 Exponentialfunktion und Logarithmus - exp 0, log () .... 4.7.2 Runden - roundO, floorO, ceilingO, truncO, digits . 4.7.3 Absolutbetrag und Vorzeichenfunktion ֊ abs(), sign() ... 4.7.4 Trigonometrie ֊ sin(), cos0, tan(), pi.............................. 4.7.5 Aggregierende Logikfunktionen - all(), any(), xor() .... 4.8 Aus der guten Programmierpraxis ..................................................... 4.8.1 Programmierstil: Funktionssammlung erweitern..................... 4.8.2 Fallbeispiel: Lottotippscheine.................................................. 4.9 Abschluss............................................................................................... 4.9.1 Zusammenfassende Kontrollfragen.......................................... 4.9.2 Ausblick...................................................................................... 4.9.3 Übungen ................................................................................... 38 39 40 41 41 43 43 45 46 46 47 47 48 49 50 50 52 52 53 58 58 59 59 5 Arbeitsverzeichnis, Objekte und Dateiordner ............................................ 5.1 Objekte.................................................................................................. 5.1.1 Objekte auflisten - Ís
()........................................................... 5.1.2 Objekte löschen ֊ rm(), rm (list = Is О ) 5.2 Pfade und Arbeitsverzeichnis - getwdO, setwdO, .. .................. 5.3 Objekte speichern und laden - save(), loadO ................................. 5.4 Namen von Ordnern und Dateien abrufen - list .files О ............ 5.5 Funktionen zur Manipulation von Dateien und Ordnern.................. 62 62 62 63 64 65 66 67
XIV Inhaltsverzeichnis 5.6 Abschluss................................................................................................ 5.6.1 Zusammenfassende Kontrollfragen................................. 68 5.6.2 Ausblick.............................................................................. 69 5.6.3 Übungen .................................................................................... 6 Mengen, Sortieren und Kombinatorik............................................................ 6.1 Mengenfunktionen................................................................................. 6.1.1 Matchings bestimmen - 7oin /։ ................................................ 6.1.2 Mehrfacheinträge streichen - unique () 6.1.3 Schnittmenge und Vereinigung mit dem “/.in /.-Operator ... 6.1.4 Schnittmenge und Vereinigung - intersect(), unionO ... 6.2 Sortieren.................................................................................................. 6.2.1 Sortierung der Einträge - sort().................................... 75 6.2.2 Generierung der sortierenden Entnahmereihenfolge - order () 6.2.3 Ränge bestimmen - rank О............................................. 76 6.2.4 Vektoren umdrehen ֊ rev()............................................. 78 6.2.5 Mehrfachsortierung - order 0 6.2.6 Mehrfachsortierung und Ränge - rankO .............................. 6.3 Kombinatorik - factorial 0, choose О, prodO.............................. 6.4 Wissenschaftliche Notation ֊ options(scipen)................................. 6.5 Aus der guten
Praxis............................................................................. 6.5.1 Fallbeispiel: Unterscheidbare Lottoziehungsergebnisse.... 6.5.2 Fallbeispiel: Unterscheidbare Playlists einer Musik-CD.... 6.6 Abschluss............................................................................................... 6.6.1 Zusammenfassende Kontrollfragen................................. 85 6.6.2 Ausblick.............................................................................. 86 6.6.3 Übungen ................................................................................... 68 69 70 71 71 73 73 74 74 75 78 80 82 82 83 83 84 85 86 7 Deskriptive Statistik.............................................................................. 89 7.1 Funktionsübersicht und fehlende Werte ausschließen - na. rm .... 90 7.2 Minimum und Maximum - min(), max(), range()........................... 90 7.3 Mittelwert, Varianz und Standardabweichung ֊ mean(), var(), sd() 92 7.4 Median und Quantile - medianO, quant ile О ................................. 92 7.5 Summarys - summary() ........................................................................ 94 7.6 Aus der guten Statistikpraxis............................................................... 94 7.6.1 Robustheit und Ausreißer................................................ 94 7.6.2 Standardisierung............................................................... 95 7.7 Abschluss............................................................................................... 96 7.7.1 Zusammenfassende
Kontrollfragen.................................. 96 7.7.2 Ausblick.............................................................................. 97 7.7.3 Übungen ................................................................................... 97 8 Kumulieren und Parallelisieren............................................................. 99 8.1 Kumulierende Funktionen..................................................................... 100 8.1.1 Kumulierte Summen - cumsumO.................................... 100 8.1.2 Kumulierte Produkte - cumprodO................................. 102 8.1.3 Kumulierte Minima und Maxima - cummin О, cummax О . . . 102
Inhaltsverzeichnis XV 8.2 Parallele Funktionen................................................................................ 103 8.2.1 Parallele Minima und Maxima ֊ pminO, pmax()............. 103 8.2.2 Vektorwertige binäre Fallunterscheidungen - if else () .... 104 8.3 Differenzieren ֊ dif f О .......................................................................... 105 8.4 Kovarianz und Korrelation - cov(), cor()........................................... 106 8.5 Aus der guten Programmierpraxis ........................................................ 107 8.5.1 Fallbeispiel: Gewinnrangermittlung beim Joker................ 107 8.5.2 Fallbeispiel: Das Geburtstagsproblem ..................................... 108 8.5.3 Programmierstil: Wiederholte Berechnungen vermeiden . . . 109 8.6 Abschluss................................................................................................... 109 8.6.1 Objekte sichern........................................................................ 109 8.6.2 Zusammenfassende Kontrollfragen...................................... 109 8.6.3 Ausblick.................................................................................... 110 8.6.4 Übungen ....................................................................................... 110 9 Verteilungen und Zufallszahlen....................................................................... 113 9.1 Namenskonventionen - d, p, q, r........................................................... 113 9.2 Normalverteilung - dnormO, pnormO, qnormO,rnormО................. 114 9.3 Verteilungen - ein
Überblick.................................................................... 116 9.4 Gleichverteilte Zufallszahlen - runif О.................................................. 116 9.5 Zufall reproduzieren: Seeding - set.seedO,RNGversionO.............. 117 9.6 Stichproben ziehen - sample().............................................................. 118 9.7 Aus der guten Statistikpraxis................................................................. 119 9.7.1 Fallbeispiel: t-Test für das mittlere Gewicht von Äpfeln . . . 119 9.8 Abschluss................................................................................................... 122 9.8.1 Zusammenfassende Kontrollfragen...................................... 122 9.8.2 Ausblick.................................................................................... 122 9.8.3 Übungen ....................................................................................... 123 C Wichtige Hilfsmittel 125 10 Texte, Zeichenketten und Strings.................................................................... 126 10.1 Zeichenketten erstellen 126 10.2 Zeichenketten sortieren - sort О , order O, ranki)......................... 127 10.3 Zeichenketten verknüpfen ֊ paste(), pasteO().................................. 127 10.4 Buchstaben und Case sensitivity - letters und LETTERS............... 129 10.5 Abschluss................................................................................................... 130 10.5.1 Zusammenfassende Kontrollfragen...................................... 130 10.5.2
Ausblick.................................................................................... 130 10.5.3 Übungen ................................................................................ ... . 131 11 Einfache Datentypen, Modes und Typumwandlung..................................... 11.1 Einfache Datentypen und ihre Hierarchie.............................................. 11.2 Mode abfragen - mode(), is.datentypO........................................... 11.3 Implizite Typumwandlung....................................................................... 11.4 Explizite Typumwandlung - as. datentyp () ..................................... 11.5 Komplexe Zahlen - complex, Re(), Im(), NaN..................................... 132 132 133 134 135 136
XVI Inhaltsverzeichnis 11.6 Abschluss................................................................................................... 11.6.1 Zusammenfassende Kontrollfragen........................................... 11.6.2 Ausblick.......................................................................................... 11.6.3 Übungen ................................................................................ ... . 137 137 137 137 12 Beschriftungen, Names und Häufigkeitstabellen........................................... 12.1 Beschriftungen bei Vektoren.................................................................... 12.1.1 Zugriff auf Beschriftungen ֊ names ()........................................ 12.1.2 Subsetting mit Names . . ............................................................ 12.1.3 Übergabe von Beschriftungen in с О........................................ 12.1.4 Beschriftungen hinzufügen, ersetzen und löschen - names () -, NULL................................................................................................ 12.2 Häufigkeitstabellen und Tücken von Names........................................ 12.2.1 Häufigkeitstabellen erstellen - table () 12.2.2 Gewichtete Mittelwerte berechnen aus Häufigkeitstabellen . . 12.2.3 Häufigkeiten selektieren aus Häufigkeitstabellen...................... 12.2.4 Lückenlose Häufigkeitstabellen erstellen.................................. 12.3 Abschluss................................................................................................... 12.3.1 Zusammenfassende
Kontrollfragen........................................... 12.3.2 Ausblick.......................................................................................... 12.3.3 Übungen ....................................................................................... 139 140 140 140 141 13 Computerarithmetik und Rundungsfehler..................................................... 13.1 Dezimalzahlen und Rundungsfehler - options (digits)................... 13.2 Prüfung auf annähernde Gleichheit........................................................ 13.2.1 Absolute Abweichung messen..................................................... 13.2.2 Funktionsbasierte Prüfung - all.equal()............................... 13.3 Abschluss................................................................................................... 13.3.1 Zusammenfassende Kontrollfragen........................................... 13.3.2 Ausblick.......................................................................................... 13.3.3 Übungen ....................................................................................... 150 150 151 151 152 153 153 154 154 14 Konstante............................................................................................................ 14.1 Eingebaute Konstante - Constants........................................................ 14.1.1 Konstante zurückgewinnen ֊ rm(Konstante)......................... 14.1.2 TRUE und FALSE .......................................................................... 14.2 Das NULL-Objekt ֊֊
NULL.......................................................................... 14.2.1 Beschriftungen löschen - names О - NULL............................ 14.2.2 Abfrage auf NULL ֊ is .null().................................................. 14.3 Fehlende Werte - NA................................................................................. 14.3.1 Auf Gleichheit mit NA abfragen ֊ is.naO............................... 14.3.2 Berechnung von Maßzahlen, unbedingter Fall......................... 14.3.3 Umgang mit fehlenden Werten in Funktionen......................... 14.3.4 Berechnung von Maßzahlen, bedingter Fall - subset () . . . 14.3.5 Logische Werte und NA................................................................. 14.4 Unendlichkeit - Inf, is.finitei), is.infiniteO............................ 14.5 Not A Number - NaN, is.nanO ........................................................... 155 156 156 157 158 158 159 159 160 160 161 162 163 164 165 142 143 143 144 145 146 147 147 148 148
Inhaltsverzeichnis 14.6 Abschluss............................................................................................... 14.6.1 Zusammenfassung der Konstanten.......................................... 14.6.2 Zusammenfassende Kontrollfragen.......................................... 14.6.3 Ausblick...................................................................................... 14.6.4 Übungen ................................................................................... XVII 166 166 166 167 167 D Datenstrukturen 169 15 Matrizen........................................................................................................... 15.1 Matrizen generieren undmanipulieren............................................... 15.1.1 Vektoren zu Matrizen anordnen - matrix()........................... 15.1.2 Vektoren aneinanderhängen -rbindO, cbindO................... 15.1.3 Dimension von Matrizen - nrow(), ncolO, dim(), length() 15.1.4 Beschriftungen bei Matrizen - colnames(), rownames() . . . 15.1.5 Matrizen transponieren - է ().................................................. 15.1.6 Matrix oder Vektor? - is.matrixO, is.vectori)............... 15.2 Selektion: Subsetting , , drop] ................................. 15.2.1 Selektion von Zeilen und Spalten mit Indizes und Names . . 15.2.2 Selektion von Zeilen und Spalten mit logischen Abfragen . . . 15.2.3 Elemente selektieren - [ ] ................................................... 15.2.4 Subsetting mit Matrizen........................................................... 15.3 Summen/Mittelwerte für Zeilen/Spalten
֊ rowSumsO, colSumsO, rowMeansO, colMeansO .................................................................... 15.4 Rechnen mit Wahrheitswerten.............................................................. 15.5 Matrix vs. Vektor................................................................................... 15.5.1 Matrix in Vektor umwandeln - as .vector() ........................ 15.5.2 Bedeutung von drop = FALSE beim Subsetting..................... 15.6 Ersetzen von Werten............................................................................. 15.6.1 Ersetzungen in der ganzen Matrix.......................................... 15.6.2 Ersetzungen von fehlenden Werten - NA, is .na()................ 15.6.3 Ersetzungen in Teilbereichen - row (), col О ........................ 15.7 Aus der guten Programmierpraxis ..................................................... 15.7.1 Programmierstil: Lesbarkeit undSpacing ............................... 15.8 Abschluss............................................................................................... 15.8.1 Objekte sichern.......................................................................... 15.8.2 Zusammenfassende Kontrollfragen.......................................... 15.8.3 Ausblick...................................................................................... 15.8.4 Übungen ................................................................................... 170 171 171 172 174 174 175 176 176 177 178 180 180 181 184 185 185 185 186 186 188 188 189 189 190 190 191 191 192 16 Rechnen mit Matrizen und Lineare
Algebra................................................ 195 16.1 Diagonalmatrizen und Diagonalelemente- diagO ............................ 195 16.2 Rechnen mit Matrizen.......................................................................... 197 16.2.1 Elementweises Rechnen 197 16.2.2 Matrixmultiplikation crossprodO, tcrossprodO . 198 16.2.3 Invertierung und Determinante - solve(), det ().................. 198
XVIII Inhaltsverzeichnis 16.3 Aus der guten Praxis................................................................................. 16.3.1 Fallbeispiel: Lineare Regression.................................................. 16.3.2 Fallbeispiel: Lineare Gleichungssysteme lösen - solve() . . . 16.4 Abschluss................................................................................................... 16.4.1 Zusammenfassende Kontrollfragen........................................... 16.4.2 Ausblick.......................................................................................... 16.4.3 Übungen ....................................................................................... 198 199 201 202 202 202 203 17 Listen.................................................................................................................. 204 17.1 Eigenwerte und Eigenvektoren - eigenO ........................................... 205 17.2 Überblick über Listen - is. listO, mode O, տէր O, length О .... 205 17.3 Subsetting und Names [ ] , [[ ]] ,namesO ................... 206 17.4 Listen erstellen und initialisieren - listO, vectorC list ) .... 208 17.5 Atomare und rekursive Objekte - is.atomicO, is. recursive О, is.vectorO ............................................................................................. 210 17.6 Elemente hinzufügen, löschen und ersetzen ֊ c(), NULL......................... 211 17.7 Listen zu Vektorenvereinfachen - unlistO........................................ 212 17.8
Abschluss................................................................................................... 213 17.8.1 Zusammenfassende Kontrollfragen........................................... 213 17.8.2 Ausblick.......................................................................................... 213 17.8.3 Übungen ....................................................................................... 214 18 Wiederholte Funktionsanwendung bei Listen .............................................. 18.1 Wiederholte Funktionsanwendung auf Elemente einer Datenstruktur - lapplyO, sapplyO............................................................................. 18.2 Parameterübergabe innerhalb von sapplyO und lapplyO ............ 18.3 Operatoren als Funktion verwenden........................................................ 18.4 Vereinfachung der Datenstruktur bei sapplyO.................................. 18.5 sapply() und lapply() bei Vektoren und Matrizen......................... 18.6 Abschluss................................................................................................... 18.6.1 Zusammenfassende Kontrollfragen........................................... 18.6.2 Ausblick.......................................................................................... 18.6.3 Übungen ....................................................................................... 215 19 Wiederholte Funktionsanwendung bei Matrizen.......................................... 19.1 Wiederholte Funktionsanwendung auf Zeilen und Spalten einer Ma trix-apply 0 19.1.1 Erstes
Anwendungsbeispiel für applyO.................................. 19.1.2 Vereinfachung der Datenstruktur bei applyO......................... 19.1.3 Anordnung der Ergebnisse bei apply О .................................. 19.1.4 Parameterübergabe innerhalb von apply О ............................ 19.2 Über Zeilen und Spalten fegen - sweep О ............................................ 19.3 Zentrierung und Standardisierung - scaleO ..................................... 19.4 Äußere Vektorprodukte - outer О, %o7» ............................................ 19.5 Abschluss................................................................................................... 19.5.1 Zusammenfassende Kontrollfragen............................................ 19.5.2 Ausblick.......................................................................................... 19.5.3 Übungen ....................................................................................... 227 216 217 219 221 222 223 223 223 224 228 228 229 230 230 231 232 233 234 234 234 235
Inhaltsverzeichnis XIX 20 Dataframes......................................................................................................... 237 20.1 Allgemeines zu Dataframes .................................................................... 238 20.1.1 Dataframes generieren - data.frame0 .................................. 238 20.1.2 Dimension von Dataframes ֊ nrow(), ncolO, length() . . . 239 20.1.3 Beschriftungen ändern ֊ rownamesO, colnamesQ,names() . 239 20.1.4 Überblick über das Dataframe - strü, head(), tailO . . . 240 20.2 Zusammenhang mit Matrizen ֊ as.matrix()..................................... 241 20.3 Zugriff auf Zeilen und Spalten: Subsetting........................................... 241 20.3.1 Zugriff auf Spalten/Variablen..................................................... 241 20.3.2 Zugriff auf Zeilen/Beobachtungen.............................................. 242 20.3.3 Flexibler Zugriff - subset () 243 20.4 Manipulation von Dataframes................................................................. 243 20.4.1 Variablen anfügen und löschen - cbindO, NULL, list (NULL) 243 20.4.2 Zeilen und Spalten umordnen.................................................... 246 20.4.3 Einträgen oder Variablen ersetzen........................................... 246 20.5 Zusammenhang mit Listen-is. listO, as.listi), is. data, f rame О, as.data.frameO, classO, unclass().............................................. 247 20.6 Funktionen revisited................................................................................ 249 20.6.1 apply 0 und sapplyO bei Dataframes
.................................. 249 20.6.2 is .na() und Vergleichsoperatoren bei Dataframes............... 252 20.7 Abschluss................................................................................................... 252 20.7.1 Objekte sichern............................................................................. 252 20.7.2 Zusammenfassende KontroUfragen........................................... 253 20.7.3 Ausblick.......................................................................................... 253 20.7.4 Übungen ....................................................................................... 254 21 Dataframes verknüpfen..................................................................................... 255 21.1 Joins - mergei).......................................................................................... 255 21.2 Zeilenweise Verknüpfung - rbind О........................................ ............... 258 21.3 Aus der guten Praxis................................................................................ 259 21.3.1 Fallbeispiel: Verwaltung einfacher Datenbanken...................... 259 21.4 Abschluss................................................................................................... 261 21.4.1 Zusammenfassende Kontrollfragen........................................... 261 21.4.2 Übungen ....................................................................................... 261 E Tools für Data Science und Statistik 263 22 Textmanipulation:
Stringfunktionen.............................................................. 264 22.1 Simple Stringfunktionen -nebari), toloweri), toupperi)............ 265 22.2 Nach Mustern in Texten suchen.............................................................. 266 22.2.1 Elemente des Vektors finden - grepli), grepi) ................... 267 22.2.2 Stellen in Texten finden - regexpri), gregexpri)................... 269 22.2.3 Anzahl der Übereinstimmungen zählen..................................... 271 22.3 Extraktion von Teilen aus Zeichenketten - substringi)................... 273 22.4 Sonderzeichen mit besonderen Fähigkeiten - [ ], ...................... 275 22.5 Ersetzungen in Zeichenketten - subi), gsubО .................................. 276 22.6 Zerlegung von Zeichenketten - strspliti) ........................................ 278
XX Inhaltsverzeichnis 22.7 Zusammenfassung der Stringfunktionen ............................................... 22.8 Abschluss................................................................................................... 22.8.1 Objekte sichern.............................................................................. 22.8.2 Zusammenfassende Kontrollfragen............................................ 22.8.3 Ausblick.......................................................................................... 22.8.4 Übungen ....................................................................................... 279 280 280 280 281 281 23 Komplexe Textsuchmuster: Regular Expressions........................................... 23.1 Sonderzeichen und Escape-Befehle - Tregex, [ ], , n, ............ 23.2 Zeichenmengen und flexible Suchmuster definieren ............................ 23.2.1 Beliebiges Zeichen .............................................................. 23.2.2 Zeichen ein- und ausschließen ֊[],[*].................................. 23.2.3 Zeichenbereiche definieren - [A-Z], [a-z], [0-9]................... 23.3 Matchlänge steuern.................................................................................... 23.3.1 Matchlängenoperatoren und Kürzel -{},+,*,?................... 23.3.2 Greedy Matching unterbinden - ? ........................................... 23.4 Teilstrings extrahieren - regmatchesO ............................................... 23.5 Nützliche Tools zum Ersten.................................................................... 23.5.1
Zeichengruppen definieren - () ............................................... 23.5.2 Zeichen und Zeichengruppen verodern ֊I............................... 23.5.3 Stringanfang und Stringende 23.5.4 Strings trimmen und White Space - [:space:]...................... 23.6 Nützliche Tools zum Zweiten................................................................. 23.6.1 Vorherige Zeichengruppe erneut matchen - k...................... 23.6.2 Bedingte Extraktion: Lookaheads und Lookbehinds - perl, (?= ), (?! ), (? = ), (? ! ) .................................................. 23.6.3 Überlappende Suche - perl, (?= )........................................... 23.7 Aus der guten Praxis................................................................................. 23.7.1 Fallbeispiel: Stationsansagen der Wiener Linien...................... 23.8 Abschluss................................................................................................... 23.8.1 Zusammenfassung der Sonderzeichen und der Syntax............. 23.8.2 Zusammenfassende Kontrollfragen........................................... 23.8.3 Übungen ....................................................................................... 283 284 286 286 287 288 289 289 291 291 294 294 295 296 297 298 298 24 Kategorielle Variablen: Faktoren.................................................................... 24.0 Die Daten des Kapitels einiesen ֊ read, table() 24.1 Faktoren: Sinn, Generierung und Verwaltung ..................................... 24.1.1 Codierung von
Ausprägungen..................................................... 24.1.2 Faktoren generieren - factor 0 24.1.3 Interne Verwaltung ֊ unclassO, modeO, is.factorO . . . 24.1.4 Zugriff auf die Ausprägungen - levels(), nlevelsO .... 24.1.5 Faktoren und Strings - as. character О.................................. 24.1.6 Codierungsreihenfolge bestimmen mit levels......................... 24.2 Kategorisierung von numerischen Variablen........................................ 24.2.1 Bedingungen aufsummieren........................................................ 24.2.2 Kategorisierung mit cut () 310 311 312 312 313 314 315 315 316 317 317 318 300 302 303 303 305 305 306 307
Inhaltsverzeichnis 24.3 Ausprägungen manipulieren.................................................................... 24.3.1 Verschmelzen von Faktorausprägungen..................................... 24.3.2 Umbenennung von Ausprägungen.............................................. 24.3.3 Neue Ausprägungen hinzufügen.................................................. 24.4 Ordinalskalierung - factor (ordered), as.orderedO, is.orderedO 24.5 Tücken im Zusammenhang mit Faktoren.............................................. 24.5.1 Umordnen von Faktorausprägungen........................................ 24.5.2 Das as.numeroc-Problem.............................................................. 24.5.3 Lückenlose Häufigkeitstabellen revisited֊ tablet)................. 24.6 Fehlende Werte als Kategorie - f actor (exclude), is.na()............ 24.7 Abschluss....................................................... 24.7.1 Objekte sichern............................................................................. 24.7.2 Zusammenfassende Kontrollfragen........................................... 24.7.3 Ausblick.......................................................................................... 24.7.4 Übungen ....................................................................................... XXI 319 320 321 321 322 324 324 325 326 327 328 328 329 330 330 25 Aggregation und Kreuztabellen....................................................................... 332 25.1 Funktionen auf Gruppen anwenden: Teil 1 - tapplyO...................... 333 25.2
Kreuztabellen............................................................................................. 336 25.2.1 Einfache Kreuztabellen - table () ........................................... 336 25.2.2 Mehrdimensionale Kreuztabellen-table(), applyO, ftable()336 25.2.3 Randsummen bestimmen und anhängen - margin, table О, addmarginsO ............................................................................. 338 25.2.4 Allgemeine Kreuztabellen - tapplyO..................................... 339 25.2.5 Zeilen-, Spalten-und Totalprozent - prop, table О ............ 339 25.3 Funktionen auf Gruppen anwenden: Teil 2 - aggregate О............... 341 25.3.1 Eine Gruppenvariable................................................................. 342 25.3.2 Mehrere Gruppenvariablen........................................................ 343 25.4 Verfügbarkeit von Variablen.................................................................... 344 25.4.1 Lokale Verfügbarkeit - withO.................................................. 344 25.4.2 Globale Verfügbarkeit - attach О, detach О......................... 344 25.5 Abschluss................................................................................................... 345 25.5.1 Zusammenfassende Kontrollfragen........................................... 345 25.5.2 Ausblick.......................................................................................... 346 25.5.3 Übungen ....................................................................................... 346 26 Klassen, generische Funktionen und
Attribute.............................................. 26.1 Klassen, generische Funktionen - classO, UseMethodO, methods О 26.2 Attribute erfragen und Klassenattribut entfernen - attributes (), unclassO................................................................................................... 26.3 Aus der guten Praxis................................................................................ 26.3.1 Fallbeispiel: Run Length Encoding........................................... 26.4 Abschluss................................................................................................... 26.4.1 Zusammenfassende Kontrollfragen........................................... 26.4.2 Ausblick.......................................................................................... 26.4.3 Übungen ....................................................................................... 348 348 351 352 352 353 353 353 353
XXII Inhaltsverzeichnis 27 Datums- und Uhrzeitobjekte ........................................................................... 355 27.1 Erste Einblicke.......................................................................................... 356 27.1.1 Datum und Uhrzeit abfragen - Sys.Date(), Sys.time() . . 356 27.1.2 Klassenübersicht - Date, POSIXct,POSIXlt.............................. 356 27.1.3 Konvertierung - as.Date(), as.POSIXctO, as.POSIXltO . 357 27.2 Datum und Uhrzeit formatieren.............................................................. 357 27.2.1 Formatierungsfunktionen und Platzhalter ֊ format.Date(), format. POSIXctO....................................................................... 357 27.2.2 Datumsfunktionen - weekdays (), months(), quarters() . . 359 27.3 Datums-und Uhrzeitobjekte erzeugen - as.Date(), as.POSIXct() . 360 27.3.1 Erzeugung aus Zeichenketten..................................................... 361 27.3.2 Erzeugung aus Referenzdatum bzw.Referenzuhrzeit............... 362 27.4 Datums- und Uhrzeitvektoren sortieren - sort О, order () ............ 363 27.5 Rechnen mit Datumswerten.................................................................... 364 27.5.1 Tage und Sekunden addieren bzw. subtrahieren...................... 364 27.5.2 Paarweise Zeitdifferenzen bestimmen - diff ()...................... 364 27.5.3 Parallele Zeitdifferenzen bestimmen difftimeO . . . 365 27.6 Spezielle Datumswerte erzeugen und Locales........................................ 371 27.7 Aus der guten
Praxis.................................................................... ... . . . 373 27.7.1 Anwendungshierarchie der drei Klassen.................................. 373 27.7.2 Fallbeispiel: Berechnung von Adventsonntagen...................... 374 27.8 Abschluss................................................................................................... 376 27.8.1 Zusammenfassende Kontrollfragen........................................... 376 27.8.2 Ausblick und Rückblick.............................................................. 377 27.8.3 Übungen ....................................................................................... 377 F Eigene Funktionen und Ablaufsteuerung 28 Kontrollstrukturen............................................................................................. 28.1 Anweisungsblöcke - {}.......................................................................... 28.2 Bedingte Anweisung und Verzweigung............................ ‘................... 28.2.1 Bedingte Anweisung ֊if........................................................... 28.2.2 Wenn/Dann-Verzweigung ֊ if, else........................................ 28.2.3 if/else vs. ifelseO................................................................. 28.3 Schleifen...................................................................................................... 28.3.1 for-Schleife - for.......................................................................... 28.3.2 Zwei Anwendungsvarianten der for-Schleife............................ 28.3.3 Sequenzielle vs. parallele
Berechnung, Schleifenvermeidung . 28.3.4 while-Schleife ֊ while................................................................. 28.3.5 Schleifensteuerung - break, next............................................... 28.3.6 Endlosschleifen - while (TRUE), repeat ............................... 28.4 Aus der guten Praxis................................................................................. 28.4.1 Programmierstil: Einrückungen.................................................. 28.4.2 Fallbeispiel: Zelluläre Automaten............................................... 379 380 381 381 381 382 384 384 384 386 388 389 390 391 392 392 393
Inhaltsverzeichnis 28.5 Abschluss................................................................................................... 28.5.1 Zusammenfassende Kontrollfragen........................................... 28.5.2 Ausblick.......................................................................................... 28.5.3 Übungen ...................................................................................... XXIII 396 396 396 397 29 Eigene Funktionen: Grundlagen....................................................................... 399 29.1 Eigene Funktionen schreiben - function............................................. 400 29.1.1 Funktionsname............................................................................. 400 29.1.2 Parameter....................................................................................... 400 29.1.3 Rückgabe ֊ returnO, invisible0........................................ 400 29.2 Fehlermeldungen und Warnungen - stopO, warningO ...................403 29.3 Bedingungen verknüpfen zum Zweiten | I ......................... 404 29.4 Parameter und Argumente....................................................................... 405 29.4.1 Statische Defaultwerte und Wrapper-Funktionen................... 405 29.4.2 Dynamische Defaultwerte........................................................... 407 29.4.3 Unspezifizierte Parameter........................................................... 408 29.4.4 Objekte switchen - switch()..................................................... 409 29.4.5 Das Dreipunkteargument - .. ., list
(...)............................ 410 29.5 Aus der guten Praxis................................................................................ 412 29.5.1 Programmierstil: Funktionskommentare.................................. 412 29.5.2 Fallbeispiel: Bisektion................................................................. 414 29.6 Environments und Scoping....................................................................... 416 29.7 Funktionen überschreiben - : : , rm() .............................................. 417 29.8 Abschluss................................................................................................... 418 29.8.1 Zusammenfassende Kontrollfragen........................................... 418 29.8.2 Ausblick.......................................................................................... 419 29.8.3 Übungen ....................................................................................... 419 30 Eigene Funktionen: Ergänzung undVertiefung ............................................. 30.1 *apply() vs. Schleifen............................................................................. 30.2 Anonyme Funktionen - functionO ..................................................... 30.3 Rekursion - Recall ()............................................................................. 30.4 Methoden für generische Funktionen schreiben .................................. 30.5 Eigene Operatoren schreiben ............................................................... 30.6 Aus der guten
Praxis................................................................................ 30.6.1 Fallbeispiel: Klasse Bruch........................................................... 30.6.2 Fallbeispiel: Auswertung von Polynomen.................................. 30.7 Abschluss................................................................................................... 30.7.1 Zusammenfassende Kontrollfragen........................................... 30.7.2 Ausblick.......................................................................................... 30.7.3 Übungen ....................................................................................... 421 422 424 425 431 432 432 432 436 439 439 439 440 G Datenimport und Datenexport 441 31 Stringformatierung, Consoleneingabe und -ausgabe..................................... 31.1 Consolenausgabe ֊ cat(), printO, n , t .................................. 31.2 Strings formatieren - format ().............................................................. 31.3 Zahlen formatieren ֊ formate 0 ........................................................... 442 442 443 444
XXIV Inhaltsverzeichnis 31.4 Tabellen erstellen....................................................................................... 445 31.5 Consoleneingabe - scanO........................................................................ 446 31.6 Aus der guten Praxis................................................................................. 448 31.6.1 Fallbeispiel: Mathequiz .............................................................. 448 31.7 Abschluss................................................................................................... 452 31.7.1 Zusammenfassende Kontrollfragen...................................... 452 31.7.2 Ausblick.................................................................................... 452 31.7.3 Übungen ....................................................................................... 452 32 Datenimport und Datenexport....................................................................... 454 32.1 Einfache Dateiformate............................................................................. 455 32.1.1 Textdateien einiesen - read.table() 455 32.1.2 Textdateien schreiben - write.table()............................. 458 32.1.3 csv-Dateien einiesen schreiben - read. csv(),write.csv() 458 32.2 Zeichencodierung....................................................................................... 459 32.2.1 Zeichencodierungsstandards.................................................. 459 32.2.2 Zeichencodierung umstellen - EncodingO, options (encoding) 461 32.2.3 Reparaturen per
Hand............................................................ 462 32.3 Datenaufbereitung.................................................................................... 462 32.3.1 Herausforderungen beim Einlesen meistern ............................ 462 32.3.2 Strings nicht als Faktoren einiesen ֊ stringsAsFactors . . . 469 32.4 Textdateien mit beliebigem Format einiesen - scanO ......................469 32.5 Textdateien mit beliebigem Format schreiben - cat ()..........................472 32.6 Einlesen aus anderen Quellen................................................................. 474 32.6.1 Excel-Dateien einiesen - read.xlsxO................................ 474 32.6.2 SPSS- und SAS-Dateien einiesen - read.spssO,read.sas0 475 32.7 Abschluss................................................................................................... 476 32.7.1 Zusammenfassende Kontrollfragen...................................... 476 32.7.2 Übungen ....................................................................................... 477 H Effizienz und Simulation 479 33 Effizienz............................................................................................................... 480 33.1 Laufzeitmessung: Spaltenmittelwerte einerMatrix................................. 480 33.1.1 Messung mittels Stoppuhr ֊ Sys.time() 480 33.1.2 Messung der CPU֊Zeit: system, time О.................................. 482 33.2 Beispiel: Dreiecksdichte auswerten ........................................................ 483 33.3
Laufzeitvergleiche....................................................................................... 485 33.4 Beispiel: Zeilenminima einer Matrix........................................................ 487 33.5 Beispiel: Würfelwurf - Augensumme erreichen..................................... 489 33.6 Beispiel: Flächeninhalt zufälliger Dreiecke............................................ 497 33.7 Monte-Carlo-Siimüation.......................................................................... 499 33.8 Abschluss................................................................................................... 500 33.8.1 Zusammenfassung der Effizienztipps................................... 500 33.8.2 Ausblick.................................................................................... 500 33.8.3 Übungen ....................................................................................... 501
Inhaltsverzeichnis XXV I 505 Visualisierung von Daten 34 Einführung in die 2D-Grafik............................................................................. 34.1 Basisfunktion zur Grafikerstellung - plot ()........................................ 34.1.1 Erste Grafiken und Einstellungen.............................................. 34.1.2 Streudiagramme zum Ersten - plot 0..................................... 34.2 Grafikparameter steuern - par()........................................................... 34.2.1 Skalierung ֊ cex.......................................................................... 34.2.2 Farben - col................................................................................ 34.2.3 Punktarten ֊ pch.......................................................................... 34.2.4 Linienart und Linienstärke - lty und lwd............................... 34.2.5 Hintergrundfarbe - bg, transparent .................................. 34.2.6 Umgang mit par()....................................................................... 34.2.7 Streudiagramme zum Zweiten.................................................... 34.3 Grafikelemente hinzufügen....................................................................... 34.3.1 Punkte, Linien, Texte - points (), lines (), text (), mtext О 34.3.2 Legenden - legendO ................................................................. 34.3.3 Boxen, Gitter, Achsen ֊ box(), gridO, axisO, pretty() . 34.3.4 Zeichenreihenfolge steuern - type = ո 34.3.5 Rechtecke und Polygone ֊֊ reet О, polygoni) ......................
34.3.6 Adjustierungen und quadratische Plots - adj, padj, par(pty = s ) .......................................................................................... 34.3.7 Linien und Pfeile - abl ine O, segment s(), arrows 0 .... 34.3.8 Titel und Überschriften - title О........................................... 34.4 Aus der guten Praxis................................................................................ 34.4.1 Fallbeispiel: Uhr.......................................................................... 34.5 Abschluss................................................................................................... 34.5.1 Zusammenfassende Kontrollfragen........................................... 34.5.2 Ausblick.......................................................................................... 34.5.3 Übungen ....................................................................................... 506 507 507 511 511 513 514 515 516 516 516 517 518 518 519 522 523 524 35 Standardgrafiken und Farben.......................................................................... 35.1 Standardgrafiken....................................................................................... 35.1.1 Parallele Liniengrafiken, Matrixplot - matplot ()................... 35.1.2 Balkendiagramme - barplot ()................................................. 35.1.3 Histogramme - hist () 35.1.4 Rückgabeobjekte von Grafikfunktionen verwerten................... 35.1.5 Boxplots - boxplotO................................................................. 35.2 Die Welt der
Farben................................................................................ 35.2.1 RGB-Farben - rgb() ................................................................. 35.2.2 HCL-Farben - hcl ()........................... 35.2.3 Standardfarbpaletten ֊ Palettes.............................................. 35.2.4 Eigene Farbpaletten - colorRamp(), colorRampPaletteO . 35.3 Aus der guten Praxis................................................................................ 35.3.1 Fallbeispiel: Farblich markierte Balkendiagramme.................. 535 536 536 540 544 547 549 551 551 552 554 555 557 557 526 527 528 529 529 532 532 533 533
XXVI Inhaltsverzeichnis 35.4 Abschluss................................................................................................... 35.4.1 Zusammenfassende Kontrollfragen............................................ 35.4.2 Ausblick.......................................................................................... 35.4.3 Übungen ....................................................................................... 560 560 561 561 36 Grafikfenster und Layout ................................................................................. 564 36.1 Grafikfenster: Devices.............................................................................. 564 36.1.1 Neues Device öffnen ֊ dev.new()............................................... 564 36.1.2 Aktives Device abfragen und setzen - dev.cur(), dev.set0 565 36.1.3 Device schließen ֊ dev. off 0, graphics. off ()...................... 565 36.2 Grafiken speichern.................................................................................... 565 36.2.1 Rastergrafiken vs. Vektorgrafiken............................................... 565 36.2.2 Speichern von Grafiken .............................................................. 566 36.3 Fenstereinteilung und Layout................................................................. 567 36.3.1 Äußere Grafikränder ֊ par ()$mar, par ()$mai ...................... 567 36.3.2 Einfache Fensterteilung - par()$mf row .................................. 568 36.3.3 Paarweise Streudiagramme ֊ pairs()..................................... 570 36.3.4 Eigene Layouts definieren ֊
layoutO, layout. show О, lcmO 571 36.4 Aus der guten Praxis................................................................................. 576 36.4.1 Fallbeispiel: Streudiagramme mit Randverteilungen - density (), substitute() 576 36.5 Abschluss................................................................................................... 585 36.5.1 Zusammenfassende Kontrollfragen........................................... 585 36.5.2 Ausblick.......................................................................................... 585 36.5.3 Übungen ....................................................................................... 586 J Data Science und Statistik in derPraxis 37 Verteilungstests und Hypothesentests.............................................................. 37.1 Verteilungstests.......................................................................................... 37.1.1 Histogramme mit Anpassungslinie ֊ hist О............................ 37.1.2 Quantil-Quantil-Plot - qqplotO, qqlineO, qqPlotO . . . 37.1.3 Kolmogorov-Smirnov-Test - ks.testi), LcKSO ................... 37.2 Hypothesentests für kategorielle Merkmale........................................... 37.2.1 Binomialtest - binom.test()..................................................... 37.2.2 Rückgabeobjekt von Testfunktionen - htest ......................... 37.2.3 Tests für Anteilswerte - prop, test О ..................................... 37.2.4 McNemar-Test ֊ mcnemar .testi) ........................................... 37.2.5 x2-Test -
chisq.testi).............................................................. 37.2.6 Weitere Tests für kategorielle Merkmale.................................. 37.3 Hypothesentests für metrische Merkmale............................................... 37.3.1 Test für Korrelationskoeffizienten - cor .test О ................... 37.3.2 t-Test für eine und zwei Stichproben - t .testО................... 37.4 Nichtparametrische Hypothesentests - wilcox. test О...................... 37.5 Weitere Tests für metrische Merkmale.................................................. 37.6 Überblick über wichtige Hypothesentests in R..................................... 589 590 592 592 593 595 596 596 597 597 598 599 600 601 601 602 604 605 606
Inhaltsverzeichnis XXVII 37.7 Abschluss................................................................................................... 606 37.7.1 Zusammenfassende Kontrollfragen...................................... 606 37.7.2 Ausblick.................................................................................... 607 37.7.3 Übungen ...................................................................................... 607 38 Statistische Modelle .......................................................................................... 608 38.1 Lineare Regression - lm(), formula ..................................................... 608 38.1.1 Einfache lineare Regression.................................................. 609 38.1.2 Mehrere metrische unabhängige Variablen, Modellbildung . . 611 38.1.3 Kategorielle Variablen - model .matrix(), contrastsO . . 613 38.1.4 Modellselektion und Modelldiagnostik - step(), anovaO . 614 38.1.5 Zusatzbeispiel zur linearen Regression - predictO, stepí) . 617 38.2 Weitere statistische Verfahren................................................................. 621 38.2.1 Varianzanalyse - aov(), Error()......................................... 621 38.2.2 Generalisierte lineare Modelle ֊֊ glm()................................ 621 38.3 Abschluss................................................................................................... 622 38.3.1 Zusammenfassende Kontrollfragen...................................... 622 38.3.2 Ausblick: Funktionen zu weiteren statistischen Verfahren . . 622 38.3.3 Übungen
....................................................................................... 623 39 Programmierpraxis............................................................................................. 624 39.1 R-Code in mehrere Dateien teilen - source ()..................................... 624 39.2 R-Code und Dokumentation integrieren.............................................. 625 39.2.1 Einleitung................................................................................. 625 39.2.2 Einfügen des R-Codes in ein Dokument............................. 626 39.2.3 Dokument mit R-Code ausführen - knit (), render О .... 628 39.3 Fehlertypen und Fehlersuche (Debugging)........................................... 629 39.3.1 Fehlertypen.............................................................................. 629 39.3.2 Fehlersuche und -korrektur - browser(), recoverO .... 630 39.4 Abschluss................................................................................................... 635 39.4.1 Zusammenfassende Kontrollfragen...................................... 635 39.4.2 Ausblick.................................................................................... 636 39.4.3 Übungen ....................................................................................... 636 40 Interaktive Webanwendungen mit Shiny........................................................ 638 40.1 Grundlegendes zur Programmierung einer Shiny-Anwendung .... 638 40.1.1 Struktur einer Shiny-Anwendung......................................... 639 40.1.2 Bereitstellung einer Shiny-
Anwendung................................ 639 40.1.3 Interaktives Verhalten steuern - react ive О ......................... 640 40.2 Serverfunktion und Render-Funktionen................................................. 640 40.3 User Interface Objekt (UI)....................................................................... 642 40.3.1 Layout........................................................................................ 642 40.3.2 Input- und Outputfunktionen............................................... 643 40.4 Shiny-Beispiel: Darstellung einer Normalverteilungsstichprobe .... 646 40.4.1 Version 1: sidebarLayout...................................................... 646 40.4.2 Version 2: sidebarLayout mit Unterseiten ............................ 647
XXVIII Inhaltsverzeichnis 40.5 Abschluss................................................................................................... 40.5.1 Zusammenfassende Kontrollfragen........................................... 40.5.2 Übungen ....................................................................................... 648 648 649 41 Relevante R-Pakete............................................................................................. 41.1 Konzeptionelle Erweiterungen vonBase-/?............................................. 41.2 Grafik......................................................................................................... 41.3 Import/Export............................................................. 41.4 Funktionensammlungen.......................................................................... 41.5 Statistische Modelle und Methoden........................................................ 41.6 Spezielle Anwendungsbereiche................................................................. 650 650 650 651 651 652 652 42 /?-Ressourcen...................................................................................................... 653 К Verzeichnisse 655 Stichwortverzeichnis................................................................................................ 656 Funktionsverzeichnis................................................................................................ 662 Operatoren- und Konstantenverzeichnis.............................................................. 667
Abbildungsverzeichnis............................................................................................. 668 Tabellenverzeichnis................................................................................................... 670 Infoboxenverzeichnis................................................................................................ 672 Regelverzeichnis ...................................................................................................... 673
|
| any_adam_object | 1 |
| author | Obszelka, Daniel 19XX- Baierl, Andreas 1973- |
| author_GND | (DE-588)1228123489 (DE-588)1111514496 |
| author_facet | Obszelka, Daniel 19XX- Baierl, Andreas 1973- |
| author_role | aut aut |
| author_sort | Obszelka, Daniel 19XX- |
| author_variant | d o do a b ab |
| building | Verbundindex |
| bvnumber | BV046808040 |
| classification_rvk | ST 601 ST 250 |
| ctrlnum | (OCoLC)1129048370 (DE-599)DNB1200042514 |
| discipline | Informatik |
| format | Book |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02858nam a22006018c 4500</leader><controlfield tag="001">BV046808040</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20231101 </controlfield><controlfield tag="007">t|</controlfield><controlfield tag="008">200715s2020 gw a||| |||| 00||| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">19,N48</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1200042514</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783658288419</subfield><subfield code="c">Festeinband : EUR 44,99</subfield><subfield code="9">978-3-658-28841-9</subfield></datafield><datafield tag="024" ind1="8" ind2=" "><subfield code="a">Bestellnummer: 86954723</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9783658288419</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1129048370</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB1200042514</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">ger</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">XA-DE-HE</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-1102</subfield><subfield code="a">DE-92</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-188</subfield><subfield code="a">DE-473</subfield><subfield code="a">DE-521</subfield><subfield code="a">DE-83</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 601</subfield><subfield code="0">(DE-625)143682:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">68-01</subfield><subfield code="2">msc/2020</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">62-04</subfield><subfield code="2">msc/2020</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">68N15</subfield><subfield code="2">msc/2020</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Obszelka, Daniel</subfield><subfield code="d">19XX-</subfield><subfield code="0">(DE-588)1228123489</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Statistisches Programmieren mit R</subfield><subfield code="b">eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung</subfield><subfield code="c">Daniel Obszelka ; Andreas Baierl</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Wiesbaden</subfield><subfield code="b">Springer Vieweg</subfield><subfield code="c">[2020]</subfield></datafield><datafield tag="264" ind1=" " ind2="4"><subfield code="c">© 2020</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XXVIII, 673 Seiten</subfield><subfield code="b">Illustrationen, Diagramme</subfield><subfield code="c">24 cm x 16.8 cm</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a">Lehrbuch</subfield></datafield><datafield tag="520" ind1="3" ind2=" "><subfield code="a">Dieses Buch gibt eine umfassende, didaktisch erprobte Einführung in die statistische Programmiersprache R. Es vermittelt fundierte Kenntnisse zum sicheren und effizienten Einsatz von R zur Datenaufbereitung, Datenanalyse, Visualisierung, Berichterstellung und Simulation.Sein didaktisches Konzept wurde im Rahmen der mit dem Teaching Award der Universität Wien ausgezeichneten Lehrveranstaltung "Statistisches Programmieren" entwickelt. Das Buch ist somit sowohl als Lehrbuch in Lehrveranstaltungen als auch zum Selbststudium und als Nachschlagewerk für R-Profis bestens geeignet.</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">R</subfield><subfield code="g">Programm</subfield><subfield code="0">(DE-588)4705956-4</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Data Science</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Datenauswertung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Programmieren</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Programmiersprache R</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Statistik</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Statistik Software</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Statistisches Programmieren Buch</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Visualisierung</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">R</subfield><subfield code="g">Programm</subfield><subfield code="0">(DE-588)4705956-4</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Baierl, Andreas</subfield><subfield code="d">1973-</subfield><subfield code="0">(DE-588)1111514496</subfield><subfield code="4">aut</subfield></datafield><datafield tag="710" ind1="2" ind2=" "><subfield code="a">Springer Fachmedien Wiesbaden</subfield><subfield code="0">(DE-588)1043386068</subfield><subfield code="4">pbl</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe</subfield><subfield code="z">978-3-658-28842-6</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau - ADAM Catalogue Enrichment</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032216653&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-032216653</subfield></datafield></record></collection> |
| id | DE-604.BV046808040 |
| illustrated | Illustrated |
| indexdate | 2024-12-24T08:16:30Z |
| institution | BVB |
| institution_GND | (DE-588)1043386068 |
| isbn | 9783658288419 |
| language | German |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-032216653 |
| oclc_num | 1129048370 |
| open_access_boolean | |
| owner | DE-1102 DE-92 DE-Aug4 DE-739 DE-188 DE-473 DE-BY-UBG DE-521 DE-83 |
| owner_facet | DE-1102 DE-92 DE-Aug4 DE-739 DE-188 DE-473 DE-BY-UBG DE-521 DE-83 |
| physical | XXVIII, 673 Seiten Illustrationen, Diagramme 24 cm x 16.8 cm |
| publishDate | 2020 |
| publishDateSearch | 2020 |
| publishDateSort | 2020 |
| publisher | Springer Vieweg |
| record_format | marc |
| series2 | Lehrbuch |
| spellingShingle | Obszelka, Daniel 19XX- Baierl, Andreas 1973- Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung R Programm (DE-588)4705956-4 gnd |
| subject_GND | (DE-588)4705956-4 |
| title | Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung |
| title_auth | Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung |
| title_exact_search | Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung |
| title_full | Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung Daniel Obszelka ; Andreas Baierl |
| title_fullStr | Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung Daniel Obszelka ; Andreas Baierl |
| title_full_unstemmed | Statistisches Programmieren mit R eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung Daniel Obszelka ; Andreas Baierl |
| title_short | Statistisches Programmieren mit R |
| title_sort | statistisches programmieren mit r eine ausfuhrliche ubersichtliche spannende und praxiserprobte einfuhrung |
| title_sub | eine ausführliche, übersichtliche, spannende und praxiserprobte Einführung |
| topic | R Programm (DE-588)4705956-4 gnd |
| topic_facet | R Programm |
| url | http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032216653&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |
| work_keys_str_mv | AT obszelkadaniel statistischesprogrammierenmitreineausfuhrlicheubersichtlichespannendeundpraxiserprobteeinfuhrung AT baierlandreas statistischesprogrammierenmitreineausfuhrlicheubersichtlichespannendeundpraxiserprobteeinfuhrung AT springerfachmedienwiesbaden statistischesprogrammierenmitreineausfuhrlicheubersichtlichespannendeundpraxiserprobteeinfuhrung |