UseMethod("t") mówi, że t() jest (S3) funkcją ogólną, która ma metody dla różnych klas obiektów.

System wysyłki metody S3

Dla klas S3, możesz użyć funkcji methods, aby wyświetlić listę metod dla konkretnej ogólnej funkcji lub klasy.

> 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

"funkcje niewidoczne są oznaczone gwiazdką" oznacza, że funkcja nie jest eksportowana z przestrzeni nazw pakietu. Nadal możesz wyświetlić jego kod źródłowy za pomocą funkcji ::: (tj. stats:::t.ts), lub za pomocą getAnywhere(). getAnywhere() jest przydatne, ponieważ nie musisz wiedzieć, z którego pakietu pochodzi ta funkcja.

> 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>

System wysyłki metody S4

System S4 jest nowszym systemem wysyłania metod i jest alternatywą dla systemu S3. Oto przykład funkcji 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.

Wyjście oferuje już wiele informacji. standardGeneric jest wskaźnikiem funkcji S4. Metoda, aby zobaczyć zdefiniowane metody S4, jest oferowana pomocnie:

> showMethods(chol2inv)
Function: chol2inv (package base)
x="ANY"
x="CHMfactor"
x="denseMatrix"
x="diagonalMatrix"
x="dtrMatrix"
x="sparseMatrix"

getMethod może być używane, aby zobaczyć kod źródłowy jednej z metod:

> getMethod("chol2inv", "diagonalMatrix")
Method Definition:

function (x, ...) 
{
    chk.s(...)
    tcrossprod(solve(x))
}
<bytecode: 0x000000000ea2cc70>
<environment: namespace:Matrix>

Signatures:
        x               
target  "diagonalMatrix"
defined "diagonalMatrix"

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"

Aby zobaczyć kod źródłowy jednej z tych metod, należy podać cały podpis, np.

getMethod("extract" , signature = c( x = "Raster" , y = "SpatialPolygons") )

Nie wystarczy podać częściowego podpisu

getMethod("extract",signature="SpatialPolygons")
#Error in getMethod("extract", signature = "SpatialPolygons") : 
#  No method found for function "extract" and signature SpatialPolygons

Funkcje, które wywołują funkcje niezerowe

W przypadku ts.union, .cbindts i .makeNamesTs są funkcjami z stats przestrzeń nazw. Kod źródłowy funkcji nieprzetworzonych można wyświetlić za pomocą operatora ::: lub 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>

Funkcje wywołujące skompilowany kod

Zauważ, że "skompilowany" nie odnosi się do skompilowanego bajtowo kodu R utworzonego przez pakiet kompilatora. Linia <bytecode: 0x294e410> na powyższym wyjściu wskazuje, że funkcja jest skompilowana bajtowo i nadal można wyświetlić źródło z wiersza poleceń R.

Funkcje wywołujące .C, .Call, .Fortran, .External, .Internal, lub .Primitive wywołują punkty wejścia w skompilowanym kodzie, więc będziesz musiał spojrzeć na źródła skompilowanego kodu, jeśli chcesz w pełni zrozumieć funkcję. to Lustro GitHub kodu źródłowego R jest przyzwoitym miejscem do rozpoczęcia. Funkcja pryr::show_c_source może być użytecznym narzędziem, ponieważ przeniesie Cię bezpośrednio do strony GitHub dla wywołań .Internal i .Primitive. Opakowania mogą używać .C, .Call, .Fortran, i .External; ale nie .Internal czy .Primitive, ponieważ są one używane do wywoływania funkcji wbudowanych w R Tłumacz.

Wywołania niektórych z powyższych funkcji mogą używać obiektu zamiast ciągu znaków do odwoływania się do skompilowanej funkcji. W takich przypadkach obiekt należy do klasy "NativeSymbolInfo", "RegisteredNativeSymbol", lub "NativeSymbol"; a wydrukowanie obiektu daje użyteczne informacje. Na przykład, optim wywołuje .External2(C_optimhess, res$par, fn1, gr1, con) (zauważ, że jest to C_optimhess, a nie "C_optimhess"). optim Znajduje się w pakiecie stats, więc możesz wpisać stats:::C_optimhess, aby zobaczyć informacje o wywołanej funkcji.

Skompilowany kod w pakiet

Jeśli chcesz wyświetlić skompilowany kod w pakiecie, musisz pobrać / rozpakować źródło pakietu. Zainstalowane pliki binarne nie są wystarczające. Kod źródłowy pakietu jest dostępny z tego samego repozytorium Cran (lub kompatybilnego z CRAN), z którego pakiet został pierwotnie zainstalowany. Funkcja download.packages() może pobrać źródło pakietu dla Ciebie.

download.packages(pkgs = "Matrix", 
                  destdir = ".",
                  type = "source")

Spowoduje to pobranie wersji źródłowej pakietu Matrix i zapisanie odpowiedniego pliku .tar.gz w bieżącym katalog. Kod źródłowy skompilowanych funkcji można znaleźć w katalogu src nieskompresowanego i nie udostępnionego pliku. Krok rozpakowywania i rozpakowywania można wykonać poza R, lub z wewnątrz {[54] } za pomocą funkcji untar(). Możliwe jest połączenie kroku download I expansion w jedno wywołanie (należy pamiętać, że tylko jeden pakiet na raz może być pobrany i rozpakowany w ten sposób): {]}

untar(download.packages(pkgs = "Matrix",
                        destdir = ".",
                        type = "source")[,2])

Alternatywnie, jeśli rozwój pakietu jest hostowany publicznie (np. poprzez GitHub, R-Forge , or RForge.net ), prawdopodobnie możesz przeglądać kod źródłowy online.

Skompilowany kod w pakiecie bazowym

Niektóre pakiety są uważane za pakiety "podstawowe". Pakiety te są dostarczane z R, a ich wersja jest zablokowana do wersji R. przykłady obejmują base, compiler, stats, i utils. W związku z tym nie są one dostępne jako oddzielne pakiety do pobrania na CRAN, jak opisano powyżej. Są raczej częścią drzewa źródłowego R w poszczególne katalogi pakietów pod /src/library/. Jak uzyskać dostęp do źródła R opisano w następnej sekcji.

Skompilowany kod wbudowany w interpreter R

Jeśli chcesz zobaczyć kod wbudowany w interpreter r, musisz pobrać / rozpakować źródła R; lub możesz przeglądać źródła online za pośrednictwem repozytorium R Subversion lub Winstona Changa na github mirror.

Uwe Ligges ' s r news article (PDF) (s. 43) is a good general odniesienie do sposobu wyświetlania kodu źródłowego funkcji .Internal i .Primitive. Podstawowe kroki to najpierw poszukać nazwy funkcji w src/main/names.c, a następnie wyszukać nazwę "C-entry" w plikach w src/main/*.