Генерация очень большой матрицы комбинаций строк с помощью combn() и пакета bigmemory

Вы можете сначала найти все двусторонние комбинации, а затем просто объединить их с трехмерным значением, сохраняя их каждый раз. Это занимает намного меньше памяти:

combn.mod <- function(x,fname){
  tmp <- combn(x,2,simplify=F)
  n <- length(x)
  for ( i in x[-c(n,n-1)]){
    # Drop all combinations that contain value i
    id <- which(!unlist(lapply(tmp,function(t) i %in% t)))
    tmp <- tmp[id]
    # add i to all other combinations and write to file
    out <- do.call(rbind,lapply(tmp,c,i))
    write(t(out),file=fname,ncolumns=3,append=T,sep=",")
  }
}

combn.mod(x,"F:/Tmp/Test.txt")

Это не такой общий ответ, как ответ Джошуа, он специально для вашего случая. Я предполагаю, что это быстрее, опять же, для этого конкретного случая, но я не сравнивал. Функция работает на моем компьютере, используя немногим более 50 МБ (приблизительно) применительно к вашему x.

РЕДАКТИРОВАТЬ

На заметку: если это для целей моделирования, мне трудно поверить, что для любого научного приложения требуется более 400 миллионов запусков моделирования. Возможно, здесь вы задаете правильный ответ на неправильный вопрос...

ПОДТВЕРЖДЕНИЕ КОНЦЕПЦИИ:

Я изменил строку записи на tt[[i]]<-out, добавил tt <- list() перед циклом и return(tt) после него. Потом:

> do.call(rbind,combn.mod(letters[1:5]))
      [,1] [,2] [,3]
 [1,] "b"  "c"  "a" 
 [2,] "b"  "d"  "a" 
 [3,] "b"  "e"  "a" 
 [4,] "c"  "d"  "a" 
 [5,] "c"  "e"  "a" 
 [6,] "d"  "e"  "a" 
 [7,] "c"  "d"  "b" 
 [8,] "c"  "e"  "b" 
 [9,] "d"  "e"  "b" 
[10,] "d"  "e"  "c" 

Вот функция, которую я написал на R, которая в настоящее время находит свой (неэкспортированный) дом в LSPM. пакет. Вы указываете общее количество элементов n, количество элементов для выбора r и индекс желаемой комбинации i; он возвращает значения в 1:n, соответствующие комбинации i.

".combinadic" <- function(n, r, i) {

  # http://msdn.microsoft.com/en-us/library/aa289166(VS.71).aspx
  # http://en.wikipedia.org/wiki/Combinadic

  if(i < 1 | i > choose(n,r)) stop("'i' must be 0 < i <= n!/(n-r)!")

  largestV <- function(n, r, i) {
    #v <- n-1
    v <- n                                  # Adjusted for one-based indexing
    #while(choose(v,r) > i) v <- v-1
    while(choose(v,r) >= i) v <- v-1        # Adjusted for one-based indexing
    return(v)
  }

  res <- rep(NA,r)
  for(j in 1:r) {
    res[j] <- largestV(n,r,i)
    i <- i-choose(res[j],r)
    n <- res[j]
    r <- r-1
  }
  res <- res + 1
  return(res)
}

Он позволяет генерировать каждую комбинацию на основе значения лексикографического индекса:

> .combinadic(1344, 3, 1)
[1] 3 2 1
> .combinadic(1344, 3, 2)
[1] 4 2 1
> .combinadic(1344, 3, 403716544)
[1] 1344 1343 1342

Так что вам просто нужно перебрать 1:403716544 и добавить результаты в файл. Это может занять некоторое время, но это, по крайней мере, осуществимо (см. Ответ Дирка). Вам также может понадобиться сделать это в несколько циклов, так как вектор 1:403716544 не помещается в памяти на моей машине.

Или вы можете просто перенести код R на C/C++ и выполнять цикл/запись там, так как это будет намного быстрее.

В первом приближении каждый алгоритм жертвует памятью ради скорости.

Вы натолкнулись на границу, пытаясь предварительно выделить полностью пронумерованную комбинационную матрицу. Так что, возможно, вам следует попробовать не предварительно выделять эту матрицу, а попробовать, скажем,

1. Если вы считаете, что вам нужны комбинации, вычислите их где-нибудь еще и сохраните их в простой базе данных (или, черт возьми, в плоском файле) и найдите их — сэкономлено 9 ГБ.

2. Воспользуйтесь преимуществом открытого исходного кода, прочитайте код combn() и измените его на клиент-сервер: при вызове с порядковым номером N он зациклится и вернет < em>N-я запись. Неэффективно, но, возможно, проще осуществимо.