UseMethod("t")está dizendo que t()é uma função genérica ( S3 ) que possui métodos para diferentes classes de objetos.
O sistema de despacho do método S3
Para classes S3, você pode usar a methodsfunção para listar os métodos para uma função ou classe genérica específica.
> methods(t)
[1] t.data.frame t.default t.ts*
Non-visible functions are asterisked
> methods(class="ts")
[1] aggregate.ts as.data.frame.ts cbind.ts* cycle.ts*
[5] diffinv.ts* diff.ts kernapply.ts* lines.ts
[9] monthplot.ts* na.omit.ts* Ops.ts* plot.ts
[13] print.ts time.ts* [<-.ts* [.ts*
[17] t.ts* window<-.ts* window.ts*
Non-visible functions are asterisked
"Funções não visíveis estão com asterisco" significa que a função não é exportada do espaço para nome do pacote. Você ainda pode visualizar seu código fonte através da :::função (ou seja stats:::t.ts) ou usando getAnywhere(). getAnywhere()é útil porque você não precisa saber de qual pacote a função veio.
> getAnywhere(t.ts)
A single object matching ‘t.ts’ was found
It was found in the following places
registered S3 method for t from namespace stats
namespace:stats
with value
function (x)
{
cl <- oldClass(x)
other <- !(cl %in% c("ts", "mts"))
class(x) <- if (any(other))
cl[other]
attr(x, "tsp") <- NULL
t(x)
}
<bytecode: 0x294e410>
<environment: namespace:stats>
O sistema de despacho do método S4
O sistema S4 é um sistema de despacho de método mais recente e é uma alternativa ao sistema S3. Aqui está um exemplo de uma função S4:
> library(Matrix)
Loading required package: lattice
> chol2inv
standardGeneric for "chol2inv" defined from package "base"
function (x, ...)
standardGeneric("chol2inv")
<bytecode: 0x000000000eafd790>
<environment: 0x000000000eb06f10>
Methods may be defined for arguments: x
Use showMethods("chol2inv") for currently available ones.
A saída já oferece muita informação. standardGenericé um indicador de uma função S4. O método para ver os métodos S4 definidos é oferecido de maneira útil:
> showMethods(chol2inv)
Function: chol2inv (package base)
x="ANY"
x="CHMfactor"
x="denseMatrix"
x="diagonalMatrix"
x="dtrMatrix"
x="sparseMatrix"
getMethod pode ser usado para ver o código fonte de um dos métodos:
> getMethod("chol2inv", "diagonalMatrix")
Method Definition:
function (x, ...)
{
chk.s(...)
tcrossprod(solve(x))
}
<bytecode: 0x000000000ea2cc70>
<environment: namespace:Matrix>
Signatures:
x
target "diagonalMatrix"
defined "diagonalMatrix"
Também existem métodos com assinaturas mais complexas para cada método, por exemplo
require(raster)
showMethods(extract)
Function: extract (package raster)
x="Raster", y="data.frame"
x="Raster", y="Extent"
x="Raster", y="matrix"
x="Raster", y="SpatialLines"
x="Raster", y="SpatialPoints"
x="Raster", y="SpatialPolygons"
x="Raster", y="vector"
Para ver o código fonte de um desses métodos, toda a assinatura deve ser fornecida, por exemplo
getMethod("extract" , signature = c( x = "Raster" , y = "SpatialPolygons") )
Não será suficiente fornecer a assinatura parcial
getMethod("extract",signature="SpatialPolygons")
#Error in getMethod("extract", signature = "SpatialPolygons") :
# No method found for function "extract" and signature SpatialPolygons
Funções que chamam funções não exportadas
No caso de ts.union, .cbindtse .makeNamesTssão funções não exportadas do statsespaço para nome. Você pode visualizar o código fonte de funções não exportadas usando o :::operador ou getAnywhere.
> stats:::.makeNamesTs
function (...)
{
l <- as.list(substitute(list(...)))[-1L]
nm <- names(l)
fixup <- if (is.null(nm))
seq_along(l)
else nm == ""
dep <- sapply(l[fixup], function(x) deparse(x)[1L])
if (is.null(nm))
return(dep)
if (any(fixup))
nm[fixup] <- dep
nm
}
<bytecode: 0x38140d0>
<environment: namespace:stats>
Funções que chamam código compilado
Observe que "compilado" não se refere ao código R compilado em bytes, criado pelo pacote do compilador . A <bytecode: 0x294e410>linha na saída acima indica que a função é compilada em bytes e você ainda pode visualizar a fonte na linha de comando R.
Funções que chamada .C, .Call, .Fortran, .External, .Internal, ou .Primitiveestão chamando pontos de entrada no código compilado, assim que você tem que olhar para as fontes do código compilado, se você quiser entender completamente a função. Esse espelho do código-fonte do GitHub é um lugar decente para começar. A função pryr::show_c_sourcepode ser uma ferramenta útil, pois o levará diretamente a uma página do GitHub para chamadas .Internale .Primitivechamadas. Os pacotes podem usar .C, .Call, .Fortran, e .External; mas não .Internalou .Primitive, porque são usados para chamar funções incorporadas ao intérprete R.
Chamadas para algumas das funções acima podem usar um objeto em vez de uma cadeia de caracteres para fazer referência à função compilada. Nesses casos, o objectivo é de classe "NativeSymbolInfo", "RegisteredNativeSymbol", ou "NativeSymbol"; e imprimir o objeto produz informações úteis. Por exemplo, optimchamadas .External2(C_optimhess, res$par, fn1, gr1, con)(observe que C_optimhessnão "C_optimhess"). optimestá no pacote de estatísticas, então você pode digitar stats:::C_optimhesspara ver informações sobre a função compilada que está sendo chamada.
Código compilado em um pacote
Se você deseja visualizar o código compilado em um pacote, será necessário baixar / descompactar a fonte do pacote. Os binários instalados não são suficientes. O código-fonte de um pacote está disponível no mesmo repositório CRAN (ou compatível com CRAN) do qual o pacote foi originalmente instalado. A download.packages()função pode obter a fonte do pacote para você.
download.packages(pkgs = "Matrix",
destdir = ".",
type = "source")
Isso fará o download da versão de origem do pacote Matrix e salvará o .tar.gzarquivo correspondente no diretório atual. O código-fonte para funções compiladas pode ser encontrado no srcdiretório do arquivo descompactado e não-marcado. A etapa de descompactação e descompactação pode ser feita fora Rou a partir do interior Rusando a untar()função É possível combinar a etapa de download e expansão em uma única chamada (observe que apenas um pacote de cada vez pode ser baixado e descompactado desta maneira):
untar(download.packages(pkgs = "Matrix",
destdir = ".",
type = "source")[,2])
Como alternativa, se o desenvolvimento do pacote for hospedado publicamente (por exemplo, via GitHub , R-Forge ou RForge.net ), você provavelmente poderá procurar o código-fonte on-line.
Código compilado em um pacote base
Certos pacotes são considerados pacotes "base". Estes pacotes fornecidos com R e sua versão é bloqueado para a versão de R. Exemplos incluem base, compiler, stats, e utils. Como tal, eles não estão disponíveis como pacotes para download separados no CRAN, conforme descrito acima. Em vez disso, eles fazem parte da árvore de origem R em diretórios de pacotes individuais em /src/library/. Como acessar a fonte R é descrito na próxima seção.
Código compilado incorporado ao intérprete R
Se você deseja visualizar o código incorporado ao intérprete R, será necessário baixar / descompactar as fontes R; ou você pode visualizar as fontes on-line através do repositório R Subversion ou do espelho do github de Winston Chang .
O artigo de notícias R de Uwe Ligges (PDF) (p. 43) é uma boa referência geral de como visualizar o código fonte .Internale as .Primitivefunções. As etapas básicas são primeiro procurar o nome da função src/main/names.ce, em seguida, procurar o nome "C-entry" nos arquivos src/main/*.