data.extrema: Compute Data Extrema

In mpoll/scale: The Scaleable Langevin Exact Algorithm -- Reference Implementation

Usage

data.extrema(datum.idx.start = 1, length.idxs = dsz)

Arguments

datum.idx.start
length.idxs

Examples

##---- Should be DIRECTLY executable !! ----
##-- ==>  Define data, use random,
##--	or do  help(data=index)  for the standard data sets.

## The function is currently defined as
function (datum.idx.start = 1, length.idxs = dsz) 
{
    if (exists("design.thresh") == TRUE) {
        if (length(design.thresh) == 1) {
            design.min <- c(1, rep(-design.thresh, dimen - 1))
            design.max <- c(1, rep(design.thresh, dimen - 1))
        }
        else {
            design.min <- c(1, -design.thresh[2:dimen])
            design.max <- design.thresh
        }
    }
    if (exists("design.thresh") == FALSE) {
        subset.design <- data.subset(datum.idx.start, length.idxs)$subset.design
        design.min <- apply(subset.design, 2, min)
        design.max <- apply(subset.design, 2, max)
    }
    extrema.design <- permutations(n = 2, r = dimen, v = c(0, 
        1), repeats.allowed = TRUE)
    for (i in 1:dimen) {
        extrema.design[, i] <- (1 - extrema.design[, i]) * design.min[i] + 
            extrema.design[, i] * design.max[i]
    }
    extrema.design <- rbind(extrema.design, extrema.design)
    data.extrema <- matrix(c(rep(0, dim(extrema.design)[1]/2), 
        rep(1, dim(extrema.design)[1]/2)), dim(extrema.design)[1], 
        1)
    data.precompute <- array(0, c(dim(extrema.design)[1], dimen, 
        dimen, 2))
    for (i in 1:dim(extrema.design)[1]) {
        for (dim.j in 1:dimen) {
            X.row <- extrema.design[i, ]
            data.precompute[i, 1:dimen, dim.j, 1] <- abs(-n.sigma[dim.j, 
                dim.j] * diag(n.sigma) * X.row[dim.j] * X.row)/4
            data.precompute[i, 1:dimen, dim.j, 2] <- abs(-(n.sigma[dim.j, 
                dim.j])^2 * diag(n.sigma) * (X.row[dim.j])^2 * 
                X.row) * 1/(6 * sqrt(3))
        }
    }
    dim.grad.max <- array(0, c(dimen, dimen, 2))
    for (dim.j in 1:dimen) {
        for (dim.k in 1:dimen) {
            dim.grad.max[dim.j, dim.k, 1] <- max(data.precompute[, 
                dim.j, dim.k, 1])
            dim.grad.max[dim.j, dim.k, 2] <- max(data.precompute[, 
                dim.j, dim.k, 2])
        }
    }
    dim.grad.max <<- dim.grad.max
    list(design.min = design.min, design.max = design.max, dim.grad.max = dim.grad.max)
  }

mpoll/scale documentation built on Dec. 9, 2019, 7:15 a.m.