Inversa del quale

Question

Mi manca qualcosa di ovvio qui? Sembra che la funzione inversa di which manchi dalla base R (googling e anche una ricerca su SO per "R inversa che" restituisce una miriade di collegamenti non correlati)?

Beh, non che io non possa scriverne uno, ma solo per alleviare la mia frustrazione per il fatto che manchi e come una sfida di flessione dei muscoli R: come andresti a scriverne uno?

Ciò di cui abbiamo bisogno è una funzione come:

invwhich<-function(indices, totlength) 

che restituisce un vettore logica di lunghezza totlength dove ogni elemento in indices è TRUE e il resto è FALSE.

Ci sono molti modi per ottenere questo risultato (alcuni dei quali sono molto bassi), quindi spiegate perché la vostra soluzione è "migliore". Oneliner qualcuno?

Se si prende in considerazione alcuni degli altri parametri di which (arr.ind ??), che è, ovviamente, ancora meglio ...

Answer 1

soluzione One-liner:

invwhich <- function(indices, totlength) is.element(seq_len(totlength), indices) 

invwhich(c(2,5), 10) 
[1] FALSE TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE 

Answer 2

la mia soluzione (per ora): MODIFICA come da suggerimento di @ Marek.

invwhich<-function(indices, outlength, useNames = TRUE) 
{ 
    rv<-logical(outlength) 
    #rv<-rep(FALSE, outlength) #see Marek's comment 
    if(length(indices) > 0) 
    { 
     rv[indices]<-TRUE 
     if(useNames) names(rv)[indices]<-names(indices) 
    } 
    return(rv) 
} 

Svolge molto bene (a quanto pare meglio di @ oneliner di Andrie) e, in quanto possibile, rappresenta usenames. Ma è possibile renderlo un oneliner?

prestazioni WRT, ho semplicemente usare:

someindices<-sample(1000000, 500000, replace=FALSE) 
system.time(replicate(100, tmp<-invwhich(someindices, 1000000))) 

come misurazione delle prestazioni molto lo-fi.

Answer 3

Un'altra variante, per fare un oneliner:

lWhich <- function(indices, totlength, vec = vector(length = totlength)){vec[indices] <- TRUE; return(vec)} 

Preferirei nomi diversi, per brevità:

lWhich <- function(ix, len, vec = vector(length = len)){vec[ix] <- TRUE; return(vec)} 

Oppure, utilizzando il pacchetto bit:

lWhichBit <- function(ix, len){return(as.logical(bitwhich(len, x = ix, poslength = length(ix))))} 

Sorprendentemente, sembra lento. Risulta che il codice utilizza rep in alcuni posti. :(

Questo è un lavoro per Rcpp o compile :)

Answer 4

versione Overkill a lavorare con tutti i tipi di indici:!

#' Logical which 
#' 
#' Inverse of \link[base]{which}. 
#' Converts an array of any indices to a logical index array. 
#' 
#' Either \code{nms} or \code{len} has to be specified. 
#' 
#' @param idx  Numeric or character indices. 
#' @param nms  Array of names or a sequence. 
#'     Required if \code{idx} is a character array 
#' @param len  Length of output array. 
#'     Alternative to \code{nms} if \code{idx} is numeric 
#' @param useNames Use the names of nms or idx 
#' 
#' @examples 
#' all(lWhich(2, len = 3) == c(F, T, F)) 
#' all(lWhich(c('a', 'c'), letters[1:3]) == c(T, F, T)) 
#' 
#' @export 
lWhich <- function(idx, nms = seq_len(len), len = length(nms), useNames = TRUE) { 
    rv <- logical(len) 
    if (is.character(nms)) # we need names here so that rv[idx] works 
     names(rv) <- nms 

    if (useNames && !is.null(names(idx))) 
     names(rv)[idx] <- names(idx) 

    rv[idx] <- TRUE 

    if (!useNames) # if we don’t want names, we’ll remove them again 
     names(rv) <- NULL 
    rv 
} 

Answer 5

setdiff(1:total_length, indices)