R内部结构与编程标准指南

需积分: 11 40 浏览量更新于2024-07-16 收藏 437KB PDF 举报

"R Internals.pdf 是一本关于R语言内部结构和核心团队编码标准的指南，适用于R语言版本3.6.1(2019-07-05)。该手册由R Core Team编写并拥有版权，允许在保留版权信息和许可通知的情况下复制和分发。" 在深入理解R语言的内部工作原理时，《R Internals》是不可或缺的参考材料。这本书主要涵盖了以下几个关键知识点： 1. **R内部结构 (R Internal Structures)**：R的核心在于其数据结构，称为**SEXPs（Special EXpressions）**。SEXPs是R中所有对象的基础，包括向量、列表、函数等。它们有多种类型，如**SEXPTYPEs**，这些类型定义了对象的用途和行为。SEXPs的头部包含了对象的元信息，如类型、长度等，而**数据部分**则存储实际的数据。分配类（Allocation classes）决定了对象如何在内存中分配和管理。 2. **环境与变量查找 (Environments and variable lookup)**：R中的环境是存储变量的地方，变量查找遵循**搜索路径**，这涉及到作用域规则。此外，**命名空间（Namespaces）**是R中实现模块化和封装的关键，它允许函数和数据包内的元素在不冲突的情况下共存。**哈希表（Hashtable）**是R中高效查找变量的一种机制。 3. **属性 (Attributes)**：属性是附加到R对象的额外信息，可以包括维度、名称、类等，它们提供了扩展R数据类型的能力。 4. **上下文 (Contexts)**：在R中，上下文可能指执行环境或函数调用的上下文，这对于理解函数如何在特定环境中运行至关重要。 5. **参数评估 (Argument evaluation)**：R在处理函数调用时，有特定的参数处理方式。**缺失值（Missingness）**是指R如何处理NA和其他缺失值，而**省略号（Dot-dot-dots）**（...）允许函数接收未指定数量的参数，增加了函数的灵活性。这些内容对于R语言的开发者和高级用户来说极其重要，因为它们揭示了R如何在底层处理数据和控制流程。了解这些内部细节可以帮助优化代码，解决复杂问题，以及更有效地利用R的特性进行数据分析和数据挖掘。

Chapter 1: R Internal Structures 8

example reasonable to have a name for an environment, and also a "path" attribute for those

environments populated from R code in a package.

When should attributes be preserved under operations on an object? Becker, Chambers &

Wilks (1988, pp. 144–6) give some guidance. Scalar functions (those which operate element-

by-element on a vector and whose output is similar to the input) should preserve attributes

(except perhaps class, and if they do preserve class they need to preserve the OBJECT and S4

bits). Binary operations normally call copyMostAttributes to copy most attributes from the

longer argument (and if they are of the same length from both, preferring the values on the

ﬁrst). Here ‘most’ means all except the names, dim and dimnames which are set appropriately

by the code for the operator.

Subsetting (other than by an empty index) generally drops all attributes except names, dim

and dimnames which are reset as appropriate. On the other hand, subassignment generally

preserves such attributes even if the length is changed. Coercion drops all attributes. For

example:

> x <- structure(1:8, names=letters[1:8], comm="a comment")

> x[]

a b c d e f g h

1 2 3 4 5 6 7 8

attr(,"comm")

[1] "a comment"

> x[1:3]

a b c

1 2 3

> x[3] <- 3

> x

a b c d e f g h

1 2 3 4 5 6 7 8

attr(,"comm")

[1] "a comment"

> x[9] <- 9

> x

a b c d e f g h

1 2 3 4 5 6 7 8 9

attr(,"comm")

[1] "a comment"

1.4 Contexts

Contexts are the internal mechanism used to keep track of where a computation has got to

(and from where), so that control-ﬂow constructs can work and reasonable information can be

produced on error conditions (such as via traceback), and otherwise (the sys.xxx functions).

Execution contexts are a stack of C structs:

