Is it possible to see source code of a value of function

Question

I am using a function from a package. this function returns some values. For example:

k<-dtw(v1,v2, keep.internals=TRUE)

and I can get this value:

k$costMatrix

Does it possible to see the source code of costMatrix? if yes how can I do that?

UPDATE this is the source code of the function:

   function (x, y = NULL, dist.method = "Euclidean", step.pattern = symmetric2, 
    window.type = "none", keep.internals = FALSE, distance.only = FALSE, 
    open.end = FALSE, open.begin = FALSE, ...) 
{
    lm <- NULL
    if (is.null(y)) {
        if (!is.matrix(x)) 
            stop("Single argument requires a global cost matrix")
        lm <- x
    }
    else if (is.character(dist.method)) {
        x <- as.matrix(x)
        y <- as.matrix(y)
        lm <- proxy::dist(x, y, method = dist.method)
    }
    else if (is.function(dist.method)) {
        stop("Unimplemented")
    }
    else {
        stop("dist.method should be a character method supported by proxy::dist()")
    }
    wfun <- .canonicalizeWindowFunction(window.type)
    dir <- step.pattern
    norm <- attr(dir, "norm")
    if (!is.null(list(...)$partial)) {
        warning("Argument `partial' is obsolete. Use `open.end' instead")
        open.end <- TRUE
    }
    n <- nrow(lm)
    m <- ncol(lm)
    if (open.begin) {
        if (is.na(norm) || norm != "N") {
            stop("Open-begin requires step patterns with 'N' normalization (e.g. asymmetric, or R-J types (c)). See papers in citation().")
        }
        lm <- rbind(0, lm)
        np <- n + 1
        precm <- matrix(NA, nrow = np, ncol = m)
        precm[1, ] <- 0
    }
    else {
        precm <- NULL
        np <- n
    }
    gcm <- globalCostMatrix(lm, step.matrix = dir, window.function = wfun, 
        seed = precm, ...)
    gcm$N <- n
    gcm$M <- m
    gcm$call <- match.call()
    gcm$openEnd <- open.end
    gcm$openBegin <- open.begin
    gcm$windowFunction <- wfun
    lastcol <- gcm$costMatrix[np, ]
    if (is.na(norm)) {
    }
    else if (norm == "N+M") {
        lastcol <- lastcol/(n + (1:m))
    }
    else if (norm == "N") {
        lastcol <- lastcol/n
    }
    else if (norm == "M") {
        lastcol <- lastcol/(1:m)
    }
    gcm$jmin <- m
    if (open.end) {
        if (is.na(norm)) {
            stop("Open-end alignments require normalizable step patterns")
        }
        gcm$jmin <- which.min(lastcol)
    }
    gcm$distance <- gcm$costMatrix[np, gcm$jmin]
    if (is.na(gcm$distance)) {
        stop("No warping path exists that is allowed by costraints")
    }
    if (!is.na(norm)) {
        gcm$normalizedDistance <- lastcol[gcm$jmin]
    }
    else {
        gcm$normalizedDistance <- NA
    }
    if (!distance.only) {
        mapping <- backtrack(gcm)
        gcm <- c(gcm, mapping)
    }
    if (open.begin) {
        gcm$index1 <- gcm$index1[-1] - 1
        gcm$index2 <- gcm$index2[-1]
        lm <- lm[-1, ]
        gcm$costMatrix <- gcm$costMatrix[-1, ]
        gcm$directionMatrix <- gcm$directionMatrix[-1, ]
    }
    if (!keep.internals) {
        gcm$costMatrix <- NULL
        gcm$directionMatrix <- NULL
    }
    else {
        gcm$localCostMatrix <- lm
        if (!is.null(y)) {
            gcm$query <- x
            gcm$reference <- y
        }
    }
    class(gcm) <- "dtw"
    return(gcm)
}

but if I write globalCostMatrix I dont get the source code of this function

Answer 1

The easiest way to find how functions work is by looking at the source. You have a good chance that by typing function name in the R console, you will get the function definitions (although not always with good layout, so seeking the source where brackets are present, is a viable option).

In your case, you have a function dtw from the same name package. This function uses a function called globalCostMatrix. If you type that name into R, you will get an error that object was not found. This happens because the function was not exported when the package was created, probably because the author thinks this is not something a regular user would use (but not see!) or to prevent clashes with other packages who may use the same function name.

However, for an interested reader, there are at least two ways to access the code in this function. One is by going to CRAN, downloading the source tarballs and finding the function in the R folder of the tar ball. The other one, easier, is by using getAnywhere function. This will give you the definition of the function just like you're used for other, user accessible functions like dtw.

> library(dtw)
> getAnywhere("globalCostMatrix")
A single object matching ‘globalCostMatrix’ was found
It was found in the following places
  namespace:dtw
with value

function (lm, step.matrix = symmetric1, window.function = noWindow, 
    native = TRUE, seed = NULL, ...) 
{
    if (!is.stepPattern(step.matrix)) 
        stop("step.matrix is no stepMatrix object")
    n <- nrow(lm)
... omitted for brevity

Answer 2

I think you want to see what the function dtw() does with your data. I seems that it creates a data.frame containing a column named costMatrix.

To find out how the data in the column costMatrix was generated, just type and execute dtw (without brackets!). R will show you the source of the function dtw() afterwards.