UseMethod("t")ti sta dicendo che t()è una funzione generica ( S3 ) che ha metodi per diverse classi di oggetti.
Il sistema di spedizione del metodo S3
Per le classi S3, è possibile utilizzare la methodsfunzione per elencare i metodi per una particolare funzione o classe generica.
> 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
"Le funzioni non visibili sono contrassegnate da un asterisco" significa che la funzione non viene esportata dallo spazio dei nomi del suo pacchetto. Puoi ancora visualizzare il suo codice sorgente tramite la :::funzione (es. stats:::t.ts), O usando getAnywhere(). getAnywhere()è utile perché non devi sapere da quale pacchetto proviene la funzione.
> 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>
Il sistema di spedizione del metodo S4
Il sistema S4 è un sistema di invio del metodo più recente ed è un'alternativa al sistema S3. Ecco un esempio di una funzione 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.
L'output offre già molte informazioni. standardGenericè un indicatore di una funzione S4. Il metodo per vedere i metodi S4 definiti è offerto utile:
> showMethods(chol2inv)
Function: chol2inv (package base)
x="ANY"
x="CHMfactor"
x="denseMatrix"
x="diagonalMatrix"
x="dtrMatrix"
x="sparseMatrix"
getMethod può essere usato per vedere il codice sorgente di uno dei metodi:
> getMethod("chol2inv", "diagonalMatrix")
Method Definition:
function (x, ...)
{
chk.s(...)
tcrossprod(solve(x))
}
<bytecode: 0x000000000ea2cc70>
<environment: namespace:Matrix>
Signatures:
x
target "diagonalMatrix"
defined "diagonalMatrix"
Esistono anche metodi con firme più complesse per ciascun metodo, ad esempio
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"
Per visualizzare il codice sorgente di uno di questi metodi, è necessario fornire l'intera firma, ad es
getMethod("extract" , signature = c( x = "Raster" , y = "SpatialPolygons") )
Non sarà sufficiente fornire la firma parziale
getMethod("extract",signature="SpatialPolygons")
#Error in getMethod("extract", signature = "SpatialPolygons") :
# No method found for function "extract" and signature SpatialPolygons
Funzioni che chiamano funzioni non esportate
Nel caso di ts.union, .cbindtse .makeNamesTssono funzioni non esportate dallo statsspazio dei nomi. È possibile visualizzare il codice sorgente di funzioni non esportate utilizzando l' :::operatore o 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>
Funzioni che chiamano codice compilato
Si noti che "compilato" non si riferisce al codice R compilato in byte come creato dal pacchetto del compilatore . La <bytecode: 0x294e410>riga nell'output sopra indica che la funzione è compilata in byte e che è ancora possibile visualizzare l'origine dalla riga di comando R.
Funzioni che chiamata .C, .Call, .Fortran, .External, .Internal, o .Primitivechiedono punti di ingresso nel codice compilato, in modo da avere a guardare sorgenti del codice compilato, se si vuole comprendere appieno la funzione. Questo mirror GitHub del codice sorgente R è un posto decente per iniziare. La funzione pryr::show_c_sourcepuò essere uno strumento utile in quanto ti porterà direttamente a una pagina GitHub per .Internale .Primitivechiama. I pacchetti possono utilizzare .C, .Call, .Fortran, e .External; ma no .Internaloppure .Primitive, poiché vengono utilizzati per chiamare funzioni integrate nell'interprete R.
Le chiamate ad alcune delle funzioni precedenti possono utilizzare un oggetto anziché una stringa di caratteri per fare riferimento alla funzione compilata. In tali casi, l'oggetto è di classe "NativeSymbolInfo", "RegisteredNativeSymbol"o "NativeSymbol"; e la stampa dell'oggetto fornisce informazioni utili. Ad esempio, optimchiamate .External2(C_optimhess, res$par, fn1, gr1, con)(nota che C_optimhessnon è "C_optimhess"). optimè nel pacchetto stats, quindi puoi digitare stats:::C_optimhessper vedere le informazioni sulla funzione compilata chiamata.
Codice compilato in un pacchetto
Se si desidera visualizzare il codice compilato in un pacchetto, sarà necessario scaricare / decomprimere l'origine del pacchetto. I binari installati non sono sufficienti. Il codice sorgente di un pacchetto è disponibile dallo stesso repository CRAN (o CRAN compatibile) da cui il pacchetto è stato originariamente installato. La download.packages()funzione può ottenere l'origine del pacchetto per te.
download.packages(pkgs = "Matrix",
destdir = ".",
type = "source")
Ciò scaricherà la versione di origine del pacchetto Matrix e salverà il .tar.gzfile corrispondente nella directory corrente. Il codice sorgente per le funzioni compilate si trova nella srcdirectory del file non compresso e non tarato. La fase di decompressione e non annotazione può essere eseguita all'esterno Ro dall'interno Rutilizzando la untar()funzione. È possibile combinare il passaggio di download ed espansione in una singola chiamata (si noti che in questo modo è possibile scaricare e decomprimere un solo pacchetto alla volta):
untar(download.packages(pkgs = "Matrix",
destdir = ".",
type = "source")[,2])
In alternativa, se lo sviluppo del pacchetto è ospitato pubblicamente (ad es. Tramite GitHub , R-Forge o RForge.net ), probabilmente è possibile sfogliare il codice sorgente online.
Codice compilato in un pacchetto base
Alcuni pacchetti sono considerati pacchetti "base". Questi pacchetti vengono forniti con R e la loro versione è bloccato alla versione di R. Esempi includono base, compiler, stats, e utils. Pertanto, non sono disponibili come pacchetti scaricabili separati su CRAN come descritto sopra. Piuttosto, fanno parte dell'albero dei sorgenti R nelle singole directory dei pacchetti sotto /src/library/. Come accedere alla fonte R è descritto nella sezione successiva.
Codice compilato incorporato nell'interprete R.
Se si desidera visualizzare il codice integrato nell'interprete R, sarà necessario scaricare / decomprimere i sorgenti R; oppure puoi visualizzare le fonti online tramite il repository R Subversion o il mirror github di Winston Chang .
L' articolo di R (PDF) di Uwe Ligges (p. 43) è un buon riferimento generale su come visualizzare il codice sorgente .Internale le .Primitivefunzioni. I passaggi di base sono innanzitutto cercare il nome della funzione in src/main/names.ce quindi cercare il nome "C-entry" nei file in src/main/*.