An Introduction to R ¶
R的介绍¶

1.1 The R environment ¶
1.1 R环境¶

R is an integrated suite of software facilities for data manipulation, calculation and graphical display. Among other things it has
R是一套用于数据处理、计算和图形显示的集成软件。除其他外，

• an effective data handling and storage facility,
  有效的数据处理和存储设施，
• a suite of operators for calculations on arrays, in particular matrices,
  一套运算符，用于计算数组，特别是矩阵，
• a large, coherent, integrated collection of intermediate tools for data analysis,
  用于数据分析的大量、连贯、综合的中间工具集，
• graphical facilities for data analysis and display either directly at the computer or on hardcopy, and
  直接在计算机上或在硬拷贝上进行数据分析和显示的图形设施，以及
• a well developed, simple and effective programming language (called ‘S’) which includes conditionals, loops, user defined recursive functions and input and output facilities. (Indeed most of the system supplied functions are themselves written in the S language.)
  一种开发良好、简单有效的编程语言（称为“S”），包括条件、循环、用户定义的递归函数以及输入和输出设施。（实际上，系统提供的大多数函数本身都是用S语言编写的。

The term “environment” is intended to characterize it as a fully planned and coherent system, rather than an incremental accretion of very specific and inflexible tools, as is frequently the case with other data analysis software.
“环境”一词旨在将其描述为一个完全规划和连贯的系统，而不是像其他数据分析软件那样，由非常具体和不灵活的工具逐步增加。

R is very much a vehicle for newly developing methods of interactive data analysis. It has developed rapidly, and has been extended by a large collection of packages. However, most programs written in R are essentially ephemeral, written for a single piece of data analysis.
R是一种新开发的交互式数据分析方法的载体。它发展迅速，并通过大量的软件包进行了扩展。然而，大多数用R编写的程序本质上是短暂的，是为单个数据分析而编写的。

1.2 Related software and documentation ¶
1.2相关软件和文档¶

R can be regarded as an implementation of the S language which was developed at Bell Laboratories by Rick Becker, John Chambers and Allan Wilks, and also forms the basis of the S-PLUS systems.
R可以被看作是S语言的一个实现，S语言是由Rick Becker、John Chambers和Allan Wilks在贝尔实验室开发的，也是S-PLUS系统的基础。

The evolution of the S language is characterized by four books by John Chambers and coauthors. For R, the basic reference is The New S Language: A Programming Environment for Data Analysis and Graphics by Richard A. Becker, John M. Chambers and Allan R. Wilks. The new features of the 1991 release of S are covered in Statistical Models in S edited by John M. Chambers and Trevor J. Hastie. The formal methods and classes of the methods package are based on those described in Programming with Data by John M. Chambers. See References, for precise references.
S语言的演变由约翰·钱伯斯和合著者的四本书描述。对于R，基本参考是Richard A.作者：John M. Chambers和Allan R.威尔克斯1991年发行的S的新特性在由John M.钱伯斯和特雷弗·J·哈斯蒂。方法包的形式化方法和类基于John M.钱伯斯参见参考文献，了解精确参考文献。

There are now a number of books which describe how to use R for data analysis and statistics, and documentation for S/S-PLUS can typically be used with R, keeping the differences between the S implementations in mind. See What documentation exists for R? in R FAQ.
现在有很多书描述了如何使用R进行数据分析和统计，S/S-PLUS的文档通常可以与R一起使用，记住S实现之间的差异。看看R有哪些文档？在R FAQ中。

1.3 R and statistics ¶
1.3 R和统计¶