typedef struct RCNTXT {

struct RCNTXT *nextcontext; /* The next context up the chain */

int callflag; /* The context ‘type’ */

JMP_BUF cjmpbuf; /* C stack and register information */

int cstacktop; /* Top of the pointer protection stack */

int evaldepth; /* Evaluation depth at inception */

SEXP promargs; /* Promises supplied to closure */

SEXP callfun; /* The closure called */

SEXP sysparent; /* Environment the closure was called from */

Chapter 1: R Internal Structures 9

SEXP call; /* The call that eﬀected this context */

SEXP cloenv; /* The environment */

SEXP conexit; /* Interpreted on.exit code */

void (*cend)(void *); /* C on.exit thunk */

void *cenddata; /* Data for C on.exit thunk */

char *vmax; /* Top of the R_alloc stack */

int intsusp; /* Interrupts are suspended */

SEXP handlerstack; /* Condition handler stack */

SEXP restartstack; /* Stack of available restarts */

struct RPRSTACK *prstack; /* Stack of pending promises */

} RCNTXT, *context;

plus additional ﬁelds for the byte-code compiler. The ‘types’ are from

enum {

CTXT_TOPLEVEL = 0, /* toplevel context */

CTXT_NEXT = 1, /* target for next */

CTXT_BREAK = 2, /* target for break */

CTXT_LOOP = 3, /* break or next target */

CTXT_FUNCTION = 4, /* function closure */

CTXT_CCODE = 8, /* other functions that need error cleanup */

CTXT_RETURN = 12, /* return() from a closure */

CTXT_BROWSER = 16, /* return target on exit from browser */

CTXT_GENERIC = 20, /* rather, running an S3 method */

CTXT_RESTART = 32, /* a call to restart was made from a closure */

CTXT_BUILTIN = 64 /* builtin internal function */

};

where the CTXT_FUNCTION bit is on wherever function closures are involved.

Contexts are created by a call to begincontext and ended by a call to endcontext: code can

search up the stack for a particular type of context via findcontext (and jump there) or jump

to a speciﬁc context via R_JumpToContext. R_ToplevelContext is the ‘idle’ state (normally the

command prompt), and R_GlobalContext is the top of the stack.

Note that whilst calls to closures and builtins set a context, those to special internal functions

never do.

Dispatching from a S3 generic (via UseMethod or its internal equivalent) or calling

NextMethod sets the context type to CTXT_GENERIC. This is used to set the sysparent of the

method call to that of the generic, so the method appears to have been called in place of the

generic rather than from the generic.

The R sys.frame and sys.call functions work by counting calls to closures (type CTXT_

FUNCTION) from either end of the context stack.

Note that the sysparent element of the structure is not the same thing as sys.parent().

Element sysparent is primarily used in managing changes of the function being evaluated, i.e.

by Recall and method dispatch.

CTXT_CCODE contexts are currently used in cat(), load(), scan() and write.table() (to

close the connection on error), by PROTECT, serialization (to recover from errors, e.g. free buﬀers)

and within the error handling code (to raise the C stack limit and reset some variables).

1.5 Argument evaluation

As we have seen, functions in R come in three types, closures (SEXPTYPE CLOSXP), specials

(SPECIALSXP) and builtins (BUILTINSXP). In this section we consider when (and if) the actual

Chapter 1: R Internal Structures 10

arguments of function calls are evaluated. The rules are diﬀerent for the internal (special/builtin)

and R-level functions (closures).

For a call to a closure, the actual and formal arguments are matched and a matched call

(another LANGSXP) is constructed. This process ﬁrst replaces the actual argument list by a list

of promises to the values supplied. It then constructs a new environment which contains the

names of the formal parameters matched to actual or default values: all the matched values

are promises, the defaults as promises to be evaluated in the environment just created. That

environment is then used for the evaluation of the body of the function, and promises will be

