DataScienceSpCourseNotes/2_RPROG/R_Programming_Course_Notes.html at master · s7c/DataScienceSpCourseNotes

History

1463 lines (1436 loc) · 890 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

<!DOCTYPE html>

<head>

<title>R Programming Course Notes</title>

table.sourceCode, tr.sourceCode, td.lineNumbers, td.sourceCode {

margin: 0; padding: 0; vertical-align: baseline; border: none; }

table.sourceCode { width: 100%; line-height: 100%; }

td.lineNumbers { text-align: right; padding-right: 4px; padding-left: 4px; color: #aaaaaa; border-right: 1px solid #aaaaaa; }

td.sourceCode { padding-left: 5px; }

code > span.kw { color: #007020; font-weight: bold; }

code > span.dt { color: #902000; }

code > span.dv { color: #40a070; }

code > span.bn { color: #40a070; }

code > span.fl { color: #40a070; }

code > span.ch { color: #4070a0; }

code > span.st { color: #4070a0; }

code > span.co { color: #60a0b0; font-style: italic; }

code > span.ot { color: #007020; }

code > span.al { color: #ff0000; font-weight: bold; }

code > span.fu { color: #06287e; }

code > span.er { color: #ff0000; font-weight: bold; }

</style>

pre:not([class]) {

background-color: white;

}

</style>

</head>

<body>

.main-container {

max-width: 940px;

margin-left: auto;

margin-right: auto;

}

code {

color: inherit;

background-color: rgba(0, 0, 0, 0.04);

}

img {

max-width:100%;

height: auto;

}

</style>

<h1 class="title">R Programming Course Notes</h1>

</div>

<ul>

<li><a href="#overview-and-history-of-r">Overview and History of R</a></li>

<li><a href="#coding-standards">Coding Standards</a></li>

<li><a href="#workspace-and-files">Workspace and Files</a></li>

<li><a href="#r-console-and-evaluation">R Console and Evaluation</a></li>

<li><a href="#r-objects-and-data-structures">R Objects and Data Structures</a><ul>

<li><a href="#vectors-and-lists">Vectors and Lists</a></li>

<li><a href="#matrices-and-data-frames">Matrices and Data Frames</a></li>

<li><a href="#arrays">Arrays</a></li>

<li><a href="#factors">Factors</a></li>

</ul></li>

<li><a href="#missing-values">Missing Values</a></li>

<li><a href="#sequence-of-numbers">Sequence of Numbers</a></li>

<li><a href="#subsetting">Subsetting</a><ul>

<li><a href="#vectors">Vectors</a></li>

<li><a href="#lists">Lists</a></li>

<li><a href="#matrices">Matrices</a></li>

<li><a href="#partial-matching">Partial Matching</a></li>

</ul></li>

<li><a href="#logic">Logic</a></li>

<li><a href="#understanding-data">Understanding Data</a></li>

<li><a href="#split-apply-combine-funtions">Split-Apply-Combine Funtions</a><ul>

<li><a href="#split"><code>split()</code></a></li>

<li><a href="#apply"><code>apply()</code></a></li>

<li><a href="#lapply"><code>lapply()</code></a></li>

<li><a href="#sapply"><code>sapply()</code></a></li>

<li><a href="#vapply"><code>vapply()</code></a></li>

<li><a href="#tapply"><code>tapply()</code></a></li>

<li><a href="#mapply"><code>mapply()</code></a></li>

<li><a href="#aggregate"><code>aggregate()</code></a></li>

</ul></li>

<li><a href="#simulation">Simulation</a><ul>

<li><a href="#simulation-examples">Simulation Examples</a></li>

<li><a href="#generate-numbers-for-a-linear-model">Generate Numbers for a Linear Model</a></li>

</ul></li>

<li><a href="#dates-and-times">Dates and Times</a></li>

<li><a href="#base-graphics">Base Graphics</a></li>

<li><a href="#reading-tabular-data">Reading Tabular Data</a><ul>

<li><a href="#larger-tables">Larger Tables</a></li>

<li><a href="#textual-data-formats">Textual Data Formats</a></li>

<li><a href="#interfaces-to-the-outside-world">Interfaces to the Outside World</a></li>

</ul></li>

<li><a href="#control-structures">Control Structures</a><ul>

<li><a href="#while"><code>while</code></a></li>

<li><a href="#repeat-and-break"><code>repeat</code> and <code>break</code></a></li>

<li><a href="#next-and-return"><code>next</code> and <code>return</code></a></li>

</ul></li>

<li><a href="#functions">Functions</a></li>

<li><a href="#scoping">Scoping</a><ul>

<li><a href="#scoping-example">Scoping Example</a></li>

<li><a href="#lexical-vs-dynamic-scoping-example">Lexical vs Dynamic Scoping Example</a></li>

<li><a href="#optimization">Optimization</a></li>

</ul></li>

<li><a href="#debugging">Debugging</a></li>

<li><a href="#r-profiler">R Profiler</a><ul>

<li><a href="#miscellaneous">Miscellaneous</a></li>

</ul></li>

</ul>

</div>

<p><span class="math">$\pagebreak$</span></p>

<h2>Overview and History of R</h2>

<ul>

<li><strong>R</strong> = dialect of the <strong>S</strong> language

<ul>

<li>S was developed by John Chambers @ Bell Labs</li>

<li>initiated in 1976 as internal tool, originally FORTRAN libraries</li>

<li>1988 rewritten in C (version 3 of language)</li>

<li>1998 version 4 (what we use today)</li>

</ul></li>

<li><strong>History of S</strong>

<ul>

<li>Bell labs –> insightful –> Lucent –> Alcatel-Lucent</li>

<li>in 1998, S won the Association for computing machinery’s software system award</li>

</ul></li>

<li><strong>History of R</strong>

<ul>

<li>1991 created in New Zealand by Ross Ihaka & RobertGentleman</li>

<li>1993 first announcement of R to public</li>

<li>1995 Martin Machler convinces founders to use GNU General Public license to make R free</li>

<li>1996 public mailing list created R-help and R-devel</li>

<li>1997 R Core Group formed</li>

<li>2000 R v1.0.0 released</li>

</ul></li>

<li><strong>R Features</strong>

<ul>

<li>Syntax similar to S, semantics similar to S, runs on any platforms, frequent releasees</li>

<li>lean software, functionalities in modular packages, sophisticated graphics capabilities</li>

<li>useful for interactive work, powerful programming language</li>

<li>active user community and <strong><em>FREE</em></strong> (4 freedoms)

<ul>

<li>freedom to run the program</li>

<li>freedom to study how the program works and adapt it</li>

<li>freedom to redistribute copies</li>

<li>freedom to improve the program</li>

</ul></li>

<li><strong>R Drawbacks</strong>

<ul>

<li>40 year-old technology</li>

<li>little built-in support for dynamic/3D graphics</li>

<li>functionality based on consumer demand</li>

<li>objects generally stored in physical memory (limited by hardware)</li>

</ul></li>

<li><strong>Design of the R system</strong>

<ul>

<li>2 conceptual parts: base R from CRAN vs. everything else</li>

<li>functionality divided into different packages

<ul>

<li><strong>base R</strong> contains core functionality and fundamental functions</li>

<li>other utility packages included in the base install: <code>util</code>, <code>stats</code>, <code>datasets</code>, …</li>

<li>Recommended packages: boot class, KernSmooth, etc</li>

</ul></li>

<li>5000+ packages available</li>

</ul></li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Coding Standards</h2>

<ul>

<li>Always use text files/editor</li>

<li>Indent code (4 space minimum)</li>

<li>limit the width of code (80 columns)</li>

<li>limit the length of individual functions</li>

</ul>

</div>

<h2>Workspace and Files</h2>

<ul>

<li><code>getwd()</code> = return current working directory</li>

<li><code>setwd()</code> = set current working directory</li>

<li><code>?function</code> = brings up help for that function</li>

<li><code>dir.create("path/foldername", recursive = TRUE)</code> = create directories/subdirectories</li>

<li><code>unlink(directory, recursive = TRUE)</code> = delete directory and subdirectories``</li>

<li><code>ls()</code> = list all objects in the local workspace</li>

<li><code>list.files(recursive = TRUE)</code> = list all, including subdirectories</li>

<li><code>args(function)</code> = returns arguments for the function</li>

<li><code>file.create("name")</code> = create file

<ul>

<li><code>.exists("name")</code> = return true/false exists in working directory</li>

<li><code>.info("name")</code> = return file info</li>

<li><code>.info("name")$property</code> = returns value for the specific attribute</li>

<li><code>.rename("name1", "name2")</code> = rename file</li>

<li><code>.path("name1")</code> = return path of file</li>

</ul></li>

</ul>

</div>

<h2>R Console and Evaluation</h2>

<ul>

<li><code><-</code> = assignment operator</li>

<li><code>#</code> = comment</li>

<li>expression is evaluated after hitting <code>enter</code> and result is returned</li>

<li>autoprinting occurs when you call a variable

<ul>

<li>print(x) = explicitly printing</li>

</ul></li>

<li><code>[1]</code> at the beginning of the output = which element of the vector is being shown</li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>R Objects and Data Structures</h2>

<ul>

<li>5 basic/<strong>atomic classes</strong> of objects:

<li>character</li>

<li>numeric</li>

<li>integer</li>

<li>complex</li>

<li>logical</li>

</ol></li>

<li><strong>Numbers</strong>

<ul>

<li>numbers generally treated as <code>numeric</code> objects (double precision real numbers - decimals)</li>

<li>Integer objects can be created by adding <code>L</code> to the end of a number(ex. 1L)</li>

<li><code>Inf</code> = infinity, can be used in calculations</li>

<li><code>NaN</code> = not a number/undefined</li>

<li><code>sqrt(value)</code> = square root of value</li>

</ul></li>

<li><strong>Variables</strong>

<ul>

<li><code>variable <- value</code> = assignment of a value to a variable name</li>

</ul></li>

</ul>

<h3>Vectors and Lists</h3>

<ul>

<li><strong>atomic vector</strong> = contains one data type, most basic object

<ul>

<li><code>vector <- c(value1, value2, …)</code> = creates a vector with specified values</li>

<li><code>vector1*vector2</code> = element by element multiplication (rather than matrix multiplication)

<ul>

<li>if the vectors are of different lengths, shorter vector will be recycled until the longer runs out</li>

<li>computation on vectors/between vectors (+, -, ==, /, etc.) are done element by element by default</li>

<li><code>%*%</code> = force matrix multiplication between vectors/matrices</li>

</ul></li>

<li><code>vector("class", n)</code> = creates empty vector of length n and specified class

<ul>

<li><code>vector("numeric", 3)</code> = creates 0 0 0</li>

</ul></li>

<li><code>c()</code> = concatenate

<ul>

<li><code>T, F</code> = shorthand for TRUE and FALSE</li>

<li><code>1+0i</code> = complex numbers</li>

</ul></li>

<li><strong>explicit coercion</strong>

<ul>

<li><code>as.numeric(x)</code>, <code>as.logical(x)</code>, <code>as.character(x)</code>, <code>as.complex(x)</code> = convert object from one class to another</li>

<li>nonsensible coercion will result in NA (ex. as.numeric(c(“a”, “b”))</li>

<li><code>as.list(data.frame)</code> = converts a <code>data.frame</code> object into a <code>list</code> object</li>

<li><code>as.characters(list)</code> = converts list into a character vector</li>

</ul></li>

<li><strong>implicit coercion</strong>

<ul>

<li>matrix/vector can only contain one data type, so when attempting to create matrix/vector with different classes, forced coercion occurs to make every element to same class

<ul>

<li><em>least common denominator</em> is the approach used (basically everything is converted to a class that all values can take, numbers –> characters) and <em>no errors generated</em></li>

<li>coercion occurs to make every element to same class (implicit)</li>

<li><code>x <- c(NA, 2, "D")</code> will create a vector of character class</li>

</ul></li>

<li><code>list()</code> = special vector wit different classes of elements

<ul>

<li><code>list</code> = vector of objects of different classes</li>

<li>elements of list use [[]], elements of other vectors use []</li>

</ul></li>

<li><strong>logical vectors</strong> = contain values <code>TRUE</code>, <code>FALSE</code>, and <code>NA</code>, values are generated as result of logical conditions comparing two objects/values</li>

<li><code>paste(characterVector, collapse = " ")</code> = join together elements of the vector and separating with the <code>collapse</code> parameter</li>

<li><code>paste(vec1, vec2, sep = " ")</code> = join together different vectors and separating with the <code>sep</code> parameter

<ul>

<li><em><strong>Note</strong>: vector recycling applies here too</em></li>

<li><code>LETTERS</code>, <code>letters</code>= predefined vectors for all 26 upper and lower letters</li>

</ul></li>

<li><code>unique(values)</code> = returns vector with all duplicates removed</li>

</ul>

</div>

<h3>Matrices and Data Frames</h3>

<ul>

<li><code>matrix</code> can contain <strong>only 1</strong> type of data</li>

<li><code>data.frame</code> can contain <strong>multiple</strong></li>

<li><code>matrix(values, nrow = n, ncol = m)</code> = creates a n by m matrix

<ul>

<li>constructed <strong>COLUMN WISE</strong> –> the elements are placed into the matrix from top to bottom for each column, and by column from left to right</li>

<li>matrices can also be created by adding the dimension attribute to vector

<ul>

</ul></li>

<li>matrices can also be created by binding columns and rows

<ul>

<li><code>rbind(x, y)</code>, <code>cbind(x, y)</code> = combine rows/columns; can be used on vectors or matrices</li>

</ul></li>

<li><code>*</code> and <code>/</code> = element by element computation between two matrices

<ul>

<li><code>%*%</code> = matrix multiplication</li>

</ul></li>

<li><code>dim(obj)</code> = dimensions of an object (returns <code>NULL</code> if a vector)

<ul>

<li><code>dim(obj) <- c(4, 5)</code> = assign <code>dim</code> attribute to an object

<ul>

<li>if object is a vector, R converts the vector to a n by m matrix (i.e. 4 rows by 5 column from the example command)

<ul>

<li><em><strong>Note</strong>: if n by m is larger than length of vector, then an error is returned</em></li>

</ul></li>

<li><strong><em>example</em></strong></li>

</ul></li>

</ul>

<pre class="sourceCode r"><code class="sourceCode r"><span class="co"># initiate a vector</span>

x <-<span class="kw">c</span>(<span class="ot">NA</span>, <span class="dv">1</span>, <span class="st">"cx"</span>, <span class="ot">NA</span>, <span class="dv">2</span>, <span class="st">"dsa"</span>)

<span class="kw">class</span>(x)</code></pre>

<pre><code>## [1] "character"</code></pre>

<pre class="sourceCode r"><code class="sourceCode r"><span class="co"># convert to matrix</span>

<span class="kw">dim</span>(x) <-<span class="st"> </span><span class="kw">c</span>(<span class="dv">3</span>, <span class="dv">2</span>)

<span class="kw">class</span>(x)</code></pre>

<pre><code>## [1] "matrix"</code></pre>

<pre><code>## [,1] [,2]

## [1,] NA NA

## [2,] "1" "2"

## [3,] "cx" "dsa"</code></pre>

<ul>

<li><code>data.frame(var = 1:4, var2 = c(….))</code> = creates a data frame

<ul>

<li><code>nrow()</code>, <code>ncol()</code> = returns row and column numbers</li>

<li><code>data.frame(vector, matrix)</code> = takes any number of arguments and returns a single object of class “data.frame” composed of original objects</li>

<li><code>as.data.frame(obj)</code> = converts object to data frame</li>

<li>data frames store tabular data</li>

<li>special type of list where every list has the same length (can be of different type)</li>

<li>data frames are usually created through <code>read.table()</code> and <code>read.cvs()</code></li>

<li><code>data.matrix()</code> = converts a matrix to data frame</li>

</ul></li>

<li><code>colMeans(matrix)</code> or <code>rowMeans(matrix)</code> = returns means of the columns/rows of a matrix/dataframe in a vector</li>

<li><code>as.numeric(rownames(df))</code> = returns row indices for rows of a data frame with unnamed rows</li>

<li><strong>attributes</strong>

<ul>

<li>objects can have attributes: <code>names</code>, <code>dimnames</code>, <code>row.names</code>, <code>dim</code> (matrices, arrays), <code>class</code>, <code>length</code>, or any user-defined ones</li>

<li><code>attributes(obj)</code>, <code>class(obj)</code> = return attributes/class for an R object</li>

<li><code>attr(object, "attribute") <- "value"</code> = creates/assigns a value to a new/existing attribute for the object</li>

<li><strong><code>names</code> attribute</strong>

<ul>

<li>all objects can have names</li>

<li><code>names(x)</code> = returns names (NULL if no name exists)

<ul>

<li><code>names(x) <- c("a", …)</code> = can be used to assign names to vectors</li>

</ul></li>

<li><code>lists(a = 1, b = 2, …)</code> = a, b are names</li>

<li><code>dimnames(matrix) <- list(c("a", "b"), c("c" , "d"))</code> = assign names to matrices

<ul>

<li>use list of two vectors: row, column in that order</li>

</ul></li>

<li><code>colnames(data.frame)</code> = return column names (can be used to set column names as well, similar to <code>dim()</code>)</li>

<li><code>row.names</code> = names of rows in the data frame (attribute)</li>

</ul></li>

</ul>

</div>

<h3>Arrays</h3>

<ul>

<li>multi-dimensional collection of data with <span class="math">$k$</span> dimensions

<ul>

<li>matrix = 2 dimensional array</li>

</ul></li>

<li><code>array(data, dim, dimnames)</code>

<ul>

<li><code>data</code> = data to be stored in array</li>

<li><code>dim</code> = dimensions of the array

<ul>

<li><code>dim = c(2, 2, 5)</code> = 3 dimensional array –> creates 5 2x2 array</li>

</ul></li>

<li><code>dimnames</code> = add names to the dimensions

<ul>

<li>input must be a <code>list</code></li>

<li>every element of the <code>list</code> must correspond in length to the dimensions of the array</li>

<li><code>dimnames(x) <- list(c("a", "b"), c("c", "d"), c("e", "f", "g", "h", "i"))</code> = set the names for row, column, and third dimension respectively (2 x 2 x 5 in this case)</li>

</ul></li>

<li><code>dim()</code> function can be used to create arrays from vectors or matrices

<ul>

<li><code>x <- rnorm(20); dim(x) <- c(2, 2, 5)</code> = converts a 20 element vector to a 2x2x5 array</li>

</ul></li>

</ul>

</div>

<h3>Factors</h3>

<ul>

<li>Factors are used to represent categorical data (integer vector where each value has a label)</li>

<li>2 types: <strong>unordered</strong> vs <strong>ordered</strong></li>

<li>treated specially by <code>lm()</code>, <code>glm()</code></li>

<li>Factors easier to understand because they self describe (vs. 1 and 2)</li>

<li><code>factor(c("a", "b"), levels = c("1", "2"))</code> = creates factor

<ul>

<li><code>levels()</code> argument can be used to specify baseline levels vs other levels

<ul>

<li><em><strong>Note</strong>:without explicit specification, R uses alphabetical order</em></li>

</ul></li>

<li><code>table(factorVar)</code> = how many of each are in the factor</li>

</ul></li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Missing Values</h2>

<ul>

<li><code>NaN</code> or <code>NA</code> = missing values

<ul>

<li><code>NaN</code> = undefined mathematical operations</li>

<li><code>NA</code> = any value not available or missing in the statistical sense

<ul>

<li>any operations with <code>NA</code> results in <code>NA</code></li>

<li>NA can have different classes potentially (integer, character, etc)</li>

</ul></li>

<li><em><strong>Note</strong>: NaN is an NA value, but NA is not NaN</em></li>

</ul></li>

<li><code>is.na(), is.nan()</code> = use to test if each element of the vector is NA and NaN

<ul>

<li><em><strong>Note</strong>: cannot compare NA (with ==) as it is not a value but a <strong>placeholder</strong> for a quantity that is not available</em><br /></li>

</ul></li>

<li><p><code>sum(my_na)</code> = sum of a logical vector (<code>TRUE</code> = 1 and <code>FALSE</code> = 0) is effectively the number of <code>TRUE</code>s</p></li>

<li><strong>Removing NA Values</strong>

<ul>

<li><code>is.na()</code> = creates logical vector where T is where value exists, F is NA

<ul>

<li>subsetting with the above result can return only the non NA elements</li>

</ul></li>

<li><code>complete.cases(obj1, obj2)</code> = creates logical vector where <code>TRUE</code> is where both values exist, and <code>FALSE</code> is where any is NA

<ul>

<li>can be used on data frames as well</li>

<li><code>complete.cases(data.frame)</code> = creates logical vectors indicating which observation/row is good</li>

<li><code>data.frame[logicalVector, ]</code> = returns all observations with complete data</li>

</ul></li>

<li><p><strong>Imputing Missing Values</strong> = replacing missing values with estimates (can be averages from all other data with the similar conditions)</p></li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Sequence of Numbers</h2>

<ul>

<li><code>1:20</code> = creates a sequence of numbers from first number to second number

<ul>

<li>works in descending order as well</li>

<li>increment = 1</li>

</ul></li>

<li><code>?':'</code> = enclose help for operators</li>

<li><code>seq(1, 20, by=0.5)</code> = sequence 1 to 20 by increment of .5

<ul>

<li><code>length=30</code> argument can be used to specify number of values generated</li>

</ul></li>

<li><code>length(variable)</code> = length of vector/sequence</li>

<li><code>seq_along(vector)</code> or <code>seq(along.with = vector)</code> = create vector that is same length as another vector</li>

<li><code>rep(0, times = 40)</code> = creates a vector with 40 zeroes

<ul>

<li><code>rep(c(1, 2), times = 10)</code> = repeats combination of numbers 10 times</li>

<li><code>rep(c(1, 2), each = 10)</code> = repeats first value 10 times followed by second value 10 times</li>

</ul></li>

</ul>

</div>

<h2>Subsetting</h2>

<ul>

<li>R uses <strong>one based index</strong> –> starts counting at <span class="math">$1$</span>

<ul>

<li><code>x[0]</code> returns <code>numeric(0)</code>, not error</li>

<li><code>x[3000]</code> returns <code>NA</code> (not out of bounds/error)</li>

</ul></li>

<li><code>[]</code> = always returns object of same class, can select more than one element of an object [1;2]</li>

<li><code>[[]]</code> = can extract one element from list or data frame, returned object not necessarily list/dataframe</li>

<li><code>$</code> = can extract elements from list/dataframe that have names associated with it, not necessarily same class</li>

</ul>

<h3>Vectors</h3>

<ul>

<li><code>x[1:10]</code> = first 10 elements of vector x</li>

<li><code>x[is.na(x)]</code> = returns all NA elements</li>

<li><code>x[!is.na(x)]</code> = returns all non NA elements

<ul>

<li><code>x > 0</code> = would return logical vector comparing all elements to 0 (<code>TRUE</code>/<code>FALSE</code> for all values except for NA and <code>NA</code> for NA elements (NA a placeholder)</li>

</ul></li>

<li><code>x[x>"a"]</code> = selects all elements bigger than a (lexicographical order in place)</li>

<li><code>x[logicalIndex]</code> = select all elements where logical index = TRUE</li>

<li><code>x[-c(2, 10)]</code> = returns everything <strong>but</strong> the second and tenth element</li>

<li><code>vect <- c(a = 1, b = 2, c = 3)</code> = names values of a vector with corresponding names</li>

<li><code>names(vect)</code> = returns element names for object

<ul>

<li><code>names(vet) <- c("a", "b", "c")</code> = assign/change names of vector</li>

</ul></li>

<li><code>identical(obj1, obj2)</code> = returns TRUE if two objects are exactly equal</li>

<li><code>all.equal(obj1, obj2)</code> = returns TRUE if two objects are near equal</li>

</ul>

</div>

<h3>Lists</h3>

<ul>

<li><code>x[1]</code> or <code>x["foo"]</code> = returns the list object <code>foo</code></li>

<li><code>x[[2]]</code> or <code>x[["bar"]]</code> or <code>x$bar</code> = returns the content of the second element from the list (in this case vector without name attribute)</li>

<li><code>x[c(1, 3)]</code> = extract multiple elements of list ([[]]

<ul>

<li><em><strong>Note</strong>: <code>$</code> can’t extract multiple</em></li>

</ul></li>

<li><code>x[[name]]</code> = extract using variable, where as $ must match name of element</li>

<li><code>x[[c(1, 3)]]</code> or <code>x[[1]][[3]]</code> = extracted nested elements of list third element of the first object extracted from the list</li>

</ul>

</div>

<h3>Matrices</h3>

<ul>

<li><code>x[1, 2]</code> = extract the (row, column) element

<ul>

<li><code>x[,2]</code> or <code>x[1,]</code> = extract the entire column/row</li>

</ul></li>

<li><code>x[ , 11:17]</code> = subset the x <code>data.frame</code> with all rows, but only 11 to 17 columns</li>

<li>when an element from the matrix is retrieved, a vector is returned

<ul>

<li>behavior can be turned off (force return a matrix) by adding <code>drop = FALSE</code>

<ul>

</ul></li>

</ul>

</div>

<h3>Partial Matching</h3>

<ul>

<li>works with <code>[[]]</code> and <code>$</code></li>

<li><code>$</code> automatically partial matches the name (<code>x$a</code>)</li>

<li><code>[[]]</code> can partial match by adding exact = <code>FALSE</code>

<ul>

<li>x[[“a”, exact = false]]</li>

</ul></li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Logic</h2>

<ul>

<li><code><</code>, <code>>=</code> –> less than, greater or equal to</li>

<li><code>==</code> –> exact equality</li>

<li><code>!=</code> –> inequality</li>

<li><code>A | B</code> = union</li>

<li><code>A & B</code> = intersection</li>

<li><code>!</code> = negation</li>

<li><code>&</code> or <code>|</code> evaluates every instance/element in vector</li>

<li><code>&&</code> or <code>||</code> evaluate only first element

<ul>

<li>All AND operators are evaluated before PR operators</li>

</ul></li>

<li><code>isTRUE(condition)</code> = returns <code>TRUE</code> or <code>FALSE</code> of the condition</li>

<li><code>xor(arg1, arg2)</code> = exclusive OR, one argument must equal <code>TRUE</code> one must equal <code>FALSE</code></li>

<li><code>which(condition)</code> = find the indicies of elements that satisfy the condition (TRUE)</li>

<li><code>any(condition)</code> = <code>TRUE</code> if one or more of the elements in logical vector is <code>TRUE</code></li>

<li><code>all(condition)</code> = <code>TRUE</code> if all of the elements in logical vector is <code>TRUE</code></li>

</ul>

</div>

<h2>Understanding Data</h2>

<ul>

<li>use <code>class()</code>, <code>dim()</code>, <code>nrow()</code>, <code>ncol()</code>, <code>names()</code> to understand dataset

<ul>

<li><code>object.size(data.frame)</code> = returns how much space the dataset is occupying in memory</li>

</ul></li>

<li><code>head(data.frame, 10)</code>, <code>tail(data.frame, 10)</code> = returns first/last 10 rows of data; default = 6</li>

<li><code>summary()</code> = provides different output for each variable, depending on class,

<ul>

<li>for numerical variables, displays min max, mean median, etx.</li>

<li>for categorical (factor) variables, displays number of times each value occurs</li>

</ul></li>

<li><code>table(data.frame$variable)</code> = table of all values of the variable, and how many observations there are for each

<ul>

<li><em><strong>Note</strong>: mean for variables that only have values 1 and 0 = proportion of success</em></li>

</ul></li>

<li><code>str(data.frame)</code> = structure of data, provides data class, num of observations vs variables, and name of class of each variable and preview of its contents

<ul>

<li>compactly display the internal structure of an R object<br /></li>

<li>“What’s in this object”</li>

<li>well-suited to compactly display the contents of lists</li>

</ul></li>

<li><code>View(data.frame)</code> = opens and view the content of the data frame</li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Split-Apply-Combine Funtions</h2>

<ul>

<li>loop functions = convenient ways of implementing the Split-Apply-Combine strategy for data analysis</li>

</ul>

<h3><code>split()</code></h3>

<ul>

<li>takes a vector/objects and splits it into group b a factor or list of factors</li>

<li><code>split(x, f, drop = FALSE)</code>

<ul>

<li><code>x</code> = vector/list/data frame</li>

<li><code>f</code> = factor/list of factors</li>

<li><code>drop</code> = whether empty factor levels should be dropped</li>

</ul></li>

<li><code>interactions(gl(2, 5), gl(5, 2))</code> = 1.1, 1.2, … 2.5

<ul>

<li><code>gl(n, m)</code> = group level function

<ul>

<li><code>n</code> = number of levels</li>

<li><code>m</code> = number of repetitions</li>

</ul></li>

<li><code>split</code> function can do this by passing in list(f1, f2) in argument

<ul>

<li><code>split(data, list(gl(2, 5), gl(5, 2)))</code> = splits the data into 1.1, 1.2, … 2.5 levels</li>

</ul></li>

</ul>

</div>

<h3><code>apply()</code></h3>

<ul>

<li>evaluate a function (often anonymous) over the margins of an array</li>

<li>often used to apply a function to the row/columns of a matrix</li>

<li>can be used to average array of matrices (general arrays)</li>

<li><code>apply(x, margin = 2, FUN, ...)</code>

<ul>

<li><code>x</code> = array</li>

<li><code>MARGIN</code> = 2 (column), 1 (row)</li>

<li><code>FUN</code> = function</li>

<li><code>…</code> = other arguments that need to be passed to other functions<br /></li>

</ul></li>

<li><strong><em>examples</em></strong>

<ul>

<li><code>apply(x, 1, sum)</code> or <code>apply(x, 1, mean)</code> = find row sums/means</li>

<li><code>apply(x, 2, sum)</code> or <code>apply(x, 2, mean)</code> = find column sums/means</li>

<li><code>apply(x, 1, quantile, props = c(0.25, 0.75))</code> = find 25% 75% percentile of each row</li>

<li><code>a <- array(rnorm(2*2*10), c(2, 2, 10))</code> = create 10 2x2 matrix</li>

<li><code>apply(a, c(1, 2), mean)</code> = returns the means of 10</li>

</ul></li>

</ul>

</div>

<h3><code>lapply()</code></h3>

<ul>

<li>loops over a <code>list</code> and evaluate a function on each element and always returns a <strong><code>list</code></strong>

<ul>

<li><em><strong>Note</strong>: since input must be a list, it is possible that conversion may be needed</em></li>

</ul></li>

<li><code>lapply(x, FUN, ...)</code> = takes list/vector as input, applies a function to each element of the list, returns a list of the same length

<ul>

<li><code>x</code> = list (if not list, will be coerced into list through “as.list”, if not possible —> error)

<ul>

<li><code>data.frame</code> are treated as collections of lists and can be used here</li>

</ul></li>

<li><code>FUN</code> = function (without parentheses)

<ul>

<li>anonymous functions are acceptable here as well - (i.e <code>function(x) x[,1]</code>)</li>

</ul></li>

<li><code>…</code> = other/additional arguments to be passed for FUN (i.e. <code>min</code>, <code>max</code> for <code>runif()</code>)</li>

</ul></li>

<li><strong><em>example</em></strong>

<ul>

<li><code>lapply(data.frame, class)</code> = the data.frame is a list of vectors, the <code>class</code> value for each vector is returned in a list (name of function, <code>class</code>, is without parentheses)</li>

<li><code>lapply(values, function(elem), elem[2])</code> = example of an anonymous function</li>

</ul></li>

</ul>

</div>

<h3><code>sapply()</code></h3>

<ul>

<li>performs same function as <code>lapply()</code> except it simplifies the result

<ul>

<li>if result is of length 1 in every element, sapply returns vector</li>

<li>if result is vectors of the same length (>1) for each element, sapply returns matrix</li>

<li>if not possible to simplify, <code>sapply</code> returns a <code>list</code> (same as <code>lapply()</code>)</li>

</ul></li>

</ul>

</div>

<h3><code>vapply()</code></h3>

<ul>

<li>safer version of <code>sapply</code> in that it allows to you specify the format for the result

<ul>

<li><code>vapply(flags, class, character(1))</code> = returns the <code>class</code> of values in the flags variable in the form of character of length 1 (1 value)</li>

</ul></li>

</ul>

</div>

<h3><code>tapply()</code></h3>

<ul>

<li>split data into groups, and apply the function to data within each subgroup</li>

<li><code>tapply(data, INDEX, FUN, ..., simplify = FALSE)</code> = apply a function over subsets of a vector

<ul>

<li><code>data</code> = vector</li>

<li><code>INDEX</code> = factor/list of factors</li>

<li><code>FUN</code> = function</li>

<li><code>…</code> = arguments to be passed to function</li>

<li><code>simplify</code> = whether to simplify the result</li>

</ul></li>

<li><strong><em>example</em></strong>

<ul>

<li><code>f <- gl(3, 10); tapply(x, f, mean)</code> = returns the mean of each group (f level) of x data</li>

</ul></li>

</ul>

</div>

<h3><code>mapply()</code></h3>

<ul>

<li>multivariate apply, applies a function in parallel over a set of arguments</li>

<li><code>mapply(FUN, ..., MoreArgs = NULL, SIMPLIFY = TRUE)</code>

<ul>

<li><code>FUN</code> = function</li>

<li><code>…</code> = arguments to apply over</li>

<li><code>MoreArgs</code> = list of other arguments to FUN</li>

<li><code>SIMPLIFY</code> = whether the result should be simplified</li>

</ul></li>

<li><strong><em>example</em></strong></li>

</ul>

<pre class="sourceCode r"><code class="sourceCode r"><span class="kw">mapply</span>(rep, <span class="dv">1</span>:<span class="dv">4</span>, <span class="dv">4</span>:<span class="dv">1</span>)</code></pre>

<pre><code>## [[1]]

## [1] 1 1 1 1

## [[2]]

## [1] 2 2 2

## [[3]]

## [1] 3 3

## [[4]]

## [1] 4</code></pre>

</div>

<h3><code>aggregate()</code></h3>

<ul>

<li>aggregate computes summary statistics of data subsets (similar to multiple <code>tapply</code> at the same time)</li>

<li><code>aggregate(list(name = dataToCompute), list(name = factorVar1,name = factorVar2), function, na.rm = TRUE)</code>

<ul>

<li><code>dataToCompute</code> = this is what the function will be applied on</li>

<li><code>factorVar1, factorVar1</code> = factor variables to split the data by</li>

<li>**<em>Note</em>: order matters here in terms of how to break down the data*</li>

<li><code>function</code> = what is applied to the subsets of data, can be sum/mean/median/etc</li>

<li><code>na.rm = TRUE</code> –> removes NA values</li>

</ul></li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Simulation</h2>

<ul>

<li><code>sample(values, n, replace = FALSE)</code> = generate random samples

<ul>

<li><code>values</code> = values to sample from</li>

<li><code>n</code> = number of values generated</li>

<li><code>replace</code> = with or without replacement</li>

<li><code>sample(1:6, 4, replace = TRUE, prob=c(.2, .2…))</code> = choose four values from the range specified with replacing (same numbers can show up twice), with probabilities specified</li>

<li><code>sample(vector)</code> = can be used to permute/rearrange elements of a vector</li>

<li><code>sample(c(y, z), 100)</code> = select 100 random elements from combination of values y and z</li>

<li><code>sample(10)</code> = select positive integer sample of size 10 without repeat</li>

</ul></li>

<li>Each probability distribution functions usually have 4 functions associated with them:

<ul>

<li><code>r***</code> function (for “random”) –> random number generation</li>

<li><code>d***</code> function (for “density”) –> calculate density</li>

<li><code>p***</code> function (for “probability”) –> cumulative distribution</li>

<li><code>q***</code> function (for “quantile”) –> quantile function</li>

</ul></li>

<li>If <span class="math">$\Phi$</span> is the cumulative distribution function for a standard Normal distribution, then <code>pnorm(q)</code> = <span class="math">$\Phi(q)$</span> and qnorm(p) = <span class="math">$\Phi^{-1}(q)$</span>.</li>

<li><code>set.seed()</code> = reproduce same data</li>

</ul>

<h3>Simulation Examples</h3>

<ul>

<li><code>rbinom(1, size = 100, prob = 0.7)</code> = returns a binomial random variable that represents the number of successes in a give number of independent trials

<ul>

<li><code>1</code> = corresponds number of observations</li>

<li><code>size = 100</code> = corresponds with the number of independent trials that culminate to each resultant observation</li>

<li><code>prob = 0.7</code> = probability of success</li>

</ul></li>

<li><code>rnorm(n, mean = m, sd = s)</code> = generate n random samples from the standard normal distribution (mean = 0, std deviation = 1 by default)

<ul>

<li><code>rnorm(1000)</code> = 1000 draws from the standard normal distribution</li>

<li><code>n</code> = number of observation generated</li>

<li><code>mean = m</code> = specified mean of distribution</li>

<li><code>sd = s</code> = specified standard deviation of distribution</li>

</ul></li>

<li><code>dnorm(x, mean = 0, sd = 1, log = FALSE)</code>

<ul>

<li><code>log</code> = evaluate on log scale</li>

</ul></li>

<li><code>pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)</code>

<ul>

<li><code>lower.tail</code> = left side, <code>FALSE</code> = right</li>

</ul></li>

<li><code>qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)</code>

<ul>

<li><code>lower.tail</code> = left side, <code>FALSE</code> = right</li>

</ul></li>

<li><code>rpois(n, lambda)</code> = generate random samples from the poisson distrbution

<ul>

<li><code>n</code> = number of observations generated</li>

<li><code>lambda</code> = <span class="math">$\lambda$</span> parameter for the poisson distribution or rate</li>

</ul></li>

<li><code>rpois(n, r)</code> = generating Poisson Data

<ul>

<li><code>n</code> = number of values</li>

</ul></li>

<li><code>ppois(n, r)</code> = cumulative distribution

<ul>

<li><code>ppois(2, 2)</code> = <span class="math">$Pr(x<=2)$</span></li>

</ul></li>

<li><code>replicate(n, rpois())</code> = repeat operation n times</li>

</ul>

</div>

<h3>Generate Numbers for a Linear Model</h3>

<ul>

<li>Linear model <span class="math">\[

y = \beta_0 + \beta_1 x + \epsilon \\

~\mbox{where}~ \epsilon \sim N(0, 2^2), x \sim N(0, 1^2), \beta_0 = 0.5, \beta_1 = 2

\]</span></li>

</ul>

<pre class="sourceCode r"><code class="sourceCode r"><span class="kw">set.seed</span>(<span class="dv">20</span>)

x <-<span class="st"> </span><span class="kw">rnorm</span>(<span class="dv">100</span>) <span class="co"># normal </span>

x <-<span class="st"> </span><span class="kw">rbinom</span>(<span class="dv">100</span>, <span class="dv">1</span>, <span class="fl">0.5</span>) <span class="co"># binomial</span>

e <-<span class="st"> </span><span class="kw">rnorm</span>(<span class="dv">100</span>, <span class="dv">0</span>, <span class="dv">2</span>)

y <-<span class="st"> </span><span class="fl">0.5</span> +<span class="st"> </span><span class="dv">2</span>*<span class="st"> </span>x +<span class="st"> </span>e</code></pre>

<ul>

<li>Poisson model<br /><span class="math">\[

Y ~ Poisson(\mu) \\

log(\mu) = \beta_0 + \beta_1 x \\

~\mbox{where}~ \beta_0 = 0.5, \beta_1 = 2

\]</span></li>

</ul>

<pre class="sourceCode r"><code class="sourceCode r">x <-<span class="st"> </span><span class="kw">rnorm</span>(<span class="dv">100</span>)

log.mu <-<span class="st"> </span><span class="fl">0.5</span> +<span class="st"> </span><span class="fl">0.3</span>*<span class="st"> </span>x

y <-<span class="st"> </span><span class="kw">rpois</span>(<span class="dv">100</span>, <span class="kw">exp</span>(log.mu))</code></pre>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Dates and Times</h2>

<ul>

<li><code>Date</code> = date class, stored as number of days since 1970-01-01</li>

<li><code>POSIXct</code> = time class, stored as number of seconds since 1970-01-01</li>

<li><code>POSIXlt</code> = time class, stored as list of sec min hours</li>

<li><code>Sys.Date()</code> = today’s date</li>

<li><code>unclass(obj)</code> = returns what obj looks like internally</li>

<li><code>Sys.time()</code> = current time in POSIXct class</li>

<li><code>t2 <- as.POSIXlt(Sys.time())</code> = time in POSIXlt class

<ul>

<li><code>t2$min</code> = return min of time (only works for POSIXlt class)</li>

</ul></li>

<li><code>weekdays(date)</code>, <code>months(date)</code>, <code>quarters(date)</code> = returns weekdays, months, and quarters of time/date inputed</li>

<li><code>strptime(string, "%B %d, %Y %H:%M")</code> = convert string into time format using the format specified</li>

<li><code>difftime(time1, time2, units = 'days')</code> = difference in times by the specified unit</li>

</ul>

</div>

<h2>Base Graphics</h2>

<ul>

<li><code>plot(data)</code> = R plots the data as best as it can

<ul>

<li><code>x</code> = variable, x axis</li>

<li><code>y</code> = variable</li>

<li><code>xlab, ylab</code> = corresponding labels</li>

<li><code>main, sub</code> = title, subtitle</li>

<li><code>col = 2</code> or <code>col = "red"</code> = color</li>

<li><code>pch = 2</code> = different symbols for points</li>

<li><code>xlim,ylim(v1, v2)</code> = restrict range of plot</li>

</ul></li>

<li><code>boxplot(x ~ y, data = d)</code> = creates boxplot for x vs y variables using the data.frame provided</li>

<li><code>hist(x, breaks)</code> = plots histogram of the data

<ul>

<li><code>break = 100</code> = split data into 100 bins</li>

</ul></li>

</ul>

<p><span class="math">$\pagebreak$</span></p>

</div>

<h2>Reading Tabular Data</h2>

<ul>

<li><code>read.table(), read.csv()</code> = most common, read text files (rows, col) return data frame</li>

<li><code>readLines()</code> = read lines of text, returns character vector</li>

<li><code>source(file)</code> = read R code</li>

<li><code>dget()</code> = read R code files (R objects that have been reparsed)</li>

<li><code>load()</code>, <code>unserialize()</code> = read binary objects</li>

<li>writing data

<ul>

<li><code>write.table()</code>, <code>writeLines()</code>, <code>dump()</code>, <code>put()</code>, <code>save()</code>, <code>serialize()</code></li>

</ul></li>

<li><code>read.table()</code> arguments:

<ul>

<li><code>file</code> = name of file/connection</li>

<li><code>header</code> = indicator if file contains header</li>

<li><code>sep</code> = string indicating how columns are separated</li>

<li><code>colClasses</code> = character vector indicating what each column is in terms of class</li>

<li><code>nrows</code> = number of rows in dataset</li>

<li><code>comment.char</code> = char indicating beginning of comment</li>

<li><code>skip</code> = number of lines to skip in the beginning</li>

<li><code>stringsAsFactors</code> = defaults to TRUE, should characters be coded as Factor</li>

</ul></li>

<li><code>read.table</code> can be used without any other argument to create data.frame

<ul>

<li>telling R what type of variables are in each column is helpful for larger datasets (efficiency)</li>

<li><code>read.csv()</code> = <code>read.table</code> except default sep is comma (read.table is " “) and header` = TRUE</li>

</ul></li>

</ul>

<h3>Larger Tables</h3>

<ul>

<li><em><strong>Note</strong>: help page for read.table important</em></li>

<li>need to know how much RAM is required –> calculating memory requirements

<ul>

<li>numRow x numCol x 8 bytes/numeric value = size required in bites</li>

<li>double the above results and convert into GB = amount of memory recommended</li>

</ul></li>

<li><code>set comment.char</code> = “” to save time if there are no comments in the file</li>

<li>specifying colClasses can make reading data much faster</li>

<li><code>nrow</code> = n, number of rows to read in (can help with memory usage)

<ul>

<li><code>initial <- read.table("file", rows = 100)</code> = read first 100 lines</li>

<li><code>classes <- sapply(initial, class)</code> = determine what classes the columns are</li>

<li><code>tabAll <- read.table("file", colClasses = classes)</code> = load in the entire file with determined classes</li>

</ul></li>

</ul>

</div>

<h3>Textual Data Formats</h3>

<ul>

<li><code>dump</code> and <code>dput</code> preserve metadata</li>

<li>text formats are editable, not space efficient, and work better with version control system (they can only track changes in text files)</li>

<li><code>dput(obj, file = "file.R")</code> = creates R code to store all data and meta data in “file.R” (ex. data, class, names, row.names)</li>

<li><code>dget("file.R")</code> = loads the file/R code and reconstructs the R object</li>

<li><code>dput</code> can only be used on one object, where as <code>dump</code> can be used on multiple objects</li>

<li><code>dump(c("obj1", "obj2"), file= "file2.R")</code> = stores two objects</li>

<li><code>source("file2.R")</code> = loads the objects</li>

</ul>

</div>

<h3>Interfaces to the Outside World</h3>

<ul>

<li><code>url()</code> = function can read from webpages</li>

<li><code>file()</code> = read uncompressed files</li>

<li><code>gzfile(), bzfile()</code> = read compressed files (gzip, bzip2)</li>

<li><code>file(description = "", open = "")</code> = file syntax, creates connection

<ul>

<li><code>description</code> = description of file</li>

<li><code>open</code> = r -readonly, w - writing, a - appending, rb/wb/ab - reading/writing/appending binary</li>

<li><code>close()</code> = closes connection</li>

<li><code>readLines()</code> = can be used to read lines after connection has been established</li>

</ul></li>

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

R_Programming_Course_Notes.html

Latest commit

History

R_Programming_Course_Notes.html

File metadata and controls