Our introduction to the R environment did not mention statistics, yet many people use R as a statistics system. We prefer to think of it of an environment within which many classical and modern statistical techniques have been implemented. A few of these are built into the base R environment, but many are supplied as packages. There are about 25 packages supplied with R (called “standard” and “recommended” packages) and many more are available through the CRAN family of Internet sites (via https://CRAN.R-project.org) and elsewhere. More details on packages are given later (see Packages).
我们对R环境的介绍没有提到统计，但许多人将R用作统计系统。我们更愿意把它看作是一个环境，在这个环境中，许多经典和现代的统计技术都得到了应用。其中一些是内置在基础R环境中的，但许多是作为包提供的。R提供了大约25个软件包（称为https://CRAN.R-project.org关于软件包的更多细节将在后面给出（参见软件包）。

Most classical statistics and much of the latest methodology is available for use with R, but users may need to be prepared to do a little work to find it.
大多数经典的统计数据和许多最新的方法都可以在R中使用，但用户可能需要做一些工作来找到它。

There is an important difference in philosophy between S (and hence R) and the other main statistical systems. In S a statistical analysis is normally done as a series of steps, with intermediate results being stored in objects.
S（因此也包括R）与其他主要统计系统之间在哲学上有着重要的区别。在S中，统计分析通常由一系列步骤完成，中间结果存储在对象中。
Thus whereas SAS and SPSS will give copious output from a regression or discriminant analysis, R will give minimal output and store the results in a fit object for subsequent interrogation by further R functions.
因此，尽管SAS和SPSS将从回归或判别分析中给出丰富的输出，但R将给出最小的输出并将结果存储在合适的对象中以供进一步的R函数进行后续询问。

1.4 R and the window system ¶
1.4 R和窗口系统¶

The most convenient way to use R is at a graphics workstation running a windowing system. This guide is aimed at users who have this facility.
使用R最方便的方法是在运行窗口系统的图形工作站上。本指南面向拥有此功能的用户。
In particular we will occasionally refer to the use of R on an X window system although the vast bulk of what is said applies generally to any implementation of the R environment.
特别是，我们偶尔会提到在X窗口系统上使用R，尽管所说的大部分内容通常适用于R环境的任何实现。

Most users will find it necessary to interact directly with the operating system on their computer from time to time. In this guide, we mainly discuss interaction with the operating system on UNIX machines.
大多数用户会发现有必要不时地直接与计算机上的操作系统进行交互。在本指南中，我们主要讨论与UNIX机器上的操作系统的交互。
If you are running R under Windows or macOS you will need to make some small adjustments.
如果你在Windows或macOS下运行R，你需要做一些小的调整。

Setting up a workstation to take full advantage of the customizable features of R is a straightforward if somewhat tedious procedure, and will not be considered further here. Users in difficulty should seek local expert help.
设置工作站以充分利用R的可定制特性是一个简单的过程，虽然有点繁琐，但在这里将不再进一步考虑。有困难的用户应寻求当地专家的帮助。

1.5 Using R interactively ¶
1.5交互式地使用R ¶

When you use the R program it issues a prompt when it expects input commands. The default prompt is ‘>’, which on UNIX might be the same as the shell prompt, and so it may appear that nothing is happening. However, as we shall see, it is easy to change to a different R prompt if you wish. We will assume that the UNIX shell prompt is ‘$’.
当你使用R程序时，它会在需要输入命令时发出提示。默认提示符是' > '，在UNIX上可能与shell提示符相同，因此可能看起来什么都没有发生。然而，正如我们将看到的，如果你愿意，很容易改变到不同的R提示符。我们将假设UNIX shell提示符为' $ '。

In using R under UNIX the suggested procedure for the first occasion is as follows:
在UNIX下使用R时，第一次建议的过程如下：

1. Create a separate sub-directory, say work, to hold data files on which you will use R for this problem. This will be the working directory whenever you use R for this particular problem.
   创建一个单独的子目录，比如 work ，来保存数据文件，你将在这些文件上使用R来解决这个问题。这将是工作目录，每当你使用R这个特定的问题。

   $ mkdir work
   $ cd work
   

2. Start the R program with the command
   使用以下命令启动R程序

   $ R
   

3. At this point R commands may be issued (see later).
   此时可能会发出R命令（见下文）。
4. To quit the R program the command is
   要退出R程序，命令为

   > q()
   

   At this point you will be asked whether you want to save the data from your R session. On some systems this will bring up a dialog box, and on others you will receive a text prompt to which you can respond yes, no or cancel (a single letter abbreviation will do) to save the data before quitting, quit without saving, or return to the R session. Data which is saved will be available in future R sessions.
   此时，系统会询问您是否要保存R会话中的数据。在某些系统上，这将弹出一个对话框，而在其他系统上，您将收到一个文本提示，您可以响应 yes ， no 或 cancel （单个字母缩写即可）以在退出前保存数据，退出而不保存，或返回R会话。保存的数据将在未来的R会话中可用。

Further R sessions are simple.
更多的R会话很简单。

1. Make work the working directory and start the program as before:
   将 work 设置为工作目录，并像以前一样启动程序：

   $ cd work
   $ R
   

2. Use the R program, terminating with the q() command at the end of the session.
   使用R程序，在会话结束时使用 q() 命令终止。

To use R under Windows the procedure to follow is basically the same. Create a folder as the working directory, and set that in the Start In field in your R shortcut. Then launch R by double clicking on the icon.
在Windows下使用R的过程基本上是一样的。创建一个文件夹作为工作目录，并将其设置在R快捷方式的 Start In 字段中。然后双击图标启动R。

1.6 An introductory session ¶
1.6介绍性会议¶

Readers wishing to get a feel for R at a computer before proceeding are strongly advised to work through the introductory session given in A sample session.
希望在继续之前在计算机上感受R的读者强烈建议通过示例会话中给出的介绍性会话进行工作。

1.7 Getting help with functions and features ¶
1.7获取有关函数和特性的帮助¶

R has an inbuilt help facility similar to the man facility of UNIX. To get more information on any specific named function, for example solve, the command is
R有一个内置的帮助工具，类似于UNIX的 man 工具。要获取有关任何特定命名函数（例如 solve ）的更多信息，命令为

> help(solve)

An alternative is  另一种方法是

> ?solve

For a feature specified by special characters, the argument must be enclosed in double or single quotes, making it a “character string”: This is also necessary for a few words with syntactic meaning including if, for and function.
对于由特殊字符指定的特性，参数必须用双引号或单引号括起来，使其成为“字符串”：这对于一些具有语法意义的单词也是必要的，包括 if ， for 和 function 。

> help("[[")

Either form of quote mark may be used to escape the other, as in the string "It's important". Our convention is to use double quote marks for preference.
任何一种形式的引号都可以用来转义另一种形式，如字符串 "It's important" 。我们的惯例是使用双引号表示偏好。

On most R installations help is available in HTML format by running
在大多数R安装中，通过运行以下命令可以获得HTML格式的帮助：

> help.start()

which will launch a Web browser that allows the help pages to be browsed with hyperlinks. On UNIX, subsequent help requests are sent to the HTML-based help system. The ‘Search Engine and Keywords’ link in the page loaded by help.start() is particularly useful as it is contains a high-level concept list which searches though available functions. It can be a great way to get your bearings quickly and to understand the breadth of what R has to offer.
这将启动一个Web浏览器，允许使用超链接浏览帮助页面。在UNIX上，后续的帮助请求将发送到基于HTML的帮助系统。由 help.start() 加载的页面中的“搜索引擎和关键字”链接特别有用，因为它包含一个高级概念列表，可以搜索可用的功能。它可以是一个很好的方式来快速获得你的轴承，并了解R所提供的广度。

The help.search command (alternatively ??) allows searching for help in various ways. For example,
help.search 命令（或者 ?? ）允许以各种方式搜索帮助。例如，在一个示例中，

> ??solve

Try ?help.search for details and more examples.
请尝试 ?help.search 以获取详细信息和更多示例。

The examples on a help topic can normally be run by
帮助主题的示例通常可以由

> example(topic)

Windows versions of R have other optional help systems: use
Windows版本的R还有其他可选的帮助系统：使用

> ?help

for further details.  了解详情。

1.8 R commands, case sensitivity, etc. ¶
1.8 R命令、区分大小写等。¶

Technically R is an expression language with a very simple syntax. It is case sensitive as are most UNIX based packages, so A and a are different symbols and would refer to different variables. The set of symbols which can be used in R names depends on the operating system and country within which R is being run (technically on the locale in use). Normally all alphanumeric symbols are allowed² (and in some countries this includes accented letters) plus ‘.’ and ‘_’, with the restriction that a name must start with ‘.’ or a letter, and if it starts with ‘.’ the second character must not be a digit. Names are effectively unlimited in length.
从技术上讲，R是一种语法非常简单的表达式语言。和大多数基于UNIX的软件包一样，它是区分大小写的，所以 A 和 a 是不同的符号，并且会引用不同的变量。R名称中使用的符号集取决于运行R的操作系统和国家（技术上取决于使用的区域设置）。通常所有字母数字符号都允许使用 ² （在某些国家，这包括重音字母）加上' . '和' _ '，但限制是名称必须以' . '或字母开头，如果以' . '开头，第二个字符不得是数字。名字的长度实际上是无限的。

Elementary commands consist of either expressions or assignments. If an expression is given as a command, it is evaluated, printed (unless specifically made invisible), and the value is lost. An assignment also evaluates an expression and passes the value to a variable but the result is not automatically printed.
基本命令由表达式或赋值组成。如果一个表达式作为命令给出，它将被计算、打印（除非特别设置为不可见），并且值将丢失。赋值也计算表达式并将值传递给变量，但结果不会自动打印。

Commands are separated either by a semi-colon (‘;’), or by a newline. Elementary commands can be grouped together into one compound expression by braces (‘{’ and ‘}’). Comments can be put almost³ anywhere, starting with a hash mark (‘#’), everything to the end of the line is a comment.
命令由分号（' ; '）或换行符分隔。基本命令可以通过大括号（' { '和' } '）组合到一个复合表达式中。注释几乎可以放在任何地方，从一个哈希标记（“ # ”）开始，到行尾的所有内容都是注释。

If a command is not complete at the end of a line, R will give a different prompt, by default
如果一个命令在一行的末尾没有完成，R会给出一个不同的提示，默认情况下

+

on second and subsequent lines and continue to read input until the command is syntactically complete. This prompt may be changed by the user. We will generally omit the continuation prompt and indicate continuation by simple indenting.
并继续读取输入，直到命令在语法上完成。用户可以更改此提示。我们通常会省略continuation提示符，并通过简单的缩进来指示continuation。

Command lines entered at the console are limited⁴ to about 4095 bytes (not characters).
在控制台输入的命令行 ⁴ 被限制为大约4095字节（不是字符）。

1.9 Recall and correction of previous commands ¶
1.9调用和更正以前的命令¶

Under many versions of UNIX and on Windows, R provides a mechanism for recalling and re-executing previous commands. The vertical arrow keys on the keyboard can be used to scroll forward and backward through a command history. Once a command is located in this way, the cursor can be moved within the command using the horizontal arrow keys, and characters can be removed with the DEL key or added with the other keys. More details are provided later: see The command-line editor.
在许多UNIX版本和Windows上，R提供了一种调用和重新执行以前命令的机制。键盘上的垂直箭头键可用于在命令历史记录中向前和向后滚动。以这种方式定位命令后，可以使用水平箭头键在命令内移动光标，并且可以使用 DEL 键删除字符或使用其他键添加字符。稍后提供更多细节：请参阅命令行编辑器。

The recall and editing capabilities under UNIX are highly customizable. You can find out how to do this by reading the manual entry for the readline library.
UNIX下的调用和编辑功能是高度可定制的。您可以通过阅读readline库的手册条目来了解如何做到这一点。

Alternatively, the Emacs text editor provides more general support mechanisms (via ESS, Emacs Speaks Statistics) for working interactively with R. See R and Emacs in R FAQ.
或者，Emacs文本编辑器提供了更通用的支持机制（通过ESS，Emacs Speaks Statistics），用于与R交互工作。R和Emacs在R FAQ中。

1.10 Executing commands from or diverting output to a file ¶
1.10从文件执行命令或将输出转移到文件¶

If commands⁵ are stored in an external file, say commands.R in the working directory work, they may be executed at any time in an R session with the command
如果命令 ⁵ 存储在外部文件中，例如工作目录 work 中的 commands.R ，则可以在R会话中的任何时间使用命令

> source("commands.R")

For Windows Source is also available on the File menu. The function sink,
对于Windows源也可以在文件菜单上。函数 sink ，

> sink("record.lis")

will divert all subsequent output from the console to an external file, record.lis. The command
将把所有后续输出从控制台转移到外部文件 record.lis 。命令

> sink()

restores it to the console once again.
再次将其恢复到控制台。

1.11 Data permanency and removing objects ¶
1.11数据永久性和删除对象¶

The entities that R creates and manipulates are known as objects. These may be variables, arrays of numbers, character strings, functions, or more general structures built from such components.
R创建和操作的实体被称为对象。这些组件可以是变量、数组、字符串、函数或由这些组件构建的更通用的结构。

During an R session, objects are created and stored by name (we discuss this process in the next section). The R command
在R会话期间，对象是按名称创建和存储的（我们将在下一节讨论这个过程）。R命令

> objects()

(alternatively, ls()) can be used to display the names of (most of) the objects which are currently stored within R. The collection of objects currently stored is called the workspace.
（或者， ls() ）可以用来显示当前存储在R中的对象的名称。当前存储的对象集合称为工作区。

To remove objects the function rm is available:
要删除对象，可以使用功能 rm ：

> rm(x, y, z, ink, junk, temp, foo, bar)

All objects created during an R session can be stored permanently in a file for use in future R sessions. At the end of each R session you are given the opportunity to save all the currently available objects.
在R会话期间创建的所有对象都可以永久存储在文件中，以供将来的R会话使用。在每个R会话结束时，您都有机会保存所有当前可用的对象。
If you indicate that you want to do this, the objects are written to a file called .RData⁶ in the current directory, and the command lines used in the session are saved to a file called .Rhistory.
如果您指明要执行此操作，则对象将写入当前目录中名为 .RData ⁶ 的文件，会话中使用的命令行将保存到名为 .Rhistory 的文件。

When R is started at later time from the same directory it reloads the workspace from this file. At the same time the associated commands history is reloaded.
当以后从同一目录启动R时，它会从这个文件重新加载工作区。与此同时，重新加载相关的命令历史记录。

It is recommended that you should use separate working directories for analyses conducted with R. It is quite common for objects with names x and y to be created during an analysis. Names like this are often meaningful in the context of a single analysis, but it can be quite hard to decide what they might be when the several analyses have been conducted in the same directory.
建议您应该使用单独的工作目录进行R分析。在分析过程中创建名称为 x 和 y 的对象是很常见的。这样的名称在单个分析的上下文中通常是有意义的，但是当在同一目录中进行多个分析时，很难确定它们是什么。

2.1 Vectors and assignment ¶
2.1向量和赋值¶

R operates on named data structures. The simplest such structure is the numeric vector, which is a single entity consisting of an ordered collection of numbers. To set up a vector named x, say, consisting of five numbers, namely 10.4, 5.6, 3.1, 6.4 and 21.7, use the R command
R操作命名的数据结构。最简单的这种结构是数字向量，它是由有序的数字集合组成的单个实体。要设置一个名为 x 的向量，比如说，由五个数字组成，即10.4、5.6、3.1、6.4和21.7，请使用R命令

> x <- c(10.4, 5.6, 3.1, 6.4, 21.7)

This is an assignment statement using the function c() which in this context can take an arbitrary number of vector arguments and whose value is a vector got by concatenating its arguments end to end.⁷
这是一个使用函数 c() 的赋值语句，在此上下文中，该函数可以接受任意数量的向量参数，并且其值是通过将其参数首尾相连而获得的向量。 ⁷

A number occurring by itself in an expression is taken as a vector of length one.
在表达式中单独出现的数被视为长度为1的向量。

Notice that the assignment operator (‘<-’), which consists of the two characters ‘<’ (“less than”) and ‘-’ (“minus”) occurring strictly side-by-side and it ‘points’ to the object receiving the value of the expression. In most contexts the ‘=’ operator can be used as an alternative.
注意赋值运算符（' <- '）由两个字符' < '（“小于”）和' - '（“减”）组成，它们严格地并排出现，并且它“指向”接收表达式值的对象。在大多数情况下，' = '运算符可以作为替代。

Assignment can also be made using the function assign(). An equivalent way of making the same assignment as above is with:
也可以使用函数 assign() 进行赋值。一个与上面相同的赋值的等价方法是：

> assign("x", c(10.4, 5.6, 3.1, 6.4, 21.7))

The usual operator, <-, can be thought of as a syntactic short-cut to this.
通常的操作符 <- 可以被认为是一种语法捷径。

Assignments can also be made in the other direction, using the obvious change in the assignment operator. So the same assignment could be made using
也可以在另一个方向上进行递归，使用赋值运算符中的明显变化。所以同样的赋值可以用

> c(10.4, 5.6, 3.1, 6.4, 21.7) -> x

If an expression is used as a complete command, the value is printed and lost⁸. So now if we were to use the command
如果一个表达式被用作一个完整的命令，则值被打印出来并丢失 ⁸ 。所以现在如果我们要使用

> 1/x

the reciprocals of the five values would be printed at the terminal (and the value of x, of course, unchanged).
五个值的倒数将在终端处打印（当然， x 的值不变）。

The further assignment  进一步的任务

> y <- c(x, 0, x)

would create a vector y with 11 entries consisting of two copies of x with a zero in the middle place.
将创建具有11个条目的向量 y ，该条目由 x 的两个副本组成，中间位置为零。

2.2 Vector arithmetic ¶
2.2向量算术¶

Vectors can be used in arithmetic expressions, in which case the operations are performed element by element. Vectors occurring in the same expression need not all be of the same length.
向量可以用在算术表达式中，在这种情况下，运算是逐个元素执行的。出现在相同表达式中的载体不需要都具有相同的长度。
If they are not, the value of the expression is a vector with the same length as the longest vector which occurs in the expression. Shorter vectors in the expression are recycled as often as need be (perhaps fractionally) until they match the length of the longest vector. In particular a constant is simply repeated. So with the above assignments the command
如果不是，则表达式的值是一个与表达式中出现的最长向量长度相同的向量。表达式中较短的向量会根据需要（可能是部分地）重复使用，直到它们与最长向量的长度匹配。特别是一个常数只是简单地重复。因此，通过上述分配，命令

> v <- 2*x + y + 1

generates a new vector v of length 11 constructed by adding together, element by element, 2*x repeated 2.2 times, y repeated just once, and 1 repeated 11 times.
生成长度为11的新向量 v ，该向量是通过逐个元素相加、 2*x 重复2.2次、 y 仅重复一次以及 1 重复11次而构造的。

The elementary arithmetic operators are the usual +, -, *, / and ^ for raising to a power. In addition all of the common arithmetic functions are available. log, exp, sin, cos, tan, sqrt, and so on, all have their usual meaning. max and min select the largest and smallest elements of a vector respectively. range is a function whose value is a vector of length two, namely c(min(x), max(x)). length(x) is the number of elements in x, sum(x) gives the total of the elements in x, and prod(x) their product.
基本算术运算符是通常的 + ， - ， * ， / 和 ^ ，用于提升到幂。此外，所有常见的算术函数都可用。 log 、 exp 、 sin 、 cos 、 tan 、 sqrt 等等，都有其通常的含义。 max 和 min 分别选择向量的最大和最小元素。 range 是一个函数，其值是一个长度为2的向量，即 c(min(x), max(x)) 。 length(x) 是 x 中元素的数量， sum(x) 给出 x 中元素的总数， prod(x) 给出它们的乘积。

Two statistical functions are mean(x) which calculates the sample mean, which is the same as sum(x)/length(x), and var(x) which gives
两个统计函数是 mean(x) 和 var(x) ， mean(x) 计算样本平均值，与 sum(x)/length(x) 相同， var(x) 给出

sum((x-mean(x))^2)/(length(x)-1)

or sample variance. If the argument to var() is an n-by-p matrix the value is a p-by-p sample covariance matrix got by regarding the rows as independent p-variate sample vectors.
或样本方差。如果 var() 的参数是一个n × p矩阵，则该值是一个p × p样本协方差矩阵，通过将行视为独立的p变量样本向量而获得。

sort(x) returns a vector of the same size as x with the elements arranged in increasing order; however there are other more flexible sorting facilities available (see order() or sort.list() which produce a permutation to do the sorting).
sort(x) 返回一个与 x 大小相同的向量，元素以递增顺序排列;然而，还有其他更灵活的排序工具可用（参见 order() 或 sort.list() ，它们产生一个排列来进行排序）。

Note that max and min select the largest and smallest values in their arguments, even if they are given several vectors. The parallel maximum and minimum functions pmax and pmin return a vector (of length equal to their longest argument) that contains in each element the largest (smallest) element in that position in any of the input vectors.
请注意， max 和 min 在其参数中选择最大值和最小值，即使它们被赋予多个向量。并行的maximum和minimum函数 pmax 和 pmin 返回一个向量（长度等于其最长参数），该向量在每个元素中包含任何输入向量中该位置的最大（最小）元素。

For most purposes the user will not be concerned if the “numbers” in a numeric vector are integers, reals or even complex. Internally calculations are done as double precision real numbers, or double precision complex numbers if the input data are complex.
在大多数情况下，用户不会关心数字向量中的“数字”是整数、实数还是复数。内部计算是作为双精度真实的数字完成的，如果输入数据是复数，则作为双精度复数完成。

To work with complex numbers, supply an explicit complex part. Thus
若要使用复数，请提供显式复数部分。因此

sqrt(-17)

will give NaN and a warning, but
将给出 NaN 和警告，但

sqrt(-17+0i)

will do the computations as complex numbers.
会用复数来计算

2.3 Generating regular sequences ¶
2.3生成正则序列¶

R has a number of facilities for generating commonly used sequences of numbers. For example 1:30 is the vector c(1, 2, …, 29, 30). The colon operator has high priority within an expression, so, for example 2*1:15 is the vector c(2, 4, …, 28, 30). Put n <- 10 and compare the sequences 1:n-1 and 1:(n-1).
R有许多生成常用数列的工具。例如， 1:30 是向量 c(1, 2, …, 29, 30) 。冒号运算符在表达式中具有高优先级，例如 2*1:15 是向量 c(2, 4, …, 28, 30) 。将 n <- 10 放入并比较序列 1:n-1 和 1:(n-1) 。

The construction 30:1 may be used to generate a sequence backwards.
构造 30:1 可用于反向生成序列。

The function seq() is a more general facility for generating sequences. It has five arguments, only some of which may be specified in any one call.
函数 seq() 是用于生成序列的更通用的工具。它有五个参数，其中只有一部分可以在任何一个调用中指定。
The first two arguments, if given, specify the beginning and end of the sequence, and if these are the only two arguments given the result is the same as the colon operator. That is seq(2,10) is the same vector as 2:10.
如果给出前两个参数，则指定序列的开始和结束，如果仅给出这两个参数，则结果与冒号运算符相同。也就是说 seq(2,10) 和 2:10 是同一个向量。

Arguments to seq(), and to many other R functions, can also be given in named form, in which case the order in which they appear is irrelevant. The first two arguments may be named from=value and to=value; thus seq(1,30), seq(from=1, to=30) and seq(to=30, from=1) are all the same as 1:30. The next two arguments to seq() may be named by=value and length=value, which specify a step size and a length for the sequence respectively. If neither of these is given, the default by=1 is assumed.
seq() 和许多其他R函数的参数也可以以命名的形式给出，在这种情况下，它们出现的顺序是无关紧要的。前两个参数可以命名为 from=value 和 to=value ;因此 seq(1,30) 、 seq(from=1, to=30) 和 seq(to=30, from=1) 都与 1:30 相同。 seq() 的下两个参数可以命名为 by=value 和 length=value ，它们分别指定序列的步长和长度。如果两者都没有给出，则假定为默认值 by=1 。

For example  例如

> seq(-5, 5, by=.2) -> s3

generates in s3 the vector c(-5.0, -4.8, -4.6, …, 4.6, 4.8, 5.0). Similarly
在 s3 中生成矢量 c(-5.0, -4.8, -4.6, …, 4.6, 4.8, 5.0) 。类似地

> s4 <- seq(length=51, from=-5, by=.2)

generates the same vector in s4.
在 s4 中生成相同的向量。

The fifth argument may be named along=vector, which is normally used as the only argument to create the sequence 1, 2, …, length(vector), or the empty sequence if the vector is empty (as it can be).
第五个参数可以命名为 along=vector ，它通常用作创建序列 1, 2, …, length(vector) 的唯一参数，或者如果向量为空（可以是空的），则为空序列。

A related function is rep() which can be used for replicating an object in various complicated ways. The simplest form is
一个相关的函数是 rep() ，它可以用于以各种复杂的方式复制对象。最简单的形式是

> s5 <- rep(x, times=5)

which will put five copies of x end-to-end in s5. Another useful version is
这将把 x 的五个副本端到端地放入 s5 中。另一个有用的版本是

> s6 <- rep(x, each=5)

which repeats each element of x five times before moving on to the next.
其在移动到下一个之前重复 x 的每个元素五次。

2.4 Logical vectors ¶
2.4逻辑向量¶

As well as numerical vectors, R allows manipulation of logical quantities. The elements of a logical vector can have the values TRUE, FALSE, and NA (for “not available”, see below). The first two are often abbreviated as T and F, respectively. Note however that T and F are just variables which are set to TRUE and FALSE by default, but are not reserved words and hence can be overwritten by the user. Hence, you should always use TRUE and FALSE.
和数字向量一样，R允许操作逻辑量。逻辑向量的元素可以具有值 TRUE 、 FALSE 和 NA （对于“不可用”，参见下文）。前两个通常分别缩写为 T 和 F 。然而，请注意， T 和 F 只是默认设置为 TRUE 和 FALSE 的变量，但不是保留字，因此可以由用户覆盖。因此，您应该始终使用 TRUE 和 FALSE 。

Logical vectors are generated by conditions. For example
逻辑向量由条件生成。例如

> temp <- x > 13

sets temp as a vector of the same length as x with values FALSE corresponding to elements of x where the condition is not met and TRUE where it is.
将 temp 设置为与 x 具有相同长度的向量，其中值 FALSE 对应于不满足条件的 x 的元素和满足条件的 TRUE 的元素。

The logical operators are <, <=, >, >=, == for exact equality and != for inequality. In addition if c1 and c2 are logical expressions, then c1 & c2 is their intersection (“and”), c1 | c2 is their union (“or”), and !c1 is the negation of c1.
逻辑运算符是 < 、 <= 、 > 、 >= 、 == ，表示完全相等，而 != 表示不等式。此外，如果 c1 和 c2 是逻辑表达式，则 c1 & c2 是它们的交集（“and”）， c1 | c2 是它们的并集（“or”），而 !c1 是 c1 的否定。

Logical vectors may be used in ordinary arithmetic, in which case they are coerced into numeric vectors, FALSE becoming 0 and TRUE becoming 1. However there are situations where logical vectors and their coerced numeric counterparts are not equivalent, for example see the next subsection.
逻辑向量可以用于普通算术，在这种情况下，它们被强制转换为数字向量， FALSE 变成 0 ， TRUE 变成 1 。然而，在某些情况下，逻辑向量和它们的强制数值对应物是不等价的，例如，请参见下一小节。

2.5 Missing values ¶
2.5缺失值¶

In some cases the components of a vector may not be completely known. When an element or value is “not available” or a “missing value” in the statistical sense, a place within a vector may be reserved for it by assigning it the special value NA. In general any operation on an NA becomes an NA. The motivation for this rule is simply that if the specification of an operation is incomplete, the result cannot be known and hence is not available.
在某些情况下，向量的分量可能不完全已知。当一个元素或值在统计意义上是“不可用”或“缺失值”时，可以通过为其分配特殊值 NA 来为它保留向量内的位置。一般来说，对 NA 的任何操作都会变成 NA 。这条规则的动机很简单，如果操作的规范不完整，结果就不可能知道，因此也就不可用。

The function is.na(x) gives a logical vector of the same size as x with value TRUE if and only if the corresponding element in x is NA.
当且仅当 x 中的对应元素是 NA 时，函数 is.na(x) 给出与 x 大小相同的逻辑向量，值为 TRUE 。

> z <- c(1:3,NA);  ind <- is.na(z)

Notice that the logical expression x == NA is quite different from is.na(x) since NA is not really a value but a marker for a quantity that is not available. Thus x == NA is a vector of the same length as x all of whose values are NA as the logical expression itself is incomplete and hence undecidable.
请注意，逻辑表达式 x == NA 与 is.na(x) 非常不同，因为 NA 实际上不是一个值，而是一个不可用的数量的标记。因此， x == NA 是一个与 x 长度相同的向量，其所有值都是 NA ，因为逻辑表达式本身是不完整的，因此不可判定。

Note that there is a second kind of “missing” values which are produced by numerical computation, the so-called Not a Number, NaN, values. Examples are
请注意，还有第二种由数值计算产生的“缺失”值，即所谓的非数字值。实例是

> 0/0

or  或

> Inf - Inf

which both give NaN since the result cannot be defined sensibly.
这两个都给出 NaN ，因为结果不能被合理地定义。

In summary, is.na(xx) is TRUE both for NA and NaN values. To differentiate these, is.nan(xx) is only TRUE for NaNs.
总之，对于 NA 和 NaN 值， is.na(xx) 都是 TRUE 。为了区分这些， is.nan(xx) 对于 NaN s来说只是 TRUE 。

Missing values are sometimes printed as <NA> when character vectors are printed without quotes.
当字符向量不带引号打印时，缺失值有时会打印为 <NA> 。

2.6 Character vectors ¶
2.6字符向量¶

Character quantities and character vectors are used frequently in R, for example as plot labels. Where needed they are denoted by a sequence of characters delimited by the double quote character, e.g., "x-values", "New iteration results".
字符量和字符向量在R中经常使用，例如作为绘图标签。在需要的地方，它们由双引号字符分隔的字符序列表示，例如， "x-values" ， "New iteration results" 。

Character strings are entered using either matching double (") or single (') quotes, but are printed using double quotes (or sometimes without quotes). They use C-style escape sequences, using \ as the escape character, so \ is entered and printed as \\, and inside double quotes " is entered as \". Other useful escape sequences are \n, newline, \t, tab and \b, backspace—see ?Quotes for a full list.
字符串使用匹配的双引号（ " ）或单引号（ ' ）输入，但使用双引号（有时不带引号）打印。它们使用C风格的转义序列，使用 \ 作为转义字符，因此 \ 被输入并打印为 \\ ，而双引号内的 " 被输入为 \" 。其他有用的转义序列是 \n ，换行符， \t ，制表符和 \b ，退格键-完整列表见 ?Quotes 。

Character vectors may be concatenated into a vector by the c() function; examples of their use will emerge frequently.
字符向量可以通过 c() 函数连接成一个向量;它们的使用示例会经常出现。

The paste() function takes an arbitrary number of arguments and concatenates them one by one into character strings. Any numbers given among the arguments are coerced into character strings in the evident way, that is, in the same way they would be if they were printed.
0#函数接受任意数量的参数，并将它们一个接一个地连接成字符串。参数中给出的任何数字都以明显的方式强制转换为字符串，也就是说，如果它们被打印出来，它们也会以同样的方式被强制转换为字符串。
The arguments are by default separated in the result by a single blank character, but this can be changed by the named argument, sep=string, which changes it to string, possibly empty.
默认情况下，参数在结果中由单个空白字符分隔，但这可以通过命名参数 sep=string 进行更改，将其更改为 string ，可能为空。

For example  例如

> labs <- paste(c("X","Y"), 1:10, sep="")

makes labs into the character vector
使 labs 成为字符向量

c("X1", "Y2", "X3", "Y4", "X5", "Y6", "X7", "Y8", "X9", "Y10")

Note particularly that recycling of short lists takes place here too; thus c("X", "Y") is repeated 5 times to match the sequence 1:10. ⁹
特别要注意的是，短列表的循环也在这里发生;因此 c("X", "Y") 重复5次以匹配序列 1:10 。 ⁹

2.7 Index vectors; selecting and modifying subsets of a data set ¶
2.7索引向量;选择和修改数据集的子集¶

Subsets of the elements of a vector may be selected by appending to the name of the vector an index vector in square brackets. More generally any expression that evaluates to a vector may have subsets of its elements similarly selected by appending an index vector in square brackets immediately after the expression.
向量的元素的子集可以通过将方括号中的索引向量附加到向量的名称来选择。更一般地，任何计算为向量的表达式都可以通过在表达式后面紧接着方括号中附加索引向量来类似地选择其元素的子集。

Such index vectors can be any of four distinct types.
这样的索引向量可以是四种不同类型中的任何一种。

1. A logical vector. In this case the index vector is recycled to the same length as the vector from which elements are to be selected. Values corresponding to TRUE in the index vector are selected and those corresponding to FALSE are omitted. For example
   逻辑向量在这种情况下，索引向量被回收到与要从中选择元素的向量相同的长度。选择与索引向量中的 TRUE 对应的值，并且省略与 FALSE 对应的值。例如

   > y <- x[!is.na(x)]
   

   creates (or re-creates) an object y which will contain the non-missing values of x, in the same order. Note that if x has missing values, y will be shorter than x. Also
   创建（或重新创建）一个对象 y ，它将以相同的顺序包含 x 的非缺失值。请注意，如果 x 有缺失值，则 y 将短于 x 。也

   > (x+1)[(!is.na(x)) & x>0] -> z
   

   creates an object z and places in it the values of the vector x+1 for which the corresponding value in x was both non-missing and positive.
   创建对象 z ，并将矢量 x+1 的值放置在其中，其中 x 中的对应值是非缺失的并且是正的。

2. A vector of positive integral quantities. In this case the values in the index vector must lie in the set {1, 2, …, length(x)}. The corresponding elements of the vector are selected and concatenated, in that order, in the result. The index vector can be of any length and the result is of the same length as the index vector. For example x[6] is the sixth component of x and
   一个正整数向量。在这种情况下，索引向量中的值必须位于集合{1，2，...， length(x) }中。在结果中，选择向量的相应元素并按该顺序连接。索引向量可以是任何长度，结果的长度与索引向量的长度相同。例如， x[6] 是 x 的第六个分量，

   > x[1:10]
   

   selects the first 10 elements of x (assuming length(x) is not less than 10). Also
   选择 x 的前10个元素（假设 length(x) 不小于10）。也

   > c("x","y")[rep(c(1,2,2,1), times=4)]
   

   (an admittedly unlikely thing to do) produces a character vector of length 16 consisting of "x", "y", "y", "x" repeated four times.
   (an无可否认，这是不可能的）产生一个长度为16的字符向量，由重复四次的 "x", "y", "y", "x" 组成。

3. A vector of negative integral quantities. Such an index vector specifies the values to be excluded rather than included. Thus
   一个负整数向量。这样的索引向量指定要排除而不是包括的值。因此

   > y <- x[-(1:5)]
   

   gives y all but the first five elements of x.
   y 给出了 x 的前五个元素。

4. A vector of character strings. This possibility only applies where an object has a names attribute to identify its components. In this case a sub-vector of the names vector may be used in the same way as the positive integral labels in item 2 further above.
   字符串的向量。这种可能性仅适用于对象具有 names 属性来标识其组件的情况。在这种情况下，名称向量的子向量可以以与上文第2项中的正整数标签相同的方式使用。

   > fruit <- c(5, 10, 1, 20)
   > names(fruit) <- c("orange", "banana", "apple", "peach")
   > lunch <- fruit[c("apple","orange")]
   

   The advantage is that alphanumeric names are often easier to remember than numeric indices. This option is particularly useful in connection with data frames, as we shall see later.
   优点是字母数字名称通常比数字索引更容易记住。这个选项对于数据帧特别有用，我们将在后面看到。

An indexed expression can also appear on the receiving end of an assignment, in which case the assignment operation is performed only on those elements of the vector. The expression must be of the form vector[index_vector] as having an arbitrary expression in place of the vector name does not make much sense here.
索引表达式也可以出现在赋值的接收端，在这种情况下，赋值操作仅对向量的这些元素执行。该表达式必须采用 vector[index_vector] 形式，因为用任意表达式代替向量名称在这里没有多大意义。

For example  例如

> x[is.na(x)] <- 0

replaces any missing values in x by zeros and
将 x 中的任何缺失值替换为零，

> y[y < 0] <- -y[y < 0]

has the same effect as
具有与

> y <- abs(y)

2.8 Other types of objects ¶
2.8其他类型的对象¶

Vectors are the most important type of object in R, but there are several others which we will meet more formally in later sections.
向量是R中最重要的对象类型，但还有其他几种我们将在后面的章节中更正式地介绍。

• matrices or more generally arrays are multi-dimensional generalizations of vectors. In fact, they are vectors that can be indexed by two or more indices and will be printed in special ways. See Arrays and matrices.
  矩阵或更一般的数组是向量的多维概括。事实上，它们是可以由两个或多个索引索引的向量，并且将以特殊的方式打印。请参见数组和矩阵。
• factors provide compact ways to handle categorical data. See Ordered and unordered factors.
  因子提供了处理分类数据的紧凑方法。请参见有序因子和无序因子。
• lists are a general form of vector in which the various elements need not be of the same type, and are often themselves vectors or lists. Lists provide a convenient way to return the results of a statistical computation. See Lists.
  列表是向量的一般形式，其中各种元素不需要是相同类型的，并且它们本身通常是向量或列表。列表提供了一种返回统计计算结果的方便方法。请参见列表。
• data frames are matrix-like structures, in which the columns can be of different types. Think of data frames as ‘data matrices’ with one row per observational unit but with (possibly) both numerical and categorical variables.
  数据帧是类似矩阵的结构，其中列可以是不同的类型。将数据框架视为“数据矩阵”，每个观察单位一行，但（可能）同时包含数值和分类变量。
  Many experiments are best described by data frames: the treatments are categorical but the response is numeric. See Data frames.
  许多实验最好用数据框架来描述：处理是分类的，但响应是数字的。请参见数据框。
• functions are themselves objects in R which can be stored in the project’s workspace. This provides a simple and convenient way to extend R. See Writing your own functions.
  函数本身就是R中的对象，可以存储在项目的工作区中。这为扩展R提供了一种简单方便的方法。请参阅编写自己的函数。

3.1 Intrinsic attributes: mode and length ¶
3.1内在属性：mode和length ¶

The entities R operates on are technically known as objects. Examples are vectors of numeric (real) or complex values, vectors of logical values and vectors of character strings. These are known as “atomic” structures since their components are all of the same type, or mode, namely numeric¹⁰, complex, logical, character and raw.
R操作的实体在技术上称为对象。例如数字（真实的）或复数值的向量、逻辑值的向量和字符串的向量。这些被称为“原子”结构，因为它们的组件都是相同的类型或模式，即数字 ¹⁰ ，复杂，逻辑，字符和原始。

Vectors must have their values all of the same mode. Thus any given vector must be unambiguously either logical, numeric, complex, character or raw. (The only apparent exception to this rule is the special “value” listed as NA for quantities not available, but in fact there are several types of NA). Note that a vector can be empty and still have a mode. For example the empty character string vector is listed as character(0) and the empty numeric vector as numeric(0).
向量的值必须全部为同一模式。因此，任何给定的向量必须是明确的逻辑，数字，复杂，字符或原始。(The这一规则的唯一明显例外是特殊的“价值”列为 NA 数量不可用，但实际上有几种类型的 NA ）。注意，向量可以是空的，但仍然有一个模式。例如，空字符串向量被列为 character(0) ，空数字向量被列为 numeric(0) 。

R also operates on objects called lists, which are of mode list. These are ordered sequences of objects which individually can be of any mode. lists are known as “recursive” rather than atomic structures since their components can themselves be lists in their own right.
R还对称为列表的对象进行操作，这些对象具有模式列表。这些是有序的对象序列，单独地可以是任何模式。列表被称为“递归”而不是原子结构，因为它们的组件本身也可以是列表。

The other recursive structures are those of mode function and expression. Functions are the objects that form part of the R system along with similar user written functions, which we discuss in some detail later. Expressions as objects form an advanced part of R which will not be discussed in this guide, except indirectly when we discuss formulae used with modeling in R.
其他递归结构是模式函数和表达式。函数是构成R系统的一部分的对象，沿着的还有类似的用户编写的函数，我们稍后会详细讨论。作为对象的表达式构成了R的高级部分，除了在讨论R建模时使用的公式时间接讨论外，本指南不会讨论它。

By the mode of an object we mean the basic type of its fundamental constituents. This is a special case of a “property” of an object. Another property of every object is its length. The functions mode(object) and length(object) can be used to find out the mode and length of any defined structure ¹¹.
我们所说的对象的模式，是指它的基本成分的基本类型。这是对象的“属性”的一个特例。每个物体的另一个属性是它的长度。函数 mode(object) 和 length(object) 可用于找出任何定义的结构 ¹¹ 的模式和长度。

Further properties of an object are usually provided by attributes(object), see Getting and setting attributes. Because of this, mode and length are also called “intrinsic attributes” of an object.
对象的更多属性通常由 attributes(object) 提供，请参阅获取和设置属性。因此，模式和长度也称为对象的“内在属性”。

For example, if z is a complex vector of length 100, then in an expression mode(z) is the character string "complex" and length(z) is 100.
例如，如果 z 是长度为100的复向量，则在表达式中 mode(z) 是字符串 "complex" ， length(z) 是 100 。

R caters for changes of mode almost anywhere it could be considered sensible to do so, (and a few where it might not be). For example with
R几乎可以在任何被认为合理的地方满足模式更改的要求（也可以在一些可能不合理的地方）。例如用

> z <- 0:9

we could put  我们可以把

> digits <- as.character(z)

after which digits is the character vector c("0", "1", "2", …, "9"). A further coercion, or change of mode, reconstructs the numerical vector again:
digits 之后是字符向量 c("0", "1", "2", …, "9") 。进一步的强制，或者说模式的改变，再次重构了数字向量：

> d <- as.integer(digits)

Now d and z are the same.¹² There is a large collection of functions of the form as.something() for either coercion from one mode to another, or for investing an object with some other attribute it may not already possess. The reader should consult the different help files to become familiar with them.
d 和 z 是一样的。有大量的函数以 as.something() 的形式存在，用于从一种模式强制转换到另一种模式，或者用于为对象赋予它可能还没有拥有的其他属性。读者应该查阅不同的帮助文件以熟悉它们。

3.2 Changing the length of an object ¶
3.2改变对象的长度¶

An “empty” object may still have a mode. For example
一个“空”的对象可能仍然有一个模式。例如

> e <- numeric()

makes e an empty vector structure of mode numeric. Similarly character() is a empty character vector, and so on. Once an object of any size has been created, new components may be added to it simply by giving it an index value outside its previous range. Thus
使 e 成为一个模式为numeric的空向量结构。类似地， character() 是一个空的字符向量，等等。一旦创建了一个任意大小的对象，只需给它一个超出其先前范围的索引值，就可以向其添加新的组件。因此

> e[3] <- 17

now makes e a vector of length 3, (the first two components of which are at this point both NA). This applies to any structure at all, provided the mode of the additional component(s) agrees with the mode of the object in the first place.
现在使 e 成为长度为3的向量，（其前两个分量此时都是 NA ）。这适用于任何结构，只要附加成分的模式首先与对象的模式一致。

This automatic adjustment of lengths of an object is used often, for example in the scan() function for input. (see The scan() function.)
这种对象长度的自动调整经常使用，例如在用于输入的 scan() 功能中。(see scan() 功能。

Conversely to truncate the size of an object requires only an assignment to do so. Hence if alpha is an object of length 10, then
相反，截断对象的大小只需要一个赋值即可。因此，如果 alpha 是长度为10的对象，则

> alpha <- alpha[2 * 1:5]

makes it an object of length 5 consisting of just the former components with even index. (The old indices are not retained, of course.) We can then retain just the first three values by
使其成为长度为5的对象，仅由具有偶数索引的前一个组件组成。(The当然，旧的索引不会保留。）然后我们可以只保留前三个值，

> length(alpha) <- 3

and vectors can be extended (by missing values) in the same way.
并且向量可以以相同的方式扩展（通过缺失值）。

3.3 Getting and setting attributes ¶
3.3获取和设置属性¶

The function attributes(object) returns a list of all the non-intrinsic attributes currently defined for that object. The function attr(object, name) can be used to select a specific attribute. These functions are rarely used, except in rather special circumstances when some new attribute is being created for some particular purpose, for example to associate a creation date or an operator with an R object.
函数 attributes(object) 返回当前为该对象定义的所有非内在属性的列表。函数 attr(object, name) 可用于选择特定属性。这些函数很少使用，除非在一些特殊的情况下，当一些新的属性被创建用于某些特定的目的，例如将创建日期或操作符与R对象相关联时。
The concept, however, is very important.
然而，这个概念非常重要。

Some care should be exercised when assigning or deleting attributes since they are an integral part of the object system used in R.
在分配或删除属性时应该小心，因为它们是R中使用的对象系统的组成部分。

When it is used on the left hand side of an assignment it can be used either to associate a new attribute with object or to change an existing one. For example
当它用在赋值语句的左手侧时，它既可以用来将新属性与 object 关联，也可以用来更改现有属性。例如

> attr(z, "dim") <- c(10,10)

allows R to treat z as if it were a 10-by-10 matrix.
允许R将 z 视为10 × 10矩阵。

3.4 The class of an object ¶
3.4对象的类¶

All objects in R have a class, reported by the function class. For simple vectors this is just the mode, for example "numeric", "logical", "character" or "list", but "matrix", "array", "factor" and "data.frame" are other possible values.
R中的所有对象都有一个类，由函数 class 报告。对于简单向量，这只是模式，例如 "numeric" 、 "logical" 、 "character" 或 "list" ，但 "matrix" 、 "array" 、 "factor" 和 "data.frame" 是其他可能的值。

A special attribute known as the class of the object is used to allow for an object-oriented style¹³ of programming in R. For example if an object has class "data.frame", it will be printed in a certain way, the plot() function will display it graphically in a certain way, and other so-called generic functions such as summary() will react to it as an argument in a way sensitive to its class.
一个被称为对象类的特殊属性用于支持R中面向对象的编程风格 ¹³ 。例如，如果一个对象有类 "data.frame" ，它将以某种方式打印， plot() 函数将以某种方式以图形方式显示它，而其他所谓的泛型函数（如 summary() ）将以对其类敏感的方式将其作为参数进行反应。

To remove temporarily the effects of class, use the function unclass(). For example if winter has the class "data.frame" then
要暂时删除类的效果，请使用函数 unclass() 。例如，如果 winter 具有类 "data.frame" ，则

> winter

will print it in data frame form, which is rather like a matrix, whereas
将以数据框的形式打印出来，这很像一个矩阵，而

> unclass(winter)

will print it as an ordinary list. Only in rather special situations do you need to use this facility, but one is when you are learning to come to terms with the idea of class and generic functions.
将其打印为普通列表。只有在相当特殊的情况下，你才需要使用这个工具，但是一个是当你学习接受类和泛型函数的概念时。

Generic functions and classes will be discussed further in Classes, generic functions and object orientation, but only briefly.
泛型函数和类将在类，泛型函数和面向对象中进一步讨论，但只是简单地讨论。

4.1 A specific example ¶
4.1一个具体的例子¶

Suppose, for example, we have a sample of 30 tax accountants from all the states and territories of Australia¹⁴ and their individual state of origin is specified by a character vector of state mnemonics as
例如，假设我们有一个来自澳大利亚所有州和地区的30名税务会计师的样本 ¹⁴ ，他们各自的原籍州由州助记符的特征向量指定为

> state <- c("tas", "sa",  "qld", "nsw", "nsw", "nt",  "wa",  "wa",
             "qld", "vic", "nsw", "vic", "qld", "qld", "sa",  "tas",
             "sa",  "nt",  "wa",  "vic", "qld", "nsw", "nsw", "wa",
             "sa",  "act", "nsw", "vic", "vic", "act")

Notice that in the case of a character vector, “sorted” means sorted in alphabetical order.
请注意，对于字符向量，“sorted”表示按字母顺序排序。

A factor is similarly created using the factor() function:
使用 factor() 函数类似地创建因子：

> statef <- factor(state)

The print() function handles factors slightly differently from other objects:
print() 函数处理因子的方式与其他对象略有不同：

> statef
 [1] tas sa  qld nsw nsw nt  wa  wa  qld vic nsw vic qld qld sa
[16] tas sa  nt  wa  vic qld nsw nsw wa  sa  act nsw vic vic act
Levels:  act nsw nt qld sa tas vic wa

To find out the levels of a factor the function levels() can be used.
要找出因子的水平，可以使用函数 levels() 。

> levels(statef)
[1] "act" "nsw" "nt"  "qld" "sa"  "tas" "vic" "wa"

4.2 The function tapply() and ragged arrays ¶
4.2函数 tapply() 和不规则数组¶

To continue the previous example, suppose we have the incomes of the same tax accountants in another vector (in suitably large units of money)
继续前面的例子，假设我们在另一个向量中有相同税务会计师的收入（以适当大的货币单位）

> incomes <- c(60, 49, 40, 61, 64, 60, 59, 54, 62, 69, 70, 42, 56,
               61, 61, 61, 58, 51, 48, 65, 49, 49, 41, 48, 52, 46,
               59, 46, 58, 43)

To calculate the sample mean income for each state we can now use the special function tapply():
为了计算每个州的样本平均收入，我们现在可以使用特殊函数 tapply() ：

> incmeans <- tapply(incomes, statef, mean)

giving a means vector with the components labelled by the levels
给出一个均值向量，其分量由水平标记

   act    nsw     nt    qld     sa    tas    vic     wa
44.500 57.333 55.500 53.600 55.000 60.500 56.000 52.250

The function tapply() is used to apply a function, here mean(), to each group of components of the first argument, here incomes, defined by the levels of the second component, here statef¹⁵, as if they were separate vector structures. The result is a structure of the same length as the levels attribute of the factor containing the results. The reader should consult the help document for more details.
函数 tapply() 用于将函数（此处为 mean() ）应用于第一参数（此处为 incomes ）的每组分量，该组分量由第二分量（此处为 statef ¹⁵ ）的级别定义，就好像它们是单独的向量结构一样。结果是一个与包含结果的因子的levels属性长度相同的结构。读者应查阅帮助文档以了解更多详细信息。

Suppose further we needed to calculate the standard errors of the state income means. To do this we need to write an R function to calculate the standard error for any given vector. Since there is an builtin function var() to calculate the sample variance, such a function is a very simple one liner, specified by the assignment:
进一步假设我们需要计算州收入均值的标准误差。为此，我们需要编写一个R函数来计算任何给定向量的标准误差。由于有一个内置函数 var() 来计算样本方差，这样的函数是一个非常简单的线性函数，由赋值指定：

> stdError <- function(x) sqrt(var(x)/length(x))

(Writing functions will be considered later in Writing your own functions. Note that R’s a builtin function sd() is something different.) After this assignment, the standard errors are calculated by
（编写函数将在后面的编写自己的函数中考虑。注意R的内置函数 sd() 是不同的。赋值后，标准误差计算如下：

> incster <- tapply(incomes, statef, stdError)

and the values calculated are then
然后计算出的值为

> incster
act    nsw  nt    qld     sa tas   vic     wa
1.5 4.3102 4.5 4.1061 2.7386 0.5 5.244 2.6575

As an exercise you may care to find the usual 95% confidence limits for the state mean incomes. To do this you could use tapply() once more with the length() function to find the sample sizes, and the qt() function to find the percentage points of the appropriate t-distributions. (You could also investigate R’s facilities for t-tests.)
作为一个练习，你可能会关心找到通常的95%置信区间的国家平均收入。要做到这一点，您可以再次使用 tapply() 和 length() 函数来查找样本大小，并使用 qt() 函数来查找适当t分布的百分比。(You也可以研究R的t检验设施。

The function tapply() can also be used to handle more complicated indexing of a vector by multiple categories. For example, we might wish to split the tax accountants by both state and sex. However in this simple instance (just one factor) what happens can be thought of as follows.
函数 tapply() 也可以用来处理更复杂的多类别向量索引。例如，我们可能希望按州和性别划分税务会计师。然而，在这个简单的例子中（只有一个因素），所发生的事情可以被认为是如下。
The values in the vector are collected into groups corresponding to the distinct entries in the factor. The function is then applied to each of these groups individually. The value is a vector of function results, labelled by the levels attribute of the factor.
向量中的值被收集到对应于因子中不同条目的组中。然后将该函数单独应用于这些组中的每一个。该值是函数结果的向量，由因子的 levels 属性标记。

The combination of a vector and a labelling factor is an example of what is sometimes called a ragged array, since the subclass sizes are possibly irregular. When the subclass sizes are all the same the indexing may be done implicitly and much more efficiently, as we see in the next section.
向量和标签因子的组合是有时被称为不规则数组的一个例子，因为子类的大小可能是不规则的。当子类的大小都相同时，索引可以隐式地完成，并且效率更高，正如我们在下一节中看到的那样。

4.3 Ordered factors ¶
4.3有序因子¶

The levels of factors are stored in alphabetical order, or in the order they were specified to factor if they were specified explicitly.
因子水平按字母顺序存储，如果显式指定，则按它们指定为 factor 的顺序存储。

Sometimes the levels will have a natural ordering that we want to record and want our statistical analysis to make use of. The ordered() function creates such ordered factors but is otherwise identical to factor. For most purposes the only difference between ordered and unordered factors is that the former are printed showing the ordering of the levels, but the contrasts generated for them in fitting linear models are different.
有时，这些水平会有一个我们想要记录并希望我们的统计分析利用的自然顺序。 ordered() 函数创建这样的有序因子，但在其他方面与 factor 相同。在大多数情况下，有序因子和无序因子之间的唯一区别是前者显示水平的排序，但在拟合线性模型时为它们生成的对比是不同的。

5.1 Arrays ¶ 5.1数组¶

An array can be considered as a multiply subscripted collection of data entries, for example numeric. R allows simple facilities for creating and handling arrays, and in particular the special case of matrices.
数组可以被认为是数据项的多下标集合，例如数值。R允许创建和处理数组的简单设施，特别是矩阵的特殊情况。

A dimension vector is a vector of non-negative integers. If its length is k then the array is k-dimensional, e.g. a matrix is a 2-dimensional array. The dimensions are indexed from one up to the values given in the dimension vector.
维数向量是非负整数的向量。如果它的长度是k，那么数组是k维的，例如矩阵是2维数组。维度的索引从1到维度向量中给定的值。

A vector can be used by R as an array only if it has a dimension vector as its dim attribute. Suppose, for example, z is a vector of 1500 elements. The assignment
一个vector可以被R用作一个数组，只有当它有一个维度vector作为它的dim属性。例如，假设 z 是一个1500个元素的向量。转让

> dim(z) <- c(3,5,100)

gives it the dim attribute that allows it to be treated as a 3 by 5 by 100 array.
为它提供dim属性，使其可以被视为3 x 5 x 100数组。

Other functions such as matrix() and array() are available for simpler and more natural looking assignments, as we shall see in The array() function.
其他函数，如 matrix() 和 array() ，可用于更简单和更自然的赋值，正如我们将在 array() 函数中看到的那样。

The values in the data vector give the values in the array in the same order as they would occur in FORTRAN, that is “column major order,” with the first subscript moving fastest and the last subscript slowest.
数据向量中的值以与FORTRAN中相同的顺序给出数组中的值，即“列优先顺序”，第一个下标移动最快，最后一个下标移动最慢。

For example if the dimension vector for an array, say a, is c(3,4,2) then there are 3 * 4 * 2 = 24 entries in a and the data vector holds them in the order a[1,1,1], a[2,1,1], …, a[2,4,2], a[3,4,2].
例如，如果一个数组的维度向量，比如说 a ，是 c(3,4,2) ，那么在 a 中有3 * 4 * 2 = 24个条目，数据向量以 a[1,1,1], a[2,1,1], …, a[2,4,2], a[3,4,2] 的顺序保存它们。

Arrays can be one-dimensional: such arrays are usually treated in the same way as vectors (including when printing), but the exceptions can cause confusion.
数组可以是一维的：这种数组通常以与向量相同的方式处理（包括打印时），但例外情况可能会导致混淆。

5.2 Array indexing. Subsections of an array ¶
5.2数组索引。数组的子部分¶

Individual elements of an array may be referenced by giving the name of the array followed by the subscripts in square brackets, separated by commas.
数组中的单个元素可以通过给出数组的名称，后跟方括号中的下标（用逗号分隔）来引用。

More generally, subsections of an array may be specified by giving a sequence of index vectors in place of subscripts; however if any index position is given an empty index vector, then the full range of that subscript is taken.
更一般地说，数组的子部分可以通过给出一系列索引向量来代替下标来指定;但是，如果任何索引位置被赋予空索引向量，则采用该下标的整个范围。

Continuing the previous example, a[2,,] is a 4 * 2 array with dimension vector c(4,2) and data vector containing the values
继续前面的示例， a[2,,] 是一个4 * 2数组，其中维度向量 c(4,2) 和数据向量包含值

c(a[2,1,1], a[2,2,1], a[2,3,1], a[2,4,1],
  a[2,1,2], a[2,2,2], a[2,3,2], a[2,4,2])

in that order. a[,,] stands for the entire array, which is the same as omitting the subscripts entirely and using a alone.
按照这个顺序 a[,,] 代表整个数组，这与完全省略下标并单独使用 a 相同。

For any array, say Z, the dimension vector may be referenced explicitly as dim(Z) (on either side of an assignment).
对于任何数组，比如说 Z ，维度向量可以显式引用为 dim(Z) （在赋值的任何一侧）。

Also, if an array name is given with just one subscript or index vector, then the corresponding values of the data vector only are used; in this case the dimension vector is ignored. This is not the case, however, if the single index is not a vector but itself an array, as we next discuss.
此外，如果数组名只有一个下标或索引向量，则只使用数据向量的相应值;在这种情况下，维度向量被忽略。然而，如果单个索引不是一个向量，而是一个数组，就不是这种情况了，我们接下来会讨论。

5.3 Index matrices ¶
5.3索引矩阵¶

As well as an index vector in any subscript position, a matrix may be used with a single index matrix in order either to assign a vector of quantities to an irregular collection of elements in the array, or to extract an irregular collection as a vector.
除了在任何下标位置的索引向量之外，矩阵可以与单个索引矩阵一起使用，以便将量的向量分配给数组中的元素的不规则集合，或者提取不规则集合作为向量。

A matrix example makes the process clear. In the case of a doubly indexed array, an index matrix may be given consisting of two columns and as many rows as desired. The entries in the index matrix are the row and column indices for the doubly indexed array.
一个矩阵示例使该过程变得清晰。在双索引数组的情况下，索引矩阵可以由两列和任意多的行组成。索引矩阵中的条目是双索引数组的行索引和列索引。
Suppose for example we have a 4 by 5 array X and we wish to do the following:
例如，假设我们有一个4 × 5的数组 X ，我们希望做以下事情：

• Extract elements X[1,3], X[2,2] and X[3,1] as a vector structure, and
  提取元素 X[1,3] 、 X[2,2] 和 X[3,1] 作为向量结构，以及
• Replace these entries in the array X by zeroes.
  将数组 X 中的这些条目替换为零。

In this case we need a 3 by 2 subscript array, as in the following example.
在这种情况下，我们需要一个3乘2的下标数组，如下面的示例所示。

> x <- array(1:20, dim=c(4,5))   # Generate a 4 by 5 array.
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    9   13   17
[2,]    2    6   10   14   18
[3,]    3    7   11   15   19
[4,]    4    8   12   16   20
> i <- array(c(1:3,3:1), dim=c(3,2))
> i                             # i is a 3 by 2 index array.
     [,1] [,2]
[1,]    1    3
[2,]    2    2
[3,]    3    1
> x[i]                          # Extract those elements
[1] 9 6 3
> x[i] <- 0                     # Replace those elements by zeros.
> x
     [,1] [,2] [,3] [,4] [,5]
[1,]    1    5    0   13   17
[2,]    2    0   10   14   18
[3,]    0    7   11   15   19
[4,]    4    8   12   16   20
>

Negative indices are not allowed in index matrices. NA and zero values are allowed: rows in the index matrix containing a zero are ignored, and rows containing an NA produce an NA in the result.
索引矩阵中不允许有负索引。允许 NA 和零值：索引矩阵中包含零的行被忽略，包含 NA 的行在结果中产生 NA 。

As a less trivial example, suppose we wish to generate an (unreduced) design matrix for a block design defined by factors blocks (b levels) and varieties (v levels). Further suppose there are n plots in the experiment. We could proceed as follows:
作为一个不太平凡的例子，假设我们希望为因子 blocks （ b 水平）和 varieties （ v 水平）定义的区组设计生成一个（未简化）设计矩阵。进一步假设实验中有 n 图。我们可以这样做：

> Xb <- matrix(0, n, b)
> Xv <- matrix(0, n, v)
> ib <- cbind(1:n, blocks)
> iv <- cbind(1:n, varieties)
> Xb[ib] <- 1
> Xv[iv] <- 1
> X <- cbind(Xb, Xv)

To construct the incidence matrix, N say, we could use
为了构造关联矩阵，比如说，我们可以使用

> N <- crossprod(Xb, Xv)

However a simpler direct way of producing this matrix is to use table():
然而，产生该矩阵的更简单的直接方式是使用 table() ：

> N <- table(blocks, varieties)

Index matrices must be numerical: any other form of matrix (e.g. a logical or character matrix) supplied as a matrix is treated as an indexing vector.
索引矩阵必须是数字的：任何其他形式的矩阵（例如逻辑或字符矩阵）作为矩阵提供，都被视为索引向量。

5.4 The array() function ¶
5.4 array() 函数¶

As well as giving a vector structure a dim attribute, arrays can be constructed from vectors by the array function, which has the form
除了给向量结构一个 dim 属性外，还可以通过 array 函数从向量构造数组，其形式为

> Z <- array(data_vector, dim_vector)

For example, if the vector h contains 24 or fewer, numbers then the command
例如，如果矢量 h 包含24个或更少的数字，则命令

> Z <- array(h, dim=c(3,4,2))

would use h to set up 3 by 4 by 2 array in Z. If the size of h is exactly 24 the result is the same as
将使用 h 在 Z 中设置3 × 4 × 2阵列。如果 h 的大小正好是24，则结果与

> Z <- h ; dim(Z) <- c(3,4,2)

However if h is shorter than 24, its values are recycled from the beginning again to make it up to size 24 (see Mixed vector and array arithmetic. The recycling rule) but dim(h) <- c(3,4,2) would signal an error about mismatching length. As an extreme but common example
但是，如果 h 小于24，它的值将从开始再次循环，以使其大小为24（请参见混合向量和数组运算。回收规则），但 dim(h) <- c(3,4,2) 将发出有关长度不匹配的错误信号。作为一个极端但常见的例子

> Z <- array(0, c(3,4,2))

makes Z an array of all zeros.
使 Z 成为全零数组。

At this point dim(Z) stands for the dimension vector c(3,4,2), and Z[1:24] stands for the data vector as it was in h, and Z[] with an empty subscript or Z with no subscript stands for the entire array as an array.
此时 dim(Z) 代表维度向量 c(3,4,2) ， Z[1:24] 代表数据向量，就像在 h 中一样，带有空下标的 Z[] 或没有下标的 Z 代表整个数组作为数组。

Arrays may be used in arithmetic expressions and the result is an array formed by element-by-element operations on the data vector. The dim attributes of operands generally need to be the same, and this becomes the dimension vector of the result. So if A, B and C are all similar arrays, then
数组可用于算术表达式中，结果是通过对数据向量进行逐个元素操作形成的数组。操作数的 dim 属性通常需要相同，这将成为结果的维度向量。所以如果 A 、 B 和 C 都是相似的数组，那么

> D <- 2*A*B + C + 1

makes D a similar array with its data vector being the result of the given element-by-element operations. However the precise rule concerning mixed array and vector calculations has to be considered a little more carefully.
使 D 成为一个类似的数组，其数据向量是给定的逐个元素操作的结果。然而，关于混合数组和向量计算的精确规则必须更仔细地考虑。

• Mixed vector and array arithmetic. The recycling rule
  混合向量和数组运算。回收规则

5.5 The outer product of two arrays ¶
5.5两个数组的外积¶

An important operation on arrays is the outer product. If a and b are two numeric arrays, their outer product is an array whose dimension vector is obtained by concatenating their two dimension vectors (order is important), and whose data vector is got by forming all possible products of elements of the data vector of a with those of b. The outer product is formed by the special operator %o%:
数组的一个重要运算是外积。如果 a 和 b 是两个数值数组，则它们的外积是一个数组，其维度向量是通过连接它们的两个维度向量获得的（顺序很重要），其数据向量是通过将 a 的数据向量的元素与 b 的元素的所有可能的乘积形成而获得的。外积由特殊算子 %o% 形成：

> ab <- a %o% b

An alternative is  另一种方法是

> ab <- outer(a, b, "*")

The multiplication function can be replaced by an arbitrary function of two variables. For example if we wished to evaluate the function f(x; y) = cos(y)/(1 + x^2) over a regular grid of values with x- and y-coordinates defined by the R vectors x and y respectively, we could proceed as follows:
乘法函数可以用任意两个变量的函数代替。例如，如果我们希望在具有分别由R向量 x 和 y 定义的x坐标和y坐标的值的规则网格上计算函数f（x; y）= cos（y）/（1 + x^2），我们可以如下进行：

> f <- function(x, y) cos(y)/(1 + x^2)
> z <- outer(x, y, f)

In particular the outer product of two ordinary vectors is a doubly subscripted array (that is a matrix, of rank at most 1). Notice that the outer product operator is of course non-commutative. Defining your own R functions will be considered further in Writing your own functions.
特别是两个普通向量的外积是一个双下标数组（即秩至多为1的矩阵）。注意，外积运算符当然是不可交换的。定义自己的R函数将在编写自己的函数中进一步考虑。

An example: Determinants of 2 by 2 single-digit matrices ¶
一个例子：2乘2个位数矩阵的行列式¶

As an artificial but cute example, consider the determinants of 2 by 2 matrices [a, b; c, d] where each entry is a non-negative integer in the range 0, 1, ..., 9, that is a digit.
作为一个人工但可爱的例子，考虑2乘2矩阵[a，B; c，d]的行列式，其中每个条目是范围0，1，.，9，这是一个数字。

The problem is to find the determinants, ad - bc, of all possible matrices of this form and represent the frequency with which each value occurs as a high density plot. This amounts to finding the probability distribution of the determinant if each digit is chosen independently and uniformly at random.
问题是找到所有可能的矩阵的行列式ad - bc，并将每个值出现的频率表示为高密度图。这相当于找到行列式的概率分布，如果每个数字是独立和均匀随机选择的。

A neat way of doing this uses the outer() function twice:
一个简单的方法是使用两次 outer() 函数：

> d <- outer(0:9, 0:9)
> fr <- table(outer(d, d, "-"))
> plot(fr, xlab="Determinant", ylab="Frequency")

Notice that plot() here uses a histogram like plot method, because it “sees” that fr is of class "table". The “obvious” way of doing this problem with for loops, to be discussed in Grouping, loops and conditional execution, is so inefficient as to be impractical.
请注意，这里的 plot() 使用了类似于plot方法的直方图，因为它“看到” fr 属于类 "table" 。用 for 循环来解决这个问题的“显而易见”的方法，将在循环，循环和条件执行中讨论，是如此低效以至于不切实际。

It is also perhaps surprising that about 1 in 20 such matrices is singular.
也许令人惊讶的是，大约每20个这样的矩阵中就有1个是奇异的。

5.6 Generalized transpose of an array ¶
5.6数组的广义转置¶

The function aperm(a, perm) may be used to permute an array, a. The argument perm must be a permutation of the integers {1, ..., k}, where k is the number of subscripts in a. The result of the function is an array of the same size as a but with old dimension given by perm[j] becoming the new j-th dimension. The easiest way to think of this operation is as a generalization of transposition for matrices. Indeed if A is a matrix, (that is, a doubly subscripted array) then B given by
函数 aperm(a, perm) 可用于置换数组 a 。参数 perm 必须是整数{1，.，k}，其中k是 a 中的下标的数量。该函数的结果是一个与 a 大小相同的数组，但由 perm[j] 给出的旧维度成为新的第 j 维度。最简单的方法来考虑这个操作是作为一个推广的转置矩阵。事实上，如果 A 是一个矩阵，（也就是说，一个双下标数组），那么 B 由下式给出：

> B <- aperm(A, c(2,1))

is just the transpose of A. For this special case a simpler function t() is available, so we could have used B <- t(A).
是 A 的转置。对于这种特殊情况，可以使用更简单的函数 t() ，因此我们可以使用 B <- t(A) 。

5.7 Matrix facilities ¶
5.7矩阵设施¶

As noted above, a matrix is just an array with two subscripts. However it is such an important special case it needs a separate discussion. R contains many operators and functions that are available only for matrices. For example t(X) is the matrix transpose function, as noted above. The functions nrow(A) and ncol(A) give the number of rows and columns in the matrix A respectively.
如上所述，矩阵只是一个有两个下标的数组。然而，这是一个如此重要的特殊情况，需要单独讨论。R包含许多仅适用于矩阵的运算符和函数。例如， t(X) 是矩阵转置函数，如上所述。函数 nrow(A) 和 ncol(A) 分别给出矩阵 A 中的行数和列数。

• Matrix multiplication  矩阵乘法
• Linear equations and inversion
  线性方程组与反演
• Eigenvalues and eigenvectors
  特征值和特征向量
• Singular value decomposition and determinants
  奇异值分解与行列式
• Least squares fitting and the QR decomposition
  最小二乘拟合和QR分解

> A * B

> A %*% B

> x %*% A %*% x

> b <- A %*% x

> solve(A,b)

solve(A)

> ev <- eigen(Sm)

> evals <- eigen(Sm)$values

> eigen(Sm)

> evals <- eigen(Sm, only.values = TRUE)$values

> absdetM <- prod(svd(M)$d)

> absdet <- function(M) prod(svd(M)$d)

> ans <- lsfit(X, y)

> Xplus <- qr(X)
> b <- qr.coef(Xplus, y)
> fit <- qr.fitted(Xplus, y)
> res <- qr.resid(Xplus, y)

5.8 Forming partitioned matrices, cbind() and rbind() ¶
5.8形成分块矩阵， cbind() 和 rbind() ¶

As we have already seen informally, matrices can be built up from other vectors and matrices by the functions cbind() and rbind(). Roughly cbind() forms matrices by binding together matrices horizontally, or column-wise, and rbind() vertically, or row-wise.
正如我们已经非正式地看到的，矩阵可以通过函数 cbind() 和 rbind() 从其他向量和矩阵建立。大致上， cbind() 通过水平或列方式将矩阵绑定在一起来形成矩阵，而 rbind() 垂直或行方式。

In the assignment  在转让中

> X <- cbind(arg_1, arg_2, arg_3, ...)

the arguments to cbind() must be either vectors of any length, or matrices with the same column size, that is the same number of rows. The result is a matrix with the concatenated arguments arg_1, arg_2, … forming the columns.
cbind() 的参数必须是任意长度的向量，或者是具有相同列大小（即相同行数）的矩阵。结果是一个矩阵，其中参数arg_1，arg_2，.串联起来形成列。

If some of the arguments to cbind() are vectors they may be shorter than the column size of any matrices present, in which case they are cyclically extended to match the matrix column size (or the length of the longest vector if no matrices are given).
如果 cbind() 的一些参数是向量，它们可能比存在的任何矩阵的列大小都短，在这种情况下，它们被循环扩展以匹配矩阵列大小（或最长向量的长度，如果没有给出矩阵）。

The function rbind() does the corresponding operation for rows. In this case any vector argument, possibly cyclically extended, are of course taken as row vectors.
函数 rbind() 对行执行相应的操作。在这种情况下，任何可能循环扩展的向量参数当然都被视为行向量。

Suppose X1 and X2 have the same number of rows. To combine these by columns into a matrix X, together with an initial column of 1s we can use
假设 X1 和 X2 具有相同的行数。为了将这些按列联合收割机组合成矩阵 X ，连同初始列 1 ，我们可以使用

> X <- cbind(1, X1, X2)

The result of rbind() or cbind() always has matrix status. Hence cbind(x) and rbind(x) are possibly the simplest ways explicitly to allow the vector x to be treated as a column or row matrix respectively.
rbind() 或 cbind() 的结果始终具有矩阵状态。因此， cbind(x) 和 rbind(x) 可能是明确允许向量 x 分别被视为列矩阵或行矩阵的最简单方式。

5.9 The concatenation function, c(), with arrays ¶
5.9连接函数 c() 与数组¶

It should be noted that whereas cbind() and rbind() are concatenation functions that respect dim attributes, the basic c() function does not, but rather clears numeric objects of all dim and dimnames attributes. This is occasionally useful in its own right.
应该注意的是，尽管 cbind() 和 rbind() 是遵守 dim 属性的串联函数，但基本的 c() 函数不遵守，而是清除所有 dim 和 dimnames 属性的数字对象。这本身有时是有用的。

The official way to coerce an array back to a simple vector object is to use as.vector()
将数组强制转换为简单向量对象的正式方法是使用 as.vector()

> vec <- as.vector(X)

However a similar result can be achieved by using c() with just one argument, simply for this side-effect:
然而，通过使用只有一个参数的 c() 可以实现类似的结果，只是为了这个副作用：

> vec <- c(X)

There are slight differences between the two, but ultimately the choice between them is largely a matter of style (with the former being preferable).
两者之间有细微的差异，但最终在它们之间的选择在很大程度上是一个风格问题（前者更可取）。

5.10 Frequency tables from factors ¶
5.10因子的频率表¶

Recall that a factor defines a partition into groups. Similarly a pair of factors defines a two way cross classification, and so on. The function table() allows frequency tables to be calculated from equal length factors. If there are k factor arguments, the result is a k-way array of frequencies.
回想一下，因子将分区定义为多个组。类似地，一对因子定义了一个双向交叉分类，等等。函数 table() 允许从等长因子计算频率表。如果有k个因子参数，则结果是k路频率数组。

Suppose, for example, that statef is a factor giving the state code for each entry in a data vector. The assignment
例如，假设 statef 是为数据向量中的每个条目给出状态代码的因子。转让

> statefr <- table(statef)

gives in statefr a table of frequencies of each state in the sample. The frequencies are ordered and labelled by the levels attribute of the factor. This simple case is equivalent to, but more convenient than,
在 statefr 中给出了样本中每个状态的频率表。频率由因子的 levels 属性排序和标记。这个简单的例子相当于，但更方便，

> statefr <- tapply(statef, statef, length)

Further suppose that incomef is a factor giving a suitably defined “income class” for each entry in the data vector, for example with the cut() function:
进一步假设 incomef 是为数据向量中的每个条目给出适当定义的“收入类别”的因子，例如使用 cut() 函数：

> factor(cut(incomes, breaks = 35+10*(0:7))) -> incomef

Then to calculate a two-way table of frequencies:
然后计算一个双向频率表：

> table(incomef,statef)
         statef
incomef   act nsw nt qld sa tas vic wa
  (35,45]   1   1  0   1  0   0   1  0
  (45,55]   1   1  1   1  2   0   1  3
  (55,65]   0   3  1   3  2   2   2  1
  (65,75]   0   1  0   0  0   0   1  0

Extension to higher-way frequency tables is immediate.
扩展到更高的方式频率表是立即的。

6.1 Lists ¶ 6.1列表¶

An R list is an object consisting of an ordered collection of objects known as its components.
一个R列表是一个对象，由一个有序的对象集合组成，称为它的组件。

There is no particular need for the components to be of the same mode or type, and, for example, a list could consist of a numeric vector, a logical value, a matrix, a complex vector, a character array, a function, and so on. Here is a simple example of how to make a list:
没有特别的必要让这些组件具有相同的模式或类型，例如，列表可以由数字向量、逻辑值、矩阵、复向量、字符数组、函数等组成。下面是一个如何创建列表的简单示例：

> Lst <- list(name="Fred", wife="Mary", no.children=3,
              child.ages=c(4,7,9))

Components are always numbered and may always be referred to as such. Thus if Lst is the name of a list with four components, these may be individually referred to as Lst[[1]], Lst[[2]], Lst[[3]] and Lst[[4]]. If, further, Lst[[4]] is a vector subscripted array then Lst[[4]][1] is its first entry.
组件总是编号的，并可能总是这样称呼。因此，如果 Lst 是具有四个分量的列表的名称，则这些分量可以被单独地称为 Lst[[1]] 、 Lst[[2]] 、 Lst[[3]] 和 Lst[[4]] 。此外，如果 Lst[[4]] 是一个向量下标数组，那么 Lst[[4]][1] 是它的第一个条目。

If Lst is a list, then the function length(Lst) gives the number of (top level) components it has.
如果 Lst 是一个列表，那么函数 length(Lst) 给出了它拥有的（顶级）组件的数量。

Components of lists may also be named, and in this case the component may be referred to either by giving the component name as a character string in place of the number in double square brackets, or, more conveniently, by giving an expression of the form
也可以命名列表的组件，在这种情况下，可以通过将组件名称作为字符串来代替双方括号中的数字来引用组件，或者更方便地，通过给出以下形式的表达式来引用组件

> name$component_name

for the same thing.
为了同样的事

This is a very useful convention as it makes it easier to get the right component if you forget the number.
这是一个非常有用的约定，因为如果您忘记了数字，它可以更容易地获得正确的组件。

So in the simple example given above:
在上面给出的简单例子中：

Lst$name is the same as Lst[[1]] and is the string "Fred",
Lst$name 与 Lst[[1]] 相同，是字符串 "Fred" ，

Lst$wife is the same as Lst[[2]] and is the string "Mary",
Lst$wife 与 Lst[[2]] 相同，是字符串 "Mary" ，

Lst$child.ages[1] is the same as Lst[[4]][1] and is the number 4.
Lst$child.ages[1] 与 Lst[[4]][1] 相同，是数字 4 。

Additionally, one can also use the names of the list components in double square brackets, i.e., Lst[["name"]] is the same as Lst$name. This is especially useful, when the name of the component to be extracted is stored in another variable as in
此外，还可以在双方括号中使用列表组件的名称，即， Lst[["name"]] 与 Lst$name 相同。当要提取的组件的名称存储在另一个变量中时（如

> x <- "name"; Lst[[x]]

It is very important to distinguish Lst[[1]] from Lst[1]. ‘[[…]]’ is the operator used to select a single element, whereas ‘[…]’ is a general subscripting operator. Thus the former is the first object in the list Lst, and if it is a named list the name is not included. The latter is a sublist of the list Lst consisting of the first entry only. If it is a named list, the names are transferred to the sublist.
区分 Lst[[1]] 和 Lst[1] 是非常重要的。' [[…]] '是用于选择单个元素的运算符，而' […] '是通用下标运算符。因此，前者是列表 Lst 中的第一个对象，如果它是一个命名列表，则不包括名称。后者是仅由第一条目组成的列表 Lst 的子列表。如果它是一个命名列表，则将名称转移到子列表。

The names of components may be abbreviated down to the minimum number of letters needed to identify them uniquely. Thus Lst$coefficients may be minimally specified as Lst$coe and Lst$covariance as Lst$cov.
组件的名称可以缩写成唯一标识它们所需的最小字母数。因此， Lst$coefficients 可以最低限度地被指定为 Lst$coe 并且 Lst$covariance 可以被指定为 Lst$cov 。

The vector of names is in fact simply an attribute of the list like any other and may be handled as such. Other structures besides lists may, of course, similarly be given a names attribute also.
名称向量实际上只是列表的一个属性，就像任何其他属性一样，可以这样处理。当然，除了列表之外的其他结构也可以类似地被赋予names属性。

6.2 Constructing and modifying lists ¶
6.2构造和修改列表¶

New lists may be formed from existing objects by the function list(). An assignment of the form
新的列表可以通过函数 list() 从现有对象中形成。形式的赋值

> Lst <- list(name_1=object_1, ..., name_m=object_m)

sets up a list Lst of m components using object_1, …, object_m for the components and giving them names as specified by the argument names, (which can be freely chosen). If these names are omitted, the components are numbered only. The components used to form the list are copied when forming the new list and the originals are not affected.
使用object_1，...，object_m为组件设置一个包含m个组件的列表 Lst ，并根据参数名称指定它们的名称（可以自由选择）。如果省略这些名称，则仅对组件进行编号。用于形成列表的组件在形成新列表时被复制，并且原始组件不受影响。

Lists, like any subscripted object, can be extended by specifying additional components. For example
列表，像任何下标对象一样，可以通过指定其他组件来扩展。例如

> Lst[5] <- list(matrix=Mat)

• Concatenating lists  连接列表

> list.ABC <- c(list.A, list.B, list.C)

6.3 Data frames ¶
6.3数据帧¶

A data frame is a list with class "data.frame". There are restrictions on lists that may be made into data frames, namely
数据帧是一个类为 "data.frame" 的列表。对可以被制成数据帧的列表有一些限制，即

• The components must be vectors (numeric, character, or logical), factors, numeric matrices, lists, or other data frames.
  组件必须是向量（数字、字符或逻辑）、因子、数字矩阵、列表或其他数据框。
• Matrices, lists, and data frames provide as many variables to the new data frame as they have columns, elements, or variables, respectively.
  矩阵、列表和数据框为新数据框提供的变量分别与它们的列、元素或变量一样多。
• Vector structures appearing as variables of the data frame must all have the same length, and matrix structures must all have the same number of rows.
  作为数据框变量出现的向量结构必须具有相同的长度，矩阵结构必须具有相同的行数。

A data frame may for many purposes be regarded as a matrix with columns possibly of differing modes and attributes. It may be displayed in matrix form, and its rows and columns extracted using matrix indexing conventions.
一个数据框在许多情况下可以被看作是一个矩阵，其中的列可能具有不同的模式和属性。它可以以矩阵形式显示，并且使用矩阵索引约定提取其行和列。

• Making data frames  制作数据框
• attach() and detach()  attach() 和 detach()
• Working with data frames
  使用数据框
• Attaching arbitrary lists
  附加任意列表
• Managing the search path
  管理搜索路径

> accountants <- data.frame(home=statef, loot=incomes, shot=incomef)

> attach(lentils)

> u <- v+w

> lentils$u <- v+w

> detach()

> attach(any.old.list)

> search()
[1] ".GlobalEnv"   "Autoloads"    "package:base"

> search()
[1] ".GlobalEnv"   "lentils"      "Autoloads"    "package:base"
> ls(2)
[1] "u" "v" "w"

> detach("lentils")
> search()
[1] ".GlobalEnv"   "Autoloads"    "package:base"

7.1 The read.table() function ¶
7.1 read.table() 函数¶

To read an entire data frame directly, the external file will normally have a special form.
为了直接读取整个数据帧，外部文件通常具有特殊的格式。

• The first line of the file should have a name for each variable in the data frame.
  文件的第一行应包含数据框中每个变量的名称。
• Each additional line of the file has as its first item a row label and the values for each variable.
  文件的每一个附加行的第一项都是行标签和每个变量的值。

If the file has one fewer item in its first line than in its second, this arrangement is presumed to be in force. So the first few lines of a file to be read as a data frame might look as follows.
如果文件的第一行比第二行少一项，则假定这种安排有效。因此，作为数据帧读取的文件的前几行可能如下所示。

Input file form with names and row labels: Price Floor Area Rooms Age Cent.heat 01 52.00 111.0 830 5 6.2 no 02 54.75 128.0 710 5 7.5 no 03 57.50 101.0 1000 5 4.2 no 04 57.50 131.0 690 6 8.8 no 05 59.75 93.0 900 5 1.9 yes ...

By default numeric items (except row labels) are read as numeric variables and non-numeric variables, such as Cent.heat in the example, as character variables. This can be changed if necessary.
默认情况下，数字项（行标签除外）被读取为数字变量，非数字变量（如示例中的 Cent.heat ）被读取为字符变量。如有必要，可以进行更改。

The function read.table() can then be used to read the data frame directly
然后可以使用函数 read.table() 直接读取数据帧

> HousePrice <- read.table("houses.data")

Often you will want to omit including the row labels directly and use the default labels. In this case the file may omit the row label column as in the following.
通常，您会希望省略直接包含行标签，而使用默认标签。在这种情况下，文件可能会省略行标签列，如下所示。

Input file form without row labels: Price Floor Area Rooms Age Cent.heat 52.00 111.0 830 5 6.2 no 54.75 128.0 710 5 7.5 no 57.50 101.0 1000 5 4.2 no 57.50 131.0 690 6 8.8 no 59.75 93.0 900 5 1.9 yes ...

The data frame may then be read as
然后，数据帧可以被读取为

> HousePrice <- read.table("houses.data", header=TRUE)

where the header=TRUE option specifies that the first line is a line of headings, and hence, by implication from the form of the file, that no explicit row labels are given.
其中 header=TRUE 选项指定第一行是一行标题，因此，从文件的形式来看，没有明确的行标签。

7.2 The scan() function ¶
7.2 scan() 函数¶

Suppose the data vectors are of equal length and are to be read in parallel. Further suppose that there are three vectors, the first of mode character and the remaining two of mode numeric, and the file is input.dat. The first step is to use scan() to read in the three vectors as a list, as follows
假设数据向量具有相等的长度并且将被并行读取。进一步假设有三个向量，第一个是模式字符，其余两个是模式数字，文件是 input.dat 。第一步是使用 scan() 将三个向量作为列表读入，如下所示

> inp <- scan("input.dat", list("",0,0))

The second argument is a dummy list structure that establishes the mode of the three vectors to be read. The result, held in inp, is a list whose components are the three vectors read in. To separate the data items into three separate vectors, use assignments like
第二个参数是一个伪列表结构，它建立了要读取的三个向量的模式。结果保存在 inp 中，是一个列表，其分量是读入的三个向量。若要将数据项分隔为三个单独的向量，请使用以下赋值方法，

> label <- inp[[1]]; x <- inp[[2]]; y <- inp[[3]]

More conveniently, the dummy list can have named components, in which case the names can be used to access the vectors read in. For example
更方便的是，虚拟列表可以有命名的组件，在这种情况下，名称可以用来访问读入的向量。例如

> inp <- scan("input.dat", list(id="", x=0, y=0))

If you wish to access the variables separately they may either be re-assigned to variables in the working frame:
如果您希望单独访问变量，则可以将它们重新分配给工作框架中的变量：

> label <- inp$id; x <- inp$x; y <- inp$y

or the list may be attached at position 2 of the search path (see Attaching arbitrary lists).
或者列表可以附加在搜索路径的位置2（请参阅附加任意列表）。

If the second argument is a single value and not a list, a single vector is read in, all components of which must be of the same mode as the dummy value.
如果第二个参数是单个值而不是列表，则读入单个向量，其所有分量必须与伪值具有相同的模式。

> X <- matrix(scan("light.dat", 0), ncol=5, byrow=TRUE)

There are more elaborate input facilities available and these are detailed in the manuals.
还有更复杂的输入设施，这些都在手册中详细说明。

7.3 Accessing builtin datasets ¶
7.3安装内置数据集¶

Around 100 datasets are supplied with R (in package datasets), and others are available in packages (including the recommended packages supplied with R). To see the list of datasets currently available use
R提供了大约100个数据集（在包数据集中），其他数据集在包中可用（包括R提供的推荐包）。要查看当前可用的数据集列表，请使用

data()

All the datasets supplied with R are available directly by name. However, many packages still use the obsolete convention in which data was also used to load datasets into R, for example
R提供的所有数据集都可以直接通过名称获得。然而，许多软件包仍然使用过时的约定，其中 data 也用于将数据集加载到R中，例如

data(infert)

and this can still be used with the standard packages (as in this example). In most cases this will load an R object of the same name. However, in a few cases it loads several objects, so see the on-line help for the object to see what to expect.
并且这仍然可以与标准包一起使用（如在该示例中）。在大多数情况下，这将加载同名的R对象。但是，在少数情况下，它会加载多个对象，因此请参阅对象的联机帮助以了解预期内容。

• Loading data from other R packages
  从其他R包加载数据

data(package="rpart")
data(Puromycin, package="datasets")

7.4 Editing data ¶
7.4编辑数据¶

When invoked on a data frame or matrix, edit brings up a separate spreadsheet-like environment for editing. This is useful for making small changes once a data set has been read. The command
当在数据框或矩阵上调用时， edit 会带来一个单独的类似电子表格的编辑环境。这对于在读取数据集后进行小的更改非常有用。命令

> xnew <- edit(xold)

will allow you to edit your data set xold, and on completion the changed object is assigned to xnew. If you want to alter the original dataset xold, the simplest way is to use fix(xold), which is equivalent to xold <- edit(xold).
将允许您编辑数据集 xold ，完成后，更改的对象将分配给 xnew 。如果你想改变原始数据集 xold ，最简单的方法是使用 fix(xold) ，它相当于 xold <- edit(xold) 。

Use  使用

> xnew <- edit(data.frame())

to enter new data via the spreadsheet interface.
通过电子表格界面输入新数据。

8.1 R as a set of statistical tables ¶
8.1 R作为一组统计表¶

One convenient use of R is to provide a comprehensive set of statistical tables. Functions are provided to evaluate the cumulative distribution function P(X <= x), the probability density function and the quantile function (given q, the smallest x such that P(X <= x) > q), and to simulate from the distribution.
R的一个方便用途是提供一套全面的统计表。提供函数来评估累积分布函数P（X <= x）、概率密度函数和分位数函数（给定q，使得P（X <= x）> q的最小x），并从分布进行模拟。

Distribution 分布	R name R名称	additional arguments 补充论点
beta	beta	shape1, shape2, ncp
binomial 二项式	binom	size, prob
Cauchy	cauchy	location, scale
chi-squared 卡方	chisq	df, ncp
exponential 指数	exp	rate
F	f	df1, df2, ncp
gamma 伽马	gamma	shape, scale
geometric 几何	geom	prob
hypergeometric 超几何	hyper	m, n, k
log-normal 对数正	lnorm	meanlog, sdlog
logistic	logis	location, scale
negative binomial 负二项	nbinom	size, prob
normal 正常	norm	mean, sd
Poisson 泊松	pois	lambda
signed rank 符号秩	signrank	n
Student’s t 学生t	t	df, ncp
uniform 均匀	unif	min, max
Weibull	weibull	shape, scale
Wilcoxon	wilcox	m, n

Prefix the name given here by ‘d’ for the density, ‘p’ for the CDF, ‘q’ for the quantile function and ‘r’ for simulation (random deviates). The first argument is x for dxxx, q for pxxx, p for qxxx and n for rxxx (except for rhyper, rsignrank and rwilcox, for which it is nn). In not quite all cases is the non-centrality parameter ncp currently available: see the on-line help for details.
在这里给出的名称前面加上' d '表示密度，' p '表示CDF，' q '表示分位数函数，' r '表示模拟（随机偏差）。第一个参数是 dxxx 的 x ， pxxx 的 q ， qxxx 的 p 和 rxxx 的 n （除了 rhyper ， rsignrank 和 rwilcox ，它是 nn ）。在不完全所有的情况下，非中心性参数 ncp 当前可用：有关详细信息，请参阅在线帮助。

The pxxx and qxxx functions all have logical arguments lower.tail and log.p and the dxxx ones have log. This allows, e.g., getting the cumulative (or “integrated”) hazard function, H(t) = - log(1 - F(t)), by
pxxx 和 qxxx 函数都有逻辑参数 lower.tail 和 log.p ， dxxx 函数有 log 。这允许，例如，得到累积（或“积分”）风险函数，H（t）= - log（1 - F（t）），通过

 - pxxx(t, ..., lower.tail = FALSE, log.p = TRUE)

or more accurate log-likelihoods (by dxxx(..., log = TRUE)), directly.
或更精确的对数似然（通过 dxxx(..., log = TRUE) ）。

In addition there are functions ptukey and qtukey for the distribution of the studentized range of samples from a normal distribution, and dmultinom and rmultinom for the multinomial distribution. Further distributions are available in contributed packages, notably SuppDists.
此外，还有函数 ptukey 和 qtukey 用于来自正态分布的样本的学生化范围的分布，以及用于多项分布的函数 dmultinom 和 rmultinom 。更多的发行版可以在贡献包中找到，特别是SuppDists。

Here are some examples
这里有一些例子

> ## 2-tailed p-value for t distribution
> 2*pt(-2.43, df = 13)
> ## upper 1% point for an F(2, 7) distribution
> qf(0.01, 2, 7, lower.tail = FALSE)

See the on-line help on RNG for how random-number generation is done in R.
请参阅 RNG 上的在线帮助，了解如何在R中生成随机数。

8.2 Examining the distribution of a set of data ¶
8.2检查一组数据的分布¶

Given a (univariate) set of data we can examine its distribution in a large number of ways. The simplest is to examine the numbers. Two slightly different summaries are given by summary and fivenum and a display of the numbers by stem (a “stem and leaf” plot).
给定一组（单变量）数据，我们可以用很多方法来检查它的分布。最简单的方法是检查数字。 summary 和 fivenum 给出了两个略有不同的摘要， stem 显示了数字（“茎和叶”图）。

> attach(faithful)
> summary(eruptions)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
  1.600   2.163   4.000   3.488   4.454   5.100
> fivenum(eruptions)
[1] 1.6000 2.1585 4.0000 4.4585 5.1000
> stem(eruptions)

  The decimal point is 1 digit(s) to the left of the |

  16 | 070355555588
  18 | 000022233333335577777777888822335777888
  20 | 00002223378800035778
  22 | 0002335578023578
  24 | 00228
  26 | 23
  28 | 080
  30 | 7
  32 | 2337
  34 | 250077
  36 | 0000823577
  38 | 2333335582225577
  40 | 0000003357788888002233555577778
  42 | 03335555778800233333555577778
  44 | 02222335557780000000023333357778888
  46 | 0000233357700000023578
  48 | 00000022335800333
  50 | 0370

A stem-and-leaf plot is like a histogram, and R has a function hist to plot histograms.
茎叶图就像直方图，R有一个函数 hist 来绘制直方图。

> hist(eruptions)
## make the bins smaller, make a plot of density
> hist(eruptions, seq(1.6, 5.2, 0.2), prob=TRUE)
> lines(density(eruptions, bw=0.1))
> rug(eruptions) # show the actual data points

More elegant density plots can be made by density, and we added a line produced by density in this example. The bandwidth bw was chosen by trial-and-error as the default gives too much smoothing (it usually does for “interesting” densities). (Better automated methods of bandwidth choice are available, and in this example bw = "SJ" gives a good result.)
更优雅的密度图可以由 density 绘制，我们在这个例子中添加了一条由 density 生成的线。带宽 bw 是通过试错法选择的，因为默认值提供了太多的平滑（它通常用于“感兴趣”的密度）。（有更好的自动化带宽选择方法，在本例中， bw = "SJ" 给出了一个很好的结果。）

We can plot the empirical cumulative distribution function by using the function ecdf.
我们可以使用函数 ecdf 绘制经验累积分布函数。

> plot(ecdf(eruptions), do.points=FALSE, verticals=TRUE)

This distribution is obviously far from any standard distribution. How about the right-hand mode, say eruptions of longer than 3 minutes? Let us fit a normal distribution and overlay the fitted CDF.
这种分布显然与任何标准分布都相去甚远。右手模式怎么样，比如喷发时间超过3分钟？让我们拟合一个正态分布并覆盖拟合的CDF。

> long <- eruptions[eruptions > 3]
> plot(ecdf(long), do.points=FALSE, verticals=TRUE)
> x <- seq(3, 5.4, 0.01)
> lines(x, pnorm(x, mean=mean(long), sd=sqrt(var(long))), lty=3)

Quantile-quantile (Q-Q) plots can help us examine this more carefully.
分位数-分位数（Q-Q）图可以帮助我们更仔细地检查这一点。

par(pty="s")       # arrange for a square figure region
qqnorm(long); qqline(long)

which shows a reasonable fit but a shorter right tail than one would expect from a normal distribution. Let us compare this with some simulated data from a t distribution
这显示了合理的拟合，但比正态分布预期的右尾短。让我们将其与来自t分布的一些模拟数据进行比较

x <- rt(250, df = 5)
qqnorm(x); qqline(x)

which will usually (if it is a random sample) show longer tails than expected for a normal. We can make a Q-Q plot against the generating distribution by
其通常（如果是随机样本）将显示比正常情况下预期的更长的尾部。我们可以通过以下方式绘制生成分布的Q-Q图：

qqplot(qt(ppoints(250), df = 5), x, xlab = "Q-Q plot for t dsn")
qqline(x)

Finally, we might want a more formal test of agreement with normality (or not). R provides the Shapiro-Wilk test
最后，我们可能需要一个更正式的检验是否符合正态性。R提供Shapiro-Wilk检验

> shapiro.test(long)

         Shapiro-Wilk normality test

data:  long
W = 0.9793, p-value = 0.01052

and the Kolmogorov-Smirnov test
Kolmogorov-Smirnov检验

> ks.test(long, "pnorm", mean = mean(long), sd = sqrt(var(long)))

         One-sample Kolmogorov-Smirnov test

data:  long
D = 0.0661, p-value = 0.4284
alternative hypothesis: two.sided

(Note that the distribution theory is not valid here as we have estimated the parameters of the normal distribution from the same sample.)
(Note分布理论在这里是无效的，因为我们已经从相同的样本中估计了正态分布的参数。

8.3 One- and two-sample tests ¶
8.3单样本和双样本检验¶

So far we have compared a single sample to a normal distribution. A much more common operation is to compare aspects of two samples. Note that in R, all “classical” tests including the ones used below are in package stats which is normally loaded.
到目前为止，我们已经比较了单个样本和正态分布。一个更常见的操作是比较两个样本的各个方面。请注意，在R中，所有“经典”测试，包括下面使用的测试，都在通常加载的包stats中。

Consider the following sets of data on the latent heat of the fusion of ice (cal/gm) from Rice (1995, p.490)
考虑以下几组来自Rice（1995年，第490页）的关于冰融合潜热（cal/gm）的数据。

Method A: 79.98 80.04 80.02 80.04 80.03 80.03 80.04 79.97
          80.05 80.03 80.02 80.00 80.02
Method B: 80.02 79.94 79.98 79.97 79.97 80.03 79.95 79.97

Boxplots provide a simple graphical comparison of the two samples.
箱形图提供了两个样品的简单图形比较。

A <- scan()
79.98 80.04 80.02 80.04 80.03 80.03 80.04 79.97
80.05 80.03 80.02 80.00 80.02

B <- scan()
80.02 79.94 79.98 79.97 79.97 80.03 79.95 79.97

boxplot(A, B)

which indicates that the first group tends to give higher results than the second.
这表明第一组倾向于给出比第二组更高的结果。

To test for the equality of the means of the two examples, we can use an unpaired t-test by
为了检验两个例子的平均值是否相等，我们可以使用非配对t检验，

> t.test(A, B)

         Welch Two Sample t-test

data:  A and B
t = 3.2499, df = 12.027, p-value = 0.00694
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 0.01385526 0.07018320
sample estimates:
mean of x mean of y
 80.02077  79.97875

which does indicate a significant difference, assuming normality. By default the R function does not assume equality of variances in the two samples. We can use the F test to test for equality in the variances, provided that the two samples are from normal populations.
这确实表明了一个显著的差异，假设正态性。默认情况下，R函数不假设两个样本的方差相等。我们可以使用F检验来检验方差的相等性，前提是两个样本来自正态总体。

> var.test(A, B)

         F test to compare two variances

data:  A and B
F = 0.5837, num df = 12, denom df =  7, p-value = 0.3938
alternative hypothesis: true ratio of variances is not equal to 1
95 percent confidence interval:
 0.1251097 2.1052687
sample estimates:
ratio of variances
         0.5837405

which shows no evidence of a significant difference, and so we can use the classical t-test that assumes equality of the variances.
这表明没有显著差异的证据，因此我们可以使用假设方差相等的经典t检验。

> t.test(A, B, var.equal=TRUE)

         Two Sample t-test

data:  A and B
t = 3.4722, df = 19, p-value = 0.002551
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 0.01669058 0.06734788
sample estimates:
mean of x mean of y
 80.02077  79.97875

All these tests assume normality of the two samples. The two-sample Wilcoxon (or Mann-Whitney) test only assumes a common continuous distribution under the null hypothesis.
所有这些检验均假定两个样本呈正态分布。双样本Wilcoxon（或Mann-Whitney）检验仅在零假设下假设共同连续分布。

> wilcox.test(A, B)

         Wilcoxon rank sum test with continuity correction

data:  A and B
W = 89, p-value = 0.007497
alternative hypothesis: true location shift is not equal to 0

Warning message:
Cannot compute exact p-value with ties in: wilcox.test(A, B)

Note the warning: there are several ties in each sample, which suggests strongly that these data are from a discrete distribution (probably due to rounding).
注意警告：每一个样本都有几个联系，这强烈表明这些数据来自离散分布（可能是由于四舍五入）。

There are several ways to compare graphically the two samples. We have already seen a pair of boxplots. The following
有几种方法可以用图形比较两个样本。我们已经看到了两个箱线图。以下

> plot(ecdf(A), do.points=FALSE, verticals=TRUE, xlim=range(A, B))
> plot(ecdf(B), do.points=FALSE, verticals=TRUE, add=TRUE)

will show the two empirical CDFs, and qqplot will perform a Q-Q plot of the two samples. The Kolmogorov-Smirnov test is of the maximal vertical distance between the two ecdfs, assuming a common continuous distribution:
将显示两个经验CDF， qqplot 将执行两个样本的Q-Q图。Kolmogorov-Smirnov检验是两个ecdf之间的最大垂直距离，假设一个共同的连续分布：

> ks.test(A, B)

         Two-sample Kolmogorov-Smirnov test

data:  A and B
D = 0.5962, p-value = 0.05919
alternative hypothesis: two-sided

Warning message:
cannot compute correct p-values with ties in: ks.test(A, B)

9.1 Grouped expressions ¶
9.1分组表达式¶

R is an expression language in the sense that its only command type is a function or expression which returns a result.
R是一种表达式语言，因为它唯一的命令类型是返回结果的函数或表达式。
Even an assignment is an expression whose result is the value assigned, and it may be used wherever any expression may be used; in particular multiple assignments are possible.
甚至赋值也是一个表达式，其结果是赋值的值，并且它可以在任何可能使用表达式的地方使用;特别是多个赋值是可能的。

Commands may be grouped together in braces, {expr_1; …; expr_m}, in which case the value of the group is the result of the last expression in the group evaluated. Since such a group is also an expression it may, for example, be itself included in parentheses and used as part of an even larger expression, and so on.
命令可以在大括号 {expr_1; …; expr_m} 中组合在一起，在这种情况下，组的值是组中最后一个表达式的结果。因为这样的一个群也是一个表达式，所以它本身可以包含在括号中，并作为一个更大的表达式的一部分使用，等等。

9.2 Control statements ¶
9.2控制语句¶

• Conditional execution: if statements
  条件执行： if 语句
• Repetitive execution: for loops, repeat and while
  重复执行： for 循环， repeat 和 while

> if (expr_1) expr_2 else expr_3

> for (name in expr_1) expr_2

> xc <- split(x, ind)
> yc <- split(y, ind)
> for (i in 1:length(yc)) {
    plot(xc[[i]], yc[[i]])
    abline(lsfit(xc[[i]], yc[[i]]))
  }

> repeat expr

> while (condition) expr

10.1 Simple examples ¶
10.1简单的例子¶

As a first example, consider a function to calculate the two sample t-statistic, showing “all the steps”. This is an artificial example, of course, since there are other, simpler ways of achieving the same end.
作为第一个例子，考虑一个函数来计算两个样本的t-统计量，显示“所有步骤”。当然，这是一个人为的例子，因为还有其他更简单的方法可以达到同样的目的。

The function is defined as follows:
函数定义如下：

> twosam <- function(y1, y2) {
    n1  <- length(y1); n2  <- length(y2)
    yb1 <- mean(y1);   yb2 <- mean(y2)
    s1  <- var(y1);    s2  <- var(y2)
    s <- ((n1-1)*s1 + (n2-1)*s2)/(n1+n2-2)
    tst <- (yb1 - yb2)/sqrt(s*(1/n1 + 1/n2))
    tst
  }

With this function defined, you could perform two sample t-tests using a call such as
定义了这个函数后，您可以使用以下调用执行两个样本t检验，

> tstat <- twosam(data$male, data$female); tstat

As a second example, consider a function to emulate directly the MATLAB backslash command, which returns the coefficients of the orthogonal projection of the vector y onto the column space of the matrix, X. (This is ordinarily called the least squares estimate of the regression coefficients.) This would ordinarily be done with the qr() function; however this is sometimes a bit tricky to use directly and it pays to have a simple function such as the following to use it safely.
作为第二个例子，考虑一个直接模拟MATLAB反斜杠命令的函数，它返回向量y在矩阵X的列空间上的正交投影的系数。(This通常称为回归系数的最小二乘估计。这通常是用 qr() 函数来完成的;然而，这有时候直接使用有点棘手，它支付了一个简单的函数，如以下安全地使用它。

Thus given a n by 1 vector y and an n by p matrix X then X \ y is defined as (X’X)^{-}X’y, where (X’X)^{-} is a generalized inverse of X'X.
因此，给定n乘1向量y和n乘p矩阵X，则X | y被定义为（X 'X）^{-} X' y，其中（X 'X）^{-}是X' X的广义逆。

> bslash <- function(X, y) {
  X <- qr(X)
  qr.coef(X, y)
}

After this object is created it may be used in statements such as
创建此对象后，它可以在以下语句中使用，

> regcoeff <- bslash(Xmat, yvar)

and so on.  等

The classical R function lsfit() does this job quite well, and more²¹. It in turn uses the functions qr() and qr.coef() in the slightly counterintuitive way above to do this part of the calculation. Hence there is probably some value in having just this part isolated in a simple to use function if it is going to be in frequent use.
经典的R函数 lsfit() 很好地完成了这项工作，而更多的是 ²¹ 。它反过来使用函数 qr() 和 qr.coef() 以上面稍微违反直觉的方式来完成这部分计算。因此，如果要频繁使用，那么将这一部分隔离在一个简单易用的函数中可能会有一些价值。
If so, we may wish to make it a matrix binary operator for even more convenient use.
如果是这样的话，我们可能希望使它成为一个矩阵二元运算符，以便更方便地使用。

10.2 Defining new binary operators ¶
10.2定义新的二元运算符¶

Had we given the bslash() function a different name, namely one of the form
如果我们给 bslash() 函数一个不同的名字，即形式之一，

%anything%

it could have been used as a binary operator in expressions rather than in function form. Suppose, for example, we choose ! for the internal character. The function definition would then start as
它可以被用作表达式中的二元运算符，而不是函数形式。例如，假设我们选择 ! 作为内部字符。函数定义将开始为

> "%!%" <- function(X, y) { ... }

(Note the use of quote marks.) The function could then be used as X %!% y. (The backslash symbol itself is not a convenient choice as it presents special problems in this context.)
(Note使用引号。）该函数可以用作 X %!% y 。(The反斜杠符号本身不是一个方便的选择，因为它在此上下文中存在特殊问题。）

The matrix multiplication operator, %*%, and the outer product matrix operator %o% are other examples of binary operators defined in this way.
矩阵乘法运算符 %*% 和外积矩阵运算符 %o% 是以这种方式定义的二元运算符的其他示例。

10.3 Named arguments and defaults ¶
10.3命名参数和默认值¶

As first noted in Generating regular sequences, if arguments to called functions are given in the “name=object” form, they may be given in any order. Furthermore the argument sequence may begin in the unnamed, positional form, and specify named arguments after the positional arguments.
正如第一次在生成规则序列中指出的，如果被调用函数的参数以“ name=object “形式给出，它们可以以任何顺序给出。此外，参数序列可以以未命名的位置形式开始，并在位置参数之后指定命名参数。

Thus if there is a function fun1 defined by
因此，如果有一个函数 fun1 定义为

> fun1 <- function(data, data.frame, graph, limit) {
    [function body omitted]
  }

then the function may be invoked in several ways, for example
则该函数可以以多种方式调用，例如

> ans <- fun1(d, df, TRUE, 20)
> ans <- fun1(d, df, graph=TRUE, limit=20)
> ans <- fun1(data=d, limit=20, graph=TRUE, data.frame=df)

are all equivalent.  都是等价的

In many cases arguments can be given commonly appropriate default values, in which case they may be omitted altogether from the call when the defaults are appropriate. For example, if fun1 were defined as
在许多情况下，参数可以被赋予通常合适的默认值，在这种情况下，当默认值合适时，它们可以从调用中完全省略。例如，如果 fun1 被定义为

> fun1 <- function(data, data.frame, graph=TRUE, limit=20) { ... }

it could be called as
可以称之为

> ans <- fun1(d, df)

which is now equivalent to the three cases above, or as
这相当于上述三种情况，或者说，

> ans <- fun1(d, df, limit=10)

which changes one of the defaults.
这会改变其中一个默认值。

It is important to note that defaults may be arbitrary expressions, even involving other arguments to the same function; they are not restricted to be constants as in our simple example here.
需要注意的是，默认值可以是任意的表达式，甚至可以包含同一函数的其他参数;它们并不像我们这里的简单例子那样被限制为常量。

10.4 The ‘…’ argument ¶
10.4" … “参数¶

Another frequent requirement is to allow one function to pass on argument settings to another. For example many graphics functions use the function par() and functions like plot() allow the user to pass on graphical parameters to par() to control the graphical output. (See Permanent changes: The par() function, for more details on the par() function.) This can be done by including an extra argument, literally ‘…’, of the function, which may then be passed on. An outline example is given below.
另一个常见的要求是允许一个函数将参数设置传递给另一个函数。例如，许多图形函数使用函数 par() ，而像 plot() 这样的函数允许用户将图形参数传递给 par() 以控制图形输出。(See永久更改： par() 函数，有关 par() 函数的更多详细信息。这可以通过在函数中包含一个额外的参数来实现，字面意思是' … '，然后可以传递。下面给出了一个概要示例。

fun1 <- function(data, data.frame, graph=TRUE, limit=20, ...) {
  [omitted statements]
  if (graph)
    par(pch="*", ...)
  [more omissions]
}

Less frequently, a function will need to refer to components of ‘…’. The expression list(...) evaluates all such arguments and returns them in a named list, while ..1, ..2, etc. evaluate them one at a time, with ‘..n’ returning the n-th unmatched argument.
函数需要引用' … '的组件，这种情况不太常见。表达式 list(...) 计算所有这样的参数，并在命名列表中返回它们，而 ..1 ， ..2 等一次计算一个参数，' ..n '返回第n个不匹配的参数。

10.5 Assignments within functions ¶
10.5在函数中调用¶

Note that any ordinary assignments done within the function are local and temporary and are lost after exit from the function. Thus the assignment X <- qr(X) does not affect the value of the argument in the calling program.
请注意，在函数内完成的任何普通赋值都是局部的和临时的，在退出函数后会丢失。因此，赋值 X <- qr(X) 不会影响调用程序中参数的值。

To understand completely the rules governing the scope of R assignments the reader needs to be familiar with the notion of an evaluation frame. This is a somewhat advanced, though hardly difficult, topic and is not covered further here.
为了完全理解控制R赋值范围的规则，读者需要熟悉评估框架的概念。这是一个有点先进的，但并不困难，主题，并没有在这里进一步介绍。

If global and permanent assignments are intended within a function, then either the ‘superassignment’ operator, <<- or the function assign() can be used. See the help document for details.
如果全局和永久赋值是在函数中进行的，那么可以使用“superassignment”操作符 <<- 或函数 assign() 。详见 help 文档。

10.6 More advanced examples ¶
10.6更多高级示例¶

• Efficiency factors in block designs
  区组设计中的效率因子
• Dropping all names in a printed array
  删除打印数组中的所有名称
• Recursive numerical integration
  递归数值积分

> bdeff <- function(blocks, varieties) {
    blocks <- as.factor(blocks)             # minor safety move
    b <- length(levels(blocks))
    varieties <- as.factor(varieties)       # minor safety move
    v <- length(levels(varieties))
    K <- as.vector(table(blocks))           # remove dim attr
    R <- as.vector(table(varieties))        # remove dim attr
    N <- table(blocks, varieties)
    A <- 1/sqrt(K) * N * rep(1/sqrt(R), rep(b, v))
    sv <- svd(A)
    list(eff=1 - sv$d^2, blockcv=sv$u, varietycv=sv$v)
}