forced (and hence actual or default arguments evaluated) when they are encountered. (Evaluat-

ing a promise sets NAMED = NAMEDMAX on its value, so if the argument was a symbol its binding

is regarded as having multiple references during the evaluation of the closure call.)

If the closure is an S3 generic (that is, contains a call to UseMethod) the evaluation process

is the same until the UseMethod call is encountered. At that point the argument on which to do

dispatch (normally the ﬁrst) will be evaluated if it has not been already. If a method has been

found which is a closure, a new evaluation environment is created for it containing the matched

arguments of the method plus any new variables deﬁned so far during the evaluation of the

body of the generic. (Note that this means changes to the values of the formal arguments in the

body of the generic are discarded when calling the method, but actual argument promises which

have been forced retain the values found when they were forced. On the other hand, missing

arguments have values which are promises to use the default supplied by the method and not

by the generic.) If the method found is a primitive it is called with the matched argument list

of promises (possibly already forced) used for the generic.

The essential diﬀerence

between special and builtin functions is that the arguments of spe-

cials are not evaluated before the C code is called, and those of builtins are. Note that being a

special/builtin is separate from being primitive or .Internal: quote is a special primitive, + is

a builtin primitive, cbind is a special .Internal and grep is a builtin .Internal.

Many of the internal functions are internal generics, which for specials means that they do

not evaluate their arguments on call, but the C code starts with a call to DispatchOrEval. The

latter evaluates the ﬁrst argument, and looks for a method based on its class. (If S4 dispatch is

on, S4 methods are looked for ﬁrst, even for S3 classes.) If it ﬁnds a method, it dispatches to

that method with a call based on promises to evaluate the remaining arguments. If no method

is found, the remaining arguments are evaluated before return to the internal generic.

The other way that internal functions can be generic is to be group generic. Most such

functions are builtins (so immediately evaluate all their arguments), and all contain a call to

the C function DispatchGeneric. There are some peculiarities over the number of arguments

for the "Math" group generic, with some members allowing only one argument, some having

two (with a default for the second) and trunc allows one or more but the default method only

accepts one.

1.5.1 Missingness

Actual arguments to (non-internal) R functions can be fewer than are required to match the

formal arguments of the function. Having unmatched formal arguments will not matter if the

argument is never used (by lazy evaluation), but when the argument is evaluated, either its

default value is evaluated (within the evaluation environment of the function) or an error is

thrown with a message along the lines of

argument "foobar" is missing, with no default

Internally missingness is handled by two mechanisms. The object R_MissingArg is used to

indicate that a formal argument has no (default) value. When matching the actual arguments

There is currently one other diﬀerence: when proﬁling builtin functions are counted as function calls but

specials are not.

剩余67页未读，继续阅读

「已注销」

粉丝: 1
资源: 15

R内部结构与编程标准指南

Microsoft_R_SQL_Server_R_2008_Internals.pdf

DSI408-Real-Application-Clusters-Internals.7z

运行wpf窗体后点击button按钮显示"未加载System.ServiceModel.Internals.pdb"是什么原因

java:[131,43] 找不到符号 符号: 变量 Sm4Utils 位置: 类 com.ctrip.framework.apollo.internals.DefaultConfig是什么原因导致的

js2py.internals.simplex.JsException: ReferenceError: require is not defined

AttributeError: module 'pandas.core.internals.blocks' has no attribute 'new_block'

ERROR Error when sending message to topic test_elk with key: null, value: 2 bytes with error: (org.apache.kafka.clients.producer.internals.ErrorLoggingCallback) org.apache.kafka.common.errors.TimeoutException: Failed to update metadata after 60000 ms.

java flink mysql binlog 代码 带pom.xml

Unhandled error during execution of scheduler flush. This is likely a Vue internals bug. Please open an issue

最新资源

java:[131,43] 找不到符号符号: 变量 Sm4Utils 位置: 类 com.ctrip.framework.apollo.internals.DefaultConfig是什么原因导致的

java flink mysql binlog 代码带pom.xml