diff --git a/.ci/atime/tests.R b/.ci/atime/tests.R index 663e23b5c..56575dd47 100644 --- a/.ci/atime/tests.R +++ b/.ci/atime/tests.R @@ -1,3 +1,24 @@ +# Test case adapted from https://github.com/Rdatatable/data.table/issues/6105#issue-2268691745 which is where the issue was reported. +# https://github.com/Rdatatable/data.table/pull/6107 fixed performance across 3 ways to specify a column as Date, and we test each individually. +extra.args.6107 <- c( + "colClasses=list(Date='date')", + "colClasses='Date'", + "select=list(Date='date')") +extra.test.list <- list() +for (extra.arg in extra.args.6107){ + this.test <- atime::atime_test( + setup = { + set.seed(1) + DT = data.table(date=.Date(sample(20000, N, replace=TRUE))) + tmp_csv = tempfile() + fwrite(DT, tmp_csv) + }, + Slow = "e9087ce9860bac77c51467b19e92cf4b72ca78c7", # Parent of the merge commit (https://github.com/Rdatatable/data.table/commit/a77e8c22e44e904835d7b34b047df2eff069d1f2) of the PR (https://github.com/Rdatatable/data.table/pull/6107) that fixes the issue + Fast = "a77e8c22e44e904835d7b34b047df2eff069d1f2") # Merge commit of the PR (https://github.com/Rdatatable/data.table/pull/6107) that fixes the issue + this.test$expr = str2lang(sprintf("data.table::fread(tmp_csv, %s)", extra.arg)) + extra.test.list[[sprintf("fread(%s) improved in #6107", extra.arg)]] <- this.test +} + # A list of performance tests. # # See documentation in https://github.com/Rdatatable/data.table/wiki/Performance-testing for best practices. @@ -19,6 +40,8 @@ # @note Please check https://github.com/tdhock/atime/blob/main/vignettes/data.table.Rmd for more information. # nolint start: undesirable_operator_linter. ':::' needed+appropriate here. test.list <- atime::atime_test_list( + # Common N and pkg.edit.fun are defined here, and inherited in all test cases below which do not re-define them. + N = as.integer(10^seq(1, 7, by=0.25)), # A function to customize R package metadata and source files to facilitate version-specific installation and testing. # # This is specifically tailored for handling data.table which requires specific changes in non-standard files (such as the object file name in Makevars and version checking code in onLoad.R) @@ -75,10 +98,9 @@ test.list <- atime::atime_test_list( paste0('useDynLib(', new.Package_)) }, - # Performance regression discussed in: https://github.com/Rdatatable/data.table/issues/4311 - # Fixed in: https://github.com/Rdatatable/data.table/pull/4440 + # Performance regression discussed in https://github.com/Rdatatable/data.table/issues/4311 + # Test case adapted from https://github.com/Rdatatable/data.table/pull/4440#issuecomment-632842980 which is the fix PR. "shallow regression fixed in #4440" = atime::atime_test( - N = 10^seq(3,8), setup = { set.seed(1L) dt <- data.table(a = sample.int(N)) @@ -89,29 +111,27 @@ test.list <- atime::atime_test_list( Regression = "b1b1832b0d2d4032b46477d9fe6efb15006664f4", # Parent of the first commit (https://github.com/Rdatatable/data.table/commit/0f0e7127b880df8459b0ed064dc841acd22f5b73) in the PR (https://github.com/Rdatatable/data.table/pull/4440/commits) that fixes the regression Fixed = "9d3b9202fddb980345025a4f6ac451ed26a423be"), # Merge commit in the PR that fixed the regression (https://github.com/Rdatatable/data.table/pull/4440) - # Test based on: https://github.com/Rdatatable/data.table/issues/5424 - # Performance regression introduced from a commit in: https://github.com/Rdatatable/data.table/pull/4491 - # Fixed in: https://github.com/Rdatatable/data.table/pull/5463 + # Test based on https://github.com/Rdatatable/data.table/issues/5424 + # Performance regression introduced from a commit in https://github.com/Rdatatable/data.table/pull/4491 + # Test case adapted from https://github.com/Rdatatable/data.table/pull/5463#issue-1373642456 which is the fix PR. "memrecycle regression fixed in #5463" = atime::atime_test( - N = 10^seq(3, 8), setup = { - n <- N/100 + bigN <- N*100 set.seed(2L) dt <- data.table( - g = sample(seq_len(n), N, TRUE), - x = runif(N), + g = sample(seq_len(N), bigN, TRUE), + x = runif(bigN), key = "g") dt_mod <- copy(dt) }, expr = data.table:::`[.data.table`(dt_mod, , N := .N, by = g), - Before = "be2f72e6f5c90622fe72e1c315ca05769a9dc854", # Parent of the regression causing commit (https://github.com/Rdatatable/data.table/commit/e793f53466d99f86e70fc2611b708ae8c601a451) in the PR that introduced the issue (https://github.com/Rdatatable/data.table/pull/4491/commits) - Regression = "e793f53466d99f86e70fc2611b708ae8c601a451", # Commit responsible for regression in the PR that introduced the issue (https://github.com/Rdatatable/data.table/pull/4491/commits) - Fixed = "58409197426ced4714af842650b0cc3b9e2cb842"), # Last commit in the PR that fixed the regression (https://github.com/Rdatatable/data.table/pull/5463/commits) + Before = "be2f72e6f5c90622fe72e1c315ca05769a9dc854", # Parent of the regression causing commit (https://github.com/Rdatatable/data.table/commit/e793f53466d99f86e70fc2611b708ae8c601a451) in the PR (https://github.com/Rdatatable/data.table/pull/4491/commits) that introduced the issue + Regression = "e793f53466d99f86e70fc2611b708ae8c601a451", # Commit responsible for regression in the PR (https://github.com/Rdatatable/data.table/pull/4491/commits) that introduced the issue + Fixed = "58409197426ced4714af842650b0cc3b9e2cb842"), # Last commit in the PR (https://github.com/Rdatatable/data.table/pull/5463/commits) that fixed the regression - # Issue reported in: https://github.com/Rdatatable/data.table/issues/5426 - # To be fixed in: https://github.com/Rdatatable/data.table/pull/5427 + # Issue reported in https://github.com/Rdatatable/data.table/issues/5426 + # Test case adapted from https://github.com/Rdatatable/data.table/pull/5427#issue-1323678063 which is the fix PR. "setDT improved in #5427" = atime::atime_test( - N = 10^seq(1, 7), setup = { L <- replicate(N, 1, simplify = FALSE) setDT(L) @@ -120,48 +140,41 @@ test.list <- atime::atime_test_list( data.table:::setattr(L, "class", NULL) data.table:::setDT(L) }, - Slow = "c4a2085e35689a108d67dacb2f8261e4964d7e12", # Parent of the first commit in the PR that fixes the issue (https://github.com/Rdatatable/data.table/commit/7cc4da4c1c8e568f655ab5167922dcdb75953801) - Fast = "1872f473b20fdcddc5c1b35d79fe9229cd9a1d15"), # Last commit in the PR that fixes the issue (https://github.com/Rdatatable/data.table/pull/5427/commits) + Slow = "c4a2085e35689a108d67dacb2f8261e4964d7e12", # Parent of the first commit (https://github.com/Rdatatable/data.table/commit/7cc4da4c1c8e568f655ab5167922dcdb75953801) in the PR (https://github.com/Rdatatable/data.table/pull/5427/commits) that fixes the issue + Fast = "af48a805e7a5026a0c2d0a7fd9b587fea5cfa3c4"), # Last commit in the PR (https://github.com/Rdatatable/data.table/pull/5427/commits) that fixes the issue - # Issue reported in: https://github.com/Rdatatable/data.table/issues/4200 - # To be fixed in: https://github.com/Rdatatable/data.table/pull/4558 + # Test case adapted from https://github.com/Rdatatable/data.table/issues/4200#issuecomment-645980224 which is where the issue was reported. + # Fixed in https://github.com/Rdatatable/data.table/pull/4558 "DT[by] fixed in #4558" = atime::atime_test( - N = 10^seq(1, 20), setup = { d <- data.table( - id3 = sample(c(seq.int(N*0.9), sample( N*0.9, N*0.1, TRUE))), + id = sample(c(seq.int(N * 0.9), sample(N * 0.9, N * 0.1, TRUE))), v1 = sample(5L, N, TRUE), v2 = sample(5L, N, TRUE) ) }, - expr = { - expr=data.table:::`[.data.table`(d, , max(v1) - min(v2), by = id3) - }, + expr = data.table:::`[.data.table`(d, , max(v1) - min(v2), by = id), Before = "7a9eaf62ede487625200981018d8692be8c6f134", # Parent of the first commit (https://github.com/Rdatatable/data.table/commit/515de90a6068911a148e54343a3503043b8bb87c) in the PR (https://github.com/Rdatatable/data.table/pull/4164/commits) that introduced the regression Regression = "c152ced0e5799acee1589910c69c1a2c6586b95d", # Parent of the first commit (https://github.com/Rdatatable/data.table/commit/15f0598b9828d3af2eb8ddc9b38e0356f42afe4f) in the PR (https://github.com/Rdatatable/data.table/pull/4558/commits) that fixes the regression Fixed = "f750448a2efcd258b3aba57136ee6a95ce56b302"), # Second commit of the PR (https://github.com/Rdatatable/data.table/pull/4558/commits) that fixes the regression - # Issue with sorting again when already sorted: https://github.com/Rdatatable/data.table/issues/4498 - # Fixed in: https://github.com/Rdatatable/data.table/pull/4501 + # Issue with sorting again when already sorted, as reported in https://github.com/Rdatatable/data.table/issues/4498 + # Test case adapted from https://github.com/Rdatatable/data.table/pull/4501#issue-625311918 which is the fix PR. "DT[,.SD] improved in #4501" = atime::atime_test( - N = 10^seq(1, 10, by=0.5), setup = { set.seed(1) L = as.data.table(as.character(rnorm(N, 1, 0.5))) setkey(L, V1) }, ## New DT can safely retain key. - expr = { - data.table:::`[.data.table`(L, , .SD) - }, + expr = data.table:::`[.data.table`(L, , .SD), Fast = "353dc7a6b66563b61e44b2fa0d7b73a0f97ca461", # Close-to-last merge commit in the PR (https://github.com/Rdatatable/data.table/pull/4501/commits) that fixes the issue Slow = "3ca83738d70d5597d9e168077f3768e32569c790", # Circa 2024 master parent of close-to-last merge commit (https://github.com/Rdatatable/data.table/commit/353dc7a6b66563b61e44b2fa0d7b73a0f97ca461) in the PR (https://github.com/Rdatatable/data.table/pull/4501/commits) that fixes the issue Slower = "cacdc92df71b777369a217b6c902c687cf35a70d"), # Circa 2020 parent of the first commit (https://github.com/Rdatatable/data.table/commit/74636333d7da965a11dad04c322c752a409db098) in the PR (https://github.com/Rdatatable/data.table/pull/4501/commits) that fixes the issue - # Issue reported in: https://github.com/Rdatatable/data.table/issues/6286 - # Fixed in: https://github.com/Rdatatable/data.table/pull/6296 - "DT[by, verbose = TRUE] improved in #6296" = atime::atime_test( - N = 10^seq(1, 9), + # Test case adapted from https://github.com/Rdatatable/data.table/issues/6286#issue-2412141289 which is where the issue was reported. + # Fixed in https://github.com/Rdatatable/data.table/pull/6296 + "DT[by,verbose=TRUE] improved in #6296" = atime::atime_test( setup = { dt = data.table(a = 1:N) dt_mod <- copy(dt) @@ -170,5 +183,30 @@ test.list <- atime::atime_test_list( Slow = "a01f00f7438daf4612280d6886e6929fa8c8f76e", # Parent of the first commit (https://github.com/Rdatatable/data.table/commit/fc0c1e76408c34a8482f16f7421d262c7f1bde32) in the PR (https://github.com/Rdatatable/data.table/pull/6296/commits) that fixes the issue Fast = "f248bbe6d1204dfc8def62328788eaadcc8e17a1"), # Merge commit of the PR (https://github.com/Rdatatable/data.table/pull/6296) that fixes the issue - NULL) + # Test case adapted from https://github.com/Rdatatable/data.table/issues/5492#issue-1416598382 which is where the issue was reported, + # and from https://github.com/Rdatatable/data.table/pull/5493#issue-1416656788 which is the fix PR. + "transform improved in #5493" = atime::atime_test( + setup = { + df <- data.frame(x = runif(N)) + dt <- as.data.table(df) + }, + expr = data.table:::transform.data.table(dt, y = round(x)), + Slow = "0895fa247afcf6b38044bd5f56c0d209691ddb31", # Parent of the first commit (https://github.com/Rdatatable/data.table/commit/93ce3ce1373bf733ebd2036e2883d2ffe377ab58) in the PR (https://github.com/Rdatatable/data.table/pull/5493/commits) that fixes the issue + Fast = "2d1a0575f87cc50e90f64825c30d7a6cb6b05dd7"), # Merge commit of the PR (https://github.com/Rdatatable/data.table/pull/5493) that fixes the issue + + # Test case created directly using the atime code below (not adapted from any other benchmark), based on the issue/fix PR https://github.com/Rdatatable/data.table/pull/5054#issue-930603663 "melt should be more efficient when there are missing input columns." + "melt improved in #5054" = atime::atime_test( + setup = { + DT <- as.data.table(as.list(1:N)) + measure.vars <- lapply(1:N, function(i) { + x = rep(NA, N) + x[i] = i + x + }) + }, + expr = data.table:::melt(DT, measure.vars = measure.vars), + Slow = "fd24a3105953f7785ea7414678ed8e04524e6955", # Parent of the merge commit (https://github.com/Rdatatable/data.table/commit/ed72e398df76a0fcfd134a4ad92356690e4210ea) of the PR (https://github.com/Rdatatable/data.table/pull/5054) that fixes the issue + Fast = "ed72e398df76a0fcfd134a4ad92356690e4210ea"), # Merge commit of the PR (https://github.com/Rdatatable/data.table/pull/5054) that fixes the issue + + tests=extra.test.list) # nolint end: undesirable_operator_linter. diff --git a/.ci/linters/po/msgfmt_linter.R b/.ci/linters/po/msgfmt_linter.R index c358d2e5c..8bae3fab2 100644 --- a/.ci/linters/po/msgfmt_linter.R +++ b/.ci/linters/po/msgfmt_linter.R @@ -20,6 +20,9 @@ msgfmt_linter <- function(po_file) { stop(po_file, " has not been compiled as ", mo_ref, ". Please fix.") } if (tools::md5sum(mo_ref) == tools::md5sum(mo_tmp)) return(invisible()) + # TODO(#6517): Re-activate this part of the check to ensure .mo is up to date. + cat(sprintf("Note: MD5 sum of msgfmt output for %s does not match %s.\n", po_file, mo_ref)) + return(invisible()) # NB: file.mtime() will probably be wrong, it will reflect the check-out time of the git repo. last_edit_time = system2("git", @@ -33,7 +36,7 @@ msgfmt_linter <- function(po_file) { unmo_tmp = tempfile() unmo_ref = tempfile() - on.exit(unlink(c(unmo_tmp, unmo_ref), add=TRUE)) + on.exit(unlink(c(unmo_tmp, unmo_ref)), add=TRUE) system2("msgunfmt", c(mo_tmp, "-o", unmo_tmp)) system2("msgunfmt", c(mo_ref, "-o", unmo_ref)) cat("Here are the observed differences after converting back to .po:\n\n") diff --git a/.ci/linters/r/class1_linter.R b/.ci/linters/r/class1_linter.R new file mode 100644 index 000000000..276f94672 --- /dev/null +++ b/.ci/linters/r/class1_linter.R @@ -0,0 +1,10 @@ +class1_linter = lintr::make_linter_from_xpath( + " + //OP-LEFT-BRACKET[ + preceding-sibling::expr/expr/SYMBOL_FUNCTION_CALL[text() = 'class'] + and following-sibling::expr/NUM_CONST[text() = '1' or text() = '1L'] + ] + /parent::expr + ", + "Use class1(x) to get class(x)[1L], or classes1(x) to do so for a full list/data.table" +) diff --git a/.dev/cc.R b/.dev/cc.R index 299b845fb..eefe09b79 100644 --- a/.dev/cc.R +++ b/.dev/cc.R @@ -91,9 +91,9 @@ cc = function(test=FALSE, clean=FALSE, debug=FALSE, omp=!debug, path=Sys.getenv( if (clean) system("rm *.o *.so") OMP = if (omp) "openmp" else "no-openmp" if (debug) { - cmd = sprintf(R"(MAKEFLAGS='-j CC=%s PKG_CFLAGS=-f% CFLAGS=-std=c99\ -O0\ -ggdb\ %s\ -pedantic' R CMD SHLIB -d -o data_table.so *.c)", CC, OMP, W32) + cmd = sprintf(R"(MAKEFLAGS='-j CC=%s PKG_CFLAGS=-f% CFLAGS=-std=c11\ -O0\ -ggdb\ %s\ -pedantic' R CMD SHLIB -d -o data_table.so *.c)", CC, OMP, W32) } else { - cmd = sprintf(R"(MAKEFLAGS='-j CC=%s CFLAGS=-f%s\ -std=c99\ -O3\ -pipe\ -Wall\ -pedantic\ -Wstrict-prototypes\ -isystem\ /usr/share/R/include\ %s\ -fno-common' R CMD SHLIB -o data_table.so *.c)", CC, OMP, W32) + cmd = sprintf(R"(MAKEFLAGS='-j CC=%s CFLAGS=-f%s\ -std=c11\ -O3\ -pipe\ -Wall\ -pedantic\ -Wstrict-prototypes\ -isystem\ /usr/share/R/include\ %s\ -fno-common' R CMD SHLIB -o data_table.so *.c)", CC, OMP, W32) # the -isystem suppresses strict-prototypes warnings from R's headers, #5477. Look at the output to see what -I is and pass the same path to -isystem. # TODO add -Wextra too? } diff --git a/.github/workflows/performance-tests.yml b/.github/workflows/performance-tests.yml index cb30e7625..e1b9a5409 100644 --- a/.github/workflows/performance-tests.yml +++ b/.github/workflows/performance-tests.yml @@ -1,4 +1,4 @@ -name: Autocomment atime-based performance regression analysis on PRs +name: atime performance tests on: pull_request: @@ -15,10 +15,11 @@ on: jobs: comment: + if: github.repository == 'Rdatatable/data.table' runs-on: ubuntu-latest container: ghcr.io/iterative/cml:0-dvc2-base1 env: GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }} repo_token: ${{ secrets.GITHUB_TOKEN }} steps: - - uses: Anirban166/Autocomment-atime-results@v1.2.0 + - uses: Anirban166/Autocomment-atime-results@v1.3.1 diff --git a/.github/workflows/test-coverage.yaml b/.github/workflows/test-coverage.yaml new file mode 100644 index 000000000..79fcd6fdc --- /dev/null +++ b/.github/workflows/test-coverage.yaml @@ -0,0 +1,55 @@ +# Workflow derived from https://github.com/r-lib/actions/tree/v2/examples +# Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help +on: + push: + branches: [master] + pull_request: + branches: [master] + +name: test-coverage.yaml + +permissions: read-all + +jobs: + test-coverage: + runs-on: ubuntu-latest + env: + GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }} + + steps: + - uses: actions/checkout@v4 + + - uses: r-lib/actions/setup-r@v2 + with: + use-public-rspm: true + r-version: '4.3' # TODO(r-lib/covr#567): Go back to using r-devel + + - uses: r-lib/actions/setup-r-dependencies@v2 + with: + extra-packages: any::covr, any::xml2 + needs: coverage + + - name: Test coverage + run: | + cov <- covr::package_coverage( + quiet = FALSE, + clean = FALSE, + install_path = file.path(normalizePath(Sys.getenv("RUNNER_TEMP"), winslash = "/"), "package") + ) + covr::to_cobertura(cov) + shell: Rscript {0} + + - uses: codecov/codecov-action@v4 + with: + fail_ci_if_error: ${{ github.event_name != 'pull_request' && true || false }} + file: ./cobertura.xml + plugin: noop + disable_search: true + token: ${{ secrets.CODECOV_TOKEN }} + + - name: Upload test results + if: failure() + uses: actions/upload-artifact@v4 + with: + name: coverage-test-failures + path: ${{ runner.temp }}/package diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 577fbcd17..c060b618a 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -12,17 +12,17 @@ variables: TZ: "UTC" ## to avoid 'Failed to create bus connection' from timedatectl via Sys.timezone() on Docker with R 3.4. ## Setting TZ for all GLCI jobs to isolate them from timezone. We could have a new GLCI job to test under ## a non-UTC timezone, although, that's what we do routinely in dev. - R_REL_VERSION: "4.3" - R_REL_WIN_BIN: "https://cloud.r-project.org/bin/windows/base/old/4.3.2/R-4.3.2-win.exe" - RTOOLS_REL_BIN: "https://cloud.r-project.org/bin/windows/Rtools/rtools43/files/rtools43-5958-5975.exe" + R_REL_VERSION: "4.4" + R_REL_WIN_BIN: "https://cloud.r-project.org/bin/windows/base/old/4.4.1/R-4.4.1-win.exe" + RTOOLS_REL_BIN: "https://cloud.r-project.org/bin/windows/Rtools/rtools44/files/rtools44-6104-6039.exe" RTOOLS43_HOME: "/c/rtools" - R_DEV_VERSION: "4.4" + R_DEV_VERSION: "4.5" R_DEV_WIN_BIN: "https://cloud.r-project.org/bin/windows/base/R-devel-win.exe" - RTOOLS_DEV_BIN: "https://cloud.r-project.org/bin/windows/Rtools/rtools43/files/rtools43-5958-5975.exe" - RTOOLS44_HOME: "" ## in case R-devel will use new Rtools toolchain, now it uses 4.3 env var - R_OLD_VERSION: "4.2" - R_OLD_WIN_BIN: "https://cloud.r-project.org/bin/windows/base/old/4.2.3/R-4.2.3-win.exe" - RTOOLS_OLD_BIN: "https://cloud.r-project.org/bin/windows/Rtools/rtools42/files/rtools42-5355-5357.exe" + RTOOLS_DEV_BIN: "https://cloud.r-project.org/bin/windows/Rtools/rtools44/files/rtools44-6104-6039.exe" + RTOOLS44_HOME: "" ## in case R-devel will use new Rtools toolchain, now it uses 4.4 env var + R_OLD_VERSION: "4.3" + R_OLD_WIN_BIN: "https://cloud.r-project.org/bin/windows/base/old/4.3.3/R-4.3.3-win.exe" + RTOOLS_OLD_BIN: "https://cloud.r-project.org/bin/windows/Rtools/rtools43/files/rtools43-5958-5975.exe" RTOOLS42_HOME: "/c/rtools" stages: diff --git a/CODEOWNERS b/CODEOWNERS index af741a6a4..918f4bee2 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -35,6 +35,10 @@ /src/shift.c @ben-schwen @michaelchirico /man/shift.Rd @ben-schwen @michaelchirico +# rbind +/src/rbindlist.c @ben-schwen +/man/rbindlist.Rd @ben-schwen + # translations /inst/po/ @michaelchirico /po/ @michaelchirico diff --git a/DESCRIPTION b/DESCRIPTION index 778024a85..5d03d5823 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -89,5 +89,7 @@ Authors@R: c( person("Iago", "Giné-Vázquez", role="ctb"), person("Anirban", "Chetia", role="ctb"), person("Doris", "Amoakohene", role="ctb"), - person("Ivan", "Krylov", role="ctb") + person("Ivan", "Krylov", role="ctb"), + person("Michael","Young", role="ctb"), + person("Mark", "Seeto", role="ctb") ) diff --git a/NAMESPACE b/NAMESPACE index 2bc30543f..0e0c733ce 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -6,6 +6,7 @@ exportClasses(data.table, IDate, ITime) ## export(data.table, tables, setkey, setkeyv, key, "key<-", haskey, CJ, SJ, copy) +export(rowwiseDT) export(setindex, setindexv, indices) export(as.data.table,is.data.table,test.data.table) export(last,first,like,"%like%","%ilike%","%flike%","%plike%",between,"%between%",inrange,"%inrange%", "%notin%") diff --git a/NEWS.md b/NEWS.md index ee13f1631..1247ab7e2 100644 --- a/NEWS.md +++ b/NEWS.md @@ -6,6 +6,65 @@ 1. In `DT[, variable := value]`, when value is class `POSIXlt`, we automatically coerce it to class `POSIXct` instead, [#1724](https://github.com/Rdatatable/data.table/issues/1724). Thanks to @linzhp for the report, and Benjamin Schwendinger for the fix. +## NEW FEATURES + +1. New function `rowwiseDT()` for creating a data.table object "row-wise", often convenient for readability of small, literally-defined tables. Thanks to @shrektan for the suggestion and PR and @tdeenes for the idea of the `name=` syntax. Inspired by `tibble::tribble()`. + +```r +library(data.table) +rowwiseDT( + a=,b=,c=, d=, + 1, 2, "a", 2:3, + 3, 4, "b", list("e"), + 5, 6, "c", ~a+b, +) +#> a b c d +#> +#> 1: 1 2 a 2,3 +#> 2: 3 4 b e +#> 3: 5 6 c ~a + b +``` + +2. Limited support for subsetting or aggregating columns of type `expression`, [#5596](https://github.com/Rdatatable/data.table/issues/5596). Thanks to @tsp for the report, and @ben-schwen for the fix. + +3. `groupingsets.data.table()`, `cube.data.table()`, and `rollup.data.table()` gain a `label` argument, which allows the user to specify a label for each grouping variable, to be included in the grouping variable column in the output in rows where the variable has been aggregated, [#5351](https://github.com/Rdatatable/data.table/issues/5351). Thanks to @markseeto for the request, @jangorecki and @markseeto for specifying the desired behaviour, and @markseeto for implementing. + + ```r + DT = data.table(V1 = rep(c("a1", "a2"), each = 5), + V2 = rep(rep(c("b1", "b2"), c(3, 2)), 2), + V3 = rep(c("c1", "c2"), c(3, 7)), + V4 = rep(1:2, c(6, 4)), + V5 = rep(1:2, c(9, 1)), + V6 = rep(c(1.1, 1.2), c(2, 8))) + + # Call groupingsets() and specify a label for V1, a different label for the other character grouping + # variables, a label for the integer grouping variables, and a label for the numeric grouping variable. + + groupingsets(DT, .N, by = c("V1", "V2", "V3", "V4", "V5", "V6"), + sets = list(c("V1", "V2", "V3"), c("V1", "V4"), c("V4", "V6"), "V2", "V5", character()), + label = list(V1 = "All values", character = "Total", integer = 999L, numeric = NaN)) + + # V1 V2 V3 V4 V5 V6 N + # + # 1: a1 b1 c1 999 999 NaN 3 + # 2: a1 b2 c2 999 999 NaN 2 + # 3: a2 b1 c2 999 999 NaN 3 + # 4: a2 b2 c2 999 999 NaN 2 + # 5: a1 Total Total 1 999 NaN 5 + # 6: a2 Total Total 1 999 NaN 1 + # 7: a2 Total Total 2 999 NaN 4 + # 8: All values Total Total 1 999 1.1 2 + # 9: All values Total Total 1 999 1.2 4 + # 10: All values Total Total 2 999 1.2 4 + # 11: All values b1 Total 999 999 NaN 6 + # 12: All values b2 Total 999 999 NaN 4 + # 13: All values Total Total 999 1 NaN 9 + # 14: All values Total Total 999 2 NaN 1 + # 15: All values Total Total 999 999 NaN 10 + ``` + +4. `patterns()` in `melt()` combines correctly with user-defined `cols=`, which can be useful to specify a subset of columns to reshape without having to use a regex, for example `patterns("2", cols=c("y1", "y2"))` will only give `y2` even if there are other columns in the input matching `2`, [#6498](https://github.com/Rdatatable/data.table/issues/6498). Thanks to @hongyuanjia for the report, and to @tdhock for the PR. + ## BUG FIXES 1. Using `print.data.table()` with character truncation using `datatable.prettyprint.char` no longer errors with `NA` entries, [#6441](https://github.com/Rdatatable/data.table/issues/6441). Thanks to @r2evans for the bug report, and @joshhwuu for the fix. @@ -14,7 +73,46 @@ 3. The data.table-only attribute `$.internal.selfref` is no longer set for data.frames. [#5286](https://github.com/Rdatatable/data.table/issues/5286). Thanks @OfekShilon for the report and fix. -4. `setDT()` no longer modifies the class of other names bound to the origin data.frame - e.g., argument DFs names at a caller to a function which uses setDT. Cf [#4784](https://github.com/Rdatatable/data.table/issues/4784). Thanks @OfekShilon for the report and fix. +4. Tagging/naming arguments of `c()` in `j=c()` should now more closely follow base R conventions for concatenation of named lists during grouping, [#2311](https://github.com/Rdatatable/data.table/issues/2311). Naming an `lapply(.SD, FUN)` call as an argument of `c()` in `j` will now always cause that tag to get prepended (with a single dot separator) to the resulting column names. Additionally, naming a `list()` call as an argument of `c()` in `j` will now always cause that tag to get prepended to any names specified within the list call. This bug only affected queries with (1) `by=` grouping (2) `getOption("datatable.optimize") >= 1L` and (3) `lapply(.SD, FUN)` in `j`. + + While the names returned by `data.table` when `j=c()` will now mostly follow base R conventions for concatenating lists, note that names which are completely unspecified will still be named positionally, matching the typical behavior in `j` and `data.table()`. according to position in `j` (e.g. `V1`, `V2`). + + Thanks to @franknarf1 for reporting and @myoung3 for the PR. + + ```r + # tag 'mean' prepended to lapply()-named columns + names(mtcars[, c(mean=lapply(.SD,sum)), by="cyl", .SDcols=c("am", "carb")]) + # [1] "cyl" "mean.am" "mean.carb" + + # tag 'mean' is prepended to the first named sublist, 'sum' to the second + names(mtcars[, c(mean=list(a=mean(hp), b=mean(wt)), sum=lapply(.SD, sum)), by="cyl", .SDcols=c("am", "carb")]) + # [1] "cyl" "mean.a" "mean.b" "sum.am" "sum.carb" + + # strict base naming would result in names c("", "b", "c") here + names(mtcars[, c(list(mean(hp), b=mean(wt)), c=list(mean(cyl)))]) + # [1] "V1" "b" "c" + ``` + +5. Queries like `DT[, min(x):max(x)]` now work as expected, i.e. the same as `DT[, seq(min(x), max(x))]` or `with(DT, min(x):max(x))`, [#2069](https://github.com/Rdatatable/data.table/issues/2069). Shorthand like `DT[, a:b]` meaning "select from columns `a` through `b`" still works. Thanks to @franknarf1 for reporting, @jangorecki for the fix, and @MichaelChirico for a follow-up ensuring back-compatibility. + +6. Fixed a segfault in `fcase()`, [#6448](https://github.com/Rdatatable/data.table/issues/6448). Thanks @ethanbsmith for reporting with reprex, @aitap for finding the root cause, and @MichaelChirico for the PR. + +7. `fread()` performance improves when specifying `Date` among `colClasses`, [#6105](https://github.com/Rdatatable/data.table/issues/6105). One implication of the change is that the column will be an `IDate` (which also inherits from `Date`), which may affect code strongly relying on the column class to be `Date` exactly; computations with `IDate` and `Date` columns should otherwise be the same. If you strongly prefer the `Date` class, run `as.Date()` explicitly following `fread()`. Thanks @scipima for the report and @MichaelChirico for the fix. + +8. `dt[, col]` now returns a copy of `col` also when it is a list column, as in any other case, [#4877](https://github.com/Rdatatable/data.table/issues/4877). Thanks to @tlapak for reporting and the PR. + +9. `rbindlist` and `rbind` binding `bit64::integer64` columns with `character`/`complex`/`list` columns now works, [#5504](https://github.com/Rdatatable/data.table/issues/5504). Thanks to @MichaelChirico for the request and @ben-schwen for the PR. + +10. Fixed possible segfault in `setDT(df); attr(df, key) <- value; set(df, ...)`, i.e. adding columns to an object with `set()` that was converted to data.table with `setDT()` and later had attributes add with `attr<-`, [#6410](https://github.com/Rdatatable/data.table/issues/6410). Thanks to @hongyuanjia for the report and @ben-schwen for the PR. Note that `setattr()` should be preferred for adding attributes to a data.table. + +11. `fread()` automatically detects timestamps with sub-second accuracy again, [#6440](https://github.com/Rdatatable/data.table/issues/6440). This was a regression due to interference with new `dec='auto'` support. Thanks @kav2k for the concise report and @MichaelChirico for the fix. + +12. Using a namespace-qualified call on the RHS of `by=`, e.g. `DT[,.N,by=base::mget(v)]`, works again, fixing [#6493](https://github.com/Rdatatable/data.table/issues/6493). Thanks to @mmoisse for the report and @MichaelChirico for the fix. + +13. Restore some join operations on `x` and `i` (e.g. an anti-join `x[!i]`) where `i` is an extended data.frame, but not a data.table (e.g. a `tbl`), [#6501](https://github.com/Rdatatable/data.table/issues/6501). Thanks @MichaelChirico for the report and PR. + +14. `setDT()` no longer modifies the class of other names bound to the origin data.frame - e.g., argument DFs names at a caller to a function which uses setDT. Cf [#4784](https://github.com/Rdatatable/data.table/issues/4784). Thanks @OfekShilon for the report and fix. + ## NOTES 1. Tests run again when some Suggests packages are missing, [#6411](https://github.com/Rdatatable/data.table/issues/6411). Thanks @aadler for the note and @MichaelChirico for the fix. @@ -27,6 +125,10 @@ 5. Some grouping operations run much faster under `verbose=TRUE`, [#6286](https://github.com/Rdatatable/data.table/issues/6286). Thanks @joshhwuu for the report and fix. This overhead was not present on Windows. As a rule, users should expect `verbose=TRUE` operations to run more slowly, as extra statistics might be calculated as part of the report; here was a case where the overhead was particularly high and the fix was particularly easy. +6. `set()` and `:=` now provide some extra guidance for common incorrect approaches to assigning `NULL` to some rows of a list column. The correct way is to put `list(list(NULL))` on the RHS of `:=` (or `.(.(NULL))` for short). Thanks to @MichaelChirico for the suggestion and @Nj221102 for the implementation. + +7. Improved the error message when trying to write code like `DT[, ":="(a := b, c := d)]` (which should be `DT[, ":="(a = b, c = d)]`), [#5296](https://github.com/Rdatatable/data.table/issues/5296). Thanks @MichaelChirico for the suggestion & fix. + # data.table [v1.16.0](https://github.com/Rdatatable/data.table/milestone/30) (25 August 2024) ## BREAKING CHANGES diff --git a/R/between.R b/R/between.R index 82703ed7b..e96434732 100644 --- a/R/between.R +++ b/R/between.R @@ -5,14 +5,14 @@ between = function(x, lower, upper, incbounds=TRUE, NAbounds=TRUE, check=FALSE) if (is.logical(upper)) upper = as.integer(upper) # typically NA (which is logical type) is.px = function(x) inherits(x, "POSIXct") is.i64 = function(x) inherits(x, "integer64") # this is true for nanotime too - # POSIX special handling to auto coerce character + # POSIXct special handling to auto coerce character if (is.px(x) && (is.character(lower) || is.character(upper))) { tz = attr(x, "tzone", exact=TRUE) if (is.null(tz)) tz = "" if (is.character(lower)) lower = tryCatch(as.POSIXct(lower, tz=tz), error=function(e)stopf( - "'between' function the 'x' argument is a POSIX class while '%s' was not, coercion to POSIX failed with: %s", 'lower', e$message)) + "The 'x' argument of the 'between' function is POSIXct while '%s' was not, coercion to POSIXct failed with: %s", 'lower', conditionMessage(e))) if (is.character(upper)) upper = tryCatch(as.POSIXct(upper, tz=tz), error=function(e)stopf( - "'between' function the 'x' argument is a POSIX class while '%s' was not, coercion to POSIX failed with: %s", 'upper', e$message)) + "The 'x' argument of the 'between' function is POSIXct while '%s' was not, coercion to POSIXct failed with: %s", 'upper', conditionMessage(e))) stopifnot(is.px(x), is.px(lower), is.px(upper)) # nocov # internal } # POSIX check timezone match diff --git a/R/bmerge.R b/R/bmerge.R index 16d58fa53..aa7ea4103 100644 --- a/R/bmerge.R +++ b/R/bmerge.R @@ -173,7 +173,8 @@ bmerge = function(i, x, icols, xcols, roll, rollends, nomatch, mult, ops, verbos xo = forderv(nqx, c(ncol(nqx), xcols)) if (verbose) {catf("done in %s\n",timetaken(last.started.at)); flush.console()} } else nqgrp = integer(0L) - if (verbose) catf(" Found %d non-equi group(s) ...\n", nqmaxgrp) + if (verbose) + catf(ngettext(nqmaxgrp, " Found %d non-equi group ...\n", " Found %d non-equi groups ...\n"), nqmaxgrp, domain=NA) } if (verbose) {last.started.at=proc.time();catf("Starting bmerge ...\n");flush.console()} diff --git a/R/data.table.R b/R/data.table.R index e740c92fd..c99701318 100644 --- a/R/data.table.R +++ b/R/data.table.R @@ -180,12 +180,12 @@ replace_dot_alias = function(e) { naturaljoin = FALSE names_x = names(x) if (missing(i) && !missing(on)) { - tt = eval.parent(.massagei(substitute(on))) - if (!is.list(tt) || !length(names(tt))) { - warningf("When on= is provided but not i=, on= must be a named list or data.table|frame, and a natural join (i.e. join on common names) is invoked. Ignoring on= which is '%s'.", class(tt)[1L]) + on_tmp = eval.parent(.massagei(substitute(on))) + if (!is.list(on_tmp) || !length(names(on_tmp))) { + warningf("When on= is provided but not i=, on= must be a named list or data.table|frame, and a natural join (i.e. join on common names) is invoked. Ignoring on= which is '%s'.", class1(on_tmp)) on = NULL } else { - i = tt + i = on_tmp naturaljoin = TRUE } } @@ -244,10 +244,12 @@ replace_dot_alias = function(e) { if (!missing(j)) { jsub = replace_dot_alias(jsub) root = root_name(jsub) - if (root == ":" || - (root %chin% c("-","!") && jsub[[2L]] %iscall% '(' && jsub[[2L]][[2L]] %iscall% ':') || - ( (!length(av<-all.vars(jsub)) || all(startsWith(av, ".."))) && - root %chin% c("","c","paste","paste0","-","!") && + av = all.vars(jsub) + all..names = FALSE + if ((.is_withFALSE_range(jsub, x, root, av)) || + (root %chin% c("-","!") && jsub[[2L]] %iscall% '(' && jsub[[2L]][[2L]] %iscall% ':') || ## x[, !(V8:V10)] + ( (!length(av) || (all..names <- all(startsWith(av, "..")))) && ## x[, "V1"]; x[, ..v] + root %chin% c("","c","paste","paste0","-","!") && ## x[, c("V1","V2")]; x[, paste("V",1:2,sep="")]; x[, paste0("V",1:2)] missingby )) { # test 763. TODO: likely that !missingby iff with==TRUE (so, with can be removed) # When no variable names (i.e. symbols) occur in j, scope doesn't matter because there are no symbols to find. # If variable names do occur, but they are all prefixed with .., then that means look up in calling scope. @@ -261,18 +263,19 @@ replace_dot_alias = function(e) { # want decisions like this to depend on the data or vector lengths since that can introduce # inconsistency reminiscent of drop=TRUE in [.data.frame that we seek to avoid. with=FALSE - if (length(av)) { + if (all..names) { for (..name in av) { name = substr(..name, 3L, nchar(..name)) if (!nzchar(name)) stopf("The symbol .. is invalid. The .. prefix must be followed by at least one character.") + parent_has_..name = exists(..name, where=parent.frame()) if (!exists(name, where=parent.frame())) { - suggested = if (exists(..name, where=parent.frame())) + suggested = if (parent_has_..name) gettextf(" Variable '..%s' does exist in calling scope though, so please just removed the .. prefix from that variable name in calling scope.", name) # We have recommended 'manual' .. prefix in the past, so try to be helpful else "" stopf("Variable '%s' is not found in calling scope. Looking in calling scope because you used the .. prefix.%s", name, suggested) - } else if (exists(..name, where=parent.frame())) { + } else if (parent_has_..name) { warningf("Both '%1$s' and '..%1$s' exist in calling scope. Please remove the '..%1$s' variable in calling scope for clarity.", name) } } @@ -289,7 +292,7 @@ replace_dot_alias = function(e) { root = root_name(jsub) } else if (length(jsub) > 2L && jsub[[2L]] %iscall% ":=") { #2142 -- j can be {} and have length 1 - stopf("You have wrapped := with {} which is ok but then := must be the only thing inside {}. You have something else inside {} as well. Consider placing the {} on the RHS of := instead; e.g. DT[,someCol:={tmpVar1<-...;tmpVar2<-...;tmpVar1*tmpVar2}") + stopf("You have wrapped := with {} which is ok but then := must be the only thing inside {}. You have something else inside {} as well. Consider placing the {} on the RHS of := instead; e.g. DT[,someCol:={tmpVar1<-...;tmpVar2<-...;tmpVar1*tmpVar2}]") } } if (root=="eval" && !any(all.vars(jsub[[2L]]) %chin% names_x)) { @@ -406,7 +409,7 @@ replace_dot_alias = function(e) { "'%s' is not found in calling scope and it is not a column name either", as.character(isub) ) else gettextf( - "'%s' is not found in calling scope, but it is a column of type %s. If you wish to select rows where that column contains TRUE, or perhaps that column contains row numbers of itself to select, try DT[(col)], DT[DT$col], or DT[col==TRUE} is particularly clear and is optimized", + "'%s' is not found in calling scope, but it is a column of type %s. If you wish to select rows where that column contains TRUE, or perhaps that column contains row numbers of itself to select, try DT[(col)], DT[DT$col], or DT[col==TRUE] is particularly clear and is optimized", as.character(isub), typeof(col) ) stopf("%s. When the first argument inside DT[...] is a single symbol (e.g. DT[var]), data.table looks for var in calling scope.", msg) @@ -712,7 +715,9 @@ replace_dot_alias = function(e) { if (is.factor(j)) j = as.character(j) # fix for FR: #358 if (is.character(j)) { if (notj) { - if (anyNA(idx <- chmatch(j, names_x))) warningf("column(s) not removed because not found: %s", brackify(j[is.na(idx)])) + if (anyNA(idx <- chmatch(j, names_x))) + warningf(ngettext(sum(is.na(idx)), "column not removed because not found: %s", "columns not removed because not found: %s"), + brackify(j[is.na(idx)]), domain=NA) # all duplicates of the name in names(x) must be removed; e.g. data.table(x=1, y=2, x=3)[, !"x"] should just output 'y'. w = !names_x %chin% j ansvars = names_x[w] @@ -726,7 +731,8 @@ replace_dot_alias = function(e) { if (!length(ansvals)) return(null.data.table()) if (!length(leftcols)) { if (!anyNA(ansvals)) return(.Call(CsubsetDT, x, irows, ansvals)) - else stopf("column(s) not found: %s", brackify(ansvars[is.na(ansvals)])) + else stopf(ngettext(sum(is.na(ansvals)), "column not found: %s", "columns not found: %s"), + brackify(ansvars[is.na(ansvals)]), domain=NA) } # else the NA in ansvals are for join inherited scope (test 1973), and NA could be in irows from join and data in i should be returned (test 1977) # in both cases leave to the R-level subsetting of i and x together further below @@ -783,7 +789,7 @@ replace_dot_alias = function(e) { tt = eval(bysub, parent.frame(), parent.frame()) if (!is.character(tt)) stopf("by=c(...), key(...) or names(...) must evaluate to 'character'") bysub=tt - } else if (is.call(bysub) && !(bysub[[1L]] %chin% c("list", "as.list", "{", ".", ":"))) { + } else if (is.call(bysub) && !(bysub %iscall% c("list", "as.list", "{", ".", ":"))) { # potential use of function, ex: by=month(date). catch it and wrap with "(", because we need to set "bysameorder" to FALSE as we don't know if the function will return ordered results just because "date" is ordered. Fixes #2670. bysub = as.call(c(as.name('('), list(bysub))) bysubl = as.list.default(bysub) @@ -892,7 +898,10 @@ replace_dot_alias = function(e) { } } tt = lengths(byval) - if (any(tt!=xnrow)) stopf("The items in the 'by' or 'keyby' list are length(s) %s. Each must be length %d; the same length as there are rows in x (after subsetting if i is provided).", brackify(tt), xnrow) + if (any(tt!=xnrow)) { + plural_part <- sprintf(ngettext(length(tt), "The item in the 'by' or 'keyby' list is length %s.", "The items in the 'by' or 'keyby' list have lengths %s."), brackify(tt)) + stopf("%s Each must be length %d; the same length as there are rows in x (after subsetting if i is provided).", plural_part, xnrow) + } if (is.null(bynames)) bynames = rep.int("",length(byval)) if (length(idx <- which(!nzchar(bynames))) && !bynull) { # TODO: improve this and unify auto-naming of jsub and bysub @@ -1031,7 +1040,7 @@ replace_dot_alias = function(e) { if (anyNA(.SDcols)) stopf(".SDcols missing at the following indices: %s", brackify(which(is.na(.SDcols)))) if (is.logical(.SDcols)) { - if (length(.SDcols)!=length(x)) stopf(".SDcols is a logical vector length %d but there are %d columns", length(.SDcols), length(x)) + if (length(.SDcols)!=length(x)) stopf(".SDcols is a logical vector of length %d but there are %d columns", length(.SDcols), length(x)) ansvals = which_(.SDcols, !negate_sdcols) ansvars = sdvars = names_x[ansvals] } else if (is.numeric(.SDcols)) { @@ -1111,7 +1120,10 @@ replace_dot_alias = function(e) { if (is.null(names(jsub))) { # regular LHS:=RHS usage, or `:=`(...) with no named arguments (an error) # `:=`(LHS,RHS) is valid though, but more because can't see how to detect that, than desire - if (length(jsub)!=3L) stopf("In %s(col1=val1, col2=val2, ...) form, all arguments must be named.", if (root == "let") "let" else "`:=`") + this_call = if (root == "let") "let" else "`:=`" + .check_nested_walrus(jsub, 2:length(jsub), this_call) + if (length(jsub) != 3L) + stopf("In %s(col1=val1, col2=val2, ...) form, all arguments must be named.", this_call) lhs = jsub[[2L]] jsub = jsub[[3L]] if (is.name(lhs)) { @@ -1131,11 +1143,12 @@ replace_dot_alias = function(e) { if (!all(named_idx <- nzchar(lhs))) { # friendly error for common case: trailing terminal comma n_lhs = length(lhs) - root_name <- if (root == "let") "let" else "`:=`" + this_call <- if (root == "let") "let" else "`:=`" + .check_nested_walrus(jsub, which(!named_idx)+1L, this_call) if (!named_idx[n_lhs] && all(named_idx[-n_lhs])) { - stopf("In %s(col1=val1, col2=val2, ...) form, all arguments must be named, but the last argument has no name. Did you forget a trailing comma?", root_name) + stopf("In %s(col1=val1, col2=val2, ...) form, all arguments must be named, but the last argument has no name. Did you forget a trailing comma?", this_call) } else { - stopf("In %s(col1=val1, col2=val2, ...) form, all arguments must be named, but these arguments lack names: %s.", root_name, brackify(which(!named_idx))) + stopf("In %s(col1=val1, col2=val2, ...) form, all arguments must be named, but these arguments lack names: %s.", this_call, brackify(which(!named_idx))) } } names(jsub)="" @@ -1382,10 +1395,14 @@ replace_dot_alias = function(e) { if (jcpy) jval = copy(jval) } else if (address(jval) == address(SDenv$.SD)) { jval = copy(jval) - } else if ( length(jcpy <- which(vapply_1c(jval, address) %chin% vapply_1c(SDenv, address))) ) { - for (jidx in jcpy) { if(!is.null(jval[[jidx]])) jval[[jidx]] = copy(jval[[jidx]]) } - } else if (jsub %iscall% 'get') { - jval = copy(jval) # fix for #1212 + } else { + sd_addresses = vapply_1c(SDenv, address) + jcpy = which(!vapply_1b(jval, is.null) & vapply_1c(jval, address) %chin% sd_addresses) + if (length(jcpy)) { + for (jidx in jcpy) jval[[jidx]] = copy(jval[[jidx]]) + } else if (address(jval) %chin% sd_addresses) { + jval = copy(jval) # fix for #4877, includes fix for #1212 + } } } @@ -1697,12 +1714,30 @@ replace_dot_alias = function(e) { deparse_ans = .massageSD(this) funi = funi + 1L # Fix for #985 jsubl[[i_]] = as.list(deparse_ans[[1L]][-1L]) # just keep the '.' from list(.) - jvnames = c(jvnames, deparse_ans[[2L]]) + jn__ = deparse_ans[[2L]] + if (isTRUE(nzchar(names(jsubl)[i_]))) { + # Fix for #2311, prepend named arguments of c() to column names of .SD + # e.g. c(mean=lapply(.SD, mean)) + jn__ = paste(names(jsubl)[i_], jn__, sep=".") # sep="." for consistency with c(A=list(a=1,b=1)) + } + jvnames = c(jvnames, jn__) } else if (this[[1L]] == "list") { # also handle c(lapply(.SD, sum), list()) - silly, yes, but can happen if (length(this) > 1L) { jl__ = as.list(jsubl[[i_]])[-1L] # just keep the '.' from list(.) - jn__ = if (is.null(names(jl__))) rep("", length(jl__)) else names(jl__) + if (isTRUE(nzchar(names(jsubl)[i_]))) { + # Fix for #2311, prepend named list arguments of c() to that list's names. See tests 2283.* + njl__ = if (is.null(names(jl__))) rep("", length(jl__)) else names(jl__) + njl__nonblank = nzchar(names(jl__)) + if (length(jl__) > 1L) { + jn__ = paste0(names(jsubl)[i_], seq_along(jl__)) + } else { + jn__ = names(jsubl)[i_] + } + jn__[njl__nonblank] = paste(names(jsubl)[i_], njl__[njl__nonblank], sep=".") + } else { + jn__ = if (is.null(names(jl__))) rep("", length(jl__)) else names(jl__) + } idx = unlist(lapply(jl__, function(x) is.name(x) && x == ".I")) if (any(idx)) jn__[idx & !nzchar(jn__)] = "I" # this & is correct not && @@ -1967,7 +2002,10 @@ replace_dot_alias = function(e) { if (any(ww)) jvnames[ww] = paste0("V",ww) setattr(ans, "names", c(bynames, jvnames)) } else { - setnames(ans,seq_along(bynames),bynames) # TO DO: reinvestigate bynames flowing from dogroups here and simplify + nonbynames = names(ans)[-seq_along(bynames)] #related to 2311. make naming of empty columns names more consistent + ww = which(!nzchar(nonbynames)) + if (length(ww)) nonbynames[ww] = paste0("V", ww) + setattr(ans, "names", c(bynames, nonbynames)) # TO DO: reinvestigate bynames flowing from dogroups here and simplify } if (byjoin && keyby && !bysameorder) { if (verbose) {last.started.at=proc.time();catf("setkey() afterwards for keyby=.EACHI ... ");flush.console()} @@ -2218,8 +2256,8 @@ tail.data.table = function(x, n=6L, ...) { "$<-.data.table" = function(x, name, value) { if (!cedta()) { - ans = `$<-.data.frame`(x, name, value) - return(setalloccol(ans)) # over-allocate (again) + ans = `$<-.data.frame`(x, name, value) # nocov + return(setalloccol(ans)) # nocov. over-allocate (again) } x = copy(x) set(x,j=name,value=value) # important i is missing here @@ -2392,7 +2430,7 @@ which_ = function(x, bool = TRUE) { } is.na.data.table = function(x) { - if (!cedta()) return(is.na.data.frame(x)) + if (!cedta()) return(is.na.data.frame(x)) # nocov do.call(cbind, lapply(x, is.na)) } @@ -2699,8 +2737,8 @@ setnames = function(x,old,new,skip_absent=FALSE) { setcolorder = function(x, neworder=key(x), before=NULL, after=NULL) # before/after #4358 { - if (is.character(neworder) && anyDuplicated(names(x))) - stopf("x has some duplicated column name(s): %s. Please remove or rename the duplicate(s) and try again.", brackify(unique(names(x)[duplicated(names(x))]))) + if (is.character(neworder)) + check_duplicate_names(x) if (!is.null(before) && !is.null(after)) stopf("Provide either before= or after= but not both") if (length(before)>1L || length(after)>1L) @@ -2760,7 +2798,7 @@ cbind.data.table = data.table rbindlist = function(l, use.names="check", fill=FALSE, idcol=NULL, ignore.attr=FALSE) { if (is.null(l)) return(null.data.table()) - if (!is.list(l) || is.data.frame(l)) stopf("Input is %s but should be a plain list of items to be stacked", class(l)[1L]) + if (!is.list(l) || is.data.frame(l)) stopf("Input is %s but should be a plain list of items to be stacked", class1(l)) if (isFALSE(idcol)) { idcol = NULL } else if (!is.null(idcol)) { if (isTRUE(idcol)) idcol = ".id" @@ -3003,6 +3041,13 @@ rleidv = function(x, cols=seq_along(x), prefix=NULL) { ids } +.is_withFALSE_range = function(e, x, root=root_name(e), vars=all.vars(e)) { + if (root != ":") return(FALSE) + if (!length(vars)) return(TRUE) # e.g. 1:10 + if (!all(vars %chin% names(x))) return(TRUE) # e.g. 1:ncol(x) + is.name(e[[1L]]) && is.name(e[[2L]]) # e.g. V1:V2, but not min(V1):max(V2) or 1:max(V2) +} + # GForce functions # to add a new function to GForce (from the R side -- the easy part!): # (1) add it to gfuns @@ -3123,6 +3168,11 @@ is_constantish = function(q, check_singleton=FALSE) { q } +.check_nested_walrus = function(e, check_entries, call_name) { + for (jj in check_entries) if (e[[jj]] %iscall% ":=") + stopf("It looks like you re-used `:=` in argument %d a functional assignment call -- use `=` instead: %s(col1=val1, col2=val2, ...)", jj-1L, call_name) +} + .prepareFastSubset = function(isub, x, enclos, notjoin, verbose = FALSE){ ## helper that decides, whether a fast binary search can be performed, if i is a call ## For details on the supported queries, see \code{\link{datatable-optimize}} diff --git a/R/devel.R b/R/devel.R index 3aed1017f..3807a6205 100644 --- a/R/devel.R +++ b/R/devel.R @@ -36,12 +36,12 @@ update_dev_pkg = function(pkg="data.table", repo="https://Rdatatable.gitlab.io/d if (upg) { unloadNamespace(pkg) ## hopefully will release dll lock on Windows utils::install.packages(pkg, repos=repo, type=type, lib=lib, ...) + msg_fmt = gettext("R %s package has been updated to %s (%s)\n") + } else { + msg_fmt = gettext("R %s package is up-to-date at %s (%s)\n") } - cat(sprintf("R %s package %s %s (%s)\n", - pkg, - c("is up-to-date at","has been updated to")[upg+1L], - unname(read.dcf(system.file("DESCRIPTION", package=pkg, lib.loc=lib, mustWork=TRUE), fields=field)[, field]), - utils::packageVersion(pkg, lib.loc=lib))) + field_val = unname(read.dcf(system.file("DESCRIPTION", package=pkg, lib.loc=lib, mustWork=TRUE), fields=field)[, field]) + cat(sprintf(msg_fmt, pkg, field_val, utils::packageVersion(pkg, lib.loc=lib))) }) invisible(upg) } diff --git a/R/duplicated.R b/R/duplicated.R index 0aad2ebdd..12c53f934 100644 --- a/R/duplicated.R +++ b/R/duplicated.R @@ -102,7 +102,7 @@ anyDuplicated.data.table = function(x, incomparables=FALSE, fromLast=FALSE, by=s uniqueN = function(x, by = if (is.list(x)) seq_along(x) else NULL, na.rm=FALSE) { # na.rm, #1455 if (is.null(x)) return(0L) if (!is.atomic(x) && !is.data.frame(x)) - stopf("x must be an atomic vector or data.frames/data.tables") + stopf("x must be an atomic vector or a data.frame/data.table") if (is.atomic(x)) { if (is.logical(x)) return(.Call(CuniqueNlogical, x, na.rm=na.rm)) x = as_list(x) diff --git a/R/fcast.R b/R/fcast.R index 58873c1f4..ac7b5f218 100644 --- a/R/fcast.R +++ b/R/fcast.R @@ -17,8 +17,8 @@ dcast <- function( else { data_name = deparse(substitute(data)) ns = tryCatch(getNamespace("reshape2"), error=function(e) - stopf("The %1$s generic in data.table has been passed a %2$s, but data.table::%1$s currently only has a method for data.tables. Please confirm your input is a data.table, with setDT(%3$s) or as.data.table(%3$s). If you intend to use a method from reshape2, try installing that package first, but do note that reshape2 is superseded and is no longer actively developed.", "dcast", class(data)[1L], data_name)) - warningf("The %1$s generic in data.table has been passed a %2$s and will attempt to redirect to the relevant reshape2 method; please note that reshape2 is superseded and is no longer actively developed, and this redirection is now deprecated. Please do this redirection yourself like reshape2::%1$s(%3$s). In the next version, this warning will become an error.", "dcast", class(data)[1L], data_name) + stopf("The %1$s generic in data.table has been passed a %2$s, but data.table::%1$s currently only has a method for data.tables. Please confirm your input is a data.table, with setDT(%3$s) or as.data.table(%3$s). If you intend to use a method from reshape2, try installing that package first, but do note that reshape2 is superseded and is no longer actively developed.", "dcast", class1(data), data_name)) + warningf("The %1$s generic in data.table has been passed a %2$s and will attempt to redirect to the relevant reshape2 method; please note that reshape2 is superseded and is no longer actively developed, and this redirection is now deprecated. Please do this redirection yourself like reshape2::%1$s(%3$s). In the next version, this warning will become an error.", "dcast", class1(data), data_name) ns$dcast(data, formula, fun.aggregate = fun.aggregate, ..., margins = margins, subset = subset, fill = fill, value.var = value.var) } @@ -192,7 +192,7 @@ dcast.data.table = function(data, formula, fun.aggregate = NULL, sep = "_", ..., fun.call = aggregate_funs(fun.call, lvals, sep, ...) maybe_err = function(list.of.columns) { if (!all(lengths(list.of.columns) == 1L)) { - msg <- gettext("Aggregating function(s) should take a vector as input and return a single value (length=1), but they do not, so the result is undefined. Please fix by modifying your function so that a single value is always returned.") + msg <- gettext("Aggregating functions should take a vector as input and return a single value (length=1), but they do not, so the result is undefined. Please fix by modifying your function so that a single value is always returned.") if (is.null(fill)) { # TODO change to always stopf #6329 stop(msg, domain=NA, call. = FALSE) } else { diff --git a/R/fmelt.R b/R/fmelt.R index c7d2661bd..c0cc47e9c 100644 --- a/R/fmelt.R +++ b/R/fmelt.R @@ -13,8 +13,8 @@ melt.default = function(data, ..., na.rm = FALSE, value.name = "value") { # nocov start data_name = deparse(substitute(data)) ns = tryCatch(getNamespace("reshape2"), error=function(e) - stopf("The %1$s generic in data.table has been passed a %2$s, but data.table::%1$s currently only has a method for data.tables. Please confirm your input is a data.table, with setDT(%3$s) or as.data.table(%3$s). If you intend to use a method from reshape2, try installing that package first, but do note that reshape2 is superseded and is no longer actively developed.", "melt", class(data)[1L], data_name)) - warningf("The %1$s generic in data.table has been passed a %2$s and will attempt to redirect to the relevant reshape2 method; please note that reshape2 is superseded and is no longer actively developed, and this redirection is now deprecated. To continue using melt methods from reshape2 while both libraries are attached, e.g. melt.list, you can prepend the namespace, i.e. reshape2::%1$s(%3$s). In the next version, this warning will become an error.", "melt", class(data)[1L], data_name) + stopf("The %1$s generic in data.table has been passed a %2$s, but data.table::%1$s currently only has a method for data.tables. Please confirm your input is a data.table, with setDT(%3$s) or as.data.table(%3$s). If you intend to use a method from reshape2, try installing that package first, but do note that reshape2 is superseded and is no longer actively developed.", "melt", class1(data), data_name)) + warningf("The %1$s generic in data.table has been passed a %2$s and will attempt to redirect to the relevant reshape2 method; please note that reshape2 is superseded and is no longer actively developed, and this redirection is now deprecated. To continue using melt methods from reshape2 while both packages are attached, e.g. melt.list, you can prepend the namespace, i.e. reshape2::%1$s(%3$s). In the next version, this warning will become an error.", "melt", class1(data), data_name) ns$melt(data, ..., na.rm=na.rm, value.name=value.name) # nocov end } @@ -22,13 +22,16 @@ melt.default = function(data, ..., na.rm = FALSE, value.name = "value") { patterns = function(..., cols=character(0L), ignore.case=FALSE, perl=FALSE, fixed=FALSE, useBytes=FALSE) { # if ... has no names, names(list(...)) will be ""; # this assures they'll be NULL instead + if (!is.character(cols) || anyNA(cols)) { + stopf("cols must be a character vector of column names") + } L = list(...) p = unlist(L, use.names = any(nzchar(names(L)))) if (!is.character(p)) stopf("Input patterns must be of type character.") - matched = lapply(p, grep, cols, ignore.case=ignore.case, perl=perl, fixed=fixed, useBytes=useBytes) + matched = lapply(p, grep, cols, ignore.case=ignore.case, perl=perl, fixed=fixed, useBytes=useBytes, value=TRUE) if (length(idx <- which(lengths(matched) == 0L))) - stopf('Pattern(s) not found: [%s]', brackify(p[idx])) + stopf(ngettext(length(idx), 'Pattern not found: [%s]', 'Patterns not found: [%s]'), brackify(p[idx]), domain=NA) if (length(matched) == 1L) return(matched[[1L]]) matched } @@ -61,14 +64,11 @@ measure = function(..., sep="_", pattern, cols, multiple.keyword="value.name") { } fun.list[[fun.i]] = fun } - measurev.args = c( - list(fun.list), - L[formal.i.vec], - list(group.desc="... arguments to measure")) + measurev.args = c(list(fun.list), L[formal.i.vec]) do.call(measurev, measurev.args) } -measurev = function(fun.list, sep="_", pattern, cols, multiple.keyword="value.name", group.desc="elements of fun.list"){ +measurev = function(fun.list, sep="_", pattern, cols, multiple.keyword="value.name"){ # 1. basic error checking. if (!missing(sep) && !missing(pattern)) { stopf("both sep and pattern arguments used; must use either sep or pattern (not both)") @@ -85,21 +85,11 @@ measurev = function(fun.list, sep="_", pattern, cols, multiple.keyword="value.na which(!nzchar(names(fun.list))) } if (length(prob.i)) { - stopf("in measurev, %s must be named, problems: %s", group.desc, brackify(prob.i)) - } - err.names.unique = function(err.what, name.vec) { - name.tab = table(name.vec) - bad.counts = name.tab[1 < name.tab] - if (length(bad.counts)) { - stopf("%s should be uniquely named, problems: %s", err.what, brackify(names(bad.counts))) - } + stopf("in measurev, elements of fun.list must be named, problems: %s", brackify(prob.i)) } - err.args.groups = function(type, N){ - if (N != length(fun.list)) { - stopf("number of %s =%d must be same as %s =%d", group.desc, length(fun.list), type, N) - } + if (length(dup.funs <- duplicated_values(names(fun.list)))) { + stopf("elements of fun.list should be uniquely named, problems: %s", brackify(dup.funs)) } - err.names.unique(group.desc, names(fun.list)) # 2. compute initial group data table, used as variable_table attribute. group.mat = if (!missing(pattern)) { if (!is.character(pattern)) { @@ -114,7 +104,9 @@ measurev = function(fun.list, sep="_", pattern, cols, multiple.keyword="value.na if (is.null(start)) { stopf("pattern must contain at least one capture group (parenthesized sub-pattern)") } - err.args.groups("number of capture groups in pattern", ncol(start)) + if (ncol(start) != length(fun.list)) { + stopf("number of elements of fun.list (%d) must be the same as the number of capture groups in pattern (%d)", length(fun.list), ncol(start)) + } end = attr(match.vec, "capture.length")[measure.vec.i,]+start-1L measure.vec <- cols[measure.vec.i] names.mat = matrix(measure.vec, nrow(start), ncol(start)) @@ -129,12 +121,16 @@ measurev = function(fun.list, sep="_", pattern, cols, multiple.keyword="value.na if (n.groups == 1) { stopf("each column name results in only one item after splitting using sep, which means that all columns would be melted; to fix please either specify melt on all columns directly without using measure, or use a different sep/pattern specification") } - err.args.groups("max number of items after splitting column names", n.groups) + if (n.groups != length(fun.list)) { + stopf("number of elements of fun.list (%d) must be the same as the max number of items after splitting column names (%d)", length(fun.list), n.groups) + } measure.vec.i = which(vector.lengths==n.groups) measure.vec = cols[measure.vec.i] do.call(rbind, list.of.vectors[measure.vec.i]) } - err.names.unique("measured columns", measure.vec) + if (length(dup.measures <- duplicated_values(measure.vec))) { + stopf("measured columns should be uniquely named, problems: %s", brackify(dup.measures)) + } uniq.mat = unique(group.mat) if (nrow(uniq.mat) < nrow(group.mat)) { stopf("number of unique column IDs =%d is less than number of melted columns =%d; fix by changing pattern/sep", nrow(uniq.mat), nrow(group.mat)) @@ -165,7 +161,7 @@ measurev = function(fun.list, sep="_", pattern, cols, multiple.keyword="value.na # 4. compute measure.vars list or vector. if (multiple.keyword %in% names(fun.list)) {# multiple output columns. if (!is.character(group.dt[[multiple.keyword]])) { - stopf("%s column class=%s after applying conversion function, but must be character", multiple.keyword, class(group.dt[[multiple.keyword]])[1L]) + stopf("%s column class=%s after applying conversion function, but must be character", multiple.keyword, class1(group.dt[[multiple.keyword]])) } is.other = names(group.dt) != multiple.keyword if (!any(is.other)) { diff --git a/R/foverlaps.R b/R/foverlaps.R index 59a8e4319..dccd42191 100644 --- a/R/foverlaps.R +++ b/R/foverlaps.R @@ -44,10 +44,11 @@ foverlaps = function(x, y, by.x=if (!is.null(key(x))) key(x) else key(y), by.y=k stopf("Duplicate columns are not allowed in overlap joins. This may change in the future.") if (length(by.x) != length(by.y)) stopf("length(by.x) != length(by.y). Columns specified in by.x should correspond to columns specified in by.y and should be of same lengths.") - if (any(dup.x<-duplicated(names(x)))) #1730 - handling join possible but would require workarounds on setcolorder further, it is really better just to rename dup column - stopf("%s has some duplicated column name(s): %s. Please remove or rename the duplicate(s) and try again.", "x", brackify(unique(names(x)[dup.x]))) - if (any(dup.y<-duplicated(names(y)))) - stopf("%s has some duplicated column name(s): %s. Please remove or rename the duplicate(s) and try again.", "y", brackify(unique(names(y)[dup.y]))) + + #1730 - handling join possible but would require workarounds on setcolorder further, it is really better just to rename dup column + check_duplicate_names(x) + check_duplicate_names(y) + xnames = by.x; xintervals = tail(xnames, 2L) ynames = by.y; yintervals = tail(ynames, 2L) xval1 = x[[xintervals[1L]]]; xval2 = x[[xintervals[2L]]] diff --git a/R/fread.R b/R/fread.R index d45774b71..837324c1a 100644 --- a/R/fread.R +++ b/R/fread.R @@ -158,6 +158,7 @@ yaml=FALSE, autostart=NA, tmpdir=tempdir(), tz="UTC") } # whitespace at the beginning or end of na.strings is checked at C level and is an error there; test 1804 } + # nocov start. Tested in other.Rraw tests 16, not in the main suite. if (yaml) { if (!requireNamespace('yaml', quietly = TRUE)) stopf("'data.table' relies on the package 'yaml' to parse the file header; please add this to your library with install.packages('yaml') and try again.") # nocov @@ -267,6 +268,7 @@ yaml=FALSE, autostart=NA, tmpdir=tempdir(), tz="UTC") } if (is.integer(skip)) skip = skip + n_read } + # nocov end warnings2errors = getOption("warn") >= 2 stopifnot(identical(tz,"UTC") || identical(tz,"")) if (tz=="") { @@ -310,8 +312,14 @@ yaml=FALSE, autostart=NA, tmpdir=tempdir(), tz="UTC") # finally: methods::as(v, new_class)) }, - warning = fun <- function(e) { - warningf("Column '%s' was requested to be '%s' but fread encountered the following %s:\n\t%s\nso the column has been left as type '%s'", names(ans)[j], new_class, if (inherits(e, "error")) "error" else "warning", e$message, typeof(v)) + warning = fun <- function(c) { + # NB: branch here for translation purposes (e.g. if error/warning have different grammatical gender) + if (inherits(c, "warning")) { + msg_fmt <- gettext("Column '%s' was requested to be '%s' but fread encountered the following warning:\n\t%s\nso the column has been left as type '%s'") + } else { + msg_fmt <- gettext("Column '%s' was requested to be '%s' but fread encountered the following error:\n\t%s\nso the column has been left as type '%s'") + } + warningf(msg_fmt, names(ans)[j], new_class, conditionMessage(c), typeof(v), domain=NA) v }, error = fun) @@ -326,7 +334,9 @@ yaml=FALSE, autostart=NA, tmpdir=tempdir(), tz="UTC") } else { cols_to_factor = which(vapply_1b(ans, is.character)) } - if (verbose) catf("stringsAsFactors=%s converted %d column(s): %s\n", stringsAsFactors, length(cols_to_factor), brackify(names(ans)[cols_to_factor])) + if (verbose) + catf(ngettext(length(cols_to_factor), "stringsAsFactors=%s converted %d column: %s\n", "stringsAsFactors=%s converted %d columns: %s\n"), + stringsAsFactors, length(cols_to_factor), brackify(names(ans)[cols_to_factor]), domain=NA) for (j in cols_to_factor) set(ans, j=j, value=as_factor(.subset2(ans, j))) } @@ -339,7 +349,7 @@ yaml=FALSE, autostart=NA, tmpdir=tempdir(), tz="UTC") key = cols_from_csv(key) setkeyv(ans, key) } - if (yaml) setattr(ans, 'yaml_metadata', yaml_header) + if (yaml) setattr(ans, 'yaml_metadata', yaml_header) # nocov if (!is.null(index) && data.table) { if (!all(vapply_1b(index, is.character))) stopf("index argument of data.table() must be a character vector naming columns (NB: col.names are applied before this)") diff --git a/R/fwrite.R b/R/fwrite.R index ad92859f3..d67c886d1 100644 --- a/R/fwrite.R +++ b/R/fwrite.R @@ -91,6 +91,7 @@ fwrite = function(x, file="", append=FALSE, quote="auto", return(invisible()) } } + # nocov start. See test 17 in other.Rraw, not tested in the main suite. yaml = if (!yaml) "" else { if (!requireNamespace('yaml', quietly=TRUE)) stopf("'data.table' relies on the package 'yaml' to write the file header; please add this to your library with install.packages('yaml') and try again.") # nocov @@ -114,6 +115,7 @@ fwrite = function(x, file="", append=FALSE, quote="auto", ) paste0('---', eol, yaml::as.yaml(yaml_header, line.sep=eol), '---', eol) # NB: as.yaml adds trailing newline } + # nocov end file = enc2native(file) # CfwriteR cannot handle UTF-8 if that is not the native encoding, see #3078. .Call(CfwriteR, x, file, sep, sep2, eol, na, dec, quote, qmethod=="escape", append, row.names, col.names, logical01, scipen, dateTimeAs, buffMB, nThread, diff --git a/R/groupingsets.R b/R/groupingsets.R index 96940497c..e3972140b 100644 --- a/R/groupingsets.R +++ b/R/groupingsets.R @@ -1,7 +1,7 @@ rollup = function(x, ...) { UseMethod("rollup") } -rollup.data.table = function(x, j, by, .SDcols, id = FALSE, ...) { +rollup.data.table = function(x, j, by, .SDcols, id = FALSE, label = NULL, ...) { # input data type basic validation if (!is.data.table(x)) stopf("Argument 'x' must be a data.table object") @@ -13,13 +13,13 @@ rollup.data.table = function(x, j, by, .SDcols, id = FALSE, ...) { sets = lapply(length(by):0L, function(i) by[0L:i]) # redirect to workhorse function jj = substitute(j) - groupingsets.data.table(x, by=by, sets=sets, .SDcols=.SDcols, id=id, jj=jj) + groupingsets.data.table(x, by=by, sets=sets, .SDcols=.SDcols, id=id, jj=jj, label=label) } cube = function(x, ...) { UseMethod("cube") } -cube.data.table = function(x, j, by, .SDcols, id = FALSE, ...) { +cube.data.table = function(x, j, by, .SDcols, id = FALSE, label = NULL, ...) { # input data type basic validation if (!is.data.table(x)) stopf("Argument 'x' must be a data.table object") @@ -35,13 +35,13 @@ cube.data.table = function(x, j, by, .SDcols, id = FALSE, ...) { sets = lapply((2L^n):1L, function(jj) by[keepBool[jj, ]]) # redirect to workhorse function jj = substitute(j) - groupingsets.data.table(x, by=by, sets=sets, .SDcols=.SDcols, id=id, jj=jj) + groupingsets.data.table(x, by=by, sets=sets, .SDcols=.SDcols, id=id, jj=jj, label=label) } groupingsets = function(x, ...) { UseMethod("groupingsets") } -groupingsets.data.table = function(x, j, by, sets, .SDcols, id = FALSE, jj, ...) { +groupingsets.data.table = function(x, j, by, sets, .SDcols, id = FALSE, jj, label = NULL, ...) { # input data type basic validation if (!is.data.table(x)) stopf("Argument 'x' must be a data.table object") @@ -57,6 +57,14 @@ groupingsets.data.table = function(x, j, by, sets, .SDcols, id = FALSE, jj, ...) stopf("Argument 'sets' must be a list of character vectors.") if (!is.logical(id)) stopf("Argument 'id' must be a logical scalar.") + if (!(is.null(label) || + (is.atomic(label) && length(label) == 1L) || + (is.list(label) && all(vapply_1b(label, is.atomic)) && all(lengths(label) == 1L) && !is.null(names(label))))) + stopf("Argument 'label', if not NULL, must be a scalar or a named list of scalars.") + if (is.list(label) && !is.null(names(label)) && ("" %chin% names(label) || anyNA(names(label)))) + stopf("When argument 'label' is a list, all of the list elements must be named.") + if (is.list(label) && anyDuplicated(names(label))) + stopf("When argument 'label' is a list, the element names must not contain duplicates.") # logic constraints validation if (!all((sets.all.by <- unique(unlist(sets))) %chin% by)) stopf("All columns used in 'sets' argument must be in 'by' too. Columns used in 'sets' but not present in 'by': %s", brackify(setdiff(sets.all.by, by))) @@ -66,6 +74,35 @@ groupingsets.data.table = function(x, j, by, sets, .SDcols, id = FALSE, jj, ...) stopf("Character vectors in 'sets' list must not have duplicated column names within a single grouping set.") if (length(sets) > 1L && (idx<-anyDuplicated(lapply(sets, sort)))) warningf("'sets' contains a duplicate (i.e., equivalent up to sorting) element at index %d; as such, there will be duplicate rows in the output -- note that grouping by A,B and B,A will produce the same aggregations. Use `sets=unique(lapply(sets, sort))` to eliminate duplicates.", idx) + if (is.list(label)) { + other.allowed.names = c("character", "integer", "numeric", "factor", "Date", "IDate") + allowed.label.list.names = c(by, classes1(.shallow(x, by)), other.allowed.names) + label.names = names(label) + if (!all(label.names %in% allowed.label.list.names)) + stopf("When argument 'label' is a list, all element names must be (1) in 'by', or (2) the first element of the class in the data.table 'x' of a variable in 'by', or (3) one of %s. Element names not satisfying this condition: %s", + brackify(other.allowed.names), brackify(setdiff(label.names, allowed.label.list.names))) + label.classes = lapply(label, class) + label.names.in.by = intersect(label.names, by) + label.names.not.in.by = setdiff(label.names, label.names.in.by) + label.names.in.by.classes = label.classes[label.names.in.by] + x.label.names.in.by.classes = lapply(.shallow(x, label.names.in.by), class) + label.names.not.in.by.classes1 = vapply_1c(label.classes[label.names.not.in.by], function(u) u[1]) + if (!all(idx <- mapply(identical, label.names.in.by.classes, x.label.names.in.by.classes))) { + info = gettextf( + "%s (label: %s; data: %s)", + label.names.in.by[!idx], + vapply_1c(label.names.in.by.classes[!idx], toString), + vapply_1c(x.label.names.in.by.classes[!idx], toString)) + stopf("When argument 'label' is a list, the class of each 'label' element with name in 'by' must match the class of the corresponding column of the data.table 'x'. Class mismatch for: %s", brackify(info)) + } + if (!all(idx <- label.names.not.in.by == label.names.not.in.by.classes1)) { + info = gettextf( + "(label name: %s; label class[1]: %s)", + label.names.not.in.by[!idx], + label.names.not.in.by.classes1[!idx]) + stopf("When argument 'label' is a list, the name of each element of 'label' not in 'by' must match the first element of the class of the element value. Mismatches: %s", brackify(info)) + } + } # input arguments handling jj = if (!missing(jj)) jj else substitute(j) av = all.vars(jj, TRUE) @@ -85,6 +122,27 @@ groupingsets.data.table = function(x, j, by, sets, .SDcols, id = FALSE, jj, ...) set(empty, j = "grouping", value = integer()) setcolorder(empty, c("grouping", by, setdiff(names(empty), c("grouping", by)))) } + # Define variables related to label + if (!is.null(label)) { + total.vars = intersect(by, unlist(lapply(sets, function(u) setdiff(by, u)))) + if (is.list(label)) { + by.vars.not.in.label = setdiff(by, names(label)) + by.vars.not.in.label.class1 = classes1(x, use.names=TRUE)[by.vars.not.in.label] + labels.by.vars.not.in.label = label[by.vars.not.in.label.class1[by.vars.not.in.label.class1 %in% label.names.not.in.by]] + names(labels.by.vars.not.in.label) <- by.vars.not.in.label[by.vars.not.in.label.class1 %in% label.names.not.in.by] + label.expanded = c(label[label.names.in.by], labels.by.vars.not.in.label) + label.expanded = label.expanded[intersect(by, names(label.expanded))] # reorder + } else { + by.vars.matching.scalar.class1 = by[classes1(x, use.names=TRUE)[by] == class1(label)] + label.expanded = as.list(rep(label, length(by.vars.matching.scalar.class1))) + names(label.expanded) <- by.vars.matching.scalar.class1 + } + label.use = label.expanded[intersect(total.vars, names(label.expanded))] + if (any(idx <- vapply_1b(names(label.expanded), function(u) label.expanded[[u]] %in% x[[u]]))) { + info = gettextf("%s (label: %s)", names(label.expanded)[idx], vapply_1c(label.expanded[idx], as.character)) + warningf("For the following variables, the 'label' value was already in the data: %s", brackify(info)) + } + } # workaround for rbindlist fill=TRUE on integer64 #1459 int64.cols = vapply_1b(empty, inherits, "integer64") int64.cols = names(int64.cols)[int64.cols] @@ -105,6 +163,8 @@ groupingsets.data.table = function(x, j, by, sets, .SDcols, id = FALSE, jj, ...) missing.int64.by.cols = setdiff(int64.by.cols, by.set) if (length(missing.int64.by.cols)) r[, (missing.int64.by.cols) := bit64::as.integer64(NA)] } + if (!is.null(label) && length(by.label.use.vars <- intersect(setdiff(by, by.set), names(label.use))) > 0L) + r[, (by.label.use.vars) := label.use[by.label.use.vars]] r } # actually processing everything here diff --git a/R/last.R b/R/last.R index 0a889e622..a93ec3173 100644 --- a/R/last.R +++ b/R/last.R @@ -1,6 +1,7 @@ # data.table defined last(x) with no arguments, just for last. If you need the last 10 then use tail(x,10). # for xts class objects it will dispatch to xts::last # reworked to avoid loading xts namespace (#3857) then again to fix dispatching of xts class (#4053) +# nocov start. Tests 19.* in other.Rraw, not in the main suite. last = function(x, n=1L, ...) { verbose = isTRUE(getOption("datatable.verbose", FALSE)) if (!inherits(x, "xts")) { @@ -82,3 +83,4 @@ first = function(x, n=1L, ...) { xts::first(x, n=n, ...) } } +# nocov end diff --git a/R/merge.R b/R/merge.R index 025488740..ab93d5498 100644 --- a/R/merge.R +++ b/R/merge.R @@ -21,10 +21,11 @@ merge.data.table = function(x, y, by = NULL, by.x = NULL, by.y = NULL, all = FAL else warningf("Input data.table '%s' has no columns.", "y") } + check_duplicate_names(x) + check_duplicate_names(y) + nm_x = names(x) nm_y = names(y) - if (anyDuplicated(nm_x)) stopf("%s has some duplicated column name(s): %s. Please remove or rename the duplicate(s) and try again.", "x", brackify(nm_x[duplicated(nm_x)])) - if (anyDuplicated(nm_y)) stopf("%s has some duplicated column name(s): %s. Please remove or rename the duplicate(s) and try again.", "y", brackify(nm_y[duplicated(nm_y)])) ## set up 'by'/'by.x'/'by.y' if ( (!is.null(by.x) || !is.null(by.y)) && length(by.x)!=length(by.y) ) diff --git a/R/onAttach.R b/R/onAttach.R index 7a4a9be3e..d8393d7a6 100644 --- a/R/onAttach.R +++ b/R/onAttach.R @@ -24,8 +24,12 @@ else packageStartupMessagef("data.table %s using %d threads (see ?getDTthreads). ", v, nth, appendLF=FALSE) packageStartupMessagef("Latest news: r-datatable.com") - if (gettext("TRANSLATION CHECK") != "TRANSLATION CHECK") - packageStartupMessagef("**********\nRunning data.table in English; package support is available in English only. When searching for online help, be sure to also check for the English error message. This can be obtained by looking at the po/R-.po and po/.po files in the package source, where the native language and English error messages can be found side-by-side\n**********") + if (gettext("TRANSLATION CHECK") != "TRANSLATION CHECK") { + packageStartupMessagef( + "**********\nRunning data.table in English; package support is available in English only. When searching for online help, be sure to also check for the English error message. This can be obtained by looking at the po/R-.po and po/.po files in the package source, where the native language and English error messages can be found side-by-side.%s\n**********", + if (exists('Sys.setLanguage', envir=baseenv())) " You can also try calling Sys.setLanguage('en') prior to reproducing the error message." else "" + ) + } if (dev && (Sys.Date() - as.Date(d))>28L) packageStartupMessagef("**********\nThis development version of data.table was built more than 4 weeks ago. Please update: data.table::update_dev_pkg()\n**********") if (!.Call(ChasOpenMP)) { diff --git a/R/onLoad.R b/R/onLoad.R index 01b159f77..ef96849e8 100644 --- a/R/onLoad.R +++ b/R/onLoad.R @@ -24,7 +24,8 @@ if (dllV != RV) { dll = if (.Platform$OS.type=="windows") "dll" else "so" # https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17478 - stopf("The data_table.%s version (%s) does not match the package (%s). Please close all R sessions to release the old %s and reinstall data.table in a fresh R session. The root cause is that R's package installer can in some unconfirmed circumstances leave a package in a state that is apparently functional but where new R code is calling old C code silently: https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17478. Once a package is in this mismatch state it may produce wrong results silently until you next upgrade the package. Please help by adding precise circumstances to 17478 to move the status to confirmed. This mismatch between R and C code can happen with any package not just data.table. It is just that data.table has added this check.", dll, dllV, RV, toupper(dll)) + # TODO(R>=4.0.0): Remove or adjust this message once we're sure all users are unaffected + stopf("The data_table.%s version (%s) does not match the package (%s). Please close all R sessions to release the old %s and reinstall data.table in a fresh R session. Prior to R version 3.6.0 patched, R's package installer could leave a package in an apparently functional state where new R code was calling old C code silently: https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17478. Once a package is in this mismatch state it may produce wrong results silently until you next upgrade the package. This mismatch between R and C code can happen with any package not just data.table. It is just that data.table has added this check.", dll, dllV, RV, toupper(dll)) } builtPath = system.file("Meta", "package.rds", package="data.table") if (builtPath != "" && !identical(session_r_version>="4.0.0", (build_r_version <- readRDS(builtPath)$Built$R)>="4.0.0")) { @@ -43,7 +44,7 @@ # If R 3.6.2 (not yet released) includes the c|rbind S3 dispatch fix, then this workaround still works. tt = base::cbind.data.frame ss = body(tt) - if (class(ss)[1L]!="{") ss = as.call(c(as.name("{"), ss)) + if (class1(ss) != "{") ss = as.call(c(as.name("{"), ss)) prefix = if (!missing(pkgname)) "data.table::" else "" # R provides the arguments when it calls .onLoad, I don't in dev/test if (!length(grep("data.table", ss[[2L]], fixed = TRUE))) { ss = ss[c(1L, NA, 2L:length(ss))] @@ -55,7 +56,7 @@ } tt = base::rbind.data.frame ss = body(tt) - if (class(ss)[1L]!="{") ss = as.call(c(as.name("{"), ss)) + if (class1(ss) != "{") ss = as.call(c(as.name("{"), ss)) if (!length(grep("data.table", ss[[2L]], fixed = TRUE))) { ss = ss[c(1L, NA, 2L:length(ss))] ss[[2L]] = parse(text=paste0("for (x in list(...)) { if (inherits(x,'data.table')) return(",prefix,".rbind.data.table(...)) }"))[[1L]] # fix for #89 diff --git a/R/print.data.table.R b/R/print.data.table.R index 280582c5e..0bebfce9a 100644 --- a/R/print.data.table.R +++ b/R/print.data.table.R @@ -103,7 +103,7 @@ print.data.table = function(x, topn=getOption("datatable.print.topn"), factor = "", POSIXct = "", logical = "", IDate = "", integer64 = "", raw = "", expression = "", ordered = "") - classes = vapply_1c(x, function(col) class(col)[1L], use.names=FALSE) + classes = classes1(x) abbs = unname(class_abb[classes]) if ( length(idx <- which(is.na(abbs))) ) abbs[idx] = paste0("<", classes[idx], ">") toprint = rbind(abbs, toprint) @@ -233,7 +233,7 @@ format_list_item.default = function(x, ...) { # format_list_item would not be reached) but this particular list item does have a format method so use it formatted } else { - paste0("<", class(x)[1L], paste_dims(x), ">") + paste0("<", class1(x), paste_dims(x), ">") } } @@ -283,7 +283,8 @@ trunc_cols_message = function(not_printed, abbs, class, col.names){ n = length(not_printed) if (class && col.names != "none") classes = paste0(" ", tail(abbs, n)) else classes = "" catf( - "%d variable(s) not shown: %s\n", - n, brackify(paste0(not_printed, classes)) + ngettext(n, "%d variable not shown: %s\n", "%d variables not shown: %s\n"), + n, brackify(paste0(not_printed, classes)), + domain=NA ) } diff --git a/R/rowwiseDT.R b/R/rowwiseDT.R new file mode 100644 index 000000000..81114ead6 --- /dev/null +++ b/R/rowwiseDT.R @@ -0,0 +1,23 @@ +rowwiseDT = function(...) { + x = substitute(list(...))[-1L] + if (is.null(nms <- names(x))) + stopf("Must provide at least one column (use `name=`). See ?rowwiseDT for details") + header_pos = which(nzchar(nms)) + if (any(nzchar(x[header_pos]))) + stopf("Named arguments must be empty") + if (!identical(header_pos, seq_along(header_pos))) + stopf("Header must be the first N arguments") + header = nms[header_pos] + ncols = length(header) + body = lapply(x[-header_pos], eval, envir = parent.frame()) + nrows = length(body) %/% ncols + if (length(body) != nrows * ncols) + stopf("There are %d columns but the number of cells is %d, which is not an integer multiple of the columns", ncols, length(body)) + # make all the non-scalar elements to a list + needs_list = lengths(body) != 1L + body[needs_list] = lapply(body[needs_list], list) + body = split(body, rep(seq_len(nrows), each = ncols)) + ans = rbindlist(body) + setnames(ans, header) + ans +} diff --git a/R/setops.R b/R/setops.R index a6a6c2936..29ea81117 100644 --- a/R/setops.R +++ b/R/setops.R @@ -6,7 +6,7 @@ setdiff_ = function(x, y, by.x=seq_along(x), by.y=seq_along(y), use.names=FALSE) by.x = colnamesInt(x, by.x, check_dups=TRUE) if (!nrow(y)) return(unique(x, by=by.x)) by.y = colnamesInt(y, by.y, check_dups=TRUE) - if (length(by.x) != length(by.y)) stopf("length(by.x) != length(by.y)") + if (length(by.x) != length(by.y)) stopf("length(by.x) != length(by.y)", domain=NA) # factor in x should've factor/character in y, and vice-versa for (a in seq_along(by.x)) { lc = by.y[a] @@ -42,15 +42,17 @@ funique = function(x) { if (!identical(names(x), names(y))) stopf("x and y must have the same column order") bad_types = c("raw", "complex", if (block_list) "list") found = bad_types %chin% c(vapply_1c(x, typeof), vapply_1c(y, typeof)) - if (any(found)) stopf("unsupported column type(s) found in x or y: %s", brackify(bad_types[found])) + if (any(found)) + stopf(ngettext(sum(found), "unsupported column type found in x or y: %s", "unsupported column types found in x or y: %s"), + brackify(bad_types[found]), domain=NA) super = function(x) { # allow character->factor and integer->numeric because from v1.12.4 i's type is retained by joins, #3820 - ans = class(x)[1L] + ans = class1(x) switch(ans, factor="character", integer="numeric", ans) } if (!identical(sx<-sapply(x, super), sy<-sapply(y, super))) { w = which.first(sx!=sy) - stopf("Item %d of x is '%s' but the corresponding item of y is '%s'.", w, class(x[[w]])[1L], class(y[[w]])[1L]) + stopf("Item %d of x is '%s' but the corresponding item of y is '%s'.", w, class1(x[[w]]), class1(y[[w]])) } if (.seqn && ".seqn" %chin% names(x)) stopf("None of the datasets should contain a column named '.seqn'") } @@ -155,9 +157,9 @@ all.equal.data.table = function(target, current, trim.levels=TRUE, check.attribu k1 = key(target) k2 = key(current) if (!identical(k1, k2)) { - return(gettextf( - "Datasets have different %s. 'target': %s. 'current': %s.", - "keys", + return(sprintf( + "%s. 'target': %s. 'current': %s.", + gettext("Datasets have different keys"), if(length(k1)) brackify(k1) else gettextf("has no key"), if(length(k2)) brackify(k2) else gettextf("has no key") )) @@ -166,9 +168,9 @@ all.equal.data.table = function(target, current, trim.levels=TRUE, check.attribu i1 = indices(target) i2 = indices(current) if (!identical(i1, i2)) { - return(gettextf( - "Datasets have different %s. 'target': %s. 'current': %s.", - "indices", + return(sprintf( + "%s. 'target': %s. 'current': %s.", + gettext("Datasets have different indices"), if(length(i1)) brackify(i1) else gettextf("has no index"), if(length(i2)) brackify(i2) else gettextf("has no index") )) diff --git a/R/test.data.table.R b/R/test.data.table.R index 922904e89..6d2a78afa 100644 --- a/R/test.data.table.R +++ b/R/test.data.table.R @@ -252,8 +252,8 @@ test.data.table = function(script="tests.Rraw", verbose=FALSE, pkg=".", silent=F if (nfail > 0L) { # nocov start stopf( - "%d error(s) out of %d. Search %s for test number(s) %s. Duration: %s.", - nfail, ntest, names(fn), toString(env$whichfail), timetaken(env$started.at) + ngettext(nfail, "%d error out of %d. Search %s for test number %s. Duration: %s.", "%d errors out of %d. Search %s for test numbers %s. Duration: %s."), + nfail, ntest, names(fn), toString(env$whichfail), timetaken(env$started.at), domain=NA ) # important to stopf() here, so that 'R CMD check' fails # nocov end @@ -290,13 +290,13 @@ test.data.table = function(script="tests.Rraw", verbose=FALSE, pkg=".", silent=F # nocov start compactprint = function(DT, topn=2L) { - tt = vapply_1c(DT,function(x)class(x)[1L]) - tt[tt=="integer64"] = "i64" - tt = substr(tt, 1L, 3L) + classes = classes1(DT) + classes[classes == "integer64"] = "i64" + classes = substr(classes, 1L, 3L) makeString = function(x) paste(x, collapse = ",") # essentially toString.default - cn = paste0(" [Key=",makeString(key(DT)), - " Types=", makeString(substr(sapply(DT, typeof), 1L, 3L)), - " Classes=", makeString(tt), "]") + cn = paste0(" [Key=", makeString(key(DT)), + " Types=", makeString(substr(vapply_1c(DT, typeof), 1L, 3L)), + " Classes=", makeString(classes), "]") if (nrow(DT)) { print(copy(DT)[,(cn):="",verbose=FALSE], topn=topn, class=FALSE) } else { diff --git a/R/utils.R b/R/utils.R index a6855f5d4..4a1aadd43 100644 --- a/R/utils.R +++ b/R/utils.R @@ -30,6 +30,21 @@ internal_error = function(...) { stop(e, call. = FALSE, domain = NA) } +check_duplicate_names = function(x, table_name=deparse(substitute(x))) { + if (!anyDuplicated(nm <- names(x))) return(invisible()) + duplicate_names = unique(nm[duplicated(nm)]) + stopf(ngettext(length(duplicate_names), + "%s has duplicated column name %s. Please remove or rename the duplicate and try again.", + "%s has duplicated column names %s. Please remove or rename the duplicates and try again."), + table_name, brackify(duplicate_names), domain=NA) +} + +duplicated_values = function(x) { + # fast anyDuplicated for the typical/non-error case; second duplicated() pass for (usually) error case + if (!anyDuplicated(x)) return(vector(typeof(x))) + unique(x[duplicated(x)]) +} + # TODO(R>=4.0.0): Remove this workaround. From R 4.0.0, rep_len() dispatches rep.Date(), which we need. # Before that, rep_len() strips attributes --> breaks data.table()'s internal recycle() helper. # This also impacts test 2 in S4.Rraw, because the error message differs for rep.int() vs. rep_len(). @@ -95,6 +110,9 @@ vapply_1i = function(x, fun, ..., use.names = TRUE) { vapply(X = x, FUN = fun, ..., FUN.VALUE = NA_integer_, USE.NAMES = use.names) } +class1 = function(x) class(x)[1L] # nolint: class1_linter. +classes1 = function(x, ..., use.names=FALSE) vapply_1c(x, class1, ..., use.names=use.names) + # base::xor(), but with scalar operators XOR = function(x, y) (x || y) && !(x && y) diff --git a/R/xts.R b/R/xts.R index 234f36cac..bd4cb75b3 100644 --- a/R/xts.R +++ b/R/xts.R @@ -1,3 +1,4 @@ +# nocov start. See tests 18.* in other.Rraw, not in the main suite. as.data.table.xts = function(x, keep.rownames = TRUE, key=NULL, ...) { stopifnot(requireNamespace("xts"), !missing(x), xts::is.xts(x)) if (length(keep.rownames) != 1L) stopf("keep.rownames must be length 1") @@ -26,3 +27,4 @@ as.xts.data.table = function(x, numeric.only = TRUE, ...) { } return(xts::xts(as.matrix(r), order.by = if (inherits(x[[1L]], "IDate")) as.Date(x[[1L]]) else x[[1L]])) } +# nocov end diff --git a/Seal_of_Approval.md b/Seal_of_Approval.md index 3d8f2fdf4..96e3c1749 100644 --- a/Seal_of_Approval.md +++ b/Seal_of_Approval.md @@ -12,6 +12,8 @@ To add your package to this list, please [submit a Pull Request to The Raft](htt ## Application packages: Use `data.table` to accomplish a particular task or analysis. +- [mlr3](https://github.com/mlr-org/mlr3): A versatile machine learning framework built on data.table. + ## Bridge package: Translate data.table syntax to different syntax or provides helper functions for transitioning between `data.table` and another object type. - [tidyfast](https://github.com/TysonStanley/tidyfast): Fast and efficient alternatives to tidyr functions built on data.table @@ -19,3 +21,5 @@ To add your package to this list, please [submit a Pull Request to The Raft](htt - [dtplyr](https://github.com/tidyverse/dtplyr): A `data.table` backend for `dplyr` ## Partner package: Not necessarily directly connected to `data.table`, but deliberately follows the [core philosophies of `data.table`](https://github.com/Rdatatable/data.table/blob/master/GOVERNANCE.md#the-r-package). + +- [collapse](https://github.com/SebKrantz/collapse): Advanced and Fast Data Transformation in R diff --git a/inst/po/fr/LC_MESSAGES/R-data.table.mo b/inst/po/fr/LC_MESSAGES/R-data.table.mo new file mode 100644 index 000000000..f75dd632f Binary files /dev/null and b/inst/po/fr/LC_MESSAGES/R-data.table.mo differ diff --git a/inst/po/fr/LC_MESSAGES/data.table.mo b/inst/po/fr/LC_MESSAGES/data.table.mo new file mode 100644 index 000000000..b734c6adc Binary files /dev/null and b/inst/po/fr/LC_MESSAGES/data.table.mo differ diff --git a/inst/tests/S4.Rraw b/inst/tests/S4.Rraw index 35cee55da..7e0b8111d 100644 --- a/inst/tests/S4.Rraw +++ b/inst/tests/S4.Rraw @@ -90,14 +90,14 @@ ans_print = utils::capture.output(print(ans)) if (TZnotUTC) { test(5.2, options=list(datatable.old.fread.datetime.character=NULL), fread("a,b,c\n2015-01-01,2015-01-02,2015-01-03 01:02:03", colClasses=c("Date","IDate","POSIXct"), tz=""), - ans, output=ans_print) + copy(ans)[, a := as.IDate(a)], output=ans_print) test(5.3, options=list(datatable.old.fread.datetime.character=NULL), fread("a,b,c\n2015-01-01,2015-01-02,2015-01-03 01:02:03", colClasses=c("Date",NA,NA), tz=""), - data.table(a=as.Date("2015-01-01"), b=as.IDate("2015-01-02"), c="2015-01-03 01:02:03"), output=ans_print) + data.table(a=as.IDate("2015-01-01"), b=as.IDate("2015-01-02"), c="2015-01-03 01:02:03"), output=ans_print) } else { test(5.4, options=list(datatable.old.fread.datetime.character=NULL), fread("a,b,c\n2015-01-01,2015-01-02,2015-01-03 01:02:03", colClasses=c("Date","IDate","POSIXct")), - ans<-data.table(a=as.Date("2015-01-01"), b=as.IDate("2015-01-02"), c=as.POSIXct("2015-01-03 01:02:03", tz="UTC")), output=ans_print) + ans<-data.table(a=as.IDate("2015-01-01"), b=as.IDate("2015-01-02"), c=as.POSIXct("2015-01-03 01:02:03", tz="UTC")), output=ans_print) test(5.5, options=list(datatable.old.fread.datetime.character=NULL), fread("a,b,c\n2015-01-01,2015-01-02,2015-01-03 01:02:03", colClasses=c("Date",NA,NA)), ans, output=ans_print) diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw index 2910a78d0..a11e9b13a 100644 --- a/inst/tests/tests.Rraw +++ b/inst/tests/tests.Rraw @@ -2427,9 +2427,9 @@ test(811.2, DT[c("b","foo","c"),which=NA,nomatch=NULL], error="which=NA with nom DT = data.table(a=1:3,b=4:6,c=7:9) # old tests using with=FALSE retained. Eventually will deprecate with=FALSE. test(812.1, DT[,!"b",with=FALSE], DT[,-match("b",names(DT)),with=FALSE]) -test(812.2, DT[,"foo",with=FALSE], error="column(s) not found: [foo]") -test(812.3, DT[,!"foo",with=FALSE], DT, warning="column(s) not removed because not found: [foo]") -test(812.4, DT[,!c("b","foo"),with=FALSE], DT[,list(a,c)], warning="column(s) not removed because not found: [foo]") +test(812.2, DT[,"foo",with=FALSE], error="column not found: [foo]") +test(812.3, DT[,!"foo",with=FALSE], DT, warning="column not removed because not found: [foo]") +test(812.4, DT[,!c("b","foo"),with=FALSE], DT[,list(a,c)], warning="column not removed because not found: [foo]") test(812.5, DT[,!2:3,with=FALSE], DT[,-(2:3),with=FALSE]) # for consistency, but ! is really for character column names mycols = "b" test(812.6, DT[,!mycols,with=FALSE], DT[,list(a,c)]) @@ -2447,11 +2447,11 @@ test(813.4, rownames(DT[2,"a"]), "1") # also repeat 812.* but without with=FALSE since that will be deprecated in future, and cover - as well as ! test(814.01, DT[,!"b"], DT[,c("a","c")]) test(814.02, DT[,-"b"], DT[,c("a","c")]) -test(814.03, DT[,"foo"], error="column(s) not found: [foo]") -test(814.04, DT[,!"foo"], DT, warning="column(s) not removed because not found: [foo]") -test(814.05, DT[,-"foo"], DT, warning="column(s) not removed because not found: [foo]") -test(814.06, DT[,!c("b","foo")], DT[,list(a,c)], warning="column(s) not removed because not found: [foo]") -test(814.07, DT[,-c("b","foo")], DT[,list(a,c)], warning="column(s) not removed because not found: [foo]") +test(814.03, DT[,"foo"], error="column not found: [foo]") +test(814.04, DT[,!"foo"], DT, warning="column not removed because not found: [foo]") +test(814.05, DT[,-"foo"], DT, warning="column not removed because not found: [foo]") +test(814.06, DT[,!c("b","foo")], DT[,list(a,c)], warning="column not removed because not found: [foo]") +test(814.07, DT[,-c("b","foo")], DT[,list(a,c)], warning="column not removed because not found: [foo]") test(814.08, DT[,!2:3], DT[,"a"]) # for consistency, and ! avoids needing to wrap with () as in next test test(814.09, DT[,-(2:3)], DT[,"a"]) mycols = "b" @@ -2488,9 +2488,9 @@ test(827.1, names(a[b]), c("User ID","Blah Blah","Yadda Yadda")) # setcolorder and merge check for dup column names, #2193(ii) setnames(DT2,"b","a") -test(828, setcolorder(DT2,c("a","b")), error="x has some duplicated column name(s): [a]. Please remove or rename") -test(829, merge(DT1,DT2), error="y has some duplicated column name(s): [a]. Please remove or rename") -test(830, merge(DT2,DT1), error="x has some duplicated column name(s): [a]. Please remove or rename") +test(828, setcolorder(DT2,c("a","b")), error="x has duplicated column name [a]. Please remove or rename") +test(829, merge(DT1,DT2), error="y has duplicated column name [a]. Please remove or rename") +test(830, merge(DT2,DT1), error="x has duplicated column name [a]. Please remove or rename") # attribs such as "comments" should be retained, #2270 DT1 <- data.table(id = seq.int(1, 10), A = LETTERS[1:10], key = "id") @@ -5580,9 +5580,14 @@ test(1352.7, DT[,sum(b),by=.(Grp=a%%2)], DT[,sum(b),by=list(Grp=a%%2)]) test(1352.8, DT[,sum(b),by=.(a%%2,c)], DT[,sum(b),by=list(a%%2,c)]) # that :=NULL together with i is now an error -DT = data.table(a=1:3, b=1:6) +DT = data.table(a=1:3, b=1:6, c=list(7, 8, 9, 8, 7, 6)) test(1353.1, DT[2, b:=NULL], error="When deleting columns, i should not be provided") test(1353.2, DT[2, c("a","b"):=list(42, NULL)], error="When deleting columns, i should not be provided") +# #5526: friendlier error nudging to the correct way to sub-assign NULL to list columns +test(1353.3, DT[2, c := NULL], error="Invalid attempt to delete a list column.*did you intend to add NULL") +test(1353.4, DT[2, c := .(NULL)], error="Invalid attempt to delete a list column.*did you intend to add NULL") +test(1353.5, DT[2, `:=`(b=2, c=NULL)], error="Invalid attempt to delete a list column.*did you intend to add NULL") +test(1353.6, DT[2, d := NULL], error="Doubly-invalid attempt to delete a non-existent column while also providing i") # order optimisation caused trouble due to chaining because of 'substitute(x)' usage in [.data.table. set.seed(1L) @@ -7246,7 +7251,7 @@ if (test_bit64) { # fix for #1082 dt1 = data.table(x=rep(c("a","b","c"),each=3), y=c(1,3,6), v=1:9, key=c("x", "y")) dt2 = copy(dt1) -test(1502.1, dt1["a", z := NULL], error="When deleting columns, i should not be provided") +test(1502.1, dt1["a", z := NULL], error="Doubly-invalid attempt to delete a non-existent column while also providing i") # this shouldn't segfault on 'dt1[...]' test(1502.2, dt1["a", z := 42L], dt2["a", z := 42L]) @@ -7534,7 +7539,7 @@ test(1538.2, !is.unsorted(tables(order.col="NROW")$NROW), output="Total:") # uniqueN not support list-of-list: reverted #1224 d1 <- data.table(a = 1:4, l = list(list(letters[1:2]),list(Sys.time()),list(1:10),list(letters[1:2]))) -test(1539, d1[,uniqueN(l)], error = "x must be an atomic vector or data.frames/data.tables") +test(1539, d1[,uniqueN(l)], error = "x must be an atomic vector or a data.frame/data.table") # feature #1130 - joins without setting keys # can't test which=TRUE with DT1.copy's results.. @@ -8986,26 +8991,26 @@ test(1626.45, nrow(fsetdiff(dt[rep(1L,4)], dt[rep(1L,5)], all=TRUE)), 0L) dt = data.table(V1 = 1:4, V2 = letters[1:4], V3 = lapply(1:4, function(x) new.env())) x = dt[c(2:4,2L,2L)] y = dt[c(1:3,2L)] -test(1626.46, fintersect(x, y), error = "unsupported column type(s) found in x or y: [list]") -test(1626.47, fintersect(x, y, all=TRUE), error = "unsupported column type(s) found in x or y: [list]") -test(1626.48, fsetdiff(x, y), error = "unsupported column type(s) found in x or y: [list]") -test(1626.49, fsetdiff(x, y, all=TRUE), error = "unsupported column type(s) found in x or y: [list]") -test(1626.50, funion(x, y), error = "unsupported column type(s) found in x or y: [list]") +test(1626.46, fintersect(x, y), error = "unsupported column type found in x or y: [list]") +test(1626.47, fintersect(x, y, all=TRUE), error = "unsupported column type found in x or y: [list]") +test(1626.48, fsetdiff(x, y), error = "unsupported column type found in x or y: [list]") +test(1626.49, fsetdiff(x, y, all=TRUE), error = "unsupported column type found in x or y: [list]") +test(1626.50, funion(x, y), error = "unsupported column type found in x or y: [list]") test(1626.51, funion(x, y, all=TRUE), dt[c(2:4,2L,2L,1:3,2L)]) -test(1626.52, fsetequal(x, y), error = "unsupported column type(s) found in x or y: [list]") -test(1626.53, fsetequal(dt[c(1:2,2L)], dt[c(1:2,2L)]), error = "unsupported column type(s) found in x or y: [list]") +test(1626.52, fsetequal(x, y), error = "unsupported column type found in x or y: [list]") +test(1626.53, fsetequal(dt[c(1:2,2L)], dt[c(1:2,2L)]), error = "unsupported column type found in x or y: [list]") # unsupported type in set-ops: complex, raw dt = data.table(V1 = 1:4, V2 = letters[1:4], V3 = as.complex(1:4), V4 = as.raw(1:4), V5 = lapply(1:4, function(x) NULL)) x = dt[c(2:4,2L,2L)] y = dt[c(1:3,2L)] -test(1626.54, fintersect(x, y), error = "unsupported column type(s) found in x or y: [raw, complex, list]") -test(1626.55, fintersect(x, y, all=TRUE), error = "unsupported column type(s) found in x or y: [raw, complex, list]") -test(1626.56, fsetdiff(x, y), error = "unsupported column type(s) found in x or y: [raw, complex, list]") -test(1626.57, fsetdiff(x, y, all=TRUE), error = "unsupported column type(s) found in x or y: [raw, complex, list]") -test(1626.58, funion(x, y), error = "unsupported column type(s) found in x or y: [raw, complex, list]") -test(1626.59, funion(x, y, all=TRUE), error = "unsupported column type(s) found in x or y: [raw, complex]") # no 'list' here which is supported for `all=TRUE` -test(1626.60, fsetequal(x, y), error = "unsupported column type(s) found in x or y: [raw, complex, list]") -test(1626.61, fsetequal(dt[c(1:2,2L)], dt[c(1:2,2L)]), error = "unsupported column type(s) found in x or y: [raw, complex, list]") +test(1626.54, fintersect(x, y), error = "unsupported column types found in x or y: [raw, complex, list]") +test(1626.55, fintersect(x, y, all=TRUE), error = "unsupported column types found in x or y: [raw, complex, list]") +test(1626.56, fsetdiff(x, y), error = "unsupported column types found in x or y: [raw, complex, list]") +test(1626.57, fsetdiff(x, y, all=TRUE), error = "unsupported column types found in x or y: [raw, complex, list]") +test(1626.58, funion(x, y), error = "unsupported column types found in x or y: [raw, complex, list]") +test(1626.59, funion(x, y, all=TRUE), error = "unsupported column types found in x or y: [raw, complex]") # no 'list' here which is supported for `all=TRUE` +test(1626.60, fsetequal(x, y), error = "unsupported column types found in x or y: [raw, complex, list]") +test(1626.61, fsetequal(dt[c(1:2,2L)], dt[c(1:2,2L)]), error = "unsupported column types found in x or y: [raw, complex, list]") # supported types multi column test dt = data.table( V1 = 1:4, @@ -10260,8 +10265,8 @@ unlink(f) # duplicate names in foverlaps #1730 a = data.table(start = 1:5, end = 2:6, c2 = rnorm(10), c2 = rnorm(10), key=c("start","end")) b = data.table(start = 1:5, end = 2:6, c3 = rnorm(5), key=c("start","end")) -test(1677.1, foverlaps(a, b), error="x has some duplicated column") -test(1677.2, foverlaps(b, a), error="y has some duplicated column") +test(1677.1, foverlaps(a, b), error="x has duplicated column") +test(1677.2, foverlaps(b, a), error="y has duplicated column") # na.omit.data.table removes indices #1734 dt = data.table(a=4:1, b=c(letters[c(1L,NA,2:3)])) @@ -11037,20 +11042,20 @@ test(1743.044, fread("a\n1", colClasses=""), data.table(a=1L)) # Issue #1634: 'fread doesn't check colClasses to be valid type' # Currently using BioGenerics, which doesn't support USE.NAMES ## Date supported character/list colClasses -test(1743.05, sapply(fread("a,b\n2017-01-01,1", colClasses=c("Date", "integer")), class), c(a="Date", b="integer")) -test(1743.06, sapply(fread("a,b\n2017-01-01,1", colClasses=list(Date = 1L, integer = 2L)), class), c(a="Date", b="integer")) -test(1743.07, sapply(fread("a,b\n2017-01-01,2017-01-02", colClasses=list(Date = 1:2)), class), c(a="Date", b="Date")) -test(1743.08, sapply(fread("a,b,c\n2017-01-01,1,1+3i", colClasses=c("Date", "integer", "complex")), class), c(a="Date", b="integer", c="complex")) -test(1743.09, sapply(fread("a,b,c\n2017-01-01,1,1+3i", colClasses=c("Date", "integer", "complex")), class), c(a="Date", b="integer", c="complex")) -test(1743.10, sapply(fread("a,b,c,d\n2017-01-01,1,1+3i,05", colClasses=c("Date", "integer", "complex", NA)), class), c(a="Date",b="integer",c="complex",d="integer")) -test(1743.11, sapply(fread("a,b,c,d\n2017-01-01,1,1+3i,05", colClasses=c("Date", "integer", "complex", "raw")), class), c(a="Date",b="integer",c="complex",d="raw")) +test(1743.05, lapply(fread("a,b\n2017-01-01,1", colClasses=c("Date", "integer")), class), list(a=c("IDate", "Date"), b="integer")) +test(1743.06, lapply(fread("a,b\n2017-01-01,1", colClasses=list(Date = 1L, integer = 2L)), class), list(a=c("IDate", "Date"), b="integer")) +test(1743.07, lapply(fread("a,b\n2017-01-01,2017-01-02", colClasses=list(Date = 1:2)), class), list(a=c("IDate", "Date"), b=c("IDate", "Date"))) +test(1743.08, lapply(fread("a,b,c\n2017-01-01,1,1+3i", colClasses=c("Date", "integer", "complex")), class), list(a=c("IDate", "Date"), b="integer", c="complex")) +test(1743.09, lapply(fread("a,b,c\n2017-01-01,1,1+3i", colClasses=c("Date", "integer", "complex")), class), list(a=c("IDate", "Date"), b="integer", c="complex")) +test(1743.10, lapply(fread("a,b,c,d\n2017-01-01,1,1+3i,05", colClasses=c("Date", "integer", "complex", NA)), class), list(a=c("IDate", "Date"), b="integer", c="complex", d="integer")) +test(1743.11, lapply(fread("a,b,c,d\n2017-01-01,1,1+3i,05", colClasses=c("Date", "integer", "complex", "raw")), class), list(a=c("IDate", "Date"), b="integer", c="complex", d="raw")) test(1743.121, sapply(fread("a,b\n2015-01-01,2015-01-01", colClasses=c(NA,"IDate")), inherits, what="IDate"), c(a=TRUE, b=TRUE)) -test(1743.122, fread("a,b\n2015-01-01,2015-01-01", colClasses=c("POSIXct","Date")), data.table(a=as.POSIXct("2015-01-01"), b=as.Date("2015-01-01"))) +test(1743.122, fread("a,b\n2015-01-01,2015-01-01", colClasses=c("POSIXct","Date")), data.table(a=as.POSIXct("2015-01-01"), b=as.IDate("2015-01-01"))) test(1743.123, fread("a,b\n1+3i,2015-01-01", colClasses=c(NA,"IDate")), data.table(a="1+3i", b=as.IDate("2015-01-01"))) ## Attempts to impose incompatible colClasses is a warning (not an error) ## and does not change the value of the columns -test(1743.13, sapply(fread("a,b\n09/05/98,2015-01-01", colClasses = "Date"), class), y=c(a="character", b="Date"), warning=base_messages$ambiguous_date_fmt) +test(1743.13, lapply(fread("a,b\n09/05/98,2015-01-01", colClasses = "Date"), class), y=list(a="character", b=c("IDate", "Date")), warning=base_messages$ambiguous_date_fmt) ## Just invalid test(1743.14, options = c(useFancyQuotes = FALSE), @@ -11080,6 +11085,9 @@ test(1743.201, fread("A,B,C,D\nA,B,X,4", select=list(factor="A"), colClasses="ch test(1743.202, fread("A,B,C,D\nA,B,X,4", select=c(A="factor"), colClasses="character"), error="select= is a named vector.*but colClasses= has been provided as well. Please remove colClasses=.") test(1743.203, fread("A,B,C,D\nA,B,X,4", select=list(character="D", factor="B")), data.table(D="4", B=factor("B"))) test(1743.204, fread("A,B,C,D\nA,B,X,4", select=list(character=4, character=2)), data.table(D="4", B="B")) +## Date+select +test(1743.205, fread("a,b\n2017-01-01,1", colClasses="Date", select="a"), data.table(a=as.IDate("2017-01-01"))) +test(1743.206, fread("a,b\n2017-01-01,1", select=list(Date="a")), data.table(a=as.IDate("2017-01-01"))) ## factors test(1743.211, sapply(fread("a,b,c\n2,2,f", colClasses = list(factor = 1L), select = 2:3), class), y = c(b="integer", c="character")) @@ -12419,6 +12427,14 @@ DTout = data.table( value2 = c("a", "b", "c", "d", "e", "f", "g", "h", "i", "j") ) test(1866.6, melt(DT, measure.vars = patterns("^x", "^y", cols=names(DT))), DTout) +# patterns supports cols arg, #6498 +test(1866.71, melt(data.table(x1=1,x2=2,y1=3,y2=4),measure.vars=patterns("2",cols=c("y1","y2"))), data.table(x1=1,x2=2,y1=3,variable=factor("y2"),value=4)) +test(1866.72, DT[, lapply(.SD, sum), .SDcols=patterns("2",cols=c("x1","x2"))], data.table(x2=40L)) + +# informative errors for bad user-provided cols arg to patterns +DT = data.table(x1=1,x2=2,y1=3,y2=4) +test(1866.80, melt(DT, measure.vars=patterns("2", cols=NULL)), error="cols must be a character vector of column names") +test(1866.81, melt(DT, measure.vars=patterns("2", cols=NA_character_)), error="cols must be a character vector of column names") # auto fill too few column names (#1625) and auto fill=TRUE when too many column names test(1867.01, fread("A,B\n1,3,5,7\n2,4,6,8\n"), data.table(A=1:2, B=3:4, V3=5:6, V4=7:8), @@ -12427,22 +12443,22 @@ test(1867.02, fread("A,B,C,D,E\n1,3,5,7\n2,4,6,8\n"), data.table(A=1:2, B=3:4, C warning="Detected 5.*but.*4.*Filling rows automatically.") if (test_R.utils) { test(1867.03, fread(testDir("fillheader.csv.bz2"))[c(1,.N), c(1,29,30)], data.table("V1"="Ashburton District", EASTING=c(5154177L,5144032L), NORTHING=NA), - warning="Detected 29.*but.*30.*Added 1 extra default column name.*guessed to be row names or an index.*valid file") + warning="Detected 29.*but.*30.*Added an extra default column name.*guessed to be row names or an index.*valid file") # in this unusual case, every data row has a trailing comma but the column names do not. So the guess is wrong; a deliberate choice currently. } test(1867.04, fread("A,B\nCol1,Col2,Col3\n1,3,5\n2,4,6\n"), data.table(Col1=1:2, Col2=3:4, Col3=5:6)) -test(1867.05, fread("A\nCol1,Col2\n1,3,5\n2,4,6\n"), data.table(V1=1:2, Col1=3:4, Col2=5:6), warning="Added 1 extra default column name.*guessed to be row names or an index") +test(1867.05, fread("A\nCol1,Col2\n1,3,5\n2,4,6\n"), data.table(V1=1:2, Col1=3:4, Col2=5:6), warning="Added an extra default column name.*guessed to be row names or an index") test(1867.06, fread("Some header\ninfo\nCol1,Col2,Col3\n1,3,5\n2,4,6\n"), data.table(Col1=1:2, Col2=3:4, Col3=5:6)) -test(1867.07, fread("Some header\ninfo\n\nCol1,Col2\n1,3,5\n2,4,6\n"), data.table(V1=1:2, Col1=3:4, Col2=5:6), warning="Added 1 extra") +test(1867.07, fread("Some header\ninfo\n\nCol1,Col2\n1,3,5\n2,4,6\n"), data.table(V1=1:2, Col1=3:4, Col2=5:6), warning="Added an extra") test(1867.08, fread("A,B,C,D,E\n1,3,5\n2,4,6\n"), data.table(A=1:2, B=3:4, C=5:6, D=NA, E=NA), warning="Detected 5.*but.*3.*Filling rows automatically") test(1867.09, fread("Heading text\nA,B,C,D,E\n1,3,5\n2,4,6\n"), data.table(A=1:2, B=3:4, C=5:6, D=NA, E=NA), warning="Detected 5.*but.*3.*Filling rows automatically") test(1867.10, fread("Heading text\n1,3,5\n2,4,6\n"), data.table("Heading text"=1:2, V2=3:4, V3=5:6), warning="Added 2 extra default column names at the end") test(1867.11, fread("A,B\n\n1,3,5\n2,4,6\n"), data.table(V1=1:2, V2=3:4, V3=5:6)) -test(1867.12, fread("A\n1,3\n2,4\n"), data.table(V1=1:2, A=3:4), warning="Added 1 extra default column name") +test(1867.12, fread("A\n1,3\n2,4\n"), data.table(V1=1:2, A=3:4), warning="Added an extra default column name") # test from #763, covers #1818 too DT = data.table(x=rep(c("a","b","c"),each=3), y=c(1L,3L,6L), v=10:18) write.table(DT, file = (f<-tempfile()), sep = "\t") -test(1867.13, fread(f), data.table(V1=1:9, x=DT$x, y=DT$y, v=DT$v), warning="Added 1 extra default column name") +test(1867.13, fread(f), data.table(V1=1:9, x=DT$x, y=DT$y, v=DT$v), warning="Added an extra default column name") unlink(f) # test(1867.14, fread(testDir("iterations.txt.bz2"))) @@ -12471,7 +12487,7 @@ if (test_R.utils) { output = "Copying file in RAM.*file is very unusual.*ends abruptly.*multiple of 4096") test(1869.7, fread(testDir("onecol4096.csv.bz2"), verbose=TRUE)[c(1,2,245,246,249,255:.N),], data.table(A=c("FooBarBazQux000","FooBarBazQux001","","FooBarBazQux245","","FooBarBazQux254","FooBarBazQux","FooBarBaz12","FooBarBazQux256","","","")), - output = "Copying file in RAM.*file is very unusual.*one single column, ends with 2 or more end-of-line.*and is a multiple of 4096") + output = "Copying file in RAM.*file is very unusual.*one single column, ends with 2 or more end-of-line.*and the file size is a multiple of 4096") } # better colname detection by comparing potential column names to the whole sample not just the first row of the sample, #2526 @@ -12880,7 +12896,7 @@ test(1908, observed, expected) if (test_R.utils) { test(1909.1, names(ans<-fread(testDir("genotypes_genome.txt.bz2"), skip="Samples:", sep=" ", colClasses="character")), c("V1","Samples:"), - warning="Detected 1 column name.*but the data has 2 columns.*Added 1 extra default column name for the first column") + warning="Detected 1 column name.*but the data has 2 columns.*Added an extra default column name for the first column") test(1909.2, ans$V1, c("POP1:","POP1:","POP1:")) test(1909.3, nchar(ans[["Samples:"]]), INT(3287,3287,3287)) test(1909.4, names(ans<-fread(testDir("genotypes_genome.txt.bz2"), skip="POP1:", sep=" ", colClasses="character", header=FALSE)), @@ -13302,9 +13318,9 @@ test(1952.2, d1[a==2, 2, which=TRUE], error="which==TRUE.*but j is also supplied # 3106 -- melt patterns don't match any columns (and more coverage tests) DT = data.table(id = 1:3, a1 = rnorm(3), a2 = rnorm(3)) test(1953.1, melt(DT, id.vars = 'id', measure.vars = patterns(a = 'a', b = 'b')), - error = 'Pattern(s) not found') + error = 'Pattern not found') test(1953.2, melt(DT, id.vars = 'id', measure.vars = patterns(a = 'a', b = 'b', c = 'c')), - error = 'Pattern(s) not found') + error = 'Patterns not found') test(1953.3, melt(DT, id.vars = 'id', measure.vars = patterns(1L)), error = 'Input patterns must be of type character') setDF(DT) @@ -13340,7 +13356,7 @@ test(1956.6, DT[, .SD, .SDcols = 3i], error = '.SDcols should be column numbers test(1957.1, brackify(1:3), '[1, 2, 3]') test(1957.2, brackify(1:11), "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]") test(1957.3, fread("A,B\na,b\nc,d\n", stringsAsFactors=TRUE, verbose=TRUE), data.table(A=factor(c("a","c")), B=factor(c("b","d"))), - output="stringsAsFactors=TRUE converted 2 column(s): [A, B]") + output="stringsAsFactors=TRUE converted 2 columns: [A, B]") # misc. coverage tests in fread test(1958.01, fread('\U0001f64d', encoding = 'UTF-16'), error = "Argument 'encoding' must be") @@ -14131,7 +14147,7 @@ test(1984.07, DT[, sum(a), by=call('sin',pi)], error='must evaluate to a vector test(1984.081, DT[, sum(a), by=as.raw(0)], error="Column or expression.*1.*type 'raw'.*not.*supported") test(1984.082, data.table(A=1:4, L=list(1, 1:2, 1, 1:3), V=1:4)[, sum(V), by=.(A,L)], # better error message, 4308 error="Column or expression.*2.*type 'list'.*not.*supported") -test(1984.09, DT[, sum(a), by=.(1,1:2)], error="The items in the 'by' or 'keyby' list are length(s) [1, 2]. Each must be length 10; the same length as there are rows in x (after subsetting if i is provided).") +test(1984.09, DT[, sum(a), by=.(1,1:2)], error="The items in the 'by' or 'keyby' list have lengths [1, 2]. Each must be length 10; the same length as there are rows in x (after subsetting if i is provided).") options('datatable.optimize' = Inf) test(1984.10, DT[ , 1, by = .(a %% 2), verbose = TRUE], data.table(a = c(1, 0), V1 = c(1, 1)), @@ -14472,7 +14488,7 @@ test(2005.10, set(DT, 1L, "d", expression(x+2)), error="type 'expression' cannot test(2005.11, set(DT, 1L, "e", expression(x+2)), error="type 'expression' cannot be coerced to 'double'") test(2005.12, set(DT, 1L, "f", expression(x+2)), error="type 'expression' cannot be coerced to 'complex'") test(2005.30, DT[2:3,c:=c(TRUE,FALSE), verbose=3L]$c, as.raw(INT(7,1,0)), ## note verbose=3L for more deeper verbose output due to memrecycle messages when it is being re-used internally #4491 - output="Zero-copy coerce when assigning 'logical' to 'raw' column 3 named 'c'") + output="Zero-copy coerce when assigning 'logical' to column 3 named 'c' which is 'raw'") test(2005.31, set(DT,1L,"c",NA)$c, as.raw(INT(0,1,0))) test(2005.32, set(DT,1:2,"c",INT(-1,255))$c, as.raw(INT(0,255,0)), warning="-1.*integer.*position 1 taken as 0 when assigning.*raw.*column 3 named 'c'") @@ -14907,10 +14923,10 @@ options(old) # exceptions in char to POSIX coercion dn = 'aa2016-09-18 08:00:00' -test(2038.14, between(x, dn, up), error="coercion to POSIX failed") +test(2038.14, between(x, dn, up), error="coercion to POSIXct failed") dn = '2016-09-18 08:00:00' up = 'bb2016-09-18 09:00:00' -test(2038.15, between(x, dn, up), error="coercion to POSIX failed") +test(2038.15, between(x, dn, up), error="coercion to POSIXct failed") # exceptions due to timezone mismatch x = as.POSIXct("2016-09-18 07:00:00", tz="UTC") + 0:10*60*15 @@ -16495,8 +16511,8 @@ DT = data.table(a = "aaaaaaaaaaaaa", c = "ccccccccccccc", d = "ddddddddddddd") test(2125.01, - capture.output(print(DT, trunc.cols=TRUE))[3L], - "2 variable(s) not shown: [c, d]") + print(DT, trunc.cols=TRUE), + output="2 variables not shown: [c, d]") # Printing with dots DT = data.table(a = vector("integer", 102L), b = "bbbbbbbbbbbbb", @@ -16515,7 +16531,7 @@ test(2125.02, capture.output(print(DT, trunc.cols=TRUE)), "100: 0 bbbbbbbbbbbbb ccccccccccccc", "101: 0 bbbbbbbbbbbbb ccccccccccccc", "102: 0 bbbbbbbbbbbbb ccccccccccccc", - "1 variable(s) not shown: [d]")) + "1 variable not shown: [d]")) test(2125.03, capture.output(print(DT, trunc.cols=TRUE, row.names=FALSE)), c(" a b c", " 0 bbbbbbbbbbbbb ccccccccccccc", @@ -16529,22 +16545,22 @@ test(2125.03, capture.output(print(DT, trunc.cols=TRUE, row.names=FALSE)), " 0 bbbbbbbbbbbbb ccccccccccccc", " 0 bbbbbbbbbbbbb ccccccccccccc", " 0 bbbbbbbbbbbbb ccccccccccccc", - "1 variable(s) not shown: [d]" )) + "1 variable not shown: [d]" )) # also testing #4266 -- getting width of row #s register right # TODO: understand why 2 variables truncated here. a,b,c combined have width # _exactly_ 40, but still wraps. If we set options(width=41) it won't truncate. # seems to be an issue with print.default. test(2125.04, capture.output(print(DT, trunc.cols=TRUE, class=TRUE))[14L], - "2 variable(s) not shown: [c , d ]") + "2 variables not shown: [c , d ]") test(2125.05, capture.output(print(DT, trunc.cols=TRUE, class=TRUE, row.names=FALSE))[c(1,14)], c(" a b c", - "1 variable(s) not shown: [d ]" )) + "1 variable not shown: [d ]" )) test(2125.06, capture.output(print(DT, trunc.cols=TRUE, col.names="none"))[c(1,12)], c(" 1: 0 bbbbbbbbbbbbb ccccccccccccc", - "1 variable(s) not shown: [d]" )) + "1 variable not shown: [d]" )) test(2125.07, capture.output(print(DT, trunc.cols=TRUE, class=TRUE, col.names="none"))[c(1,13)], c(" 1: 0 bbbbbbbbbbbbb", - "2 variable(s) not shown: [c, d]" ), + "2 variables not shown: [c, d]" ), warning = "Column classes will be suppressed when col.names is 'none'") options("width" = 20) DT = data.table(a = vector("integer", 2), @@ -16555,16 +16571,16 @@ test(2125.08, capture.output(print(DT, trunc.cols=TRUE)), c(" a b", "1: 0 bbbbbbbbbbbbb", "2: 0 bbbbbbbbbbbbb", - "2 variable(s) not shown: [c, d]")) + "2 variables not shown: [c, d]")) options("width" = 10) DT = data.table(a = "aaaaaaaaaaaaa", b = "bbbbbbbbbbbbb", c = "ccccccccccccc", d = "ddddddddddddd") test(2125.09, capture.output(print(DT, trunc.cols=TRUE)), - "4 variable(s) not shown: [a, b, c, d]") + "4 variables not shown: [a, b, c, d]") test(2125.10, capture.output(print(DT, trunc.cols=TRUE, class=TRUE)), - "4 variable(s) not shown: [a , b , c , d ]") + "4 variables not shown: [a , b , c , d ]") options(old_width) # segfault when i is NULL or zero-column, #4060 @@ -16953,7 +16969,7 @@ test(2150.10, fread(tmp), copy(DT)[ , times := format(times, '%FT%T+00:XX')]) test(2150.11,fread("a,b\n2015-01-01,2015-01-01", colClasses="POSIXct"), # local time for backwards compatibility data.table(a=as.POSIXct("2015-01-01"), b=as.POSIXct("2015-01-01"))) test(2150.12,fread("a,b\n2015-01-01,2015-01-01", select=c(a="Date",b="POSIXct")), # select colClasses form, for coverage - data.table(a=as.Date("2015-01-01"), b=as.POSIXct("2015-01-01"))) + data.table(a=as.IDate("2015-01-01"), b=as.POSIXct("2015-01-01"))) test(2150.13, fread("a,b\n2015-01-01,1.1\n2015-01-02 01:02:03,1.2", tz=""), # no Z, tz="" needed for this test from v1.14.0 if (TZnotUTC) data.table(a=c("2015-01-01","2015-01-02 01:02:03"), b=c(1.1, 1.2)) else data.table(a=setattr(as.POSIXct(c("2015-01-01 00:00:00", "2015-01-02 01:02:03"), tz="UTC"), "tzone", "UTC"), b=c(1.1, 1.2))) @@ -17288,11 +17304,11 @@ test(2183.00020, melt(iris.dt, measure.vars=measurev(value.name, dim, sep=".", p test(2183.000201, melt(iris.dt, measure.vars=measurev(list(NULL, dim=NULL), sep=".")), error="in measurev, elements of fun.list must be named, problems: [1]") test(2183.000202, melt(iris.dt, measure.vars=measurev(list(NULL, NULL), sep=".")), error="in measurev, elements of fun.list must be named, problems: [1, 2]") test(2183.00027, melt(iris.dt, measure.vars=measurev(list(value.name=NULL, dim="bar"), sep=".")), error="in the measurev fun.list, each non-NULL element must be a function with at least one argument, problem: dim") -test(2183.00028, melt(iris.dt, measure.vars=measurev(list(value.name=NULL, dim=NULL, baz=NULL), sep=".")), error="number of elements of fun.list =3 must be same as max number of items after splitting column names =2") +test(2183.00028, melt(iris.dt, measure.vars=measurev(list(value.name=NULL, dim=NULL, baz=NULL), sep=".")), error="number of elements of fun.list (3) must be the same as the max number of items after splitting column names (2)") test(2183.00042, melt(DTid, measure.vars=measurev(list(value.name=NULL, istr=function()1), pattern="([ab])([12])")), error="in the measurev fun.list, each non-NULL element must be a function with at least one argument, problem: istr") test(2183.00043, melt(DTid, measure.vars=measurev(list(value.name=NULL, istr=interactive), pattern="([ab])([12])")), error="in the measurev fun.list, each non-NULL element must be a function with at least one argument, problem: istr") test(2183.00044, melt(DTid, measure.vars=measurev(list(value.name=NULL, istr=function(x)1), pattern="([ab])([12])")), error="each conversion function must return an atomic vector with same length as its first argument, problem: istr") -test(2183.00045, melt(iris.dt, measure.vars=measurev(list(value.name=NULL, dim=NULL, baz=NULL), pattern="(.*)[.](.*)")), error="number of elements of fun.list =3 must be same as number of capture groups in pattern =2") +test(2183.00045, melt(iris.dt, measure.vars=measurev(list(value.name=NULL, dim=NULL, baz=NULL), pattern="(.*)[.](.*)")), error="number of elements of fun.list (3) must be the same as the number of capture groups in pattern (2)") test(2183.00048, melt(iris.dt, measure.vars=measurev(list(value.name=NULL, value.name=NULL), sep=".")), error="elements of fun.list should be uniquely named, problems: [value.name]") # measure with factor conversion. myfac = function(x)factor(x)#user-defined conversion function. @@ -17335,7 +17351,7 @@ test(2183.24, names(melt(iris.dt, measure.vars=measure(value.name, dim, sep=".") test(2183.25, names(melt(iris.dt, measure.vars=measure(part, value.name, sep="."))), c("Species", "part", "Length", "Width")) test(2183.26, names(melt(iris.dt, measure.vars=measure(part, dim, sep="."))), c("Species", "part", "dim", "value")) test(2183.27, melt(iris.dt, measure.vars=measure(value.name, dim="bar", sep=".")), error="each ... argument to measure must be a function with at least one argument, problem: dim") -test(2183.28, melt(iris.dt, measure.vars=measure(value.name, dim, baz, sep=".")), error="number of ... arguments to measure =3 must be same as max number of items after splitting column names =2") +test(2183.28, melt(iris.dt, measure.vars=measure(value.name, dim, baz, sep=".")), error="number of elements of fun.list (3) must be the same as the max number of items after splitting column names (2)") test(2183.29, melt(iris.dt, measure.vars=measure()), error="each column name results in only one item after splitting using sep, which means that all columns would be melted; to fix please either specify melt on all columns directly without using measure, or use a different sep/pattern specification") # patterns with iris data. test(2183.40, names(melt(iris.dt, measure.vars=patterns("[.]"))), c("Species", "variable", "value")) @@ -17344,10 +17360,10 @@ test(2183.41, melt(DTid, measure.vars=measure(value.name, istr="bar", pattern="( test(2183.42, melt(DTid, measure.vars=measure(value.name, istr=function()1, pattern="([ab])([12])")), error="each ... argument to measure must be a function with at least one argument, problem: istr") test(2183.43, melt(DTid, measure.vars=measure(value.name, istr=interactive, pattern="([ab])([12])")), error="each ... argument to measure must be a function with at least one argument, problem: istr") test(2183.44, melt(DTid, measure.vars=measure(value.name, istr=function(x)1, pattern="([ab])([12])")), error="each conversion function must return an atomic vector with same length as its first argument, problem: istr") -test(2183.45, melt(iris.dt, measure.vars=measure(value.name, dim, baz, pattern="(.*)[.](.*)")), error="number of ... arguments to measure =3 must be same as number of capture groups in pattern =2") +test(2183.45, melt(iris.dt, measure.vars=measure(value.name, dim, baz, pattern="(.*)[.](.*)")), error="number of elements of fun.list (3) must be the same as the number of capture groups in pattern (2)") test(2183.46, melt(iris.dt, measure.vars=measure(function(x)factor(x), dim, pattern="(.*)[.](.*)")), error="each ... argument to measure must be either a symbol without argument name, or a function with argument name, problems: [1]") test(2183.47, melt(iris.dt, measure.vars=measure(function(x)factor(x), pattern="(.*)[.](.*)")), error="each ... argument to measure must be either a symbol without argument name, or a function with argument name, problems: [1]") -test(2183.48, melt(iris.dt, measure.vars=measure(value.name, value.name, sep=".")), error="... arguments to measure should be uniquely named, problems: [value.name]") +test(2183.48, melt(iris.dt, measure.vars=measure(value.name, value.name, sep=".")), error="elements of fun.list should be uniquely named, problems: [value.name]") # measure with factor conversion. myfac = function(x)factor(x)#user-defined conversion function. test(2183.60, melt(DTid, measure.vars=measure(letter=myfac, value.name, pattern="([ab])([12])")), data.table(id=1, letter=factor(c("a","b")), "2"=c(2,2), "1"=c(NA,1))) @@ -18541,21 +18557,38 @@ test(2255, as.data.table(DF), output="DF1.V1.*DF1.V2.*DF2.V3.*DF2.V4.*V5") DT = data.table(a = letters, b = 1:26/6, c = 1:26) ## auto-detect dec=',' fwrite(DT, f <- tempfile(), dec=',', sep=';') -test(2256.1, fread(f), DT) +test(2256.01, fread(f), DT) fwrite(DT, f, dec=',', sep='|') -test(2256.2, fread(f), DT) +test(2256.02, fread(f), DT) ## auto-detect dec='.' fwrite(DT, f) -test(2256.3, fread(f), DT) +test(2256.03, fread(f), DT) ## verbose output -test(2256.4, fread(f, verbose=TRUE), DT, output="sep=',' so dec set to '.'") +test(2256.04, fread(f, verbose=TRUE), DT, output="sep=',' so dec set to '.'") fwrite(DT, f, dec=',', sep=';') -test(2256.5, fread(f, verbose=TRUE), DT, output="dec=',' detected based on a balance of 18") -test(2256.6, fread('a;b\n1,14;5', verbose=TRUE), data.table(a=1.14, b=5L), output="dec=',' detected based on a balance of 1 ") +test(2256.05, fread(f, verbose=TRUE), DT, output="dec=',' detected based on a balance of 18") +test(2256.06, fread('a;b\n1,14;5', verbose=TRUE), data.table(a=1.14, b=5L), output="dec=',' detected based on a balance of 1 ") + +## timestamps with subsecond accuracy thrown off by auto-dec #6440 +test(2256.07, fread(text="t\n2023-10-12T06:53:53.123Z"), data.table(t=as.POSIXct('2023-10-12 06:53:53.123', tz='UTC'))) +### TODO(#6447): sep="\t" shouldn't be needed here, right? +test(2256.08, fread(text="t\n2023-10-12T06:53:53,123Z", sep="\t"), data.table(t=as.POSIXct('2023-10-12 06:53:53.123', tz='UTC'))) +test(2256.09, fread(text="x,t\n1.0,2023-10-12T06:53:53.123Z"), data.table(x=1.0, t=as.POSIXct('2023-10-12 06:53:53.123', tz='UTC'))) +test(2256.10, fread(text="t,x\n2023-10-12T06:53:53.123Z,1.0"), data.table(t=as.POSIXct('2023-10-12 06:53:53.123', tz='UTC'), x=1.0)) +### from PR comment +s = 'CoilID;AntennaID;Time;TagID;Pen;Side;Position;Location;Coil_Y;Coil_X +1;16403160;2023-10-12T10:30:55.270Z;DA2C6411;1;AKB;Litter central;middle;1;6 +3;16403160;2023-10-12T10:30:55.270Z;DA459D86;1;AKB;Litter central;middle;1;4 +15;16402963;2023-10-12T10:31:00.900Z;DA459D86;1;AKB;Litter central;right;2;3 +14;16402963;2023-10-12T10:31:02.240Z;DA2C6411;1;AKB;Litter central;right;2;1 +11;16403160;2023-10-12T10:31:02.650Z;DA2C6411;1;AKB;Litter central;middle;2;6' +test(2256.11, + unname(sapply(fread(s, sep=';'), function(x) class(x)[1L])), + c("integer", "integer", "POSIXct", "character", "integer", "character", "character", "character", "integer", "integer")) # helpful error about deleting during grouping, #1873 DT = data.table(id = c(1, 1, 2, 2), a = 1:4, b = 5:8) @@ -18728,7 +18761,7 @@ test(2264.8, print(DT, show.indices=TRUE), output=ans) if (test_bit64) local({ DT = data.table(a = 'abc', b = as.integer64(1)) suppressPackageStartupMessages(unloadNamespace("bit64")) - on.exit(suppressPackageStartupMessages(library(bit64))) + on.exit(suppressPackageStartupMessages(library(bit64, pos="package:base"))) test(2265, DT, output="abc\\s*1$") }) @@ -19064,8 +19097,1495 @@ test(2280.3, foo(), error="Internal error in foo: broken") test(2281.1, fwrite(data.table(a=.POSIXct(0.001)), dec=',', sep=';'), output="1970-01-01T00:00:00,001Z") test(2281.2, fwrite(data.table(a=.POSIXct(0.0001)), dec=',', sep=';'), output="1970-01-01T00:00:00,000100Z") +# rowwisely creating a data.table +DT = rowwiseDT( + A=, B=, + 1, "a" +) +test(2282.01, DT, data.table(A = 1, B = "a")) +# error if named argument is not empty +test(2282.02, rowwiseDT(A=,B=2,1,2), error="Named arguments must be empty") +# error if no header +test(2282.03, rowwiseDT(1,"a"), error = "Must provide at least one column") +# error if body is not multiple length of the header +test(2282.04, rowwiseDT(A=,B=,C=, 1,"a",2,"b",3), error = "There are 3 columns but the number of cells is 5, which is not an integer multiple of the columns") +# create list element automatically +test(2282.05, rowwiseDT(A=,list(1)), data.table(A=list(1))) +test(2282.06, rowwiseDT(A=,1:2), data.table(A=list(1:2))) +test(2282.07, rowwiseDT(A=,double()), data.table(A=list(double()))) +# error if named argument is in the middle +test(2282.08, rowwiseDT(A=,B=,1,2,C=,4), error="Header must be the first N arguments") +# evaluate arguments in the correct frame +ncols = 1e6 +test(2282.09, rowwiseDT(A=,ncols), data.table(A=ncols)) + +# named arguments of c() in j get prepended to lapply(.SD, FUN) #2311 + +M <- as.data.table(mtcars) +M[, " " := hp] +M[, "." := hp] + +sdnames <- setdiff(names(M), "cyl") +sdlist <- vector("list", length(sdnames)) +names(sdlist) <- sdnames + +for (opt in c(0, 1, 2)) { + test(2283 + opt/10 + 0.001, options=c(datatable.optimize=opt), + names(M[, c(m=lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c(m=sdlist)))) + test(2283 + opt/10 + 0.002, options=c(datatable.optimize=opt), + names(M[, c(Mpg=list(mpg), lapply(.SD, mean)), by="cyl"]), + c("cyl", "Mpg", sdnames)) + test(2283 + opt/10 + 0.003, options=c(datatable.optimize=opt), + names(M[, c(Mpg=list(mpg), m=lapply(.SD, mean)), by="cyl"]), + c("cyl", "Mpg", names(c(m=sdlist)))) + test(2283 + opt/10 + 0.004, options=c(datatable.optimize=opt), + names(M[, c(mpg=list(mpg), mpg=lapply(.SD, mean)), by="cyl"]), + c("cyl", "mpg", names(c(mpg=sdlist)))) + test(2283 + opt/10 + 0.005, options=c(datatable.optimize=opt), + names(M[, c(list(mpg), lapply(.SD, mean)), by="cyl"]), + c("cyl", "V1", sdnames)) + test(2283 + opt/10 + 0.006, options=c(datatable.optimize=opt), + names(M[, c(lapply(.SD, mean), list(mpg)), by="cyl"]), + c("cyl", sdnames, sprintf("V%d", length(sdnames)+1L))) + test(2283 + opt/10 + 0.007, options=c(datatable.optimize=opt), + names(M[, c(lapply(.SD, mean), lapply(.SD, sum)), by="cyl"]), + c("cyl", sdnames, sdnames)) + test(2283 + opt/10 + 0.008, options=c(datatable.optimize=opt), + names(M[, c(mean=lapply(.SD, mean), sum=lapply(.SD, sum)), by="cyl"]), + c("cyl", names(c(mean=sdlist, sum=sdlist)))) + test(2283 + opt/10 + 0.009, options=c(datatable.optimize=opt), + names(M[, c(lapply(.SD, mean), sum=lapply(.SD, sum)), by="cyl"]), + c("cyl", sdnames, names(c(sum=sdlist))) ) + test(2283 + opt/10 + 0.010, options=c(datatable.optimize=opt), + names(M[, c(" "=lapply(.SD, mean), "."=lapply(.SD, sum)), by="cyl"]), + c("cyl", names(c(" "=sdlist, "."=sdlist)))) + test(2283 + opt/10 + 0.011, options=c(datatable.optimize=opt), + names(M[, c(A=list(a=mpg, b=hp), lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c(A=list(a=0, b=0))), sdnames)) + test(2283 + opt/10 + 0.012, options=c(datatable.optimize=opt), + names(M[, c(A=list(mpg, hp), lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c(A=list(0, 0))), sdnames)) + test(2283 + opt/10 + 0.013, options=c(datatable.optimize=opt), + names(M[, c(A=list(mpg, b=hp, wt), lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c(A=list(0, b=0, 0))), sdnames)) + test(2283 + opt/10 + 0.014, options=c(datatable.optimize=opt), + names(M[, c(A=list(mpg), lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c(A=list(0))), sdnames)) + test(2283 + opt/10 + 0.015, options=c(datatable.optimize=opt), + names(M[, c(" "=list(" "=hp, "."=disp, mpg), lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c(" "=list(" "=0, "."=0, 0))), sdnames)) + test(2283 + opt/10 + 0.016, options=c(datatable.optimize=opt), + names(M[, c("."=list(" "=hp, "."=disp, mpg), lapply(.SD, mean)), by="cyl"]), + c("cyl", names(c("."=list(" "=0, "."=0, 0))), sdnames)) + test(2283 + opt/10 + 0.017, options=c(datatable.optimize=opt), + names(M[, c(list(mpg, b=hp), lapply(.SD, mean)), by="cyl", .SDcols=c("vs", "am")]), + c("cyl", "V1", "b", "vs", "am")) + test(2283 + opt/10 + 0.018, options=c(datatable.optimize=opt), + names(M[, c(list(mpg, b=hp), c(lapply(.SD, mean))), by="cyl", .SDcols=c("vs", "am")]), + c("cyl", "V1", "b", "vs", "am")) + test(2283 + opt/10 + 0.019, options=c(datatable.optimize=opt), + names(M[, c(mpg[1], list(mpg, b=hp), c(lapply(.SD, mean))), by="cyl", .SDcols=c("vs", "am")]), + c("cyl", "V1", "V2", "b", "vs", "am")) +} + +# Confusing behavior with DT[, min(var):max(var)] #2069 +DT = data.table(t = c(2L, 1L, 3L), a=0, b=1) +test(2284.1, DT[, min(t):max(t)], with(DT, min(t):max(t))) +test(2284.2, DT[, 1:max(t)], with(DT, 1:max(t))) +test(2284.3, DT[, max(t):1], with(DT, max(t):1)) +test(2284.4, DT[, 1:t[1L]], with(DT, 1:t[1L])) +test(2284.5, DT[, t[2L]:1], with(DT, t[2L]:1)) +test(2284.6, DT[, min(a):max(t)], with(DT, min(a):max(t))) +# but not every `:` with a call in from or to is with=TRUE, #6486 +test(2284.7, DT[, 1:ncol(DT)], DT) +test(2284.8, DT[, 2:(ncol(DT) - 1L)], DT[, "a"]) +test(2284.9, DT[, (ncol(DT) - 1L):ncol(DT)], DT[, c("a", "b")]) + +# Extra regression tests for #4772, which was already incidentally fixed by #5183. +x = data.table(a=1:3) +y = data.table(a=2:4) +z = data.table(a=3:5) +test(2285.01, merge(x, merge(y, z)), data.table(a=3L, key="a")) +test(2285.02, merge(x, merge(z, y)), data.table(a=3L, key="a")) +test(2285.03, merge(y, merge(x, z)), data.table(a=3L, key="a")) +test(2285.04, merge(y, merge(z, x)), data.table(a=3L, key="a")) +test(2285.05, merge(z, merge(x, y)), data.table(a=3L, key="a")) +test(2285.06, merge(z, merge(y, x)), data.table(a=3L, key="a")) +test(2285.07, merge(merge(x, y), z), data.table(a=3L, key="a")) +test(2285.08, merge(merge(x, z), y), data.table(a=3L, key="a")) +test(2285.09, merge(merge(y, x), z), data.table(a=3L, key="a")) +test(2285.10, merge(merge(y, z), x), data.table(a=3L, key="a")) +test(2285.11, merge(merge(z, x), y), data.table(a=3L, key="a")) +test(2285.12, merge(merge(z, y), x), data.table(a=3L, key="a")) + +# ensure proper PROTECT() within fcase, #6448 +x <- 1:3 +test(2286, + fcase( + x<2, structure(list(1), class = "foo"), + x<3, structure(list(2), class = "foo"), + # Force gc() and some allocations which have a good chance at landing in the region that was earlier left unprotected + # TODO(R>=3.5.0): no need to branch here for gc(full=TRUE) + { if ("full" %in% names(formals(gc))) gc(full = TRUE) else gc(); replicate(10, FALSE); x<4 }, + `attr<-`(list(3), "class", "foo")), + structure(list(1, 2, 3), class = "foo")) + +# Always return a copy of columns, even when returning a single list column, #4788 +dt = data.table(A=list('a', 'b', 'c')) +test(2287.1, address(dt[, A]) != address(dt[, A])) +l = dt[, A] +dt[1L, A := .(list(1L))] +test(2287.2, !identical(DT$A[[1L]], l[[1L]])) + +# rbind do not copy class/attributes for integer64 and CPLXSXP/STRSXP/VECSXP #5504 +if (test_bit64) { + a = data.table(as.integer64(c(1,2))) + b = data.table(c("a","b")) + c = data.table(complex(real = 3:4, imaginary = 5:6)) + d = data.table(list(3.5, 4L)) + test(2288.1, rbind(a,b), data.table(c("1","2","a","b"))) + test(2288.2, rbind(b,a), data.table(c("a","b","1","2"))) + test(2288.3, rbind(a,c), data.table(complex(real = 1:4, imaginary = c(0, 0, 5:6)))) + test(2288.4, rbind(c,a), data.table(complex(real = c(3:4, 1:2), imaginary = c(5:6, 0, 0)))) + test(2288.5, rbind(a,d), data.table(list(as.integer64(1), as.integer64(2), 3.5, 4L))) + test(2288.6, rbind(d,a), data.table(list(3.5, 4L, as.integer64(1), as.integer64(2)))) +} + +# support column type 'expression' #5596 +dt = data.table(a=1:2, b=expression(1,2)) +test(2289.1, dt[1,], data.table(a=1L, b=expression(1))) +test(2289.2, dt[,b,a], dt) + +# error message improvement, #5296 +DT = data.table(a = 1) +test(2290.1, DT[, `:=`(a := 2)], error="It looks like you re-used `:=`") +# special case where length(jsub) == 3 that would have failed later +test(2290.2, DT[, `:=`(a := 2, c := 3)], error="It looks like you re-used `:=` in argument 1") +# NB: _not_ a = 2, because that means partially-named --> not currently covered +test(2290.3, DT[, `:=`(a, c := 3)], error="It looks like you re-used `:=` in argument 2") +# partially-named `:=`(...) --> different branch, same error +test(2290.4, DT[, `:=`(a = 2, c := 3)], error="It looks like you re-used `:=` in argument 2") + +# segfault when selfref is not ok before set #6410 +df = data.frame(a=1:3) +setDT(df) +attr(df, "att") = 1 +test(2291.1, set(df, NULL, "new", "new"), error="attributes .* have been reassigned") + +# ns-qualified bysub error, #6493 +DT = data.table(a = 1) +test(2292.1, DT[, .N, by=base::mget("a")], data.table(a = 1, N = 1L)) +test(2292.2, DT[, .N, by=base::c("a")], data.table(a = 1, N = 1L)) + +# don't try to re-use sorting on a non-data.table, #6501 +x = data.table(id = "aaa") +y = data.frame(id = "bbb") +test(2293.1, x[!y, on='id'], x) +class(y) = c("tbl_df", "tbl", "data.frame") +test(2293.2, x[!y, on = "id"], x) + +# groupingsets/cube/rollup 'label' argument, #5351 +DT1 = data.table(VCharA = rep(c("C1", "C2", "C3"), each = 12), + VCharB = c(rep(c("C3", "C4"), c(6, 6)), + rep(c("C3", "C4"), c(8, 4)), + rep(c("C3", "C4"), c(4, 8))), + VFacA = factor(rep(c("F1", "F2", "F3"), c(14, 12, 10))), + VFacB = factor(rep(c("F3", "F4"), c(30, 6))), + VIntA = rep(1:2, c(24, 12)), + VIntB = rep(2:3, c(6, 30))) +DT1[, `:=`(VDate = as.Date(sub("F", "2024-01-0", VFacA)), + VIDate = as.IDate(sub("F", "2024-01-0", VFacB)), + VNumA = as.numeric(VIntA), + VNumB = as.numeric(VIntB), + integer = VCharB, + Y = 1:36)] +DT1[35:36, VCharA := NA] +DT1[36, VFacA := NA] +DT1[36, VDate := NA] +# Ans1: character, factor, integer grouping variables. +Ans1 = rbind(DT1[, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB")], + DT1[, .(VFacB = factor("Total"), VIntB = 999L, Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VIntA")], + DT1[, .(VFacB = factor("Total"), VIntA = 999L, VIntB = 999L, Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA")], + DT1[, .(VFacA = factor("Total"), VIntA = 999L, VIntB = 999L, Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacB")], + DT1[, .(VCharB = "Total", VFacA = factor("Total"), VIntA = 999L, VIntB = 999L, + Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VFacB")], + DT1[, .(VCharA = "Total", VFacB = factor("Total"), VIntA = 999L, VIntB = 999L, + Count = .N, Y_Sum = sum(Y)), + by = c("VCharB", "VFacA")], + DT1[, .(VCharB = "Total", VFacA = factor("Total"), VFacB = factor("Total"), + VIntA = 999L, VIntB = 999L, Count = .N, Y_Sum = sum(Y)), + by = "VCharA"], + DT1[, .(VCharA = "Total", VCharB = "Total", VFacA = factor("Total"), VFacB = factor("Total"), + VIntA = 999L, VIntB = 999L, Count = .N, Y_Sum = sum(Y))] + ) +# Ans2: character, factor, integer grouping variables; some variables have no 'total' rows. +Ans2 = rbind(DT1[0, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB")], + DT1[, .(VFacB = factor("Total"), VIntB = 999L, Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VIntA")], + DT1[, .(VFacB = factor("Total"), VIntA = 999L, VIntB = 999L, Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA")]) +# Ans3: character, Date, IDate, numeric grouping variables. +Ans3 = Ans1[, .(VCharA, VCharB, + VDate = fifelse(VFacA == "Total", as.Date("3000-01-01"), as.Date(sub("F", "2024-01-0", VFacA))), + VIDate = fifelse(VFacB == "Total", as.IDate("3000-01-01"), as.IDate(sub("F", "2024-01-0", VFacB))), + VNumA = as.numeric(VIntA), + VNumB = as.numeric(VIntB), + Count, Y_Sum)] +# 01. label is an atomic vector with length = 0. +test(2294.01, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = character(0)), + error = "Argument 'label', if not NULL, must be a scalar or a named list of scalars.") +# 02. label is an atomic vector with length > 1. +test(2294.02, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = c("Total A", "Total B")), + error = "Argument 'label', if not NULL, must be a scalar or a named list of scalars.") +# 03. label is a list and one of the elements is a list. +test(2294.03, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = list(VCharA = "Total VCharA", VCharB = "Total VCharB"))), + error = "Argument 'label', if not NULL, must be a scalar or a named list of scalars.") +# 04. label is a list and one of the elements is an atomic vector with length > 1. +test(2294.04, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", VCharB = c("Total VCharB", "Total"))), + error = "Argument 'label', if not NULL, must be a scalar or a named list of scalars.") +# 05. label is a list with no elements named. +test(2294.05, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list("Total VCharA", "Total VCharB")), + error = "Argument 'label', if not NULL, must be a scalar or a named list of scalars.") +# 06. label is a list with some but not all elements named. +test(2294.06, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", "Total VCharB")), + error = "When argument 'label' is a list, all of the list elements must be named.") +# 07. label is a list with an NA name. +test(2294.07, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = structure(list("Total VCharA", "Total VCharB"), names = c("VCharA", NA))), + error = "When argument 'label' is a list, all of the list elements must be named.") +# 08. label is a list with duplicate names. +test(2294.08, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", VCharA = "Total VCharA", VCharB = "Total VCharB")), + error = "When argument 'label' is a list, the element names must not contain duplicates.") +# 09. label is a list with a name not in 'by', not first element of class in 'x' of a variable in 'by', and not one of the other allowed names. +test(2294.09, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", z = "Total", VNumA = 1)), + error = "When argument 'label' is a list, all element names must be (1) in 'by', or (2) the first element of the class in the data.table 'x' of a variable in 'by', or (3) one of [character, integer, numeric, factor, Date, IDate]. Element names not satisfying this condition: [z, VNumA]") +# 10. label is a list and an element with name in 'by' has class not matching class in 'x'. +test(2294.10, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", VCharB = 999L, + VFacA = "Total VFacA", VFacB = 1L, + VIntA = 100L, VIntB = 200)), + error = "When argument 'label' is a list, the class of each 'label' element with name in 'by' must match the class of the corresponding column of the data.table 'x'. Class mismatch for: [VCharB (label: integer; data: character), VFacA (label: character; data: factor), VFacB (label: integer; data: factor), VIntB (label: numeric; data: integer)]") +# 11. label is a list and an element with name in 'by' has class not matching class in 'x' with classes that have length > 1. +test(2294.11, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VDate", "VIDate"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VDate", "VIDate"), + c("VCharA", "VCharB", "VFacA", "VDate"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", VCharB = "Total VCharB", + VFacA = factor("Total VFacA"), VFacB = factor("Total VFacB"), + VDate = as.IDate("3000-01-01"), VIDate = as.Date("3000-01-01"))), + error = "When argument 'label' is a list, the class of each 'label' element with name in 'by' must match the class of the corresponding column of the data.table 'x'. Class mismatch for: [VDate (label: IDate, Date; data: Date), VIDate (label: Date; data: IDate, Date)]") +# 12. label is a list and an element with name in 'by' has class not matching class in 'x', and the variable name is also first element of the class of other variables in 'by'. +test(2294.12, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "integer", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "integer", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "integer", "VFacA", "VIntA"), + c("VCharA", "integer", "VFacA"), + c("VCharA", "integer", "VFacB"), + c("VCharA", "VFacB"), + c("integer", "VFacA"), + "VCharA", + character()), + label = list(integer = 999L)), + error = "When argument 'label' is a list, the class of each 'label' element with name in 'by' must match the class of the corresponding column of the data.table 'x'. Class mismatch for: [integer (label: integer; data: character)]") +# 13. label is a list and an element with name not in 'by' has name not matching first element of class of the element. +test(2294.13, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = "Total", factor = "Total", integer = 999, + Date = as.IDate("3000-01-01"), IDate = as.Date("3000-01-01"))), + error = "When argument 'label' is a list, the name of each element of 'label' not in 'by' must match the first element of the class of the element value. Mismatches: [(label name: factor; label class[1]: character), (label name: integer; label class[1]: numeric), (label name: Date; label class[1]: IDate), (label name: IDate; label class[1]: Date)]") +# 14. label specified by variable for each variable. +test(2294.14, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total", VCharB = "Total", + VFacA = factor("Total"), VFacB = factor("Total"), + VIntA = 999L, VIntB = 999L)), + Ans1) +# 15. label specified by variable for each variable with different values for different variables. +test(2294.15, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", VCharB = "Total VCharB", + VFacA = factor("Total VFacA"), VFacB = factor("Total VFacB"), + VIntA = 901L, VIntB = 902L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB = fifelse(VCharB == "Total", "Total VCharB", VCharB), + VFacA = factor(VFacA, levels = levels(VFacA), + labels = sub("Total", "Total VFacA", levels(VFacA))), + VFacB = factor(VFacB, levels = levels(VFacB), + labels = sub("Total", "Total VFacB", levels(VFacB))), + VIntA = fifelse(VIntA == 999L, 901L, VIntA), + VIntB = fifelse(VIntB == 999L, 902L, VIntB), + Count, Y_Sum)]) +# 16. label specified by variable but not for all variables. +test(2294.16, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total", VFacA = factor("Total"))), + Ans1[, .(VCharA, + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA, + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 17. label specified by variable with some label values being NA. +test(2294.17, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total", VCharB = NA_character_, + VFacA = factor("Total"), VFacB = factor(NA), + VIntA = NA_integer_, VIntB = 999L)), + Ans1[, .(VCharA, + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA, + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), VIntB, + Count, Y_Sum)]) +# 18. label specified by first element of class. +test(2294.18, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = "Total", factor = factor("Total"), integer = 999L)), + Ans1) +# 19. label specified by first element of class but not for all classes of variable in 'by'. +test(2294.19, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(factor = factor("Total"))), + Ans1[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA, VFacB, + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 20. label specified by first element of class but for none of the classes of variables in 'by'. +test(2294.20, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(Date = as.Date("3000-01-01"))), + Ans1[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 21. label specified by variable for some classes and by class for other classes. +test(2294.21, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total", VCharB = "Total", factor = factor("Total"), integer = 999L)), + Ans1) +# 22. label specified by variable for some classes and by class for other classes. +test(2294.22, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VFacA = factor("Total"), VFacB = factor("Total"), + VIntA = 999L, VIntB = 999L, character = "Total")), + Ans1) +# 23. label specified by variable for some variables having a particular class and by class for other variables having that class. +test(2294.23, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", character = "Total", + factor = factor("Total"), integer = 999L, + VFacB = factor("Total VFacB"), VIntA = 901L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB, VFacA, + VFacB = factor(VFacB, levels = levels(VFacB), + labels = sub("Total", "Total VFacB", levels(VFacB))), + VIntA = fifelse(VIntA == 999L, 901L, VIntA), + VIntB, Count, Y_Sum)]) +# 24. label specified by variable for some variables having a particular class and by class for other variables having that class, and specified for a class not in 'by'. +test(2294.24, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", character = "Total", + factor = factor("Total"), integer = 999L, + VFacB = factor("Total VFacB"), VIntA = 901L, Date = as.Date("3000-01-01"))), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB, VFacA, + VFacB = factor(VFacB, levels = levels(VFacB), + labels = sub("Total", "Total VFacB", levels(VFacB))), + VIntA = fifelse(VIntA == 999L, 901L, VIntA), + VIntB, Count, Y_Sum)]) +# 25. label specified by variable and by class, with class specification not used because all matching variables are specified by variable. +test(2294.25, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = "Total", VCharA = "Total VCharA", VCharB = "Total VCharB", + VFacA = factor("Total VFacA"), VFacB = factor("Total VFacB"), + integer = 999L, VIntA = 901L, VIntB = 902L, factor = factor("Total"))), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB = fifelse(VCharB == "Total", "Total VCharB", VCharB), + VFacA = factor(VFacA, levels = levels(VFacA), + labels = sub("Total", "Total VFacA", levels(VFacA))), + VFacB = factor(VFacB, levels = levels(VFacB), + labels = sub("Total", "Total VFacB", levels(VFacB))), + VIntA = fifelse(VIntA == 999L, 901L, VIntA), + VIntB = fifelse(VIntB == 999L, 902L, VIntB), + Count, Y_Sum)]) +# 26. label specified by variable for a variable with name that is also first element of the class of other variables in 'by'. +test(2294.26, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "integer", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "integer", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "integer", "VFacA", "VIntA"), + c("VCharA", "integer", "VFacA"), + c("VCharA", "integer", "VFacB"), + c("VCharA", "VFacB"), + c("integer", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total", integer = "Total", factor = factor("Total"))), + Ans1[, .(VCharA, integer = VCharB, VFacA, VFacB, + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 27. label specified by variable and by class, with id=TRUE. +# Get correct 'grouping' values by using groupingsets() without 'label'. +grouping_correct = groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + id=TRUE)$grouping +test(2294.27, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + id=TRUE, + label = list(VCharA = "Total", VCharB = "Total", factor = factor("Total"), integer = 999L)), + data.table(grouping = grouping_correct, Ans1)) +# 28. label specified by variable and by class, with id=TRUE and .SDcols used. +test(2294.28, + groupingsets(DT1, lapply(.SD, sum), .SDcols = "Y", + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + id=TRUE, + label = list(VCharA = "Total", VCharB = "Total", factor = factor("Total"), integer = 999L)), + Ans1[, .(grouping = grouping_correct, + VCharA, VCharB, VFacA, VFacB, VIntA, VIntB, Y = Y_Sum)]) +# 29. label specified by variable with label value in the data for one variable. +test(2294.29, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "C2", VCharB = "Total", + VFacA = factor("Total"), VFacB = factor("Total"), + VIntA = 999L, VIntB = 999L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB, VFacA, VFacB, VIntA, VIntB, Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2)]") +# 30. label specified by variable with label value in the data for more than one variable. +test(2294.30, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "C2", VCharB = "Total", + VFacA = factor("Total"), VFacB = factor("F3"), + VIntA = 1L, VIntB = 3L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB, VFacA, + VFacB = fifelse(VFacB == "Total", factor("F3", levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, 1L, VIntA), + VIntB = fifelse(VIntB == 999L, 3L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2), VFacB (label: F3), VIntA (label: 1), VIntB (label: 3)]") +# 31. label specified by first element of class with label value in the data. +test(2294.31, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = "C2", factor = factor("Total"), integer = 999L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB = fifelse(VCharB == "Total", "C2", VCharB), + VFacA, VFacB, VIntA, VIntB, Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2)]") +# 32. label specified by first element of class with label value in the data. +test(2294.32, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = "C3", factor = factor("F4"), integer = 3L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C3", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VFacA = factor(VFacA, levels = levels(VFacA), labels = sub("Total", "F4", levels(VFacA))), + VFacB = fifelse(VFacB == "Total", factor("F4", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA = fifelse(VIntA == 999L, 3L, VIntA), + VIntB = fifelse(VIntB == 999L, 3L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VCharB (label: C3), VFacB (label: F4), VIntB (label: 3)]") +# 33. label specified by first element of class with label value in the data. +test(2294.33, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(character = "C3", factor = factor("F3"), integer = 2L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C3", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VFacA = fifelse(VFacA == "Total", factor("F3", levels = setdiff(levels(VFacA), "Total")), + factor(VFacA, levels = setdiff(levels(VFacA), "Total"))), + VFacB = fifelse(VFacB == "Total", factor("F3", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA = fifelse(VIntA == 999L, 2L, VIntA), + VIntB = fifelse(VIntB == 999L, 2L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VCharB (label: C3), VFacA (label: F3), VFacB (label: F3), VIntA (label: 2), VIntB (label: 2)]") +# 34. label specified by variable and class with label value in the data. +test(2294.34, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "C3", character = "Total", + factor = factor("F3"), integer = 2L, + VFacA = factor("Total"), VIntA = 999L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C3", VCharA), + VCharB, VFacA, + VFacB = fifelse(VFacB == "Total", factor("F3", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA, + VIntB = fifelse(VIntB == 999L, 2L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VFacB (label: F3), VIntB (label: 2)]") +# 35. label specified by variable and class with label value in the data. +test(2294.35, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "Total", character = "C3", + factor = factor("Total"), integer = 999L, + VFacA = factor("F3"), VIntA = 2L)), + Ans1[, .(VCharA, + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VFacA = fifelse(VFacA == "Total", factor("F3", levels = setdiff(levels(VFacA), "Total")), + factor(VFacA, levels = setdiff(levels(VFacA), "Total"))), + VFacB, + VIntA = fifelse(VIntA == 999L, 2L, VIntA), + VIntB, + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharB (label: C3), VFacA (label: F3), VIntA (label: 2)]") +# 36. label specified by variable and class with label value in the data. +test(2294.36, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = list(VCharA = "C2", character = "C3", + factor = factor("F4"), integer = 3L, + VFacA = factor("F3"), VIntA = 2L)), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VFacA = fifelse(VFacA == "Total", factor("F3", levels = setdiff(levels(VFacA), "Total")), + factor(VFacA, levels = setdiff(levels(VFacA), "Total"))), + VFacB = fifelse(VFacB == "Total", factor("F4", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA = fifelse(VIntA == 999L, 2L, VIntA), + VIntB = fifelse(VIntB == 999L, 3L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2), VCharB (label: C3), VFacA (label: F3), VFacB (label: F4), VIntA (label: 2), VIntB (label: 3)]") +# 37. Some variables have no 'total' rows, label specified by variable. +test(2294.37, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA")), + label = list(VCharA = "Total", VCharB = "Total", + VFacA = factor("Total"), VFacB = factor("Total"), + VIntA = 999L, VIntB = 999L)), + Ans2) +# 38. Some variables have no 'total' rows, label specified by first element of class. +test(2294.38, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA")), + label = list(character = "Total", factor = factor("Total"), integer = 999L)), + Ans2) +# 39. Some variables have no 'total' rows, label specified by variable and by first element of class. +test(2294.39, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA")), + label = list(VCharA = "Total VCharA", character = "Total", + factor = factor("Total"), integer = 999L, + VFacA = factor("Total VFacA"), VIntA = 901L)), + Ans2[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB, + VFacA = factor(VFacA, levels = levels(VFacA), + labels = sub("Total", "Total VFacA", levels(VFacA))), + VFacB, + VIntA = fifelse(VIntA == 999L, 901L, VIntA), + VIntB, Count, Y_Sum)]) +# 40. Some variables have no 'total' rows, label specified by variable with label value in the data. +test(2294.40, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA")), + label = list(VCharA = "C2", VCharB = "C4", + VFacA = factor("F2"), VFacB = factor("F4"), + VIntA = 2L, VIntB = 3L)), + Ans2[, .(VCharA, VCharB, VFacA, + VFacB = fifelse(VFacB == "Total", factor("F4", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA = fifelse(VIntA == 999L, 2L, VIntA), + VIntB = fifelse(VIntB == 999L, 3L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2), VCharB (label: C4), VFacA (label: F2), VFacB (label: F4), VIntA (label: 2), VIntB (label: 3)]") +# 41. Some variables have no 'total' rows, label specified by first element of class with label value in the data. +test(2294.41, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA")), + label = list(character = "C3", factor = factor("F3"), integer = 2L)), + Ans2[, .(VCharA, VCharB, VFacA, + VFacB = fifelse(VFacB == "Total", factor("F3", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA = fifelse(VIntA == 999L, 2L, VIntA), + VIntB = fifelse(VIntB == 999L, 2L, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VCharB (label: C3), VFacA (label: F3), VFacB (label: F3), VIntA (label: 2), VIntB (label: 2)]") +# 42. Date, IDate, numeric: label specified by variable for each variable. +test(2294.42, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(VCharA = "Total", VCharB = "Total", + VDate = as.Date("3000-01-01"), VIDate = as.IDate("3000-01-01"), + VNumA = 999, VNumB = 999)), + Ans3) +# 43. Date, IDate, numeric: label specified by first element of class. +test(2294.43, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(character = "Total", Date = as.Date("3000-01-01"), + IDate = as.IDate("3000-01-01"), numeric = 999)), + Ans3) +# 44. Date, IDate, numeric: label specified by first element of class but not for all classes of variable in 'by'. +test(2294.44, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(Date = as.Date("3000-01-01"))), + Ans3[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VDate, + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate(NA), VIDate), + VNumA = fifelse(abs(VNumA - 999) < 0.1, NA_real_, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, NA_real_, VNumB), + Count, Y_Sum)]) +# 45. Date, IDate, numeric: label specified by variable for some classes and by class for other classes. +test(2294.45, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(VCharA = "Total", VCharB = "Total", + Date = as.Date("3000-01-01"), IDate = as.IDate("3000-01-01"), + numeric = 999)), + Ans3) +# 46. Date, IDate, numeric: label specified by variable for some classes and by class for other classes. +test(2294.46, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(VDate = as.Date("3000-01-01"), VIDate = as.IDate("3000-01-01"), + VNumA = 999, VNumB = 999, character = "Total")), + Ans3) +# 47. Date, IDate, numeric: label specified by variable for some variables having a particular class and by class for other variables having that class. +test(2294.47, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(VCharA = "Total VCharA", character = "Total", + Date = as.Date("3000-01-01"), IDate = as.IDate("3000-01-01"), + numeric = 999, VNumA = 901)), + Ans3[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB, VDate, VIDate, + VNumA = fifelse(abs(VNumA - 999) < 0.1, 901, VNumA), + VNumB, Count, Y_Sum)]) +# 48. Date, IDate, numeric: label specified by variable and by class, with class specification not used because all matching variables are specified by variable. +test(2294.48, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(character = "Total", VCharA = "Total VCharA", VCharB = "Total VCharB", + VDate = as.Date("2999-01-01"), VIDate = as.IDate("2999-01-01"), + numeric = 999, VNumA = 901, VNumB = 902, + Date = as.Date("3000-01-01"), IDate = as.IDate("3000-01-01"))), + Ans3[, .(VCharA = fifelse(VCharA == "Total", "Total VCharA", VCharA), + VCharB = fifelse(VCharB == "Total", "Total VCharB", VCharB), + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date("2999-01-01"), VDate), + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate("2999-01-01"), VIDate), + VNumA = fifelse(abs(VNumA - 999) < 0.1, 901, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, 902, VNumB), + Count, Y_Sum)]) +# 49. Date, IDate, numeric: label specified by variable with label value in the data. +test(2294.49, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(VCharA = "C2", VCharB = "Total", + VDate = as.Date("2024-01-03"), VIDate = as.IDate("2024-01-03"), + VNumA = 1, VNumB = 3)), + Ans3[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB, + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date("2024-01-03"), VDate), + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate("2024-01-03"), VIDate), + VNumA = fifelse(abs(VNumA - 999) < 0.1, 1, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, 3, VNumB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2), VDate (label: 2024-01-03), VIDate (label: 2024-01-03), VNumA (label: 1), VNumB (label: 3)]") +# 50. Date, IDate, numeric: label specified by first element of class with label value in the data. +test(2294.50, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(character = "C3", Date = as.Date("2024-01-03"), + IDate = as.IDate("3000-01-01"), numeric = 3)), + Ans3[, .(VCharA = fifelse(VCharA == "Total", "C3", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date("2024-01-03"), VDate), + VIDate, + VNumA = fifelse(abs(VNumA - 999) < 0.1, 3, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, 3, VNumB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VCharB (label: C3), VDate (label: 2024-01-03), VNumB (label: 3)]") +# 51. Date, IDate, numeric: label specified by first element of class with label value in the data. +test(2294.51, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(character = "C3", Date = as.Date("2024-01-03"), + IDate = as.IDate("2024-01-03"), numeric = 2)), + Ans3[, .(VCharA = fifelse(VCharA == "Total", "C3", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date("2024-01-03"), VDate), + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate("2024-01-03"), VIDate), + VNumA = fifelse(abs(VNumA - 999) < 0.1, 2, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, 2, VNumB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VCharB (label: C3), VDate (label: 2024-01-03), VIDate (label: 2024-01-03), VNumA (label: 2), VNumB (label: 2)]") +# 52. Date, IDate, numeric: label specified by variable and class with label value in the data. +test(2294.52, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = list(VCharA = "C2", character = "C3", + Date = as.Date("2024-01-03"), IDate = as.IDate("3000-01-01"), + numeric = 3, VDate = as.Date("3000-01-01"), + VNumA = 2)), + Ans3[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VDate, VIDate, + VNumA = fifelse(abs(VNumA - 999) < 0.1, 2, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, 3, VNumB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2), VCharB (label: C3), VNumA (label: 2), VNumB (label: 3)]") +# 53. label is a character scalar. +test(2294.53, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = "Total"), + Ans1[, .(VCharA, VCharB, + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 54. label is a named character scalar. +test(2294.54, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = c(z = "Total")), + Ans1[, .(VCharA, VCharB, + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 55. label is a factor scalar. +test(2294.55, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = factor("Total")), + Ans1[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA, VFacB, + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 56. label is an integer scalar. +test(2294.56, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = 999L), + Ans1[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA, VIntB, + Count, Y_Sum)]) +# 57. label is a Date scalar. +test(2294.57, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = as.Date("3000-01-01")), + Ans3[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VDate, + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate(NA), VIDate), + VNumA = fifelse(abs(VNumA - 999) < 0.1, NA_real_, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, NA_real_, VNumB), + Count, Y_Sum)]) +# 58. label is an IDate scalar. +test(2294.58, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = as.IDate("3000-01-01")), + Ans3[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date(NA), VDate), + VIDate, + VNumA = fifelse(abs(VNumA - 999) < 0.1, NA_real_, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, NA_real_, VNumB), + Count, Y_Sum)]) +# 59. label is a numeric scalar. +test(2294.59, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = 999), + Ans3[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date(NA), VDate), + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate(NA), VIDate), + VNumA, VNumB, Count, Y_Sum)]) +# 60. label is a scalar with class not matching any variable in 'by'. +test(2294.60, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = as.Date("3000-01-01")), + Ans1[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)]) +# 61. label is a character scalar with value in the data. +test(2294.61, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = "C2"), + Ans1[, .(VCharA = fifelse(VCharA == "Total", "C2", VCharA), + VCharB = fifelse(VCharB == "Total", "C2", VCharB), + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C2)") +# 62. label is a factor scalar with value in the data. +test(2294.62, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB", "VFacB"), + c("VCharA", "VFacB"), + c("VCharB", "VFacA"), + "VCharA", + character()), + label = factor("F3")), + Ans1[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VFacA = fifelse(VFacA == "Total", factor("F3", levels = setdiff(levels(VFacA), "Total")), + factor(VFacA, levels = setdiff(levels(VFacA), "Total"))), + VFacB = fifelse(VFacB == "Total", factor("F3", levels = setdiff(levels(VFacB), "Total")), + factor(VFacB, levels = setdiff(levels(VFacB), "Total"))), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VFacA (label: F3), VFacB (label: F3)") +# 63. label is a numeric scalar with value in the data. +test(2294.63, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + sets = list(c("VCharA", "VCharB", "VDate", "VIDate", "VNumA", "VNumB"), + c("VCharA", "VCharB", "VDate", "VNumA"), + c("VCharA", "VCharB", "VDate"), + c("VCharA", "VCharB", "VIDate"), + c("VCharA", "VIDate"), + c("VCharB", "VDate"), + "VCharA", + character()), + label = 2), + Ans3[, .(VCharA = fifelse(VCharA == "Total", NA_character_, VCharA), + VCharB = fifelse(VCharB == "Total", NA_character_, VCharB), + VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date(NA), VDate), + VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate(NA), VIDate), + VNumA = fifelse(abs(VNumA - 999) < 0.1, 2, VNumA), + VNumB = fifelse(abs(VNumB - 999) < 0.1, 2, VNumB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VNumA (label: 2), VNumB (label: 2)") +# 64. label is a character scalar with value in the data and the character variables have no 'total' rows. +test(2294.64, + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), + by = c("VCharA", "VCharB", "VFacA", "VFacB", "VIntA", "VIntB"), + sets = list(c("VCharA", "VCharB", "VFacA", "VIntA"), + c("VCharA", "VCharB", "VFacA")), + label = "C3"), + Ans2[, .(VCharA = fifelse(VCharA == "Total", "C3", VCharA), + VCharB = fifelse(VCharB == "Total", "C3", VCharB), + VFacA = fifelse(VFacA == "Total", factor(NA, levels = levels(VFacA)), VFacA), + VFacB = fifelse(VFacB == "Total", factor(NA, levels = levels(VFacB)), VFacB), + VIntA = fifelse(VIntA == 999L, NA_integer_, VIntA), + VIntB = fifelse(VIntB == 999L, NA_integer_, VIntB), + Count, Y_Sum)], + warning = "For the following variables, the 'label' value was already in the data: [VCharA (label: C3), VCharB (label: C3)]") +# 65. cube: label is a list and an element with name in 'by' has class not matching class in 'x'. +test(2294.65, + cube(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VFacA"), + label = list(VCharA = "Total", VCharB = 999, VFacA = "Total")), + error = "When argument 'label' is a list, the class of each 'label' element with name in 'by' must match the class of the corresponding column of the data.table 'x'. Class mismatch for: [VCharB (label: numeric; data: character), VFacA (label: character; data: factor)]") +# 66. cube: label specified by variable for each variable. +test(2294.66, + cube(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VFacA"), + label = list(VCharA = "Total", VCharB = "Total", VFacA = factor("Total"))), + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VFacA"), + sets = list(c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB"), + c("VCharA", "VFacA"), + "VCharA", + c("VCharB", "VFacA"), + "VCharB", "VFacA", + character(0)), + label = list(VCharA = "Total", VCharB = "Total", VFacA = factor("Total")))) +# 67. cube: label specified by variable and by class. +test(2294.67, + cube(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + label = list(character = "Total", VCharA = "Total VIntA", integer = 999L)), + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + sets = list(c("VCharA", "VCharB", "VIntA"), + c("VCharA", "VCharB"), + c("VCharA", "VIntA"), + "VCharA", + c("VCharB", "VIntA"), + "VCharB", "VIntA", + character(0)), + label = list(character = "Total", VCharA = "Total VIntA", integer = 999L))) +# 68. cube: label specified by variable and by class with label value in the data. +test(2294.68, + cube(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + label = list(character = "C3", VCharA = "Total", integer = 2L)), + suppressWarnings( + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + sets = list(c("VCharA", "VCharB", "VIntA"), + c("VCharA", "VCharB"), + c("VCharA", "VIntA"), + "VCharA", + c("VCharB", "VIntA"), + "VCharB", "VIntA", + character(0)), + label = list(character = "C3", VCharA = "Total", integer = 2L))), + warning = "For the following variables, the 'label' value was already in the data: [VCharB (label: C3), VIntA (label: 2)]") +# 69: rollup: label is a list and an element with name in 'by' has class not matching class in 'x'. +test(2294.69, + rollup(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VFacA"), + label = list(VCharA = "Total", VCharB = 999, VFacA = "Total")), + error = "When argument 'label' is a list, the class of each 'label' element with name in 'by' must match the class of the corresponding column of the data.table 'x'. Class mismatch for: [VCharB (label: numeric; data: character), VFacA (label: character; data: factor)]") +# 70. rollup: label specified by variable for each variable. +test(2294.70, + rollup(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VFacA"), + label = list(VCharA = "Total", VCharB = "Total", VFacA = factor("Total"))), + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VFacA"), + sets = list(c("VCharA", "VCharB", "VFacA"), + c("VCharA", "VCharB"), + "VCharA", + character(0)), + label = list(VCharA = "Total", VCharB = "Total", VFacA = factor("Total")))) +# 71. rollup: label specified by variable and by class. +test(2294.71, + rollup(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + label = list(character = "Total", VCharA = "Total VIntA", integer = 999L)), + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + sets = list(c("VCharA", "VCharB", "VIntA"), + c("VCharA", "VCharB"), + "VCharA", + character(0)), + label = list(character = "Total", VCharA = "Total VIntA", integer = 999L))) +# 72. rollup: label specified by variable and by class with label value in the data. +test(2294.72, + rollup(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + label = list(character = "C3", VCharA = "Total", integer = 2L)), + suppressWarnings( + groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)), by = c("VCharA", "VCharB", "VIntA"), + sets = list(c("VCharA", "VCharB", "VIntA"), + c("VCharA", "VCharB"), + "VCharA", + character(0)), + label = list(character = "C3", VCharA = "Total", integer = 2L))), + warning = "For the following variables, the 'label' value was already in the data: [VCharB (label: C3), VIntA (label: 2)]") + # setDT no longer leaks class modification to origin copy, #4784 d1 <- data.frame(a=1) d2 <- d1 setDT(d2) -test(2283, !is.data.table(d1)) \ No newline at end of file +test(2295, !is.data.table(d1)) diff --git a/man/J.Rd b/man/J.Rd index 914ca07f2..b2b581eaa 100644 --- a/man/J.Rd +++ b/man/J.Rd @@ -56,9 +56,7 @@ x = c(1, 1, 2) y = c(4, 6, 4) CJ(x, y) # output columns are automatically named 'x' and 'y' CJ(x, y, unique=TRUE) # unique(x) and unique(y) are computed automatically - -z = 0:1 + (0:1)*1i -CJ(x, z, sorted = FALSE) # support for sorting complex is not yet implemented +CJ(x, y, sorted = FALSE) # retain input order for y } \keyword{ data } diff --git a/man/data.table.Rd b/man/data.table.Rd index 5bf8c4c4e..56738a9d3 100644 --- a/man/data.table.Rd +++ b/man/data.table.Rd @@ -241,7 +241,7 @@ column called \code{keep} containing \code{TRUE} and this is correct behaviour; \code{POSIXlt} is not supported as a column type because it uses 40 bytes to store a single datetime. They are implicitly converted to \code{POSIXct} type with \emph{warning}. You may also be interested in \code{\link{IDateTime}} instead; it has methods to convert to and from \code{POSIXlt}. } -\seealso{ \code{\link{special-symbols}}, \code{\link{data.frame}}, \code{\link{[.data.frame}}, \code{\link{as.data.table}}, \code{\link{setkey}}, \code{\link{setorder}}, \code{\link{setDT}}, \code{\link{setDF}}, \code{\link{J}}, \code{\link{SJ}}, \code{\link{CJ}}, \code{\link{merge.data.table}}, \code{\link{tables}}, \code{\link{test.data.table}}, \code{\link{IDateTime}}, \code{\link{unique.data.table}}, \code{\link{copy}}, \code{\link{:=}}, \code{\link{setalloccol}}, \code{\link{truelength}}, \code{\link{rbindlist}}, \code{\link{setNumericRounding}}, \code{\link{datatable-optimize}}, \code{\link{fsetdiff}}, \code{\link{funion}}, \code{\link{fintersect}}, \code{\link{fsetequal}}, \code{\link{anyDuplicated}}, \code{\link{uniqueN}}, \code{\link{rowid}}, \code{\link{rleid}}, \code{\link{na.omit}}, \code{\link{frank}} } +\seealso{ \code{\link{special-symbols}}, \code{\link{data.frame}}, \code{\link{[.data.frame}}, \code{\link{as.data.table}}, \code{\link{setkey}}, \code{\link{setorder}}, \code{\link{setDT}}, \code{\link{setDF}}, \code{\link{J}}, \code{\link{SJ}}, \code{\link{CJ}}, \code{\link{merge.data.table}}, \code{\link{tables}}, \code{\link{test.data.table}}, \code{\link{IDateTime}}, \code{\link{unique.data.table}}, \code{\link{copy}}, \code{\link{:=}}, \code{\link{setalloccol}}, \code{\link{truelength}}, \code{\link{rbindlist}}, \code{\link{setNumericRounding}}, \code{\link{datatable-optimize}}, \code{\link{fsetdiff}}, \code{\link{funion}}, \code{\link{fintersect}}, \code{\link{fsetequal}}, \code{\link{anyDuplicated}}, \code{\link{uniqueN}}, \code{\link{rowid}}, \code{\link{rleid}}, \code{\link{na.omit}}, \code{\link{frank}}, \code{\link{rowwiseDT}} } \examples{ \dontrun{ example(data.table) # to run these examples yourself diff --git a/man/groupingsets.Rd b/man/groupingsets.Rd index 6ae02779c..5d8a30954 100644 --- a/man/groupingsets.Rd +++ b/man/groupingsets.Rd @@ -11,11 +11,11 @@ } \usage{ rollup(x, \dots) -\method{rollup}{data.table}(x, j, by, .SDcols, id = FALSE, \dots) +\method{rollup}{data.table}(x, j, by, .SDcols, id = FALSE, label = NULL, \dots) cube(x, \dots) -\method{cube}{data.table}(x, j, by, .SDcols, id = FALSE, \dots) +\method{cube}{data.table}(x, j, by, .SDcols, id = FALSE, label = NULL, \dots) groupingsets(x, \dots) -\method{groupingsets}{data.table}(x, j, by, sets, .SDcols, id = FALSE, jj, \dots) +\method{groupingsets}{data.table}(x, j, by, sets, .SDcols, id = FALSE, jj, label = NULL, \dots) } \arguments{ \item{x}{\code{data.table}.} @@ -26,9 +26,14 @@ groupingsets(x, \dots) \item{.SDcols}{columns to be used in \code{j} expression in \code{.SD} object.} \item{id}{logical default \code{FALSE}. If \code{TRUE} it will add leading column with bit mask of grouping sets.} \item{jj}{quoted version of \code{j} argument, for convenience. When provided function will ignore \code{j} argument.} + \item{label}{label(s) to be used in the 'total' rows in the grouping variable columns of the output, that is, in rows where the grouping variable has been aggregated. Can be a named list of scalars, or a scalar, or \code{NULL}. Defaults to \code{NULL}, which results in the grouping variables having \code{NA} in their 'total' rows. See Details.} } \details{ All three functions \code{rollup, cube, groupingsets} are generic methods, \code{data.table} methods are provided. + + The \code{label} argument can be a named list of scalars, or a scalar, or \code{NULL}. When \code{label} is a list, each element name must be (1) a variable name in \code{by}, or (2) the first element of the class in the data.table \code{x} of a variable in \code{by}, or (3) one of 'character', 'integer', 'numeric', 'factor', 'Date', 'IDate'. The order of the list elements is not important. A label specified by variable name will apply only to that variable, while a label specified by first element of a class will apply to all variables in \code{by} for which the first element of the class of the variable in \code{x} matches the \code{label} element name, except for variables that have a label specified by variable name (that is, specification by variable name takes precedence over specification by class). For \code{label} elements with name in \code{by}, the class of the label value must be the same as the class of the variable in \code{x}. For \code{label} elements with name not in \code{by}, the first element of the class of the label value must be the same as the \code{label} element name. For example, \code{label = list(integer = 999, IDate = as.Date("3000-01-01"))} would produce an error because \code{class(999)[1]} is not \code{"integer"} and \code{class(as.Date("3000-01-01"))[1]} is not \code{"IDate"}. A corrected specification would be \code{label = list(integer = 999L, IDate = as.IDate("3000-01-01"))}. + + The \code{label = } option provides a shorter alternative in the case where only one class of grouping variable requires a label. For example, \code{label = list(character = "Total")} can be shortened to \code{label = "Total"}. When this option is used, the label will be applied to all variables in \code{by} for which the first element of the class of the variable in \code{x} matches the first element of the class of the scalar. } \value{ A data.table with various aggregates. @@ -51,10 +56,22 @@ DT <- data.table( ) # rollup -rollup(DT, j = sum(value), by = c("color","year","status")) # default id=FALSE -rollup(DT, j = sum(value), by = c("color","year","status"), id=TRUE) -rollup(DT, j = lapply(.SD, sum), by = c("color","year","status"), id=TRUE, .SDcols="value") -rollup(DT, j = c(list(count=.N), lapply(.SD, sum)), by = c("color","year","status"), id=TRUE) +by_vars = c("color", "year", "status") +rollup(DT, j=sum(value), by=by_vars) # default id=FALSE +rollup(DT, j=sum(value), by=by_vars, id=TRUE) +rollup(DT, j=lapply(.SD, sum), by=by_vars, id=TRUE, .SDcols="value") +rollup(DT, j=c(list(count=.N), lapply(.SD, sum)), by=by_vars, id=TRUE) +rollup(DT, j=sum(value), by=by_vars, + # specify label by variable name + label=list(color="total", year=as.Date("3000-01-01"), status=factor("total"))) +rollup(DT, j=sum(value), by=by_vars, + # specify label by variable name and first element of class + label=list(color="total", Date=as.Date("3000-01-01"), factor=factor("total"))) +# label is character scalar so applies to color only +rollup(DT, j=sum(value), by=by_vars, label="total") +rollup(DT, j=.N, by=c("color", "year", "status", "value"), + # label can be explicitly specified as NA or NaN + label = list(color=NA_character_, year=as.Date(NA), status=factor(NA), value=NaN)) # cube cube(DT, j = sum(value), by = c("color","year","status"), id=TRUE) diff --git a/man/measure.Rd b/man/measure.Rd index 73a315e00..b7933e17e 100644 --- a/man/measure.Rd +++ b/man/measure.Rd @@ -18,8 +18,7 @@ } \usage{ measure(\dots, sep, pattern, cols, multiple.keyword="value.name") -measurev(fun.list, sep, pattern, cols, multiple.keyword="value.name", - group.desc="elements of fun.list") +measurev(fun.list, sep, pattern, cols, multiple.keyword="value.name") } \arguments{ \item{\dots}{One or more (1) symbols (without argument name; symbol @@ -44,7 +43,6 @@ measurev(fun.list, sep, pattern, cols, multiple.keyword="value.name", value columns (with names defined by the unique values in that group). Otherwise if the string not used as a group name, then measure returns a vector and melt returns a single value column.} - \item{group.desc}{Internal, used in error messages.} } \seealso{ \code{\link{melt}}, diff --git a/man/melt.data.table.Rd b/man/melt.data.table.Rd index ad4dfd8dd..e76edceb3 100644 --- a/man/melt.data.table.Rd +++ b/man/melt.data.table.Rd @@ -31,7 +31,7 @@ non-measure columns will be assigned to it. If integer, must be positive; see De } For convenience/clarity in the case of multiple \code{melt}ed columns, resulting column names can be supplied as names to the elements \code{measure.vars} (in the \code{list} and \code{patterns} usages). See also \code{Examples}. } -\item{variable.name}{name (default \code{'variable'}) of output column containing information about which input column(s) were melted. If \code{measure.vars} is an integer/character vector, then each entry of this column contains the name of a melted column from \code{data}. If \code{measure.vars} is a list of integer/character vectors, then each entry of this column contains an integer indicating an index/position in each of those vectors. If \code{measure.vars} has attribute \code{variable_table} then it must be a data table with nrow = length of \code{measure.vars} vector(s), each row describing the corresponding measured variables(s), (typically created via \code{measure}) and its columns will be output instead of the \code{variable.name} column.} +\item{variable.name}{name (default \code{'variable'}) of output column containing information about which input column(s) were melted. If \code{measure.vars} is an integer/character vector, then each entry of this column contains the name of a melted column from \code{data}. If \code{measure.vars} is a list of integer/character vectors, then each entry of this column contains an integer indicating an index/position in each of those vectors. If \code{measure.vars} has attribute \code{variable_table} then it must be a data table with nrow = length of \code{measure.vars} vector(s), each row describing the corresponding measured variables(s), (typically created via \code{\link{measure}}) and its columns will be output instead of the \code{variable.name} column.} \item{value.name}{name for the molten data values column(s). The default name is \code{'value'}. Multiple names can be provided here for the case when \code{measure.vars} is a \code{list}, though note well that the names provided in \code{measure.vars} take precedence. } \item{na.rm}{If \code{TRUE}, \code{NA} values will be removed from the molten data.} @@ -66,8 +66,8 @@ into multiple columns in a single function call efficiently. If a vector in the list contains missing values, or is shorter than the max length of the list elements, then the output will include runs of missing values at the specified position, or at the end. -The function -\code{\link{patterns}} can be used to provide regular expression patterns. When +The functions +\code{\link{patterns}} and \code{\link{measure}} can be used to provide regular expression patterns. When used along with \code{melt}, if \code{cols} argument is not provided, the patterns will be matched against \code{names(data)}, for convenience. diff --git a/man/patterns.Rd b/man/patterns.Rd index cd3d3fd8b..d48bb9724 100644 --- a/man/patterns.Rd +++ b/man/patterns.Rd @@ -2,8 +2,8 @@ \alias{patterns} \title{Obtain matching indices corresponding to patterns} \description{ -\code{patterns} returns the matching indices in the argument \code{cols} -corresponding to the regular expression patterns provided. The patterns must be +\code{patterns} returns the elements of \code{cols} +that match the regular expression patterns, which must be supported by \code{\link[base]{grep}}. From \code{v1.9.6}, \code{\link{melt.data.table}} has an enhanced functionality diff --git a/man/rowwiseDT.Rd b/man/rowwiseDT.Rd new file mode 100644 index 000000000..c21f425e3 --- /dev/null +++ b/man/rowwiseDT.Rd @@ -0,0 +1,25 @@ +\name{rowwiseDT} +\alias{rowwiseDT} +\title{ Create a data.table row-wise } +\description{ + \code{rowwiseDT} creates a \code{data.table} object by specifying a row-by-row layout. This is convenient and highly readable for small tables. +} +\usage{ +rowwiseDT(...) +} +\arguments{ + \item{...}{ Arguments that define the structure of a \code{data.table}. The column names come from named arguments (like \code{col=}), which must precede the data. See Examples. } +} +\value{ +A \code{data.table}. The default is for each column to return as a vector. However, if any entry has a length that is not one (e.g., \code{list(1, 2)}), the whole column will be converted to a list column. +} +\seealso{ + \code{\link{data.table}} +} +\examples{ +rowwiseDT( + A=,B=, C=, + 1, "a",2:3, + 2, "b",list(5) +) +} diff --git a/man/special-symbols.Rd b/man/special-symbols.Rd index 5b609ab06..64e251e79 100644 --- a/man/special-symbols.Rd +++ b/man/special-symbols.Rd @@ -15,7 +15,7 @@ \code{.EACHI} is a symbol passed to \code{by}; i.e. \code{by=.EACHI}, \code{.NATURAL} is a symbol passed to \code{on}; i.e. \code{on=.NATURAL} } \details{ - The bindings of these variables are locked and attempting to assign to them will generate an error. If you wish to manipulate \code{.SD} before returning it, take a \code{copy(.SD)} first (see FAQ 4.5). Using \code{:=} in the \code{j} of \code{.SD} is reserved for future use as a (tortuously) flexible way to update \code{DT} by reference by group (even when groups are not contiguous in an ad hoc by). + The bindings of these variables are locked and attempting to assign to them will generate an error. If you wish to manipulate \code{.SD} before returning it, take a \code{\link{copy}(.SD)} first (see FAQ 4.5). Using \code{:=} in the \code{j} of \code{.SD} is reserved for future use as a (tortuously) flexible way to update \code{DT} by reference by group (even when groups are not contiguous in an ad hoc by). These symbols used in \code{j} are defined as follows. @@ -33,6 +33,8 @@ \code{.NATURAL} is defined as \code{NULL} but its value is not used. Its usage is \code{on=.NATURAL} (alternative of \code{X[on=Y]}) which joins two tables on their common column names, performing a natural join; see \code{\link{data.table}}'s \code{on} argument for more details. Note that \code{.N} in \code{i} is computed up-front, while that in \code{j} applies \emph{after filtering in \code{i}}. That means that even absent grouping, \code{.N} in \code{i} can be different from \code{.N} in \code{j}. See Examples. + + Note also that you should consider these symbols read-only and of limited scope -- internal data.table code might manipulate them in unexpected ways, and as such their bindings are locked. There are subtle ways to wind up with the wrong object, especially when attempting to copy their values outside a grouping context. See examples; when in doubt, \code{copy()} is your friend. } \seealso{ \code{\link{data.table}}, \code{\link{:=}}, \code{\link{set}}, \code{\link{datatable-optimize}} @@ -66,5 +68,9 @@ DT[{cat(sprintf('in i, .N is \%d\n', .N)); a < .N/2}, # .I can be different in j and by, enabling rowwise operations in by DT[, .(.I, min(.SD[,-1]))] DT[, .(min(.SD[,-1])), by=.I] + +# Do not expect this to correctly append the value of .BY in each group; copy(.BY) will work. +by_tracker = list() +DT[, { append(by_tracker, .BY); sum(v) }, by=x] } \keyword{ data } diff --git a/po/R-fr.po b/po/R-fr.po new file mode 100644 index 000000000..1464f0162 --- /dev/null +++ b/po/R-fr.po @@ -0,0 +1,3705 @@ +msgid "" +msgstr "" +"Project-Id-Version: data.table 1.16.99\n" +"POT-Creation-Date: 2024-08-28 21:08+0000\n" +"PO-Revision-Date: 2024-09-04 13:53+0200\n" +"Last-Translator: Christian Wiat \n" +"Language-Team: \n" +"Language: fr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" +"X-Generator: Poedit 3.5\n" + +#: AllS4.R:2 +#, c-format +msgid "data.table package loaded. When developing don't load package" +msgstr "" +"package data.table chargé. En cours de développement, ne pas charger le package" + +#: IDateTime.R:107 +#, c-format +msgid "binary + is not defined for \"IDate\" objects" +msgstr "l'opérateur binaire + n'est pas défini pour les objets \"IDate\"" + +#: IDateTime.R:114 +#, c-format +msgid "can only subtract from \"IDate\" objects" +msgstr "seule la soustraction est autorisée sur les objets \"IDate\"" + +#: IDateTime.R:119 +#, c-format +msgid "unary - is not defined for \"IDate\" objects" +msgstr "l'opérateur unaire - n'est pas défini sur les objets \"IDate\"" + +#: IDateTime.R:309 +#, c-format +msgid "Valid options for ms are 'truncate', 'nearest', and 'ceil'." +msgstr "Les options valides pour ms sont 'truncate', 'nearest', et 'ceil'." + +#: as.data.table.R:86 +#, c-format +msgid "" +"as.data.table.array method should only be called for arrays with 3+ " +"dimensions; use the matrix method for 2-dimensional arrays" +msgstr "" +"la méthode as.data.table.array ne doit être appelée que pour les tableaux de " +"dimension 3+ ; Utiliser la méthode matrix pour les tableaux de dimension 2" + +#: as.data.table.R:88 +#, c-format +msgid "" +"Argument 'value.name' must be scalar character, non-NA and at least one " +"character" +msgstr "" +"L'argument 'value.name' doit être un caractère scalaire, pas NA et d'au moins " +"un caractère" + +#: as.data.table.R:90 +#, c-format +msgid "Argument 'sorted' must be scalar logical and non-NA" +msgstr "L'argument 'sorted' doit être un scalaire, un booléen et différent de NA" + +#: as.data.table.R:92 +#, c-format +msgid "Argument 'na.rm' must be scalar logical and non-NA" +msgstr "L'argument 'na.rm' doit être un scalaire, un booléen et différent de NA" + +#: as.data.table.R:94 +#, c-format +msgid "Please provide either 'key' or 'sorted', but not both." +msgstr "Utiliser 'key' ou 'sorted' mais pas les deux simultanément." + +#: as.data.table.R:108 +#, c-format +msgid "Argument 'value.name' should not overlap with column names in result: %s" +msgstr "" +"L'argument 'value.name' ne doit pas recouvrir le nom des colonnes dans le " +"résultat : %s" + +#: as.data.table.R:140 +#, c-format +msgid "" +"POSIXlt column type detected and converted to POSIXct. We do not recommend use " +"of POSIXlt at all because it uses 40 bytes to store one date." +msgstr "" +"Le type de colonne POSIXlt a été détecté et converti en POSIXct. Nous ne " +"recommandons pas l'utilisation de POSIXlt car il utilise 40 octets pour " +"stocker une date." + +#: as.data.table.R:181 +#, c-format +msgid "Item %d has %d rows but longest item has %d; recycled with remainder." +msgstr "" +"L'élément %d a %d lignes mais l'élément le plus long en a %d ; Il est recyclé " +"avec le reste." + +#: as.data.table.R:196 +#, c-format +msgid "A column may not be called .SD. That has special meaning." +msgstr "" +"Une colonne ne peut pas s'appeler .SD. Ceci a une signification particulière." + +#: as.data.table.R:210 +#, c-format +msgid "class must be length 1" +msgstr "la classe doit être de longueur 1" + +#: between.R:3 +#, c-format +msgid "between has been passed an argument x of type logical" +msgstr "'between' contient un argument x booléen" + +#: between.R:13 between.R:15 +#, c-format +msgid "" +"'between' function the 'x' argument is a POSIX class while '%s' was not, " +"coercion to POSIX failed with: %s" +msgstr "" +"fonction 'between' l'argument 'x' est une classe POSIX alors que '%s' ne l'est " +"pas, échec de la conversion automatique en POSIX avec : %s" + +#: between.R:27 +#, c-format +msgid "" +"'between' lower= and upper= are both POSIXct but have different tzone " +"attributes: %s. Please align their time zones." +msgstr "" +"'between' lower= et upper= sont tous deux traduits en POSIXct mais leurs " +"attributs ‘tzone’ sont différents : %s. Veuillez aligner leur fuseau horaire." + +#: between.R:31 +#, c-format +msgid "" +"'between' arguments are all POSIXct but have mismatched tzone attributes: %s. " +"The UTC times will be compared." +msgstr "" +"les arguments 'between' sont tous POSIXct mais les attributs tzone associés ne " +"correspondent pas : %s. La comparaison se fera sur le temps UTC." + +#: between.R:36 +#, c-format +msgid "trying to use integer64 class when 'bit64' package is not installed" +msgstr "" +"utilisation de la classe integer64 alors que le package 'bit64' n'est pas " +"installé" + +#: between.R:48 +#, c-format +msgid "" +"Not yet implemented NAbounds=TRUE for this non-numeric and non-character type" +msgstr "" +"NAbounds=TRUE n'est pas encore implémenté pour ce type non numérique et non " +"caractère" + +#: between.R:49 +#, c-format +msgid "Some lower>upper for this non-numeric and non-character type" +msgstr "" +"Certains inférieurs sont plus grands que les supérieurs (lower>upper) pour ce " +"type non numérique et non caractère" + +#: between.R:63 +#, c-format +msgid "Perhaps you meant %s?" +msgstr "Peut-être vouliez-vous dire %s ?" + +#: between.R:64 +#, c-format +msgid "" +"RHS has length() %d; expecting length 2. %sThe first element should be the " +"lower bound(s); the second element should be the upper bound(s)." +msgstr "" +"Le membre de droite a pour longueur %d au lieu de 2 attendu. %s Le premier " +"élément représente la ou les borne(s) inférieure(s) ; Le second élément " +"représente la ou les borne(s) supérieure(s)." + +#: bmerge.R:48 bmerge.R:49 +#, c-format +msgid "%s is type %s which is not supported by data.table join" +msgstr "" +"%s est de type %s qui n'est pas pris en charge pour une jointure data.table" + +#: bmerge.R:52 +#, c-format +msgid "" +"Attempting roll join on factor column when joining %s to %s. Only integer, " +"double or character columns may be roll joined." +msgstr "" +"Tentative de jointure par roulement sur une colonne de facteurs lors de la " +"jointure de %s à %s. Seules les colonnes de nombres entiers, de nombres " +"doubles ou de caractères peuvent être jointes par roulement." + +#: bmerge.R:71 +#, c-format +msgid "" +"Incompatible join types: %s (%s) and %s (%s). Factor columns must join to " +"factor or character columns." +msgstr "" +"Types de jointures incompatibles : %s (%s) et %s (%s). Les colonnes de " +"facteurs doivent être jointes à des colonnes de facteurs ou de caractères." + +#: bmerge.R:90 +#, c-format +msgid "Incompatible join types: %s (%s) and %s (%s)" +msgstr "Types incompatibles pour la jointure : %s (%s) et %s (%s)" + +#: bmerge.R:98 +#, c-format +msgid "" +"Incompatible join types: %s is type integer64 but %s is type double and " +"contains fractions" +msgstr "" +"Types de jointures incompatibles : %s est de type integer64 mais %s est de " +"type double et contient des fractions" + +#: bmerge.R:150 +#, c-format +msgid "roll is not implemented for non-equi joins yet." +msgstr "roll n'est pas encore implémenté avec des jointure non-equi." + +#: bmerge.R:170 +#, c-format +msgid "Column name '_nqgrp_' is reserved for non-equi joins." +msgstr "Le nom de colonne '_nqgrp_' est réservé pour les jointures non-equi." + +#: data.table.R:55 +#, c-format +msgid "key argument of data.table() must be character" +msgstr "l'argument key de data.table() doit être une chaîne de caractères" + +#: data.table.R:121 +#, c-format +msgid "Object '%s' not found. Perhaps you intended %s" +msgstr "Objet '%s' non trouvé. Peut-être vous vouliez dire %s" + +#: data.table.R:123 +#, c-format +msgid "Object '%s' not found amongst %s" +msgstr "Objet '%s' non trouvé parmi %s" + +#: data.table.R:139 +#, c-format +msgid "" +"[ was called on a data.table in an environment that is not data.table-aware (i." +"e. cedta()), but '%s' was used, implying the owner of this call really " +"intended for data.table methods to be called. See vignette('datatable-" +"importing') for details on properly importing data.table." +msgstr "" +"[ a été appelé sur un data.table dans un environnement qui n'est pas " +"compatible avec data.table (i.e. cedta()), mais '%s' a été utilisé, ce qui " +"implique que le propriétaire de cet appel avait vraiment l'intention d'appeler " +"des méthodes data.table. Voir la vignette('datatable-importing') pour plus de " +"détails sur l’importation correcte de data.table." + +#: data.table.R:150 +#, c-format +msgid "verbose must be logical or integer" +msgstr "verbose doit être soit un booléen, soit un entier" + +#: data.table.R:151 +#, c-format +msgid "verbose must be length 1 non-NA" +msgstr "verbose doit être de longueur 1 et différent de NA" + +#: data.table.R:159 +#, c-format +msgid "Ignoring by/keyby because 'j' is not supplied" +msgstr "L'argument by ou keyby est ignoré car 'j' n'est pas fourni" + +#: data.table.R:173 +#, c-format +msgid "When by and keyby are both provided, keyby must be TRUE or FALSE" +msgstr "Si by et keyby sont fournis simultanément, keyby doit être TRUE ou FALSE" + +#: data.table.R:185 +#, c-format +msgid "" +"When on= is provided but not i=, on= must be a named list or data.table|frame, " +"and a natural join (i.e. join on common names) is invoked. Ignoring on= which " +"is '%s'." +msgstr "" +"Lorsque on= est fourni mais pas i=, on= doit être une liste nommée ou un data." +"table|frame, et une jointure naturelle (c'est-à-dire une jointure sur les noms " +"communs) est invoquée. La valeur de on= qui est '%s' est ignorée." + +#: data.table.R:198 +#, c-format +msgid "" +"i and j are both missing so ignoring the other arguments. This warning will be " +"upgraded to error in future." +msgstr "" +"i et j sont tous les deux absents, donc les autres arguments sont ignorés. Cet " +"avertissement deviendra une erreur à l'avenir." + +#: data.table.R:202 +#, c-format +msgid "mult argument can only be 'first', 'last' or 'all'" +msgstr "l'argument mult ne peut valoir que 'first', 'last' ou 'all'" + +#: data.table.R:204 +#, c-format +msgid "" +"roll must be a single TRUE, FALSE, positive/negative integer/double including " +"+Inf and -Inf or 'nearest'" +msgstr "" +"roll doit être une seule valeur TRUE, FALSE, un entier ou un double, positif " +"ou négatif, +Inf, -Inf ou 'nearest' compris" + +#: data.table.R:206 +#, c-format +msgid "roll is '%s' (type character). Only valid character value is 'nearest'." +msgstr "" +"roll vaut '%s' (de type caractère). La seule chaîne valide est 'nearest'." + +#: data.table.R:211 +#, c-format +msgid "rollends must be a logical vector" +msgstr "rollends doit être un vecteur de booléens" + +#: data.table.R:212 +#, c-format +msgid "rollends must be length 1 or 2" +msgstr "rollends doit être de longueur 1 ou 2" + +#: data.table.R:220 +#, c-format +msgid "" +"nomatch= must be either NA or NULL (or 0 for backwards compatibility which is " +"the same as NULL but please use NULL)" +msgstr "" +"nomatch= doit valoir soit NA, soit NULL (ou 0 pour la compatibilité " +"descendante qui équivaut à NULL, mais utiliser NULL dorénavant)" + +#: data.table.R:223 +#, c-format +msgid "which= must be a logical vector length 1. Either FALSE, TRUE or NA." +msgstr "" +"which= doit être un vecteur de booléens de longueur 1. Valeur FALSE, TRUE ou " +"NA." + +#: data.table.R:224 +#, c-format +msgid "" +"which==%s (meaning return row numbers) but j is also supplied. Either you need " +"row numbers or the result of j, but only one type of result can be returned." +msgstr "" +"which==%s (renvoie des numéros de ligne) mais j est également fourni. Vous " +"avez besoin soit des numéros de ligne, soit du résultat de j, mais un seul " +"type de résultat peut être renvoyé." + +#: data.table.R:225 +#, c-format +msgid "" +"which=NA with nomatch=0|NULL would always return an empty vector. Please " +"change or remove either which or nomatch." +msgstr "" +"which=NA avec nomatch=0|NULL renverrait toujours un vecteur vide. Veuillez " +"modifier ou supprimer soit which, soit nomatch." + +#: data.table.R:226 +#, c-format +msgid "j must be provided when with=FALSE" +msgstr "j doit être fourni quand with=FALSE" + +#: data.table.R:227 +#, c-format +msgid "%s must be TRUE or FALSE" +msgstr "%s doit être TRUE ou FALSE" + +#: data.table.R:267 +#, c-format +msgid "" +"The symbol .. is invalid. The .. prefix must be followed by at least one " +"character." +msgstr "" +"Le symbole .. n'est pas valide. Le préfixe .. doit être suivi d'au moins un " +"caractère." + +#: data.table.R:270 +#, c-format +msgid "" +"Variable '..%s' does exist in calling scope though, so please just removed " +"the .. prefix from that variable name in calling scope." +msgstr "" +"La variable '..%s' existe dans la portée de l'appelant, il suffit donc de " +"supprimer le préfixe .. de ce nom de variable dans la portée de l'appelant." + +#: data.table.R:274 +#, c-format +msgid "" +"Variable '%s' is not found in calling scope. Looking in calling scope because " +"you used the .. prefix.%s" +msgstr "" +"La variable '%s' n'est pas visible dans le contexte de l'appelant désigné par " +"le préfixe .. .%s" + +#: data.table.R:276 +#, c-format +msgid "" +"Both '%1$s' and '..%1$s' exist in calling scope. Please remove the '..%1$s' " +"variable in calling scope for clarity." +msgstr "" +"'%1$s' et '..%1$s' sont tous deux visibles dans le contexte de l'appelant. " +"Veuillez supprimer la variable '..%1$s' de ce contexte pour clarifier." + +#: data.table.R:284 +#, c-format +msgid "" +"Variable '%s' is not found in calling scope. Looking in calling scope because " +"you set with=FALSE. Also, please use .. symbol prefix and remove with=FALSE." +msgstr "" +"La variable '%s' n'est pas visible dans le contexte de l'appelant désigné par " +"with=FALSE. Utilisez alors le préfixe de symbole .. et supprimez with=FALSE." + +#: data.table.R:292 +#, c-format +msgid "" +"You have wrapped := with {} which is ok but then := must be the only thing " +"inside {}. You have something else inside {} as well. Consider placing the {} " +"on the RHS of := instead; e.g. DT[,someCol:={tmpVar1<-...;tmpVar2<-...;" +"tmpVar1*tmpVar2}" +msgstr "" +"L'opérateur := est entouré d’accolades {} ce qui est bien, mais ensuite := " +"doit être le seul élément dans {}. Or il y a autre chose également dans {} . " +"Déplacez plutôt les {} vers le membre droit de := ; par exemple DT[,someCol:" +"={tmpVar1<-...;tmpVar2<-...;tmpVar1*tmpVar2}" + +#: data.table.R:310 +#, c-format +msgid "" +":= with keyby is only possible when i is not supplied since you can't setkey " +"on a subset of rows. Either change keyby to by or remove i" +msgstr "" +":= avec keyby n'est accepté que si i n'est pas fourni parce que setkey sur un " +"sous-ensemble de lignes n'est pas possible. Modifiez soit keyby en by, ou " +"supprimez i" + +#: data.table.R:312 +#, c-format +msgid "nomatch isn't relevant together with :=, ignoring nomatch" +msgstr "nomatch n'est pas pertinent avec with :=, nomatch est ignoré" + +#: data.table.R:368 +#, c-format +msgid "" +"not-join '!' prefix is present on i but nomatch is provided. Please remove " +"nomatch." +msgstr "" +"le préfixe de non-jointure '!' est présent sur i mais nomatch est fourni. " +"Supprimer nomatch." + +#: data.table.R:396 +#, c-format +msgid "" +"Operator := detected in i, the first argument inside DT[...], but is only " +"valid in the second argument, j. Most often, this happens when forgetting the " +"first comma (e.g. DT[newvar := 5] instead of DT[ , new_var := 5]). Please " +"double-check the syntax. Run traceback(), and debugger() to get a line number." +msgstr "" +"L'opérateur := est présent dans i, le premier argument de DT[...], mais n'est " +"valide que dans le second argument, j. Le plus souvent, cela se produit " +"lorsqu'on oublie la première virgule (par exemple, DT[newvar := 5] au lieu de " +"DT[ , new_var := 5]). Veuillez vérifier la syntaxe. Exécuter traceback(), et " +"debugger() pour obtenir un numéro de ligne." + +#: data.table.R:406 +#, c-format +msgid "'%s' is not found in calling scope and it is not a column name either" +msgstr "" +"'%s' n'est pas visible dans le contexte de l'appelant et ce n'est pas non plus " +"un nom de colonne" + +#: data.table.R:409 +#, c-format +msgid "" +"'%s' is not found in calling scope, but it is a column of type %s. If you wish " +"to select rows where that column contains TRUE, or perhaps that column " +"contains row numbers of itself to select, try DT[(col)], DT[DT$col], or " +"DT[col==TRUE} is particularly clear and is optimized" +msgstr "" +"'%s' n'est pas visible dans le contexte de l'appelant, mais c'est une colonne " +"de type %s. Si vous souhaitez sélectionner des lignes pour lesquelles cette " +"colonne vaut TRUE, ou peut-être que cette colonne contient ses propres numéros " +"de lignes à sélectionner, essayez DT[(col)], DT[DT$col], ou DT[col==TRUE] qui " +"est particulièrement clair et optimisé" + +#: data.table.R:412 +#, c-format +msgid "" +"%s. When the first argument inside DT[...] is a single symbol (e.g. DT[var]), " +"data.table looks for var in calling scope." +msgstr "" +"%s. Lorsque le premier argument de DT[...] est un symbole unique (par exemple " +"DT[var]), data.table cherche var dans le contexte de l'appelant." + +#: data.table.R:424 +#, c-format +msgid "" +"i is invalid type (matrix). Perhaps in future a 2 column matrix could return a " +"list of elements of DT (in the spirit of A[B] in FAQ 2.14). Please report to " +"data.table issue tracker if you'd like this, or add your comments to FR #657." +msgstr "" +"i a un type non valide (matrice). Peut-être qu'à l'avenir, une matrice à 2 " +"colonnes pourrait renvoyer une liste d'éléments de DT (dans l'esprit de A[B] " +"de la FAQ 2.14). Veuillez rapporter ce problème dans le gestionnaire de " +"tickets (issues tracker) de data.table si vous le souhaitez, ou ajouter vos " +"commentaires à FR #657." + +#: data.table.R:447 +#, c-format +msgid "" +"When i is a data.table (or character vector), the columns to join by must be " +"specified using 'on=' argument (see ?data.table), by keying x (i.e. sorted, " +"and, marked as sorted, see ?setkey), or by sharing column names between x and " +"i (i.e., a natural join). Keyed joins might have further speed benefits on " +"very large data due to x being sorted in RAM." +msgstr "" +"Lorsque i est une data.table (ou un vecteur de chaînes de caractères), les " +"colonnes à joindre doivent être spécifiées à l'aide de l'argument 'on=' (voir ?" +"data.table), par l'attribution d'une clé à x (c'est-à-dire trié, et, marqué " +"comme trié, voir ?setkey), ou en partageant les noms des colonnes entre x et i " +"(c'est-à-dire, une jointure naturelle). Les jointures avec clé peuvent avoir " +"des avantages supplémentaires en termes de rapidité sur des données très " +"volumineuses, car x est trié en mémoire vive." + +#: data.table.R:455 +#, c-format +msgid "Attempting to do natural join but no common columns in provided tables" +msgstr "" +"Aucune colonne commune dans les tables fournies pour réaliser la jointure " +"naturelle" + +#: data.table.R:587 +#, c-format +msgid "logical error. i is not a data.table, but 'on' argument is provided." +msgstr "" +"erreur logique. i n'est pas une data.table, mais l'argument 'on' est fourni." + +#: data.table.R:591 +#, c-format +msgid "i has evaluated to type %s. Expecting logical, integer or double." +msgstr "" +"i a pour type %s alors qu'un booléen, un entier ou un double est attendu." + +#: data.table.R:613 +#, c-format +msgid "" +"i evaluates to a logical vector length %d but there are %d rows. Recycling of " +"logical i is no longer allowed as it hides more bugs than is worth the rare " +"convenience. Explicitly use rep(...,length=.N) if you really need to recycle." +msgstr "" +"i représente un vecteur logique de longueur %d mais il y a %d lignes. Le " +"recyclage du vecteur logique i n'est plus autorisé, car il cache plus souvent " +"des bogues qu'il n'en vaut la peine. Utiliser explicitement rep(...,length=.N) " +"si vous avez vraiment besoin de recycler ce vecteur." + +#: data.table.R:616 +#, c-format +msgid "" +"Please use nomatch=NULL instead of nomatch=0; see news item 5 in v1.12.0 (Jan " +"2019)" +msgstr "" +"Veuillez utiliser nomatch=NULL au lieu de nomatch=0; voir l'élément 5 des news " +"v1.12.0 (janvier 2019)" + +#: data.table.R:688 +#, c-format +msgid "" +"with=FALSE together with := was deprecated in v1.9.4 released Oct 2014. Please " +"wrap the LHS of := with parentheses; e.g., DT[,(myVar):=sum(b),by=a] to assign " +"to column name(s) held in variable myVar. See ?':=' for other examples. As " +"warned in 2014, this is now a warning." +msgstr "" +"with=FALSE avec := a été déprécié dans la version 1.9.4 publiée en octobre " +"2014. Veuillez entourer le membre gauche de := avec des parenthèses ; Par " +"exemple, DT[,(monVar):=sum(b),by=a] pour affecter le(s) nom(s) de colonne(s) " +"contenu(s) dans la variable myVar. Voir ?':=' pour d'autres exemples. Comme " +"annoncé en 2014, il s'agit maintenant d'un avertissement." + +#: data.table.R:691 +#, c-format +msgid "" +"with=FALSE ignored, it isn't needed when using :=. See ?':=' for examples." +msgstr "" +"with=FALSE est ignoré quand := est utilisé. Voir ?':=' pour les exemples." + +#: data.table.R:715 +#, c-format +msgid "column(s) not removed because not found: %s" +msgstr "colonne(s) non supprimée(s) car manquante(s) : %s" + +#: data.table.R:729 +#, c-format +msgid "column(s) not found: %s" +msgstr "colonnes(s) absente(s) : %s" + +#: data.table.R:735 +#, c-format +msgid "Item %d of j is %d which is outside the column number range [1,ncol=%d]" +msgstr "" +"L'élément %d de j vaut %d qui n'est pas dans l'intervalle des index de colonne " +"[1,ncol=%d]" + +#: data.table.R:738 +#, c-format +msgid "j mixes positives and negatives" +msgstr "j mélange les valeurs positives et négatives" + +#: data.table.R:746 +#, c-format +msgid "" +"When with=FALSE, j-argument should be of type logical/character/integer " +"indicating the columns to select." +msgstr "" +"Lorsque with=FALSE, l’argument j doit être de type boléen/caractère/entier " +"indiquant les colonnes à sélectionner." + +#: data.table.R:760 +#, c-format +msgid "" +"'by' contains .I but only the following are currently supported: by=.I, by=.(." +"I), by=c(.I), by=list(.I)" +msgstr "" +"'by' contient .I qui n'autorisé que pour : by=.I, by=.(.I), by=c(.I), by=list(." +"I)" + +#: data.table.R:784 +#, c-format +msgid "by=c(...), key(...) or names(...) must evaluate to 'character'" +msgstr "by=c(...), key(...) ou names(...) doivent être de type 'character'" + +#: data.table.R:794 +#, c-format +msgid "" +"'by' is a character vector length %d but one or more items include a comma. " +"Either pass a vector of column names (which can contain spaces, but no " +"commas), or pass a vector length 1 containing comma separated column names. " +"See ?data.table for other possibilities." +msgstr "" +"'by' est un vecteur de caractères de longueur %d mais un ou plusieurs éléments " +"contiennent une virgule. Passer un vecteur de noms de colonnes (pouvant " +"contenir des espaces, mais pas de virgule), ou un vecteur de longueur 1 " +"contenant des noms de colonnes séparés par une virgule. Voir ?data.table pour " +"d'autres possibilités." + +#: data.table.R:801 +#, c-format +msgid "At least one entry of by is empty" +msgstr "Au moins une valeur de by est vide" + +#: data.table.R:876 +#, c-format +msgid "" +"'by' appears to evaluate to column names but isn't c() or key(). Use " +"by=list(...) if you can. Otherwise, by=eval%s should work. This is for " +"efficiency so data.table can detect which columns are needed." +msgstr "" +"'by' semble représenter des noms de colonnes mais n'est pas c() ni key(). " +"Utiliser by=list(...) si vous le pouvez. Sinon, by=eval%s doit fonctionner. " +"C'est à data.table de détecter les colonnes nécessaires pour un traitement " +"efficace." + +#: data.table.R:887 +#, c-format +msgid "" +"'by' or 'keyby' must evaluate to a vector or a list of vectors (where 'list' " +"includes data.table and data.frame which are lists, too)" +msgstr "" +"'by' ou 'keyby' doit correspondre à un vecteur ou à une liste de vecteurs (où " +"'list' inclut data.table et data.frame qui sont également des listes)" + +#: data.table.R:891 +#, c-format +msgid "" +"Column or expression %d of 'by' or 'keyby' is type '%s' which is not currently " +"supported. If you have a compelling use case, please add it to https://github." +"com/Rdatatable/data.table/issues/1597. As a workaround, consider converting " +"the column to a supported type, e.g. by=sapply(list_col, toString), whilst " +"taking care to maintain distinctness in the process." +msgstr "" +"La colonne ou l'expression %d de 'by' ou 'keyby' est de type '%s' qui n'est " +"pas pris en charge actuellement. Si vous avez un cas d'utilisation " +"convaincant, veuillez l'ajouter sur https://github.com/Rdatatable/data.table/" +"issues/1597. Comme solution de contournement, envisagez de convertir la " +"colonne en un type pris en charge, par exemple by=sapply(list_col, toString), " +"tout en veillant à maintenir la distinction dans le processus." + +#: data.table.R:895 +#, c-format +msgid "" +"The items in the 'by' or 'keyby' list are length(s) %s. Each must be length " +"%d; the same length as there are rows in x (after subsetting if i is provided)." +msgstr "" +"Les éléments de la liste ‘by’ ou ‘keyby’ sont de longueur(s) %s. Chacun d'eux " +"doit être de longueur %d ; la même longueur que celle des lignes de x (après " +"le sous-ensemble si i est fourni)." + +#: data.table.R:948 +#, c-format +msgid "Item %d of the .() or list() passed to j is missing" +msgstr "L'élément %d de .() ou de list() passé à j est absent" + +#: data.table.R:954 +#, c-format +msgid "" +"j may not evaluate to the same number of columns for each group; if you're " +"sure this warning is in error, please put the branching logic outside of [ for " +"efficiency" +msgstr "" +"j peut ne pas évaluer le même nombre de colonnes pour chaque groupe ; si vous " +"êtes sûr que cet avertissement est une erreur, veuillez placer la logique de " +"branchement en dehors de [ pour plus d'efficacité" + +#: data.table.R:956 +#, c-format +msgid "" +"Different branches of j expression produced different auto-named columns: %s; " +"using the most \"last\" names. If this was intentional (e.g., you know only " +"one branch will ever be used in a given query because the branch is controlled " +"by a function argument), please (1) pull this branch out of the call; (2) " +"explicitly provide missing defaults for each branch in all cases; or (3) use " +"the same name for each branch and re-name it in a follow-up call." +msgstr "" +"Différentes branches de l'expression j ont produit différentes colonnes auto-" +"nommées : %s ; Les derniers noms connus sont utilisés. Si cela était " +"intentionnel (par exemple, vous savez qu'une seule branche sera utilisée dans " +"une requête donnée parce que la branche est contrôlée par un argument de " +"fonction), veuillez (1) retirer cette branche de l'appel ; (2) fournir " +"explicitement les valeurs par défaut manquantes pour chaque branche dans tous " +"les cas ; ou (3) utiliser le même nom pour chaque branche et la renommer dans " +"un appel ultérieur." + +#: data.table.R:1026 +#, c-format +msgid "" +"When .SDcols is a function, it is applied to each column; the output of this " +"function must be a non-missing boolean scalar signalling inclusion/exclusion " +"of the column. However, these conditions were not met for: %s" +msgstr "" +"Quand .SDcols est une fonction, elle est appliquée à chaque colonne ; La " +"sortie de cette fonction doit être un scalaire booléen présent indiquant " +"l'inclusion ou l'exclusion de la colonne. Néanmoins ces conditions ne sont pas " +"satisfaite pour : %s" + +#: data.table.R:1032 +#, c-format +msgid ".SDcols missing at the following indices: %s" +msgstr ".SDcols est absent aux indices suivants : %s" + +#: data.table.R:1034 +#, c-format +msgid ".SDcols is a logical vector length %d but there are %d columns" +msgstr ".SDcols est un vecteur booléens de longueur %d mais il y a %d colonnes" + +#: data.table.R:1040 +#, c-format +msgid ".SDcols is numeric but has both +ve and -ve indices" +msgstr ".SDcols est numérique mais comporte à la fois des indices +ve et -ve" + +#: data.table.R:1042 +#, c-format +msgid ".SDcols is numeric but out of bounds [1, %d] at: %s" +msgstr ".SDcols est numérique mais hors de l'intervalle [1, %d] à : %s" + +#: data.table.R:1046 +#, c-format +msgid ".SDcols should be column numbers or names" +msgstr ".SDcols doit fournir des numéros de colonnes ou des noms" + +#: data.table.R:1048 +#, c-format +msgid "Some items of .SDcols are not column names: %s" +msgstr "Certains éléments de .SDcols ne sont pas des noms de colonnes : %s" + +#: data.table.R:1090 +#, c-format +msgid "" +"This j doesn't use .SD but .SDcols has been supplied. Ignoring .SDcols. See ?" +"data.table." +msgstr "" +"Ce j n'utilise pas .SD mais .SDcols qui a été fourni. .SDcols est ignoré. " +"Voir ?data.table." + +#: data.table.R:1106 +#, c-format +msgid "" +".SD is locked. Using := in .SD's j is reserved for possible future use; a " +"tortuously flexible way to modify by group. Use := in j directly to modify by " +"group by reference." +msgstr "" +".SD est verrouillé. L'utilisation de := dans j de .SD est réservée pour une " +"utilisation future possible ; une manière un peu tordue de modifier par " +"groupe. Utiliser := dans j directement pour modifier par groupe et par " +"référence." + +#: data.table.R:1114 +#, c-format +msgid "In %s(col1=val1, col2=val2, ...) form, all arguments must be named." +msgstr "" +"Dans la forme %s(col1=val1, col2=val2, ...), tous les arguments doivent être " +"nommés." + +#: data.table.R:1136 +#, c-format +msgid "" +"In %s(col1=val1, col2=val2, ...) form, all arguments must be named, but the " +"last argument has no name. Did you forget a trailing comma?" +msgstr "" +"Dans la forme %s(col1=val1, col2=val2, ...), tous les arguments doivent être " +"nommés, cependant le dernier argument n’a pas de nom. Avez-vous oublié une " +"virgule à la fin ?" + +#: data.table.R:1138 +#, c-format +msgid "" +"In %s(col1=val1, col2=val2, ...) form, all arguments must be named, but these " +"arguments lack names: %s." +msgstr "" +"Dans la forme %s(col1=val1, col2=val2, ...), tous les arguments doivent être " +"nommés, mais les arguments suivants n’ont pas de nom : %s." + +#: data.table.R:1145 +#, c-format +msgid "" +"LHS of := must be a symbol, or an atomic vector (column names or positions)." +msgstr "" +"Le membre gauche de := doit être un symbole, ou un vecteur atomique (noms de " +"colonnes ou positions)." + +#: data.table.R:1150 +#, c-format +msgid "" +"LHS of := appears to be column positions but are outside [1,ncol] range. New " +"columns can only be added by name." +msgstr "" +"Le membre gauche de := semble être des positions de colonnes mais elles sont " +"en dehors de l'intervalle [1,ncol] . Ajouter les nouvelles colonnes par nom " +"uniquement." + +#: data.table.R:1153 +#, c-format +msgid "" +"LHS of := isn't column names ('character') or positions ('integer' or " +"'numeric')" +msgstr "" +"Le membre gauche de := ne correspond pas à des noms de colonnes ('character') " +"ni à des positions ('integer' ou 'numeric')" + +#: data.table.R:1184 +#, c-format +msgid "" +"Invalid .internal.selfref detected and fixed by taking a (shallow) copy of the " +"data.table so that := can add this new column by reference. At an earlier " +"point, this data.table has been copied by R (or was created manually using " +"structure() or similar). Avoid names<- and attr<- which in R currently (and " +"oddly) may copy the whole data.table. Use set* syntax instead to avoid " +"copying: ?set, ?setnames and ?setattr. If this message doesn't help, please " +"report your use case to the data.table issue tracker so the root cause can be " +"fixed or this message improved." +msgstr "" +"Invalide .internal.selfref détecté et corrigé en prenant une copie (peu " +"profonde) du data.table afin que := puisse ajouter cette nouvelle colonne par " +"référence. Ce data.table a été copié antérieurement par R (ou a été créé " +"manuellement en utilisant structure() ou similaire). Évitez names<- et attr<- " +"qui, dans R, peuvent actuellement (et bizarrement) copier tout le data.table. " +"Utilisez plutôt la syntaxe set* pour éviter la copie : ?set, ?setnames et ?" +"setattr. Si ce message ne vous aide pas, veuillez rapporter votre cas " +"d'utilisation dans le gestionnaire de tickets de data.table (issue tracker) " +"afin que la cause première puisse être corrigée ou que ce message soit " +"amélioré." + +#: data.table.R:1215 +#, c-format +msgid "" +"Cannot assign to an under-allocated recursively indexed list -- L[[i]][,:=] " +"syntax is only valid when i is length 1, but its length is %d" +msgstr "" +"Impossible d'assigner à une sous-liste indexée récursivement -- la syntaxe " +"L[[i]][,:=] n'est autorisée que si i est de longueur 1 mais sa longueur est %d" + +#: data.table.R:1284 +#, c-format +msgid "" +"Variable '%s' is not found in calling scope. Looking in calling scope because " +"this symbol was prefixed with .. in the j= parameter." +msgstr "" +"La variable '%s' n'est pas visible dans le contexte de l'appelant désigné par " +"le préfixe .. du symbole dans le paramètre j= ." + +#: data.table.R:1370 +#, c-format +msgid "" +"j (the 2nd argument inside [...]) is a single symbol but column name '%1$s' is " +"not found. If you intended to select columns using a variable in calling " +"scope, please try DT[, ..%1$s]. The .. prefix conveys one-level-up similar to " +"a file system path." +msgstr "" +"j (le deuxième argument à l'intérieur de [...]) est un symbole unique mais le " +"nom de la colonne '%1$s' n'est pas trouvé. Si vous souhaitez sélectionner des " +"colonnes à l'aide d'une variable dans la portée de l'appelant, essayez DT[, .." +"%1$s]. Le préfixe .. indique un niveau supérieur similaire à celui d'un chemin " +"d'accès pour un système de fichiers." + +#: data.table.R:1454 +#, c-format +msgid "" +"The column '.N' can't be grouped because it conflicts with the special .N " +"variable. Try setnames(DT,'.N','N') first." +msgstr "" +"La colonne '.N' ne peut pas être groupée car elle est en conflit avec la " +"variable spéciale .N variable. Essayer d'abord setnames(DT,'.N','N') ." + +#: data.table.R:1455 +#, c-format +msgid "" +"The column '.I' can't be grouped because it conflicts with the special .I " +"variable. Try setnames(DT,'.I','I') first." +msgstr "" +"La colonne '.I' ne peut pas être groupée car elle est en conflit avec la " +"variable spéciale .I . Essayez d'abord setnames(DT,'.I','I')." + +#: data.table.R:1483 +#, c-format +msgid "logical error. i is not data.table, but mult='all' and 'by'=.EACHI" +msgstr "" +"erreur logique. i n'est pas une data.table, mais mult='all' et 'by'=.EACHI" + +#: data.table.R:1804 +#, c-format +msgid "" +"Unable to optimize call to mean() and could be very slow. You must name 'na." +"rm' like that otherwise if you do mean(x,TRUE) the TRUE is taken to mean " +"'trim' which is the 2nd argument of mean. 'trim' is not yet optimized." +msgstr "" +"Impossible d'optimiser l'appel à mean() et risque d'être très lent. Vous devez " +"nommer 'na.rm' comme cela, sinon si vous faites mean(x,TRUE), TRUE est " +"considéré comme signifiant 'trim' qui est le deuxième argument de mean. 'trim' " +"n'est pas encore optimisé." + +#: data.table.R:1950 +#, c-format +msgid "" +"The setkey() normally performed by keyby= has been skipped (as if by= was " +"used) because := is being used together with keyby= but the keyby= contains " +"some expressions. To avoid this warning, use by= instead, or provide existing " +"column names to keyby=." +msgstr "" +"Le setkey() normalement exécuté par keyby= a été ignoré (comme si by= était " +"utilisé) parce que := est utilisé avec keyby=, mais keyby= contient des " +"expressions. Pour éviter cet avertissement, utilisez by= à la place, ou " +"fournissez des noms de colonnes existantes à keyby=." + +#: data.table.R:2039 +#, c-format +msgid "rownames and rownames.value cannot both be used at the same time" +msgstr "rownames et rownames.value ne peuvent pas être utilisés simultanément" + +#: data.table.R:2044 +#, c-format +msgid "" +"length(rownames)==%d but nrow(DT)==%d. The rownames argument specifies a " +"single column name or number. Consider rownames.value= instead." +msgstr "" +"length(rownames)==%d mais nrow(DT)==%d. L'argument rownames spécifie un nom de " +"colonne unique ou un nombre. Remplacez par rownames.value= ." + +#: data.table.R:2048 +#, c-format +msgid "length(rownames)==0 but should be a single column name or number, or NULL" +msgstr "" +"length(rownames)==0 mais doit être un nom de vecteur colonne, ou un nombre, ou " +"NULL" + +#: data.table.R:2052 +#, c-format +msgid "" +"rownames is TRUE but key has multiple columns %s; taking first column x[,1] as " +"rownames" +msgstr "" +"rownames vaut TRUE mais la clé a plusieurs colonnes %s ; Seule la première " +"colonne x[,1] est utilisée pour le nom des lignes" + +#: data.table.R:2062 +#, c-format +msgid "'%s' is not a column of x" +msgstr "'%s' n'est pas une colonne de x" + +#: data.table.R:2068 +#, c-format +msgid "" +"as.integer(rownames)==%d which is outside the column number range [1,ncol=%d]." +msgstr "" +"as.integer(rownames)==%d est en dehors de l'intervalle des numéros de colonne " +"[1,ncol=%d]." + +#: data.table.R:2073 +#, c-format +msgid "length(rownames.value)==%d but should be nrow(x)==%d" +msgstr "length(rownames.value)==%d mais devrait être nrow(x)==%d" + +#: data.table.R:2169 +#, c-format +msgid "" +"When i is a matrix in DT[i]<-value syntax, it doesn't make sense to provide j" +msgstr "" +"Si i est une matrice, dans la syntaxe DT[i]<-valeur, fournir j n'a pas de sens" + +#: data.table.R:2179 +#, c-format +msgid "j must be an atomic vector, see ?is.atomic" +msgstr "j doit être un vecteur atomique, voir ?is.atomic" + +#: data.table.R:2180 +#, c-format +msgid "NA in j" +msgstr "NA trouvé dans j" + +#: data.table.R:2186 +#, c-format +msgid "j must be vector of column name or positions" +msgstr "j doit être un vecteur de noms de colonnes ou de positions" + +#: data.table.R:2187 +#, c-format +msgid "" +"Attempt to assign to column position greater than ncol(x). Create the column " +"by name, instead. This logic intends to catch (most likely) user errors." +msgstr "" +"Tentative d'accès à une colonne située au-delà de ncol(x). À la place, créez " +"la colonne par nom. Cette logique permet d'intercepter les erreurs utilisateur " +"(le plus souvent)." + +#: data.table.R:2254 +#, c-format +msgid "" +"data.table inherits from data.frame (from v1.5), but this data.table does not. " +"Has it been created manually (e.g. by using 'structure' rather than 'data." +"table') or saved to disk using a prior version of data.table?" +msgstr "" +"data.table hérite de data.frame (à partir de la version 1.5), mais pas ce data." +"table. A-t-il été créé manuellement (par exemple en utilisant 'structure' " +"plutôt que 'data.table') ou sauvegardé sur disque à l'aide d'une version " +"antérieure de data.table ?" + +#: data.table.R:2263 +#, c-format +msgid "attempting to assign invalid object to dimnames of a data.table" +msgstr "assignation d'un objet non valide à dimnames d'une data.table" + +#: data.table.R:2264 +#, c-format +msgid "data.tables do not have rownames" +msgstr "les data.tables n'ont pas de rownames" + +#: data.table.R:2265 data.table.R:2634 +#, c-format +msgid "Can't assign %d names to a %d-column data.table" +msgstr "Impossible d'assigner %d noms à une data.table de %d colonne(s)" + +#: data.table.R:2329 +#, c-format +msgid "'subset' must evaluate to logical" +msgstr "'subset' doit représenter une valeur booléenne" + +#: data.table.R:2372 +#, c-format +msgid "Argument 'invert' must be logical TRUE/FALSE" +msgstr "L'argument 'invert' doit être un booléen TRUE / FALSE" + +#: data.table.R:2413 +#, c-format +msgid "x argument must be a data.table" +msgstr "l'argument x doit être une data.table" + +#: data.table.R:2418 +#, c-format +msgid "group length is 0 but data nrow > 0" +msgstr "la longueur du groupe est 0 mais pour les données, nrow > 0" + +#: data.table.R:2420 +#, c-format +msgid "" +"passing 'f' argument together with 'by' is not allowed, use 'by' when split by " +"column in data.table and 'f' when split by external factor" +msgstr "" +"le passage de l'argument 'f' en même temps que 'by' n'est pas autorisé, " +"utilisez 'by' pour la division par colonne dans data.table et 'f' pour la " +"division par facteur externe" + +#: data.table.R:2428 +#, c-format +msgid "Either 'by' or 'f' argument must be supplied" +msgstr "Fournir un seul argument 'by' ou 'f' mais pas les deux" + +#: data.table.R:2430 +#, c-format +msgid "Column '.ll.tech.split' is reserved for split.data.table processing" +msgstr "" +"La colonne '.ll.tech.split' est réservée au traitement de split.data.table" + +#: data.table.R:2431 +#, c-format +msgid "Column '.nm.tech.split' is reserved for split.data.table processing" +msgstr "" +"La colonne '.nm.tech.split' est réservée au traitement de split.data.table" + +#: data.table.R:2432 +#, c-format +msgid "Argument 'by' must refer to column names in x" +msgstr "L'argument 'by' doit se rapporter aux noms des colonnes dans x" + +#: data.table.R:2433 +#, c-format +msgid "" +"Argument 'by' must refer only to atomic-type columns, but the following " +"columns are non-atomic: %s" +msgstr "" +"L'argument 'by' doit faire référence uniquement à des colonnes de type " +"atomique, mais les colonnes suivantes ne le sont pas : %s" + +#: data.table.R:2565 +#, c-format +msgid "" +"x is not a data.table|frame. Shallow copy is a copy of the vector of column " +"pointers (only), so is only meaningful for data.table|frame" +msgstr "" +"x n'est pas un data.table|frame. Shallow copy est une copie du vecteur de " +"pointeurs de colonnes (uniquement), et n'a donc de sens que pour un data.table|" +"frame" + +#: data.table.R:2574 +#, c-format +msgid "setalloccol attempting to modify `*tmp*`" +msgstr "setalloccol essaie de modifier `*tmp*`" + +#: data.table.R:2609 +#, c-format +msgid "" +"Input is a length=1 logical that points to the same address as R's global " +"value. Therefore the attribute has not been set by reference, rather on a " +"copy. You will need to assign the result back to a variable. See issue #1281." +msgstr "" +"L'entrée est un booléen de longueur 1 pointant vers la même adresse que la " +"valeur globale de R. C'est pourquoi l'attribut n'a pas été initialisé par " +"référence mais plutôt par copie. Vous devrez donc assigner le résultat à une " +"variable. Voir le tickets (issues) numéro #1281." + +#: data.table.R:2624 +#, c-format +msgid "x is not a data.table or data.frame" +msgstr "x n'est pas une data.table ni un data.frame" + +#: data.table.R:2626 +#, c-format +msgid "x has %d columns but its names are length %d" +msgstr "x a %d colonnes mais les noms sont de longueur %d" + +#: data.table.R:2633 +#, c-format +msgid "Passed a vector of type '%s'. Needs to be type 'character'." +msgstr "Passage d'un vecteur de type '%s'. Doit être de type 'character'." + +#: data.table.R:2646 +#, c-format +msgid "'new' is not a character vector or a function" +msgstr "'new' n’est pas un vecteur de chaîne de caractères ni une fonction" + +#: data.table.R:2648 +#, c-format +msgid "NA in 'new' at positions %s" +msgstr "NA est présent dans 'new' aux positions %s" + +#: data.table.R:2649 +#, c-format +msgid "Some duplicates exist in 'old': %s" +msgstr "Présence de certains doublons dans 'old' : %s" + +#: data.table.R:2651 +#, c-format +msgid "'old' is type %s but should be integer, double or character" +msgstr "" +"'old' est de type %s mais doit être un entier, un double ou de type 'character'" + +#: data.table.R:2652 +#, c-format +msgid "'old' is length %d but 'new' is length %d" +msgstr "'old' est de longueur %d et 'new' est de longueur %d" + +#: data.table.R:2653 +#, c-format +msgid "NA (or out of bounds) in 'old' at positions %s" +msgstr "NA (ou valeurs hors limites) trouvées dans 'old' aux positions %s" + +#: data.table.R:2656 +#, c-format +msgid "" +"Item %d of 'old' is '%s' which appears several times in column names. Just the " +"first will be changed. There are %d other items in 'old' that are also " +"duplicated in column names." +msgstr "" +"L'élément %d de 'old' est '%s' et apparait plusieurs fois dans les noms des " +"colonnes. Seul le premier sera modifié. Il reste %d autres éléments dans 'old' " +"qui sont également dupliqués dans les noms des colonnes." + +#: data.table.R:2664 +#, c-format +msgid "Items of 'old' not found in column names: %s. Consider skip_absent=TRUE." +msgstr "" +"Eléments de 'old' non trouvés parmi les noms de colonnes : %s. Veuillez " +"utiliser skip_absent=TRUE." + +#: data.table.R:2703 +#, c-format +msgid "" +"x has some duplicated column name(s): %s. Please remove or rename the " +"duplicate(s) and try again." +msgstr "" +"x comporte des doublons de noms de colonnes : %s. Veuillez les supprimer ou " +"les renommer et recommencer." + +#: data.table.R:2705 +#, c-format +msgid "Provide either before= or after= but not both" +msgstr "Fournir before= ou after= mais pas les deux simultanément" + +#: data.table.R:2707 +#, c-format +msgid "before=/after= accept a single column name or number, not more than one" +msgstr "" +"before= ou after= n'acceptent qu'un seul nom de colonne ou nombre et pas plus" + +#: data.table.R:2763 +#, c-format +msgid "Input is %s but should be a plain list of items to be stacked" +msgstr "L'entrée est %s mais doit être une liste d'éléments à empiler" + +#: data.table.R:2767 +#, c-format +msgid "" +"idcol must be a logical or character vector of length 1. If logical TRUE the " +"id column will named '.id'." +msgstr "" +"idcol doit être un vecteur booléen ou un vecteur de caractères de longueur 1. " +"Si la valeur logique est TRUE, la colonne id sera nommée '.id'." + +#: data.table.R:2772 +#, c-format +msgid "use.names=NA invalid" +msgstr "use.names=NA non valide" + +#: data.table.R:2774 +#, c-format +msgid "" +"use.names='check' cannot be used explicitly because the value 'check' is new " +"in v1.12.2 and subject to change. It is just meant to convey default behavior. " +"See ?rbindlist." +msgstr "" +"use.names='check' ne peut être utilisé explicitement car la valeur 'check' est " +"nouvelle en v1.12.2 et peut changer à l'avenir. Elle est présente juste pour " +"garder le comportement par défaut. Voir ?rbindlist." + +#: data.table.R:2789 +#, c-format +msgid "" +"Check that is.data.table(DT) == TRUE. Otherwise, :=, `:=`(...) and let(...) " +"are defined for use in j, once only and in particular ways. Note that " +"namespace-qualification like data.table::`:=`(...) is not supported. See " +"help(\":=\")." +msgstr "" +"Vérifiez que is.data.table(DT) == TRUE. Sinon, :=, ':='(...) et let(...) sont " +"définis pour être utilisés dans j, une seule fois et de manières " +"particulières. Notez que la spécification de l’espace de noms comme data." +"table::`:=`(…) n’est pas supportée. Voir help(\":=\")." + +#: data.table.R:2806 +#, c-format +msgid "" +"setDF only accepts data.table, data.frame or list of equal length as input" +msgstr "" +"setDF n'accepte en entrée que des types data.table, data.frame ou des listes " +"d'égale longeur" + +#: data.table.R:2807 +#, c-format +msgid "rownames contains duplicates" +msgstr "doublons présents dans rownames" + +#: data.table.R:2814 data.table.R:2825 data.table.R:2848 +#, c-format +msgid "rownames incorrect length; expected %d names, got %d" +msgstr "longueur incorrecte de rownames ; %d noms attendus, %d sont fournis" + +#: data.table.R:2833 +#, c-format +msgid "All elements in argument 'x' to 'setDF' must be of same length" +msgstr "" +"Tous les éléments de l'argument 'x' de 'setDF' doivent avoir la même longueur" + +#: data.table.R:2862 +#, c-format +msgid "Cannot find symbol %s" +msgstr "Symbole %s non trouvé" + +#: data.table.R:2869 +#, c-format +msgid "" +"Cannot convert '%1$s' to data.table by reference because binding is locked. It " +"is very likely that '%1$s' resides within a package (or an environment) that " +"is locked to prevent modifying its variable bindings. Try copying the object " +"to your current environment, ex: var <- copy(var) and then using setDT again." +msgstr "" +"Impossible de convertir '%1$s' en data.table par référence car le lien est " +"verrouillé. Il est très probable que '%1$s' se trouve dans un package (ou un " +"environnement) qui est verrouillé pour empêcher la modification de ses objets. " +"Essayez de copier l'objet dans votre environnement actuel, ex : var <- " +"copy(var) et utilisez ensuite setDT à nouveau." + +#: data.table.R:2922 +#, c-format +msgid "Argument 'x' to 'setDT' should be a 'list', 'data.frame' or 'data.table'" +msgstr "" +"L'argument 'x' de 'setDT' doit être de type 'list', 'data.frame' ou 'data." +"table'" + +#: data.table.R:2937 +#, c-format +msgid "Item '%s' not found in names of input list" +msgstr "Élément '%s' non trouvé parmi les noms de la liste d'entrée" + +#: data.table.R:2962 data.table.R:2987 +#, c-format +msgid "'prefix' must be NULL or a character vector of length 1." +msgstr "" +"'prefix' doit être NULL ou un vecteur de chaîne de caractères de longueur 1." + +#: data.table.R:2965 data.table.R:2990 +#, c-format +msgid "x is a single vector, non-NULL 'cols' doesn't make sense." +msgstr "x est un vecteur unique, donc 'cols' non NULL n'a pas de sens." + +#: data.table.R:2969 data.table.R:2994 +#, c-format +msgid "x is a list, 'cols' cannot be 0-length." +msgstr "x est une liste, 'cols' ne peut avoir une longueur 0." + +#: data.table.R:3185 +#, c-format +msgid "" +"RHS of %s is length %d which is not 1 or nrow (%d). For robustness, no " +"recycling is allowed (other than of length 1 RHS). Consider %%in%% instead." +msgstr "" +"Le membre de droite de %s a pour longueur %d au lieu de 1 ou nrow (%d) " +"attendu. Pour la robustesse, aucun recyclage n'est autorisé (autre que sur une " +"longueur de 1 du membre de droite). Essayez %%in%% à la place." + +#: data.table.R:3300 +#, c-format +msgid "" +"'on' argument should be a named atomic vector of column names indicating which " +"columns in 'i' should be joined with which columns in 'x'." +msgstr "" +"l'argument 'on' doit être un vecteur atomique nommé composé de noms de " +"colonnes indiquant quelle colonne de 'i' doit être jointe à quelle colonne de " +"'x'." + +#: data.table.R:3341 +#, c-format +msgid "" +"Found more than one operator in one 'on' statement: %s. Please specify a " +"single operator." +msgstr "" +"Plus d'un opérateur trouvé dans une déclaration 'on' : %s. Veuillez spécifier " +"un seul opérateur." + +#: data.table.R:3364 +#, c-format +msgid "" +"'on' contains no column name: %s. Each 'on' clause must contain one or two " +"column names." +msgstr "" +"'on' n'a pas de nom de colonne : %s. Chaque clause 'on' doit contenir un ou " +"deux noms de colonnes." + +#: data.table.R:3366 +#, c-format +msgid "" +"'on' contains more than 2 column names: %s. Each 'on' clause must contain one " +"or two column names." +msgstr "" +"la clause 'on' contient plus de 2 noms de colonnes : %s. Chaque clause 'on' " +"doit contenir un ou deux noms de colonnes." + +#: data.table.R:3371 +#, c-format +msgid "Invalid join operators %s. Only allowed operators are %s." +msgstr "" +"Opérateurs de jointure non valides %s. Les seuls opérateurs autorisés sont %s." + +#: devel.R:16 +#, c-format +msgid "There is no package %s in provided repository." +msgstr "Package %s non trouvé dans le dépôt fourni." + +#: duplicated.R:7 +#, c-format +msgid "'fromLast' must be TRUE or FALSE" +msgstr "'fromLast' doit être TRUE ou FALSE" + +#: duplicated.R:105 +#, c-format +msgid "x must be an atomic vector or data.frames/data.tables" +msgstr "x doit être un vecteur atomique ou des data.frames / data.tables" + +#: fcast.R:7 +#, c-format +msgid "Using '%s' as value column. Use 'value.var' to override" +msgstr "" +"'%s' est utilisé comme colonne de valeurs. Utiliser 'value.var' pour redéfinir" + +#: fcast.R:20 fmelt.R:16 +#, c-format +msgid "" +"The %1$s generic in data.table has been passed a %2$s, but data.table::%1$s " +"currently only has a method for data.tables. Please confirm your input is a " +"data.table, with setDT(%3$s) or as.data.table(%3$s). If you intend to use a " +"method from reshape2, try installing that package first, but do note that " +"reshape2 is superseded and is no longer actively developed." +msgstr "" +"Le générique %1$s dans data.table a été transmis à un %2$s, mais data.table: :" +"%1$s n'a actuellement qu'une méthode pour data.tables. Veuillez confirmer que " +"votre entrée est un data.table, avec setDT(%3$s) ou as.data.table(%3$s). Si " +"vous avez l'intention d'utiliser une méthode de reshape2, essayez d'installer " +"ce package en premier, mais notez que reshape2 est dépassé et n'est plus " +"activement développé." + +#: fcast.R:21 +#, c-format +msgid "" +"The %1$s generic in data.table has been passed a %2$s and will attempt to " +"redirect to the relevant reshape2 method; please note that reshape2 is " +"superseded and is no longer actively developed, and this redirection is now " +"deprecated. Please do this redirection yourself like reshape2::%1$s(%3$s). In " +"the next version, this warning will become an error." +msgstr "" +"Le générique %1$s dans data.table s'est vu passer un %2$s et tentera de " +"rediriger vers la méthode reshape2 correspondante ; veuillez noter que " +"reshape2 est dépassé et n'est plus activement développé, et que cette " +"redirection est désormais obsolète. Veuillez effectuer cette redirection vous-" +"même comme reshape2: :%1$s(%3$s). Dans la prochaine version, cet avertissement " +"deviendra une erreur." + +#: fcast.R:31 +#, c-format +msgid "" +"Invalid formula. Cast formula should be of the form LHS ~ RHS, for e.g., a + b " +"~ c." +msgstr "" +"Formule non valide. La formule du cast s'écrit : membre gauche ~ membre droit, " +"par exemple : a + b ~ c." + +#: fcast.R:38 +#, c-format +msgid "data.table to cast must have unique column names" +msgstr "" +"cast impossible si les noms de colonnes ne sont pas uniques dans la data.table" + +#: fcast.R:83 +#, c-format +msgid "value.var values %s are not found in 'data'." +msgstr "valeurs %s de value.var absentes dans 'data'." + +#: fcast.R:99 +#, c-format +msgid "" +"When 'fun.aggregate' and 'value.var' are both lists, 'value.var' must be " +"either of length =1 or =length(fun.aggregate)." +msgstr "" +"Si 'fun.aggregate' et 'value.var' sont tous deux des listes, 'value.var' doit " +"avoir une longueur =1 ou =length(fun.aggregate)." + +#: fcast.R:132 +#, c-format +msgid "'data' must be a data.table." +msgstr "'data' doit être une data.table." + +#: fcast.R:134 +#, c-format +msgid "'drop' must be logical TRUE/FALSE" +msgstr "'drop' doit être un booléen TRUE / FALSE" + +#: fcast.R:136 +#, c-format +msgid "Argument 'value.var.in.dots' should be logical TRUE/FALSE" +msgstr "L'argument ‘value.var.in.dots’ doit être un booléen TRUE/FALSE" + +#: fcast.R:138 +#, c-format +msgid "" +"Arguments 'value.var.in.LHSdots', 'value.var.in.RHSdots' should be logical " +"TRUE/FALSE" +msgstr "" +"Les arguments 'value.var.in.LHSdots', 'value.var.in.RHSdots' doivent être des " +"booléens TRUE/FALSE" + +#: fcast.R:155 +#, c-format +msgid "Column [%s] not found or of unknown type." +msgstr "La colonne [%s] est absente ou de type inconnu." + +#: fcast.R:170 +#, c-format +msgid "Columns specified in formula can not be of type list" +msgstr "" +"Les colonnes spécifiées dans la formule ne peuvent pas avoir le type liste" + +#: fcast.R:185 +#, c-format +msgid "" +"'fun.aggregate' is NULL, but found duplicate row/column combinations, so " +"defaulting to length(). That is, the variables %s used in 'formula' do not " +"uniquely identify rows in the input 'data'. In such cases, 'fun.aggregate' is " +"used to derive a single representative value for each combination in the " +"output data.table, for example by summing or averaging (fun.aggregate=sum or " +"fun.aggregate=mean, respectively). Check the resulting table for values larger " +"than 1 to see which combinations were not unique. See ?dcast.data.table for " +"more details." +msgstr "" +"'fun.aggregate' est NULL, mais des combinaisons de lignes/colonnes dupliquées " +"sont rencontrées, donc par défaut length() est utilisé. En d'autres termes, " +"les variables %s utilisées dans 'formula' n'identifient pas de manière unique " +"les lignes dans les données d'entrée 'data'. Dans ce cas, 'fun.aggregate' est " +"utilisé pour dériver une valeur représentative unique pour chaque combinaison " +"dans la 'data.table' de sortie, par exemple en faisant la somme ou la moyenne " +"(fun.aggregate=sum ou fun.aggregate=mean, respectivement). Vérifiez que le " +"tableau résultant contient des valeurs supérieures à 1 pour voir quelles " +"combinaisons n'étaient pas uniques. Voir ?dcast.data.table pour plus de " +"détails." + +#: fcast.R:195 +msgid "" +"Aggregating function(s) should take a vector as input and return a single " +"value (length=1), but they do not, so the result is undefined. Please fix by " +"modifying your function so that a single value is always returned." +msgstr "" +"La ou les fonction(s) d'agrégation devraient prendre un vecteur en entrée et " +"renvoyer une seule valeur (longueur=1), mais ce n'est pas le cas, et le " +"résultat est donc indéfini. Veuillez corriger en modifiant votre fonction de " +"manière à ce qu'une seule valeur soit toujours renvoyée." + +#: fdroplevels.R:13 +#, c-format +msgid "" +"droplevels() with in.place=TRUE is deprecated. Use setdroplevels() instead." +msgstr "" +"droplevels() avec in.place=TRUE est obsolète. Utilisez plutôt setdroplevels()." + +#: fmelt.R:17 +#, c-format +msgid "" +"The %1$s generic in data.table has been passed a %2$s and will attempt to " +"redirect to the relevant reshape2 method; please note that reshape2 is " +"superseded and is no longer actively developed, and this redirection is now " +"deprecated. To continue using melt methods from reshape2 while both libraries " +"are attached, e.g. melt.list, you can prepend the namespace, i.e. reshape2::" +"%1$s(%3$s). In the next version, this warning will become an error." +msgstr "" +"Le générique %1$s dans data.table a reçu un %2$s et tentera de rediriger vers " +"la méthode reshape2 correspondante ; Veuillez noter que reshape2 est remplacé " +"et n'est plus activement développé, et que cette redirection est maintenant " +"dépréciée. Pour continuer à utiliser les méthodes 'melt' de reshape2 alors que " +"les deux bibliothèques sont attachées, par exemple 'melt.list', vous pouvez " +"ajouter l'espace de noms, c'est-à-dire reshape2: :%1$s(%3$s). Dans la " +"prochaine version, cet avertissement deviendra une erreur." + +#: fmelt.R:28 +#, c-format +msgid "Input patterns must be of type character." +msgstr "Les motifs d'entrée doivent être de type chaînes de caractères." + +#: fmelt.R:31 +#, c-format +msgid "Pattern(s) not found: [%s]" +msgstr "Motif(s) non trouvé(s) : [%s]" + +#: fmelt.R:46 +#, c-format +msgid "" +"each ... argument to measure must be either a symbol without argument name, or " +"a function with argument name, problems: %s" +msgstr "" +"chaque argument ... à mesurer doit être soit un symbole sans nom d'argument, " +"soit une fonction avec nom d'argument, problèmes : %s" + +#: fmelt.R:54 +#, c-format +msgid "" +"group names specified in ... conflict with measure argument names; please fix " +"by changing group names: %s" +msgstr "" +"les noms de groupes spécifiés dans ... sont en conflit avec les noms des " +"arguments de mesure ; veuillez corriger en changeant les noms de groupes : %s" + +#: fmelt.R:60 +#, c-format +msgid "" +"each ... argument to measure must be a function with at least one argument, " +"problem: %s" +msgstr "" +"chaque argument ... à mesurer doit être une fonction avec au moins un " +"argument, problème : %s" + +#: fmelt.R:74 +#, c-format +msgid "" +"both sep and pattern arguments used; must use either sep or pattern (not both)" +msgstr "" +"vous utilisez à la fois les arguments sep et pattern ; Choisir entre sep ou " +"pattern (mais pas les deux)" + +#: fmelt.R:77 +#, c-format +msgid "multiple.keyword must be a character string with nchar>0" +msgstr "multiple.keyword doit être une chaîne de caractères avec nchar>0" + +#: fmelt.R:80 +#, c-format +msgid "cols must be a character vector of column names" +msgstr "cols doit être un vecteur de chaînes de caractères de noms de colonnes" + +#: fmelt.R:88 +#, c-format +msgid "in measurev, %s must be named, problems: %s" +msgstr "dans measurev, %s doit avoir un nom, problèmes : %s" + +#: fmelt.R:94 +#, c-format +msgid "%s should be uniquely named, problems: %s" +msgstr "%s doit avoir un nom unique, problèmes : %s" + +#: fmelt.R:99 +#, c-format +msgid "number of %s =%d must be same as %s =%d" +msgstr "le nombre de %s =%d doit être le même que %s =%d" + +#: fmelt.R:106 +#, c-format +msgid "pattern must be character string" +msgstr "le motif doit être une chaîne de caractères" + +#: fmelt.R:111 +#, c-format +msgid "" +"pattern did not match any cols, so nothing would be melted; fix by changing " +"pattern" +msgstr "" +"le motif ne correspondait à aucune colonne, donc rien n'aurait été fait " +"(melt) ; corrigez en changeant de motif" + +#: fmelt.R:115 +#, c-format +msgid "" +"pattern must contain at least one capture group (parenthesized sub-pattern)" +msgstr "" +"le motif doit contenir au moins un groupe de capture (sous-motif entre " +"parenthèses)" + +#: fmelt.R:124 +#, c-format +msgid "sep must be character string" +msgstr "sep doit être une chaîne de caractères" + +#: fmelt.R:130 +#, c-format +msgid "" +"each column name results in only one item after splitting using sep, which " +"means that all columns would be melted; to fix please either specify melt on " +"all columns directly without using measure, or use a different sep/pattern " +"specification" +msgstr "" +"chaque nom de colonne ne donne qu'un seul élément après séparation à l'aide de " +"'sep', ce qui signifie que toutes les colonnes seraient fusionnées ; pour " +"résoudre ce problème, veuillez spécifier la fusion (melt) sur toutes les " +"colonnes directement sans utiliser la mesure, ou utiliser une spécification " +"sep/motif différente" + +#: fmelt.R:140 +#, c-format +msgid "" +"number of unique column IDs =%d is less than number of melted columns =%d; fix " +"by changing pattern/sep" +msgstr "" +"le nombre d'ID de colonnes uniques =%d est inférieur au nombre de colonnes " +"fusionnées =%d ; corrigez en changeant le motif ou sep" + +#: fmelt.R:150 +#, c-format +msgid "" +"in the measurev fun.list, each non-NULL element must be a function with at " +"least one argument, problem: %s" +msgstr "" +"dans la mesurev fun.list, chaque élément non NULL doit être une fonction avec " +"au moins un argument, problème : %s" + +#: fmelt.R:154 +#, c-format +msgid "" +"each conversion function must return an atomic vector with same length as its " +"first argument, problem: %s" +msgstr "" +"chaque fonction de conversion doit renvoyer un vecteur atomique de même " +"longueur que son premier argument, problème : %s" + +#: fmelt.R:157 +#, c-format +msgid "%s conversion function returned vector of all NA" +msgstr "" +"la fonction de conversion %s a renvoyé un vecteur ne contenant que des NA" + +#: fmelt.R:163 +#, c-format +msgid "" +"number of unique groups after applying type conversion functions less than " +"number of groups, change type conversion" +msgstr "" +"nombre de groupes uniques après application des fonctions de conversion de " +"type inférieur au nombre de groupes, modifier la conversion de type" + +#: fmelt.R:168 +#, c-format +msgid "" +"%s column class=%s after applying conversion function, but must be character" +msgstr "" +"colonne %s class=%s après avoir appliqué les fonctions de conversion, mais " +"doivent être des chaînes de caractères" + +#: fmelt.R:172 +#, c-format +msgid "%s is the only group; fix by creating at least one more group" +msgstr "" +"%s est le seul groupe ; Corrigez en créant au moins un groupe supplémentaire" + +#: fmelt.R:195 +#, c-format +msgid "'data' must be a data.table" +msgstr "'data' doit être une data.table" + +#: fmelt.R:214 +#, c-format +msgid "" +"'value.name' provided in both 'measure.vars' and 'value.name argument'; value " +"provided in 'measure.vars' is given precedence." +msgstr "" +"'value.name' est fourni à la fois dans 'measure.vars' et 'value.name " +"argument' ; La valeur de 'measure.vars' prévaut." + +#: fmelt.R:217 +#, c-format +msgid "Please provide a name to each element of 'measure.vars'." +msgstr "Veuillez fournir un nom pour chaque élément de 'measure.vars'." + +#: foverlaps.R:3 +#, c-format +msgid "" +"y and x must both be data.tables. Use `setDT()` to convert list/data.frames to " +"data.tables by reference or as.data.table() to convert to data.tables by " +"copying." +msgstr "" +"y et x doivent tous deux être des data.tables. Utilisez `setDT()` pour " +"convertir des list/data.frames en data.tables par référence ou as.data.table() " +"pour convertir en data.tables par copie." + +#: foverlaps.R:9 +#, c-format +msgid "maxgap must be a non-negative integer value of length 1" +msgstr "maxgap doit être un entier positif ou nul de longueur 1" + +#: foverlaps.R:11 +#, c-format +msgid "minoverlap must be a positive integer value of length 1" +msgstr "minorverlap doit être un entier positif ou nul de longueur 1" + +#: foverlaps.R:13 +#, c-format +msgid "which must be a logical vector of length 1. Either TRUE/FALSE" +msgstr "which doit être un vecteur de booléens de longueur 1. Soit TRUE ou FALSE" + +#: foverlaps.R:15 +#, c-format +msgid "nomatch must either be NA or NULL" +msgstr "nomatch doit valoir soit NA soit NULL" + +#: foverlaps.R:20 +#, c-format +msgid "maxgap and minoverlap arguments are not yet implemented." +msgstr "les arguments maxgap et minoverlap ne sont pas encore implémentés." + +#: foverlaps.R:22 +#, c-format +msgid "" +"y must be keyed (i.e., sorted, and, marked as sorted). Call setkey(y, ...) " +"first, see ?setkey. Also check the examples in ?foverlaps." +msgstr "" +"y doit être transformé en 'key' (c'est-à-dire trié, et, marqué comme étant " +"trié). Appelez d'abord setkey(y, ...), voir ?setkey. Consultez également les " +"exemples dans ?foverlaps." + +#: foverlaps.R:24 +#, c-format +msgid "" +"'by.x' and 'by.y' should contain at least two column names (or numbers) each - " +"corresponding to 'start' and 'end' points of intervals. Please see ?foverlaps " +"and examples for more info." +msgstr "" +"'by.x' et 'by.y' doivent contenir chacun au moins deux noms de colonnes (ou " +"leurs indices) - correspondant aux bornes 'start' et 'end' des intervalles. " +"Voir ?foverlaps et les exemples pour plus d'information." + +#: foverlaps.R:27 +#, c-format +msgid "" +"Invalid numeric value for 'by.x'; it should be a vector with values 1 <= by.x " +"<= length(x)" +msgstr "" +"Valeur numérique non valide pour 'by.x' ; Doit être un vecteur de valeurs 1 <= " +"by.x <= length(x)" + +#: foverlaps.R:32 +#, c-format +msgid "" +"Invalid numeric value for 'by.y'; it should be a vector with values 1 <= by.y " +"<= length(y)" +msgstr "" +"Valeur numérique non valide pour 'by.y' ; Doit être un vecteur de valeurs 1 <= " +"by.y <= length(y)" + +#: foverlaps.R:36 +#, c-format +msgid "A non-empty vector of column names or numbers is required for by.x" +msgstr "" +"Un vecteur non vide de noms de colonnes ou d’indices (nombres) est nécessaire " +"pour by.x" + +#: foverlaps.R:38 +#, c-format +msgid "A non-empty vector of column names or numbers is required for by.y" +msgstr "" +"Un vecteur non vide de noms de colonnes ou d’indices (nombres) est nécessaire " +"pour by.y" + +#: foverlaps.R:40 +#, c-format +msgid "" +"The first %d columns of y's key must be identical to the columns specified in " +"by.y." +msgstr "" +"Les %d premières colonnes de la clé de y doivent être identiques aux colonnes " +"spécifiées dans by.y." + +#: foverlaps.R:42 +#, c-format +msgid "Elements listed in 'by.x' must be valid names in data.table x" +msgstr "" +"Les éléments listés dans 'by.x' doivent être des noms valides de la data.table " +"x" + +#: foverlaps.R:44 +#, c-format +msgid "" +"Duplicate columns are not allowed in overlap joins. This may change in the " +"future." +msgstr "" +"Les colonnes dupliquées ne sont pas autorisées pour la jointure avec " +"recouvrement. Ceci peut changer à l'avenir." + +#: foverlaps.R:46 +#, c-format +msgid "" +"length(by.x) != length(by.y). Columns specified in by.x should correspond to " +"columns specified in by.y and should be of same lengths." +msgstr "" +"length(by.x) != length(by.y). Les colonnes spécifiées dans by.x doivent " +"correspondre aux colonnes spécifiées dans by.y et être de même longueur." + +#: foverlaps.R:48 foverlaps.R:50 merge.R:26 merge.R:27 +#, c-format +msgid "" +"%s has some duplicated column name(s): %s. Please remove or rename the " +"duplicate(s) and try again." +msgstr "" +"%s comporte certains noms de colonnes dupliqués : %s. Veuillez supprimer les " +"doublons ou les renommer et recommencer." + +#: foverlaps.R:56 +#, c-format +msgid "" +"The last two columns in by.x should correspond to the 'start' and 'end' " +"intervals in data.table x and must be integer/numeric type." +msgstr "" +"Les deux dernières colonnes de by.x doivent correspondre à l'intervalle " +"'start' et 'end' de la data.table x et doivent être de type entier ou " +"numérique." + +#: foverlaps.R:60 foverlaps.R:62 foverlaps.R:69 foverlaps.R:71 +#, c-format +msgid "" +"NA values in data.table %s '%s' column: '%s'. All rows with NA values in the " +"range columns must be removed for foverlaps() to work." +msgstr "" +"Valeurs NA présentes dans la data.table %s colonne '%s’ : '%s'. Toutes les " +"lignes avec des valeurs NA dans l'intervalle des colonnes doivent être " +"supprimées avant d’exécuter foverlaps()." + +#: foverlaps.R:63 +#, c-format +msgid "" +"All entries in column '%s' should be <= corresponding entries in column '%s' " +"in data.table x." +msgstr "" +"Toutes les entrées de la colonne '%s' doivent être <= aux entrées " +"correspondantes de la colonne '%s' de la data.table x." + +#: foverlaps.R:66 +#, c-format +msgid "" +"The last two columns in by.y should correspond to the 'start' and 'end' " +"intervals in data.table y and must be integer/numeric type." +msgstr "" +"Les deux dernières colonnes de by.y doivent correspondre aux intervalles de " +"'start' et 'end' de la data.table y et doivent être de type entier/numérique." + +#: foverlaps.R:72 +#, c-format +msgid "" +"All entries in column '%s' should be <= corresponding entries in column '%s' " +"in data.table y." +msgstr "" +"Toutes les entrées de la colonne '%s' doivent être <= aux entrées " +"correspondantes de la colonne '%s' de la data.table y." + +#: foverlaps.R:77 +#, c-format +msgid "" +"Some interval cols are of type POSIXct while others are not. Please ensure all " +"interval cols are (or are not) of POSIXct type" +msgstr "" +"Certains interval cols sont de type POSIXct et d'autres non. Veuillez vous " +"assurer que tous les 'interval cols' sont (ou ne sont pas) de type POSIXct" + +#: foverlaps.R:83 +#, c-format +msgid "" +"POSIXct interval cols have mixed timezones. Overlaps are performed on the " +"internal numerical representation of POSIXct objects (always in UTC epoch " +"time), therefore printed values may give the impression that values don't " +"overlap but their internal representations do Please ensure that POSIXct type " +"interval cols have identical 'tzone' attributes to avoid confusion." +msgstr "" +"Les colonnes d'intervalles POSIXct ont des fuseaux horaires différents. Les " +"chevauchements sont effectués sur la représentation numérique interne des " +"objets POSIXct (toujours en temps UTC), par conséquent les valeurs imprimées " +"peuvent donner l'impression que les valeurs ne se chevauchent pas mais leurs " +"représentations internes le font. Veuillez vous assurer que les colonnes " +"d'intervalle de type POSIXct ont des attributs 'tzone' identiques afin " +"d'éviter toute confusion." + +#: foverlaps.R:164 foverlaps.R:166 foverlaps.R:170 +#, c-format +msgid "Not yet implemented" +msgstr "Non encore implémenté" + +#: foverlaps.R:169 +#, c-format +msgid "maxgap > minoverlap. maxgap will have no effect here." +msgstr "maxgap > minoverlap. maxgap n'a pas de conséquence ici." + +#: frank.R:3 +#, c-format +msgid "length(na.last) = 0" +msgstr "length(na.last) = 0" + +#: frank.R:5 +#, c-format +msgid "length(na.last) > 1, only the first element will be used" +msgstr "length(na.last) > 1, seul le premier élément sera utilisé" + +#: frank.R:17 +#, c-format +msgid "x is a single vector, non-NULL 'cols' doesn't make sense" +msgstr "x est un vecteur colonne, les 'cols' non NULL n'ont pas de sens" + +#: frank.R:23 +#, c-format +msgid "x is a list, 'cols' can not be 0-length" +msgstr "x est une liste, 'cols' ne peut pas avoir une longueur 0" + +#: frank.R:31 +#, c-format +msgid "" +"Input column '..na_prefix..' conflicts with data.table internal usage; please " +"rename" +msgstr "" +"La colonne d'entrée '..na_prefix..' est en conflit avec l'utilisation interne " +"de data.table ; Veuillez la renommer" + +#: frank.R:46 +#, c-format +msgid "" +"Input column '..stats_runif..' conflicts with data.table internal usage; " +"please rename" +msgstr "" +"La colonne d'entrée '..stats_runif..' est en conflit avec l'utilisation " +"interne de data.table ; Veuillez la renommer" + +#: fread.R:10 +#, c-format +msgid "Used more than one of the arguments input=, file=, text= and cmd=." +msgstr "" +"Plusieurs occurrences d'un des arguments suivants input=, file=, text=, cmd=." + +#: fread.R:23 +#, c-format +msgid "Argument 'encoding' must be 'unknown', 'UTF-8' or 'Latin-1'." +msgstr "L'argument 'encoding' doit être 'unknown', 'UTF-8' ou 'Latin-1'." + +#: fread.R:42 +#, c-format +msgid "'text=' is type %s but must be character." +msgstr "'text=' est de type %s mais doit être de type 'character'." + +#: fread.R:55 +#, c-format +msgid "" +"input= must be a single character string containing a file name, a system " +"command containing at least one space, a URL starting 'http[s]://', " +"'ftp[s]://' or 'file://', or, the input data itself containing at least one " +"\\n or \\r" +msgstr "" +"input= doit être une seule chaîne de caractères contenant un nom de fichier, " +"une commande système contenant au moins une espace, une URL commençant par " +"'http[s]://', 'ftp[s]://' ou 'file://', ou les données d'entrée elles-mêmes " +"contenant au moins un \\n ou \\r" + +#: fread.R:60 +#, c-format +msgid "" +"input= contains no \\n or \\r, but starts with a space. Please remove the " +"leading space, or use text=, file= or cmd=" +msgstr "" +"input= ne contient ni \\n, ni \\r, mais commence par une espace. Veuillez " +"supprimer l'espace qui précède ou utiliser text=, file= ou cmd=" + +#: fread.R:64 +#, c-format +msgid "" +"Taking input= as a system command because it contains a space ('%s'). If it's " +"a filename please remove the space, or use file= explicitly. A variable is " +"being passed to input= and when this is taken as a system command there is a " +"security concern if you are creating an app, the app could have a malicious " +"user, and the app is not running in a secure environment; e.g. the app is " +"running as root. Please read item 5 in the NEWS file for v1.11.6 for more " +"information and for the option to suppress this message." +msgstr "" +"Le contenu de l’argument input= est considéré comme une commande système parce " +"qu'il contient une espace ('%s'). S'il s'agit d'un nom de fichier, supprimez " +"l'espace ou utilisez explicitement file=. Une variable est passée à input= et " +"lorsque cela est pris comme une commande système, il y a un problème de " +"sécurité si vous créez une application. L’application pourrait alors être " +"détournée par un utilisateur malveillant, si elle ne s'exécute pas dans un " +"environnement sécurisé, par exemple si l'application s'exécute en tant que " +"root. Veuillez lire le point 5 dans le fichier NEWS pour la v1.11.6 pour plus " +"d'informations et pour l'option permettant de supprimer ce message." + +#: fread.R:77 +#, c-format +msgid "" +"file= must be a single character string containing a filename, or URL starting " +"'http[s]://', 'ftp[s]://' or 'file://'" +msgstr "" +"file= doit être une seule chaîne de caractères contenant un nom de fichier ou " +"une URL commençant par 'http[s]://', 'ftp[s]://' or 'file://'" + +#: fread.R:90 +#, c-format +msgid "File '%s' does not exist or is non-readable. getwd()=='%s'" +msgstr "Fichier '%s' absent ou non accessible en lecture. getwd()=='%s'" + +#: fread.R:91 +#, c-format +msgid "File '%s' is a directory. Not yet implemented." +msgstr "Le fichier '%s' est un répertoire. Ceci n’est pas encore implémenté." + +#: fread.R:93 +#, c-format +msgid "File '%s' has size 0. Returning a NULL %s." +msgstr "Le fichier '%s' a pour taille 0. Renvoi de %s NULL." + +#: fread.R:105 +#, c-format +msgid "Compressed files containing more than 1 file are currently not supported." +msgstr "" +"Les fichiers compressés contenant plusieurs fichiers ne sont pas reconnus " +"actuellement." + +#: fread.R:115 +#, c-format +msgid "" +"To read %s files directly, fread() requires 'R.utils' package which cannot be " +"found. Please install 'R.utils' using 'install.packages('R.utils')'." +msgstr "" +"Pour lire directement les fichiers %s, fread() a besoin du package 'R.utils' " +"qui n'a pas été trouvé. Veuillez installer 'R.utils' via 'install.packages('R." +"utils')'." + +#: fread.R:125 +#, c-format +msgid "" +"'autostart' is now deprecated and ignored. Consider skip='string' or skip=n" +msgstr "" +"'autostart' est maintenant obsolète et ignoré. Remplacer par skip='chaîne' ou " +"skip=n" + +#: fread.R:127 +#, c-format +msgid "" +"colClasses is type 'logical' which is ok if all NA but it has some TRUE or " +"FALSE values in it which is not allowed. Please consider the drop= or select= " +"argument instead. See ?fread." +msgstr "" +"colClasses est de type booléen, ce qui est acceptable si toutes les valeurs " +"sont NA, mais il contient des valeurs TRUE ou FALSE, ce qui n'est pas " +"autorisé. Veuillez considérer l'argument drop= ou select= à la place. Voir ?" +"fread." + +#: fread.R:131 +#, c-format +msgid "colClasses is not type list or character vector" +msgstr "colClasses n'est ni du type liste ni un vecteur de chaînes de caractères" + +#: fread.R:136 +#, c-format +msgid "" +"colClasses=\"NULL\" (quoted) is interpreted as colClasses=NULL (the default) " +"as opposed to dropping every column." +msgstr "" +"colClasses=\"NULL\" (avec des guillemets) est interprété comme colClasses=NULL " +"(la valeur par défaut) contrairement à la suppression de toutes les colonnes." + +#: fread.R:148 +#, c-format +msgid "na.strings[%d]==\"%s\" consists only of whitespace, ignoring" +msgstr "na.strings[%d]==\"%s\" n'est formé que d'espaces, il est ignoré" + +#: fread.R:151 +#, c-format +msgid "" +"%s. Since strip.white=TRUE (default), use na.strings=\"\" to specify that any " +"number of spaces in a string column should be read as ." +msgstr "" +"%s. Parce que strip.white=TRUE (valeur par défaut), utilisez na.strings=\"\" " +"pour spécifier que toute suite d'espaces d'une colonne de chaînes doit être " +"lue comme ." + +#: fread.R:153 +#, c-format +msgid "" +"%s. strip.white==TRUE (default) and \"\" is present in na.strings, so any " +"number of spaces in string columns will already be read as ." +msgstr "" +"%s. strip.white==TRUE (par défault) et \"\" est présent dans na.strings, donc " +"toute suite d'espaces dans les colonnes de chaînes de caractères est déjà lue " +"comme étant ." + +#: fread.R:157 +#, c-format +msgid "" +"%s. But strip.white=FALSE. Use strip.white=TRUE (default) together with na." +"strings=\"\" to turn any number of spaces in string columns into " +msgstr "" +"%s. Mais strip.white=FALSE. Utiliser strip.white=TRUE (par défaut) avec na." +"strings=\"\" pour transformer les suites d'espaces en dans les colonnes " +"de chaînes de caractères" + +#: fread.R:163 +#, c-format +msgid "" +"'data.table' relies on the package 'yaml' to parse the file header; please add " +"this to your library with install.packages('yaml') and try again." +msgstr "" +"'data.table' dépend du package 'yaml' pour analyser l'entête du fichier ; " +"Veuillez l’ajouter dans votre bibliothèque avec install.packages('yaml') et " +"recommencer." + +#: fread.R:167 +#, c-format +msgid "" +"Combining a search string as 'skip' and reading a YAML header may not work as " +"expected -- currently, reading will proceed to search for 'skip' from the " +"beginning of the file, NOT from the end of the metadata; please file an issue " +"on GitHub if you'd like to see more intuitive behavior supported." +msgstr "" +"La combinaison d'une chaîne de recherche comme 'skip' et la lecture d'un " +"entête YAML peuvent ne pas fonctionner comme prévu -- actuellement, la lecture " +"va rechercher 'skip' à partir du début du fichier, PAS à partir de la fin des " +"métadonnées ; Veuillez renseigner ce problème sur GitHub si vous souhaitez " +"qu'un comportement plus intuitif soit pris en charge." + +#: fread.R:177 +#, c-format +msgid "" +"Encountered <%s%s> at the first unskipped line (%d), which does not constitute " +"the start to a valid YAML header (expecting something matching regex \"%s\"); " +"please check your input and try again." +msgstr "" +"<%s%s> trouvé à la première ligne non sautée (%d), ce qui ne constitue pas le " +"début d'un entête YAML valide (on s'attendait à quelque chose correspondant à " +"l'expression régulière \"%s\") ; veuillez vérifier votre entrée et réessayer." + +#: fread.R:189 +#, c-format +msgid "" +"Reached the end of the file before finding a completion to the YAML header. A " +"valid YAML header is bookended by lines matching the regex \"%s\". Please " +"double check the input file is a valid csvy." +msgstr "" +"La fin du fichier est atteinte avant de trouver la fin de l'entête YAML. Un " +"entête YAML valide est complété par des lignes correspondant à l'expression " +"régulière \"%s\". Veuillez bien vérifier que le fichier d'entrée est un csvy " +"valide." + +#: fread.R:203 +#, c-format +msgid "User-supplied 'header' will override that found in metadata." +msgstr "" +"Le 'header' fourni par l'utilisateur redéfinira celui trouvé dans les " +"métadonnées." + +#: fread.R:221 +#, c-format +msgid "" +"User-supplied column names in 'col.names' will override those found in YAML " +"metadata." +msgstr "" +"Les noms de colonnes fournis par l'utilisateur dans 'col.names' remplaceront " +"ceux trouvés dans les métadonnées YAML." + +#: fread.R:230 +#, c-format +msgid "" +"colClasses dictated by user input and those read from YAML header are in " +"conflict (specifically, for column(s) [%s]); the proceeding assumes the user " +"input was an intentional override and will ignore the type(s) implied by the " +"YAML header; please exclude the column(s) from colClasses if this was " +"unintentional." +msgstr "" +"les colClasses imposées par les entrées de l'utilisateur et celles lues dans " +"l'entête YAML sont en conflit (en particulier, pour la/les colonne(s) [%s]) ; " +"La procédure suppose que la proposition de l'utilisateur est une modification " +"intentionnelle et ignore le(s) type(s) défini(s) par l'entête YAML ; veuillez " +"exclure la/les colonne(s) des colClasses si cela n'est pas intentionnel." + +#: fread.R:251 +#, c-format +msgid "User-supplied 'sep' will override that found in metadata." +msgstr "" +"Le 'sep' fourni par l'utilisateur redéfinira celui trouvé dans les métadonnées." + +#: fread.R:256 +#, c-format +msgid "User-supplied 'quote' will override that found in metadata." +msgstr "" +"Le 'quote' fourni par l'utilisateur redéfinira celui trouvé dans les " +"métadonnées." + +#: fread.R:261 +#, c-format +msgid "User-supplied 'dec' will override that found in metadata." +msgstr "" +"Le 'dec' fourni par l'utilisateur redéfinira celui trouvé dans les métadonnées." + +#: fread.R:265 +#, c-format +msgid "User-supplied 'na.strings' will override that found in metadata." +msgstr "" +"Le 'na.strings' fourni par l'utilisateur redéfinira celui trouvé dans les " +"métadonnées." + +#: fread.R:314 +#, c-format +msgid "" +"Column '%s' was requested to be '%s' but fread encountered the following %s:\n" +"\t%s\n" +"so the column has been left as type '%s'" +msgstr "" +"La colonne '%s' devait être '%s' mais fread a rencontré le problème suivant " +"%s :\n" +"\t%s\n" +"la colonne a donc été laissée au type '%s'" + +#: fread.R:337 +#, c-format +msgid "" +"key argument of data.table() must be a character vector naming columns (NB: " +"col.names are applied before this)" +msgstr "" +"l'argument clé de data.table() doit être un vecteur de caractères nommant les " +"colonnes (NB : col.names est appliqué avant cela)" + +#: fread.R:345 +#, c-format +msgid "" +"index argument of data.table() must be a character vector naming columns (NB: " +"col.names are applied before this)" +msgstr "" +"l'argument index de data.table() doit être un vecteur de chaînes de caractères " +"qui nomme les colonnes (NB: col.names est appliqué avant)" + +#: fwrite.R:19 +#, c-format +msgid "Argument 'encoding' must be '', 'UTF-8' or 'native'." +msgstr "L'argument 'encoding' doit être '', 'UTF-8' ou 'native'." + +#: fwrite.R:24 +#, c-format +msgid "dateTimeAs must be a single string" +msgstr "dateTimeAs doit être une seule chaîne de caractères" + +#: fwrite.R:26 +#, c-format +msgid "dateTimeAs must be 'ISO','squash','epoch' or 'write.csv'" +msgstr "dateTimeAs doit être 'ISO', 'squash', 'epoch' ou 'write.csv'" + +#: fwrite.R:28 +#, c-format +msgid "logicalAsInt has been renamed logical01. Use logical01 only, not both." +msgstr "" +"logicalAsInt a été renommé logical01. Utiliser logical01 uniquement, pas les " +"deux." + +#: fwrite.R:30 +#, c-format +msgid "" +"logicalAsInt has been renamed logical01 for consistency with fread. It works " +"fine for now but please change to logical01 at your convenience so we can " +"remove logicalAsInt in future." +msgstr "" +"logicalAsInt a été renommé logical01 pour des raisons de cohérence avec fread. " +"Cela fonctionne bien pour l'instant, mais nous vous invitons à passer à " +"logical01 à votre convenance afin que nous puissions supprimer logicalAsInt à " +"l'avenir." + +#: fwrite.R:40 +#, c-format +msgid "x being coerced from class: matrix to data.table" +msgstr "conversion automatique de classe pour x : matrix vers data.table" + +#: fwrite.R:85 +#, c-format +msgid "" +"If you intended to overwrite the file at %s with an empty one, please use file." +"remove first." +msgstr "" +"Si vous souhaitiez écraser le fichier %s par un fichier vide, utilisez d'abord " +"file.remove." + +#: fwrite.R:86 +#, c-format +msgid "Input has no columns; doing nothing.%s" +msgstr "L'entrée n'a pas de colonne ; aucune action réalisée. %s" + +#: fwrite.R:89 +#, c-format +msgid "Input has no columns; creating an empty file at '%s' and exiting." +msgstr "" +"L'entrée n'a pas de colonne ; Création d'un fichier vide à '%s' et sortie." + +#: fwrite.R:96 +#, c-format +msgid "" +"'data.table' relies on the package 'yaml' to write the file header; please add " +"this to your library with install.packages('yaml') and try again." +msgstr "" +"'data.table' dépend du package 'yaml' pour écrire l'entête du fichier ; " +"Veuillez l’ajouter à votre bibliothèque avec install.packages('yaml') et " +"recommencer." + +#: groupingsets.R:7 groupingsets.R:25 groupingsets.R:47 +#, c-format +msgid "Argument 'x' must be a data.table object" +msgstr "L'argument 'x' doit être un objet data.table" + +#: groupingsets.R:9 groupingsets.R:27 groupingsets.R:53 +#, c-format +msgid "" +"Argument 'by' must be a character vector of column names used in grouping." +msgstr "" +"L'argument 'by' doit être un vecteur de chaînes de caractères composé de noms " +"de colonnes utilisées pour le groupement." + +#: groupingsets.R:11 groupingsets.R:29 groupingsets.R:59 +#, c-format +msgid "Argument 'id' must be a logical scalar." +msgstr "L'argument 'id' doit être un scalaire booléen." + +#: groupingsets.R:31 +#, c-format +msgid "Argument 'j' is required" +msgstr "L'argument 'j' est obligatoire" + +#: groupingsets.R:49 +#, c-format +msgid "Argument 'x' is a 0-column data.table; no measure to apply grouping over." +msgstr "" +"L'argument 'x' est une data.table à 0 colonne ; Aucune possibilité de " +"groupement." + +#: groupingsets.R:51 +#, c-format +msgid "Input data.table must not contain duplicate column names." +msgstr "L'entrée data.table ne doit pas contenir de noms de colonnes dupliqués." + +#: groupingsets.R:55 +#, c-format +msgid "Argument 'by' must have unique column names for grouping." +msgstr "" +"L'argument 'by' doit avoir des noms de colonnes uniques pour le groupement." + +#: groupingsets.R:57 +#, c-format +msgid "Argument 'sets' must be a list of character vectors." +msgstr "" +"L'argument 'sets' doit être une liste de vecteurs de chaînes de caractères." + +#: groupingsets.R:62 +#, c-format +msgid "" +"All columns used in 'sets' argument must be in 'by' too. Columns used in " +"'sets' but not present in 'by': %s" +msgstr "" +"Toutes les colonnes utilisées dans l'argument 'sets' doivent également figurer " +"dans 'by'. Colonnes utilisées dans 'sets' mais non présentes dans 'by' : %s" + +#: groupingsets.R:64 +#, c-format +msgid "" +"When using `id=TRUE` the 'x' data.table must not have a column named " +"'grouping'." +msgstr "" +"Lorsqu'on utilise `id=TRUE`, le data.table 'x' ne doit pas avoir de colonne " +"nommée 'grouping'." + +#: groupingsets.R:66 +#, c-format +msgid "" +"Character vectors in 'sets' list must not have duplicated column names within " +"a single grouping set." +msgstr "" +"Les vecteurs de chaînes de caractères de la liste 'sets' ne doivent pas avoir " +"de noms de colonnes dupliqués au sein d'un même ensemble de regroupement." + +#: groupingsets.R:68 +#, c-format +msgid "" +"'sets' contains a duplicate (i.e., equivalent up to sorting) element at index " +"%d; as such, there will be duplicate rows in the output -- note that grouping " +"by A,B and B,A will produce the same aggregations. Use " +"`sets=unique(lapply(sets, sort))` to eliminate duplicates." +msgstr "" +"'sets' contient un élément dupliqué (c'est-à-dire équivalent lors du tri) à " +"l'index %d ; Il y aura donc des lignes dupliquées dans la sortie -- notez que " +"le regroupement par A,B et B,A produira les mêmes agrégations. Utiliser " +"`sets=unique(lapply(sets, sort))` pour éliminer les doublons." + +#: groupingsets.R:73 +#, c-format +msgid "" +"Expression passed to grouping sets function must not update by reference. Use " +"':=' on results of your grouping function." +msgstr "" +"L'expression transmise à la fonction de regroupement des ensembles ne doit pas " +"être mise à jour par référence. Utilisez ':=' sur les résultats de votre " +"fonction de regroupement." + +#: groupingsets.R:80 +#, c-format +msgid "" +"When using `id=TRUE` the 'j' expression must not evaluate to a column named " +"'grouping'." +msgstr "" +"Lors de l'utilisation de `id=TRUE`, l'expression 'j' ne doit pas être évaluée " +"à une colonne nommée 'grouping'." + +#: groupingsets.R:82 +#, c-format +msgid "" +"There exists duplicated column names in the results, ensure the column passed/" +"evaluated in `j` and those in `by` are not overlapping." +msgstr "" +"Le résultat comporte des doublons parmi les noms de colonnes, vérifier que les " +"colonnes passées ou évaluées dans 'j' et celles du 'by' ne se recouvrent pas." + +#: groupingsets.R:92 +#, c-format +msgid "Using integer64 class columns require to have 'bit64' package installed." +msgstr "" +"L'utilisation de colonnes de classe integer64 nécessite d'avoir installé le " +"package 'bit64'." + +#: last.R:38 last.R:79 +#, c-format +msgid "" +"'xts' class passed to %s function but 'xts' is not available, you should have " +"'xts' installed already" +msgstr "" +"la classe 'xts' est passée à la fonction %s mais le package 'xts' n'est pas " +"présent; 'xts' doit être installé auparavant" + +#: merge.R:4 +#, c-format +msgid "Argument 'sort' should be logical TRUE/FALSE" +msgstr "L'argument 'sort' doit être un booléen TRUE ou FALSE" + +#: merge.R:6 +#, c-format +msgid "Argument 'no.dups' should be logical TRUE/FALSE" +msgstr "L'argument 'no.dups' doit être un booléen TRUE ou FALSE" + +#: merge.R:18 +#, c-format +msgid "Neither of the input data.tables to join have columns." +msgstr "Lors de la jointure, aucune des data.tables d'entrée n'a de colonne." + +#: merge.R:20 merge.R:22 +#, c-format +msgid "Input data.table '%s' has no columns." +msgstr "La data.table d'entrée '%s' n'a pas de colonne." + +#: merge.R:31 +#, c-format +msgid "`by.x` and `by.y` must be of same length." +msgstr "'by.x' et 'by.y' doivent avoir la même longueur." + +#: merge.R:33 +#, c-format +msgid "Supplied both `by` and `by.x/by.y`. `by` argument will be ignored." +msgstr "" +"Quand 'by' et 'by.x/by.y' sont présents simultanément, l'argument 'by' est " +"ignoré." + +#: merge.R:36 +#, c-format +msgid "A non-empty vector of column names is required for `by.x` and `by.y`." +msgstr "" +"'by.x' et 'by.y' doivent être des vecteurs non vides comportant des noms de " +"colonnes." + +#: merge.R:38 +#, c-format +msgid "Elements listed in `by.x` must be valid column names in x." +msgstr "" +"Les éléments listés dans 'by.x' doivent être des noms de colonnes valides de x." + +#: merge.R:40 +#, c-format +msgid "Elements listed in `by.y` must be valid column names in y." +msgstr "" +"Les éléments listés dans 'by.y' doivent être des noms de colonnes valides de y." + +#: merge.R:51 +#, c-format +msgid "A non-empty vector of column names for `by` is required." +msgstr "'by' doit être un vecteur non vide de noms de colonnes." + +#: merge.R:53 +#, c-format +msgid "Elements listed in `by` must be valid column names in x and y" +msgstr "" +"Les éléments listés dans 'by' doivent être des noms de colonnes valides de x " +"et de y" + +#: merge.R:61 +#, c-format +msgid "Unknown argument '%s' has been passed." +msgstr "L'argument '%s' fourni n'est pas connu." + +#: merge.R:64 +#, c-format +msgid "Passed %d unknown and unnamed arguments." +msgstr "Les %d arguments fournis sont inconnus et non nommés." + +#: merge.R:114 +#, c-format +msgid "column names %s are duplicated in the result" +msgstr "noms de colonnes en doublon %s dans le résultat" + +#: onAttach.R:23 +#, c-format +msgid "" +"data.table %s IN DEVELOPMENT built %s%s using %d threads (see ?getDTthreads)." +msgstr "" +"data.table %s EN DEVELOPPEMENT build %s%s utilisant %d threads (voir ?" +"getDTthreads)." + +#: onAttach.R:25 +#, c-format +msgid "data.table %s using %d threads (see ?getDTthreads)." +msgstr "data.table %s utilise %d threads (voir ?getDTthreads)." + +#: onAttach.R:26 +#, c-format +msgid "Latest news: r-datatable.com" +msgstr "Dernières actualités : r-datatable.com" + +#: onAttach.R:27 +msgid "TRANSLATION CHECK" +msgstr "CONTROLE DE TRADUCTION" + +#: onAttach.R:28 +#, c-format +msgid "" +"**********\n" +"Running data.table in English; package support is available in English only. " +"When searching for online help, be sure to also check for the English error " +"message. This can be obtained by looking at the po/R-.po and po/" +".po files in the package source, where the native language and English " +"error messages can be found side-by-side\n" +"**********" +msgstr "" +"**********\n" +"Exécution de data.table en anglais ; L'aide du package n'est disponible qu'en " +"anglais. Lorsque vous recherchez de l'aide en ligne, veillez à vérifier " +"également le message d'erreur en anglais. Pour ce faire, consultez les " +"fichiers po/R-.po et po/.po dans le source du package, où les " +"messages d'erreur en langue native et en anglais sont mis côte à côte\n" +"**********" + +#: onAttach.R:30 +#, c-format +msgid "" +"**********\n" +"This development version of data.table was built more than 4 weeks ago. Please " +"update: data.table::update_dev_pkg()\n" +"**********" +msgstr "" +"**********\n" +"Cette version de développement de data.table a été construite il y a plus de 4 " +"semaines. Veuillez mettre à jour : data.table::update_dev_pkg()\n" +"**********" + +#: onAttach.R:32 +#, c-format +msgid "" +"**********\n" +"This installation of data.table has not detected OpenMP support. It should " +"still work but in single-threaded mode." +msgstr "" +"**********\n" +"Cette installation de data.table n'a pas détecté le support OpenMP. Elle " +"devrait fonctionner, mais en mode monotâche." + +#: onAttach.R:34 +#, c-format +msgid "" +"This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage " +"with Apple and ask them for support. Check r-datatable.com for updates, and " +"our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/" +"Installation. After several years of many reports of installation problems on " +"Mac, it's time to gingerly point out that there have been no similar problems " +"on Windows or Linux.\n" +"**********" +msgstr "" +"Il s'agit d'un Mac. Veuillez lire https://mac.r-project.org/openmp/. Contactez " +"Apple et demandez-lui de mieux supporter OpenMP. Consultez r-datable.com pour " +"les mises à jour, et nos instructions pour Mac ici : https://github.com/" +"Rdatatable/data.table/wiki/Installation. Après plusieurs années de rapports " +"faisant état de problèmes d'installation sur Mac, il est temps de souligner " +"avec insistance qu'il n'y a pas eu de problèmes similaires sous Windows ou " +"Linux.\n" +"**********" + +#: onAttach.R:36 +#, c-format +msgid "" +"This is %s. This warning should not normally occur on Windows or Linux where " +"OpenMP is turned on by data.table's configure script by passing -fopenmp to " +"the compiler. If you see this warning on Windows or Linux, please file a " +"GitHub issue.\n" +"**********" +msgstr "" +"Il s'agit de %s. Cet avertissement ne doit pas se produire normalement sous " +"Windows ou Linux où OpenMP est activé par le script de configuration de data." +"table en passant -fopenmp au compilateur. Si vous voyez cet avertissement sous " +"Windows ou Linux, veuillez reporter le problème dans le gestionnaire de " +"tickets (issue tracker) sur GitHub.\n" +"**********" + +#: onAttach.R:40 +#, c-format +msgid "" +"**********\n" +"This data.table installation was compiled for R < 3.4.0 (Apr 2017) and is " +"known to leak memory. Please upgrade R and reinstall data.table to fix the " +"leak. Maintaining and testing code branches to support very old versions " +"increases development time so please do upgrade R. We intend to bump data." +"table's dependency from 8 year old R 3.1.0 (Apr 2014) to 5 year old R 3.4.0 " +"(Apr 2017).\n" +"**********" +msgstr "" +"**********\n" +"Cette installation de data.table a été compilée pour R < 3.4.0 (avril 2017) et " +"elle est connue pour avoir des fuites mémoire. Veuillez mettre à jour R et " +"réinstaller data.table pour corriger ces fuites. Maintenir et tester des " +"branches de code pour supporter de très anciennes versions augmentent le temps " +"de développement, veuillez donc mettre à jour R. Nous avons l'intention de " +"faire passer la dépendance de data.table du R 3.1.0 (avril 2014) d'il y a 8 " +"ans au R 3.4.0 (avril 2017) d'il y a 5 ans.\n" +"**********" + +#: onLoad.R:9 +#, c-format +msgid "" +"Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 " +"in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2." +msgstr "" +"L'option 'datatable.nomatch' est définie mais est désormais ignorée. Voir la " +"note 11 dans la v1.12.4 NEWS (Oct 2019), et la note 14 dans la v1.14.2." + +#: onLoad.R:27 +#, c-format +msgid "" +"The data_table.%s version (%s) does not match the package (%s). Please close " +"all R sessions to release the old %s and reinstall data.table in a fresh R " +"session. The root cause is that R's package installer can in some unconfirmed " +"circumstances leave a package in a state that is apparently functional but " +"where new R code is calling old C code silently: https://bugs.r-project.org/" +"bugzilla/show_bug.cgi?id=17478. Once a package is in this mismatch state it " +"may produce wrong results silently until you next upgrade the package. Please " +"help by adding precise circumstances to 17478 to move the status to confirmed. " +"This mismatch between R and C code can happen with any package not just data." +"table. It is just that data.table has added this check." +msgstr "" +"La data_table.%s version (%s) ne correspond pas au package (%s). Veuillez " +"fermer toutes les sessions R pour libérer l'ancien %s et réinstaller data." +"table dans une nouvelle session R. La cause principale est que l'installateur " +"de packages de R peut, dans certaines circonstances non confirmées, laisser un " +"package dans un état apparemment fonctionnel, mais où le nouveau code R " +"appelle silencieusement l'ancien code C : https://bugs.r-project.org/bugzilla/" +"show_bug.cgi?id=17478. Une fois qu'un package est dans cet état instable, il " +"peut produire des résultats erronés en silence jusqu'à la prochaine mise à " +"jour du package. Merci de nous aider en ajoutant des circonstances précises au " +"17478 pour faire passer le statut à confirmé. Cette incompatibilité entre le " +"code R et le code C peut se produire avec n'importe quel package, et pas " +"seulement avec data.table. C'est juste que data.table a ajouté cette " +"vérification." + +#: onLoad.R:31 +#, c-format +msgid "" +"This is R %s but data.table has been installed using R %s. The major version " +"must match. Please reinstall data.table." +msgstr "" +"Il s'agit de R %s mais data.table a été installé avec R %s. La version majeure " +"doit correspondre. Veuillez réinstaller data.table." + +#: onLoad.R:98 +#, c-format +msgid "Unexpected base R behaviour: list(x) has copied x" +msgstr "Comportement inattendu de R de base : list(x) a recopié x" + +#: onLoad.R:106 +#, c-format +msgid "Unexpected base R behaviour: names<- has copied column contents" +msgstr "" +"Comportement inattendu de R de base : names<- a recopié le contenu de la " +"colonne" + +#: onLoad.R:116 +#, c-format +msgid "" +"Unexpected base R behaviour: DF[2,2]<- did not copy column 2 which was " +"assigned to" +msgstr "" +"Comportement inattendu de la base R : DF[2,2]<- n'a pas copié la colonne 2 qui " +"était assignée à" + +#: onLoad.R:117 +#, c-format +msgid "" +"Unexpected base R behaviour: DF[2,2]<- copied the first column which was not " +"assigned to, too" +msgstr "" +"Comportement inattendu de la base R : DF[2,2]<- a copié la première colonne " +"qui n'a pas non plus été affectée à" + +#: onLoad.R:119 +#, c-format +msgid "Unexpected base R behaviour: DF[2,2]<- has not copied address(DF)" +msgstr "" +"Comportement inattendu de R de base : DF[2,2]<- n'a pas copié address(DF)" + +#: openmp-utils.R:3 +#, c-format +msgid "Provide either threads= or percent= but not both" +msgstr "Utiliser threads= ou percent= mais pas les deux simultanément" + +#: openmp-utils.R:4 +#, c-format +msgid "percent= is provided but is length %d" +msgstr "percent= est fourni mais sa longueur vaut %d" + +#: openmp-utils.R:6 +#, c-format +msgid "percent==%d but should be a number between 2 and 100" +msgstr "percent==%d mais doit être un nombre entre 2 et 100" + +#: print.data.table.R:19 +#, c-format +msgid "Valid options for col.names are 'auto', 'top', and 'none'" +msgstr "Les options valides pour col.names sont 'auto', 'top', ou 'none'" + +#: print.data.table.R:21 +#, c-format +msgid "Valid options for trunc.cols are TRUE and FALSE" +msgstr "Les options valides pour trunc.cols sont TRUE ou FALSE" + +#: print.data.table.R:23 +#, c-format +msgid "Column classes will be suppressed when col.names is 'none'" +msgstr "Les classes des colonnes seront supprimées si col.names est 'none'" + +#: print.data.table.R:156 +#, c-format +msgid "" +"Internal structure doesn't seem to be a list. Possibly corrupt data.table." +msgstr "" +"La structure interne ne correspond pas à une liste. La data.table est " +"éventuellement corrompue." + +#: programming.R:14 programming.R:40 +#, c-format +msgid "'x' must be a list" +msgstr "'x' doit être une liste" + +#: programming.R:22 +#, c-format +msgid "" +"Character objects provided in the input are not scalar objects, if you need " +"them as character vector rather than a name, then wrap each into 'I' call: %s" +msgstr "" +"Les objets caractères fournis en entrée ne sont pas des objets scalaires, si " +"vous avez besoin d'un vecteur de caractères plutôt que d'un nom, encadrez " +"chacun d'eux dans un appel 'I' : %s" + +#: programming.R:50 +#, c-format +msgid "'env' must not be missing" +msgstr "'env' doit être fourni" + +#: programming.R:56 +#, c-format +msgid "'env' must be a list or an environment" +msgstr "'env' doit être une liste ou un environnement" + +#: programming.R:63 +#, c-format +msgid "'env' argument does not have names" +msgstr "il manque les noms dans l'argument 'env'" + +#: programming.R:65 +#, c-format +msgid "'env' argument has zero char names" +msgstr "L’argument 'env' contient des noms à zéro caractère" + +#: programming.R:67 +#, c-format +msgid "'env' argument has NA names" +msgstr "l'argument 'env' comporte des noms à NA" + +#: programming.R:69 +#, c-format +msgid "'env' argument has duplicated names" +msgstr "l'argument 'env' contient des noms dupliqués" + +#: setkey.R:3 +#, c-format +msgid "" +"x may no longer be the character name of the data.table. The possibility was " +"undocumented and has been removed." +msgstr "" +"x ne peut plus être le nom sous forme de chaîne de caractère de data.table. " +"Cette possibilité n'était pas documentée et a été supprimée." + +#: setkey.R:23 +#, c-format +msgid "" +"key(x)<-value is deprecated and not supported. Please change to use setkey() " +"with perhaps copy(). Has been warning since 2012." +msgstr "" +"key(x)<-valeur est obsolète et n'est pas supporté. Veuillez changer pour " +"utiliser setkey() avec peut-être copy(). Avertissement depuis 2012." + +#: setkey.R:39 +#, c-format +msgid "x is not a data.table" +msgstr "x n'est pas une data.table" + +#: setkey.R:40 +#, c-format +msgid "" +"cols is not a character vector. Please see further information in ?setkey." +msgstr "" +"cols n'est pas un vecteur de chaînes de caractères. Voir les informations " +"supplémentaires dans ?setkey." + +#: setkey.R:41 +#, c-format +msgid "" +"Setting a physical key on .SD is reserved for possible future use; to modify " +"the original data's order by group. Try setindex() instead. Or, set*(copy(." +"SD)) as a (slow) last resort." +msgstr "" +"La définition d'une clé physique sur .SD est réservée à une utilisation future " +"possible, pour modifier l'ordre des données d'origine par groupe. Essayez " +"plutôt setindex(), ou encore, set*(copy(.SD)) en dernier recours (lent)." + +#: setkey.R:43 +#, c-format +msgid "" +"cols is a character vector of zero length. Removed the key, but use NULL " +"instead, or wrap with suppressWarnings() to avoid this warning." +msgstr "" +"cols est un vecteur de chaînes de caractères de longueur zéro. Supprimer la " +"clé à remplacer par NULL, ou encadrer le code dans suppressWarnings() pour " +"éviter cet avertissement." + +#: setkey.R:47 +#, c-format +msgid "cols is the empty string. Use NULL to remove the key." +msgstr "cols est une chaîne vide. Utiliser NULL pour supprimer la clé." + +#: setkey.R:48 setkey.R:262 +#, c-format +msgid "cols contains some blanks." +msgstr "cols contient des blancs." + +#: setkey.R:51 setkey.R:266 +#, c-format +msgid "some columns are not in the data.table: %s" +msgstr "certaines colonnes n'appartiennent pas à la data.table : %s" + +#: setkey.R:59 setkey.R:267 +#, c-format +msgid "" +"x contains a column called '.xi'. Conflicts with internal use by data.table." +msgstr "" +"x contient une colonne appelée '.xi'. Ceci entre en conflit avec l'utilisation " +"interne de data.table." + +#: setkey.R:62 +#, c-format +msgid "" +"Column '%s' is type '%s' which is not supported as a key column type, " +"currently." +msgstr "" +"La colonne '%s' a pour type '%s' qui n'est pas reconnu actuellement comme type " +"de clé de colonne." + +#: setkey.R:137 +#, c-format +msgid "x is vector but 'by' is supplied" +msgstr "x est un vecteur mais 'by' est fourni" + +#: setkey.R:153 +#, c-format +msgid "x is a single vector, non-NULL 'by' doesn't make sense" +msgstr "x est un vecteur colonne, 'by' non NULL n'a pas de sens" + +#: setkey.R:184 +#, c-format +msgid "Attempting to order a 0-column data.table or data.frame." +msgstr "" +"Tentative de tri d'une data.table ou d'un data.frame qui n'a pas de colonne." + +#: setkey.R:189 +#, c-format +msgid "" +"The first item passed to [f]order is a plain list but there are more items. It " +"should be a data.table or data.frame." +msgstr "" +"Le premier élément transmis à [f]order est une simple liste, mais il y a " +"d'autres éléments. Il faut un data.table ou un data.frame." + +#: setkey.R:206 +#, c-format +msgid "Internal code should not be being called on type double" +msgstr "Le code interne ne doit pas être appelé avec un type double" + +#: setkey.R:214 +#, c-format +msgid "" +"Input is not a vector of type double. New parallel sort has only been done for " +"double vectors so far. Using one thread." +msgstr "" +"L'entrée n'est pas un vecteur de type double. Le nouveau tri parallèle n'a été " +"implémenté que pour les vecteurs de doubles jusqu'à présent. Utilisation d'un " +"seul thread." + +#: setkey.R:215 +#, c-format +msgid "" +"New parallel sort has not been implemented for decreasing=TRUE so far. Using " +"one thread." +msgstr "" +"Le nouveau tri parallèle n'a pas été implémenté pour decreasing=TRUE jusqu'à " +"présent. Utilisation d'un seul thread." + +#: setkey.R:216 +#, c-format +msgid "" +"New parallel sort has not been implemented for vectors containing NA values so " +"far. Using one thread." +msgstr "" +"Le nouveau tri parallèle n'a pas été implémenté pour les vecteurs contenant " +"des valeurs NA jusqu'à présent. Utilisation d'un seul thread." + +#: setkey.R:228 setkey.R:254 +#, c-format +msgid "x must be a data.frame or data.table" +msgstr "x doit être un data.frame ou une data.table" + +#: setkey.R:256 +#, c-format +msgid "na.last must be logical TRUE/FALSE" +msgstr "na.last doit être un booléen TRUE ou FALSE" + +#: setkey.R:257 +#, c-format +msgid "" +"cols is not a character vector. Please see further information in ?setorder." +msgstr "" +"cols n'est pas un vecteur de chaînes de caractères. Voir les informations " +"supplémentaires dans ?setorder." + +#: setkey.R:259 +#, c-format +msgid "" +"cols is a character vector of zero length. Use NULL instead, or wrap with " +"suppressWarnings() to avoid this warning." +msgstr "" +"cols est un vecteur de caractères de longueur nulle. Utilisez NULL à la place, " +"ou utilisez suppressWarnings() pour éviter cet avertissement." + +#: setkey.R:270 +#, c-format +msgid "Column '%s' is type '%s' which is not supported for ordering currently." +msgstr "" +"La colonne '%s' a pour type '%s' qui n'est pas reconnu actuellement pour le " +"classement." + +#: setkey.R:314 +#, c-format +msgid "" +"'sorted' is TRUE but element %d is non-atomic, which can't be sorted; try " +"setting sorted = FALSE" +msgstr "" +"'sorted' vaut TRUE mais l'élément %d n'est pas atomique, on ne peut donc pas " +"le trier ; Essayez sorted = FALSE" + +#: setkey.R:329 +#, c-format +msgid "" +"Cross product of elements provided to CJ() would result in %.0f rows which " +"exceeds .Machine$integer.max == %d" +msgstr "" +"Le produit croisé des éléments fournis à CJ() donnerait %.0f lignes, ce qui " +"dépasse .Machine$integer.max == %d" + +#: setops.R:3 setops.R:40 +#, c-format +msgid "x and y must both be data.tables" +msgstr "x et y doivent être tous deux des data.tables" + +#: setops.R:9 +#, c-format +msgid "length(by.x) != length(by.y)" +msgstr "length(by.x) != length(by.y)" + +#: setops.R:17 +#, c-format +msgid "" +"When x's column ('%s') is character, the corresponding column in y ('%s') " +"should be factor or character, but found incompatible type '%s'." +msgstr "" +"Lorsqu’une colonne de x ('%s') est de type caractère, la colonne " +"correspondante de y ('%s') doit être de type facteur ou caractère, mais le " +"type actuel '%s' n'est pas compatible." + +#: setops.R:19 +#, c-format +msgid "" +"When x's column ('%s') is factor, the corresponding column in y ('%s') should " +"be character or factor, but found incompatible type '%s'." +msgstr "" +"Lorsque la colonne de x ('%s') est un facteur, la colonne correspondante dans " +"y ('%s') doit aussi être de type caractère ou facteur, mais un type " +"incompatible '%s' est rencontré." + +#: setops.R:21 +#, c-format +msgid "" +"When x's column ('%s') is integer or numeric, the corresponding column in y " +"('%s') can not be character or logical types, but found incompatible type '%s'." +msgstr "" +"Lorsque la colonne de x ('%s') est entière ou numérique, la colonne " +"correspondante dans y ('%s') ne peut pas être de type caractère ou booléen, " +"mais le type incompatible '%s' est rencontré." + +#: setops.R:39 +#, c-format +msgid "argument 'all' should be logical of length one" +msgstr "l'argument 'all' doit être un booléen de longueur unitaire" + +#: setops.R:41 +#, c-format +msgid "x and y must have the same column names" +msgstr "x et y doivent avoir les mêmes noms de colonnes" + +#: setops.R:42 +#, c-format +msgid "x and y must have the same column order" +msgstr "x et y doivent avoir les colonnes dans le même ordre" + +#: setops.R:45 +#, c-format +msgid "unsupported column type(s) found in x or y: %s" +msgstr "type(s) de colonne non supporté(s) trouvé(s) dans x ou y : %s" + +#: setops.R:53 +#, c-format +msgid "Item %d of x is '%s' but the corresponding item of y is '%s'." +msgstr "L'élément %d de x est '%s' mais l'élément correspondant de y est '%s'." + +#: setops.R:55 +#, c-format +msgid "None of the datasets should contain a column named '.seqn'" +msgstr "Aucun jeu de données ne doit contenir de colonne nommée '.seqn'" + +#: setops.R:159 setops.R:170 +#, c-format +msgid "Datasets have different %s. 'target': %s. 'current': %s." +msgstr "Les jeux de données ont différents %s. 'target': %s. 'current': %s." + +#: setops.R:161 setops.R:162 +#, c-format +msgid "has no key" +msgstr "n’a pas de clé" + +#: setops.R:172 setops.R:173 +#, c-format +msgid "has no index" +msgstr "n’a pas d’index" + +#: setops.R:190 +#, c-format +msgid "None of the datasets to compare should contain a column named '.seqn'" +msgstr "" +"Aucun des jeux de données à comparer ne doit contenir de colonne nommée '.seqn'" + +#: setops.R:193 +#, c-format +msgid "" +"Datasets to compare with 'ignore.row.order' must not have unsupported column " +"types: %s" +msgstr "" +"Les jeux de données à comparer avec 'ignore.row.order' ne doivent pas avoir de " +"types de colonnes non supportés : %s" + +#: setops.R:195 +#, c-format +msgid "" +"Argument 'tolerance' was forced to lowest accepted value `sqrt(.Machine$double." +"eps)` from provided %s" +msgstr "" +"L'argument 'tolerance' a été forcé à la plus petite valeur acceptable `sqrt(." +"Machine$double.eps)` de %s fourni" + +#: setops.R:208 +#, c-format +msgid "" +"Duplicate rows in datasets, numeric columns and ignore.row.order cannot be " +"used with non 0 tolerance argument" +msgstr "" +"Les doublons dans les lignes des jeux de données, les colonnes numériques et " +"ignore.row.order ne peuvent pas être utilisés avec un argument de tolérance " +"différent de 0" + +#: setops.R:222 +#, c-format +msgid "" +"Factor columns and ignore.row.order cannot be used with non 0 tolerance " +"argument" +msgstr "" +"Les colonnes de type facteur et ignore.row.order ne peuvent pas être utilisés " +"avec un argument de tolérance différent de 0" + +#: shift.R:3 +#, c-format +msgid "Provided argument fill=%s will be ignored since type='cyclic'." +msgstr "L'argument fourni fill=%s sera ignoré puisque le type='cyclique'." + +#: tables.R:46 +#, c-format +msgid "order.col='%s' not a column name of info" +msgstr "order.col='%s' n'est pas un nom de colonne de info" + +#: test.data.table.R:17 +#, c-format +msgid "data.table package is loaded. Unload or start a fresh R session." +msgstr "" +"le package data.table est chargé. Déchargez-le ou redémarrez une nouvelle " +"session R." + +#: test.data.table.R:33 +#, c-format +msgid "" +"script must end with '.Rraw'. If a file ending '.Rraw.bz2' exists, that will " +"be found and used." +msgstr "" +"le script doit se terminer par '.Rraw'. Si un fichier se terminant par '.Rraw." +"bz2' existe, il sera trouvé et utilisé." + +#: test.data.table.R:63 +#, c-format +msgid "Neither %s nor %s exist in %s" +msgstr "Ni %s, ni %s n’est trouvé dans %s" + +#: test.data.table.R:118 +msgid "object '%s' not found" +msgstr "objet '%s' introuvable" + +#: test.data.table.R:142 +#, c-format +msgid "" +"memtest intended for Linux. Step through data.table:::rss() to see what went " +"wrong." +msgstr "" +"memtest est prévu pour Linux. Investiguer à l'aide de data.table:::rss() pour " +"localiser le problème." + +#: test.data.table.R:196 +#, c-format +msgid "Attempt to subset to %d tests matching '%s' failed, running full suite." +msgstr "" +"La tentative de création d’un sous-ensemble de %d tests correspondant à '%s' a " +"échoué, la suite complète est en cours d'exécution." + +#: test.data.table.R:245 +#, c-format +msgid "Failed in %s after test %s before the next test() call in %s" +msgstr "Echec dans %s après le test %s avant l'appel suivant de test() dans %s" + +#: test.data.table.R:255 +#, c-format +msgid "%d error(s) out of %d. Search %s for test number(s) %s. Duration: %s." +msgstr "" +"%d erreur(s) sur %d. Recherche de %s pour le(s) test(s) numéro %s. Durée : %s." + +#: test.data.table.R:268 +#, c-format +msgid "Timings count mismatch: %d vs %d" +msgstr "Différence dans les délais enregistrés : %d versus %d" + +#: test.data.table.R:399 +#, c-format +msgid "" +"Test %s is invalid: when error= is provided it does not make sense to pass y " +"as well" +msgstr "" +"Le test %s n 'est pas valide : Si error= est fourni alors il n'a pas de sens " +"dans ce cas" + +#: timetaken.R:3 +#, c-format +msgid "Use started.at=proc.time() not Sys.time() (POSIXt and slow)" +msgstr "" +"Utiliser started.at=proc.time() et non pas Sys.time() (POSIXt et plus lent)" + +#: transpose.R:7 +#, c-format +msgid "make.names='%s' not found in names of input" +msgstr "make.names='%s' non trouvé parmi les noms d'entrée" + +#: transpose.R:12 +#, c-format +msgid "make.names=%d is out of range [1,ncol=%d]" +msgstr "make.names=%d hors limites [1,ncol=%d]" + +#: transpose.R:28 +#, c-format +msgid "'names' must be TRUE/FALSE or a character vector." +msgstr "'names' doit être TRUE ou FALSE ou un vecteur de chaînes de caractères." + +#: transpose.R:34 +#, c-format +msgid "'keep' should contain integer values between %d and %d." +msgstr "'keep' doit contenir des valeurs entières entre %d et %d." + +#: transpose.R:51 +#, c-format +msgid "The argument 'type.convert' does not support empty list." +msgstr "L'argument 'type.convert' n'accepte pas de liste vide." + +#: transpose.R:57 +#, c-format +msgid "" +"When the argument 'type.convert' contains an unnamed element, it is expected " +"to be the last element and should be a function. More than one unnamed element " +"is not allowed unless all elements are functions with length equal to %d (the " +"length of the transpose list or 'keep' argument if it is specified)." +msgstr "" +"Lorsque l'argument 'type.convert' contient un élément non nommé, il est censé " +"être le dernier élément et doit être une fonction. Plus d'un élément non nommé " +"n'est pas autorisé, sauf si tous les éléments sont des fonctions de longueur " +"égale à %d (la longueur de la liste de transpositions ou de l'argument 'keep' " +"s'il est spécifié)." + +#: transpose.R:66 +#, c-format +msgid "" +"When the argument 'type.convert' contains transpose list indices, it should be " +"a named list of non-missing integer values (with no duplicate) except the last " +"element that should be unnamed if it is a function." +msgstr "" +"Lorsque l'argument 'type.convert' contient des indices de liste de " +"transposition, il doit être une liste nommée de valeurs entières sans valeur " +"manquante (et sans doublons), à l'exception du dernier élément qui ne doit pas " +"être nommé s'il s'agit d'une fonction." + +#: transpose.R:68 +#, c-format +msgid "" +"When the argument 'type.convert' contains transpose list indices, they should " +"be integer values contained in the argument 'keep' (if it is specified) or be " +"between %d and %d (if it is not). But '%s' is/are not contained in '%s'." +msgstr "" +"Lorsque l'argument 'type.convert' contient des indices de liste de " +"transposition, ceux-ci doivent être des valeurs entières contenues dans " +"l'argument 'keep' (s'il est spécifié) ou comprises entre %d et %d (s'il ne " +"l'est pas). Mais '%s' n’est/ne sont pas contenu(e)s dans '%s'." + +#: transpose.R:74 +#, c-format +msgid "" +"In the argument 'type.convert', '%s' was ignored because all elements in the " +"transpose list or elements corresponding to indices specified in the 'keep' " +"argument have already been converted." +msgstr "" +"Dans l'argument 'type.convert', '%s' a été ignoré parce que tous les éléments " +"de la liste de transposition ou les éléments correspondant aux indices " +"spécifiés dans l'argument 'keep' ont déjà été convertis." + +#: transpose.R:83 +#, c-format +msgid "" +"The argument 'type.convert' should be TRUE/FALSE, a function, a list of " +"functions, or a named list of pairs 'fun=indices' with optionally one unnamed " +"element (a function) but an object of type '%s' was provided." +msgstr "" +"L'argument 'type.convert' doit être TRUE/FALSE, une fonction, une liste de " +"fonctions ou une liste nommée de paires 'fun=indices' avec éventuellement un " +"élément non nommé (une fonction), mais un objet de type '%s' a été fourni." + +#: transpose.R:88 +#, c-format +msgid "length(names) (= %d) is not equal to length(%s) (= %d)." +msgstr "length(names) (= %d) est différent de length(%s) (= %d)." + +#: uniqlist.R:11 +#, c-format +msgid "l not type list" +msgstr "l n'est pas de type 'list'" + +#: utils.R:18 +#, c-format +msgid "Argument 'nan' must be length 1" +msgstr "L'argument 'nan' doit être de longueur 1" + +#: utils.R:21 +#, c-format +msgid "Argument 'nan' must be NA or NaN" +msgstr "L'argument 'nan' doit être NA ou NaN" + +#: utils.R:25 +msgid "Internal error in" +msgstr "Erreur interne dans" + +#: utils.R:28 +msgid "Please report to the data.table issues tracker." +msgstr "" +"Veuillez signaler l'erreur au gestionnaire de tickets (issue tracker) de data." +"table." + +#: utils.R:57 utils.R:66 +#, c-format +msgid "x not boolean" +msgstr "x n'est pas un booléen" + +#: utils.R:77 +#, c-format +msgid "" +"Some columns are type 'integer64' but package bit64 is not installed. Those " +"columns will print as strange looking floating point data. There is no need to " +"reload the data. Simply install.packages('bit64') to obtain the integer64 " +"print method and print the data again." +msgstr "" +"Certaines colonnes sont de type 'integer64' mais le package bit64 n'est pas " +"installé. Ces colonnes s'afficheront sous la forme de données en virgule " +"flottante à l'aspect étrange. Il n'est pas nécessaire de recharger les " +"données. Il suffit d'installer.packages('bit64') pour obtenir la méthode " +"d'impression integer64 et imprimer à nouveau les données." + +#: xts.R:3 +#, c-format +msgid "keep.rownames must be length 1" +msgstr "keep.rownames doit être de longueur 1" + +#: xts.R:4 +#, c-format +msgid "keep.rownames must not be NA" +msgstr "keep.rownames ne peut pas être NA" + +#: xts.R:10 +#, c-format +msgid "" +"Input xts object should not have '%s' column because it would result in " +"duplicate column names. Rename '%s' column in xts or use `keep.rownames` to " +"change the index column name." +msgstr "" +"L'objet xts d'entrée ne doit pas avoir de colonne '%s' car cela entraînerait " +"une duplication des noms de colonnes. Renommez la colonne '%s' dans l'objet " +"xts ou utilisez `keep.rownames` pour changer le nom de la colonne d'index." + +#: xts.R:20 +#, c-format +msgid "" +"data.table must have a time based column in first position, use `setcolorder` " +"function to change the order, or see ?timeBased for supported types" +msgstr "" +"data.table doit avoir une colonne basée sur le temps en première position, " +"utiliser la fonction `setcolorder` pour changer l'ordre, ou voir ?timeBased " +"pour les types pris en charge" + +#: xts.R:24 +#, c-format +msgid "Following columns are not numeric and will be omitted: %s" +msgstr "Les colonnes suivantes ne sont pas numériques et seront omises : %s" + +#: print.data.table.R:53 +msgid "Index: %s\n" +msgid_plural "Indices: %s\n" +msgstr[0] "Indice : %s\n" +msgstr[1] "Indices : %s\n" + +#, c-format +#~ msgid "" +#~ "Internal error -- difftime objects may not be added to IDate, but Ops " +#~ "dispatch should have intervened to prevent this" +#~ msgstr "" +#~ "Erreur interne -- les objets difftime ne peuvent pas être ajoutés à IDate, " +#~ "mais le dispatching de méthode Ops aurait dû empêcher cela" + +#, c-format +#~ msgid "Internal error: storage mode of IDate is somehow no longer integer" +#~ msgstr "" +#~ "Erreur interne : le mode d'enregistrement de IDate n'est plus sous forme " +#~ "d'entiers" + +#, c-format +#~ msgid "" +#~ "Internal error -- difftime objects may not be subtracted from IDate, but " +#~ "Ops dispatch should have intervened to prevent this" +#~ msgstr "" +#~ "Erreur interne -- les objets difftime ne peuvent pas être soustraits de " +#~ "IDate, mais le dispatching de méthodes Ops aurait dû empêcher cela" + +#, c-format +#~ msgid "" +#~ "Internal error: DT[, ..var] should be dealt with by the branch above now." +#~ msgstr "" +#~ "Erreur interne : DT[, ..var] doit être négocié avec la branche supérieure " +#~ "maintenant." + +#, c-format +#~ msgid "Internal error. Cannot by=.EACHI when joining to an index, yet" +#~ msgstr "" +#~ "Erreur interne. Il n'est pas encore possible d'utiliser by=.EACHI pour une " +#~ "jointure vers un index" + +#, c-format +#~ msgid "Internal error. irows has length in by=.EACHI" +#~ msgstr "Erreur interne. irows a la longueur dans by=.EACHI" + +#, c-format +#~ msgid "" +#~ "internal error: notjoin and which=NA (non-matches), huh? please provide " +#~ "reproducible example to issue tracker" +#~ msgstr "" +#~ "erreur interne : notjoin et which=NA (ne vont pas ensemble), n’est-ce-pas ? " +#~ "Veuillez fournir un exemple reproductible pour le gestionnaire de tickets " +#~ "(issue tracker)" + +#, c-format +#~ msgid "Internal error: notjoin but byjoin or !integer or nomatch==NA" +#~ msgstr "Erreur interne : notjoin mais byjoin ou !integer ou nomatch==NA" + +#, c-format +#~ msgid "Internal error: irows isn't integer" +#~ msgstr "Erreur interne : irows n'est pas un entier" + +#, c-format +#~ msgid "Internal error: drop_dot passed %d items" +#~ msgstr "Erreur interne : drop_dot a passé %d éléments" + +#, c-format +#~ msgid "Internal error -- item '%s' not found in names of list" +#~ msgstr "Erreur interne -- élément '%s' non trouvé parmi les noms de la liste" + +#, c-format +#~ msgid "Internal error -- column(s) not found: %s" +#~ msgstr "Erreur interne -- colonne(s) introuvable(s) : %s" + +#, c-format +#~ msgid "" +#~ "strptime() usage detected and wrapped with as.POSIXct(). This is to " +#~ "minimize the chance of assigning POSIXlt columns, which use 40+ bytes to " +#~ "store one date (versus 8 for POSIXct). Use as.POSIXct() (which will call " +#~ "strptime() as needed internally) to avoid this warning." +#~ msgstr "" +#~ "l'utilisation de strptime() est détectée et enveloppée par as.POSIXct(). " +#~ "Ceci afin de minimiser le risque d'assigner des colonnes POSIXlt, qui " +#~ "utilisent plus de 40 octets pour stocker une date (contre 8 pour POSIXct). " +#~ "Utilisez as.POSIXct() (qui appellera strptime() si nécessaire en interne) " +#~ "pour éviter cet avertissement." + +#, c-format +#~ msgid "Internal error: xcolAns does not pass checks: %d/%d/%d/%s" +#~ msgstr "Erreur interne : xcolAns ne passe pas les contrôles : %d/%d/%d/%s" + +#, c-format +#~ msgid "" +#~ "Internal error: irows is NULL when making join result at R level. Should no " +#~ "longer happen now we use CsubsetDT earlier." +#~ msgstr "" +#~ "Erreur interne : irows est NULL lors de la création d'un résultat de " +#~ "jointure au niveau R. Cela ne devrait plus se produire maintenant que nous " +#~ "utilisons CsubsetDT plus tôt." + +#, c-format +#~ msgid "" +#~ "Internal error: j has created a data.table result containing a NULL column" +#~ msgstr "" +#~ "Erreur interne : j a produit un résultat data.table contenant une colonne " +#~ "NULL" + +#, c-format +#~ msgid "Internal error: byindex not the index name" +#~ msgstr "Erreur interne : byindex n’est pas le nom de l'index" + +#, c-format +#~ msgid "Internal error: byindex not found" +#~ msgstr "Erreur interne : byindex est absent" + +#, c-format +#~ msgid "Internal error: length(irows)!=length(o__)" +#~ msgstr "Erreur interne : length(irows)!=length(o__)" + +#, c-format +#~ msgid "Internal error: jvnames is length %d but ans is %d and bynames is %d" +#~ msgstr "" +#~ "Erreur interne : jvnames a pour longueur %d mais ans vaut %d et bynames " +#~ "vaut %d" + +#, c-format +#~ msgid "" +#~ "Internal error: as.matrix.data.table length(X)==%d but a dimension is zero" +#~ msgstr "" +#~ "Erreur interne : as.matrix.data.table length(X)==%d mais une dimension est " +#~ "à zéro" + +#, c-format +#~ msgid "Internal error: length(i)!=length(new)" +#~ msgstr "Erreur interne : length(i)!=length(new)" + +#, c-format +#~ msgid "" +#~ "Some columns are a multi-column type (such as a matrix column): %s. setDT " +#~ "will retain these columns as-is but subsequent operations like grouping and " +#~ "joining may fail. Please consider as.data.table() instead which will create " +#~ "a new column for each embedded column." +#~ msgstr "" +#~ "Certaines colonnes sont de type multi-colonnes (comme une colonne de " +#~ "matrice) : %s. setDT conservera ces colonnes telles quelles, mais les " +#~ "opérations ultérieures telles que le regroupement et la jointure peuvent " +#~ "échouer. Pensez plutôt à utiliser as.data.table() qui créera une nouvelle " +#~ "colonne pour chaque colonne imbriquée." + +#, c-format +#~ msgid "" +#~ "Column %d is of POSIXlt type. Please convert it to POSIXct using as.POSIXct " +#~ "and run setDT again. We do not recommend use of POSIXlt at all because it " +#~ "uses 40 bytes to store one date." +#~ msgstr "" +#~ "La colonne %d est de type POSIXlt. Veuillez la convertir en POSIXct en " +#~ "utilisant as.POSIXct et relancez setDT. Nous ne recommandons pas " +#~ "l'utilisation de POSIXlt car il utilise 40 octets pour stocker une date." + +#, c-format +#~ msgid "" +#~ "All elements in argument 'x' to 'setDT' must be of same length, but the " +#~ "profile of input lengths (length:frequency) is: %s\n" +#~ "The first entry with fewer than %d entries is %d." +#~ msgstr "" +#~ "Tous les éléments de l'argument 'x' de 'setDT' doivent avoir la même " +#~ "longueur, mais le profil des longueurs d'entrée (longueur:fréquence) est : " +#~ "%s\n" +#~ "La première entrée avec moins de %d entrées est %d." + +#, c-format +#~ msgid "" +#~ "Internal error in .isFastSubsettable. Please report to data.table developers" +#~ msgstr "" +#~ "Erreur interne dans .isFastSubsettable. Veuillez rapporter ce point aux " +#~ "développeurs de data.table" + +#, c-format +#~ msgid "Aggregate function missing, defaulting to 'length'" +#~ msgstr "Fonction d’agrégation absente, repli par défaut sur 'length'" + +#~ msgid "" +#~ "Aggregating function(s) should take vector inputs and return a single value " +#~ "(length=1). However, function(s) returns length!=1. This value will have to " +#~ "be used to fill any missing combinations, and therefore must be length=1. " +#~ "Either override by setting the 'fill' argument explicitly or modify your " +#~ "function to handle this case appropriately." +#~ msgstr "" +#~ "La (les) fonction(s) d'agrégation doit (doivent) prendre des entrées " +#~ "vectorielles et renvoyer une seule valeur (length=1). Cependant, la " +#~ "fonction(s) renvoie length!=1. Cette valeur devra être utilisée pour " +#~ "remplir toutes les combinaisons manquantes, et doit donc être length=1. " +#~ "Vous pouvez soit passer outre en définissant explicitement l'argument " +#~ "'fill', soit modifier votre fonction pour gérer ce cas de manière " +#~ "appropriée." + +#, c-format +#~ msgid "Internal error -- empty rhsnames in dcast; please report" +#~ msgstr "" +#~ "Erreur interne -- rhsnames est vide dans dcast ; Veuillez rapporter cette " +#~ "anomalie" + +#, c-format +#~ msgid "" +#~ "URL requires download.file functionalities from R >=3.2.2. You can still " +#~ "manually download the file and fread the downloaded file." +#~ msgstr "" +#~ "L’URL nécessite les fonctionnalités de download.file à partir de R >=3.2.2. " +#~ "Il est encore possible de télécharger manuellement le fichier et de faire " +#~ "un fread dessus." + +#, c-format +#~ msgid "" +#~ "Option 'datatable.CJ.names' no longer has any effect, as promised for 4 " +#~ "years. It is now ignored. Manually name `...` entries as needed if you " +#~ "still prefer the old behavior." +#~ msgstr "" +#~ "L'option 'datatable.CJ.names' n'a plus d'effet, comme explicité depuis 4 " +#~ "ans. Elle est maintenant ignorée. Nommez manuellement les entrées `...` si " +#~ "nécessaire si vous préférez toujours l'ancien comportement." + +#, c-format +#~ msgid "" +#~ "Internal error. 'cols' should be character at this point in setkey; please " +#~ "report." +#~ msgstr "" +#~ "Erreur interne. 'cols' doit être de type caractère à ce niveau dans " +#~ "setkey ; Veuillez rapporter le problème." + +#, c-format +#~ msgid "Internal error: index '%s' exists but is invalid" +#~ msgstr "Erreur interne : l'index '%s' existe mais il n'est pas valide" + +#, c-format +#~ msgid "Internal error: ncol(current)==ncol(target) was checked above" +#~ msgstr "Erreur interne : ncol(current)==ncol(target) a été vérifié ci-dessus" + +#, c-format +#~ msgid "Internal error: factor type mismatch should have been caught earlier" +#~ msgstr "" +#~ "Erreur interne : type factor incohérent ; Cela aurait dû être détecté plus " +#~ "tôt" + +#~ msgid "Provided argument fill=" +#~ msgstr "L’argument fill= fourni" + +#~ msgid "Internal error: use endsWithAny instead of base::endsWith" +#~ msgstr "Erreur interne : utiliser endsWithAny à la place de base::endsWith" diff --git a/po/fr.po b/po/fr.po new file mode 100644 index 000000000..e63209de3 --- /dev/null +++ b/po/fr.po @@ -0,0 +1,5398 @@ +msgid "" +msgstr "" +"Project-Id-Version: data.table 1.16.99\n" +"POT-Creation-Date: 2024-08-28 21:08+0000\n" +"PO-Revision-Date: 2024-09-02 20:11+0200\n" +"Last-Translator: Elise Maigné \n" +"Language-Team: \n" +"Language: fr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 3.5\n" + +#: assign.c:121 +msgid "" +".internal.selfref ptr is NULL. This is expected and normal for a data.table " +"loaded from disk. Please remember to always setDT() immediately after " +"loading to prevent unexpected behavior. If this table was not loaded from " +"disk or you've already run setDT(), please report to data.table issue " +"tracker.\n" +msgstr "" +".internal.selfref ptr est NULL. Ceci est normal et attendu pour une table de " +"données chargée depuis le disque. Rappelez-vous de toujours exécuter setDT() " +"immédiatement après le chargement pour éviter tout comportement inattendu. " +"Si cette table n'a pas été chargée depuis le disque ou si vous avez déjà " +"exécuté setDT(), veuillez le signaler dans le gestionnaire de tickets (issue " +"tracker) de data.table.\n" + +#: assign.c:202 +#, c-format +msgid "" +"Some columns are a multi-column type (such as a matrix column), for example " +"column %d. setDT will retain these columns as-is but subsequent operations " +"like grouping and joining may fail. Please consider as.data.table() instead " +"which will create a new column for each embedded column." +msgstr "" +"Certaines colonnes sont de type multi-colonnes (comme une colonne de " +"matrice), par exemple la colonne %d. setDT conservera ces colonnes telles " +"quelles, mais les opérations ultérieures telles que le regroupement et la " +"jointure peuvent échouer. Pensez plutôt à utiliser as.data.table() qui " +"créera une nouvelle colonne pour chaque colonne intégrée." + +#: assign.c:219 +#, c-format +msgid "" +"Column %d has class 'POSIXlt'. Please convert it to POSIXct (using as." +"POSIXct) and run setDT() again. We do not recommend the use of POSIXlt at " +"all because it uses 40 bytes to store one date." +msgstr "" +"La colonne %d a la classe 'POSIXlt'. Veuillez la convertir en POSIXct (en " +"utilisant as.POSIXct) et exécutez à nouveau setDT(). Nous ne recommandons " +"pas du tout l'utilisation de POSIXlt parce qu'il utilise 40 octets pour " +"stocker une date." + +#: assign.c:239 +#, c-format +msgid "" +"All elements in argument 'x' to 'setDT' must be of equal length, but input " +"%d has length %d whereas the first non-empty input had length %d" +msgstr "" +"Tous les éléments de l’argument 'x' de 'setDT' doivent être de même " +"longueur, mais l'entrée %d a une longueur de %d alors que la première entrée " +"non vide a une longueur de %d" + +#: assign.c:249 +msgid "alloccol has been passed a NULL dt" +msgstr "'alloccol' a reçu un dt NULL" + +#: assign.c:250 +msgid "dt passed to alloccol isn't type VECSXP" +msgstr "dt transmis à 'alloccol' n'est pas de type VECSXP" + +#: assign.c:252 +msgid "" +"dt passed to alloccol has no class attribute. Please report result of " +"traceback() to data.table issue tracker." +msgstr "" +"dt transmis à 'alloccol' n'a pas d'attribut de classe. Veuillez rapporter le " +"résultat de 'traceback()' dans le gestionnaire de tickets (issue tracker) de " +"data.table." + +#: assign.c:269 +#, c-format +msgid "" +"tl (%d) is greater than 10,000 items over-allocated (l = %d). If you didn't " +"set the datatable.alloccol option to be very large, please report to data." +"table issue tracker including the result of sessionInfo()." +msgstr "" +"tl (%d) est supérieur à 10 000 éléments sur-alloués (l = %d). Si vous n'avez " +"pas défini l'option datatable.alloccol comme étant très grande, merci de " +"rapporter ce problème dans le gestionnaire de tickets (issue tracker) de " +"data.table en incluant le résultat de sessionInfo()." + +#: assign.c:271 +#, c-format +msgid "" +"Attempt to reduce allocation from %d to %d ignored. Can only increase " +"allocation via shallow copy. Please do not use DT[...]<- or DT$someCol<-. " +"Use := inside DT[...] instead." +msgstr "" +"Tentative de réduction de l'allocation de %d à %d ignorée. L'allocation ne " +"peut être augmentée que par une copie superficielle (shallow). N'utilisez " +"pas DT[...]<- ou DT$someCol<-. Utilisez plutôt := à l'intérieur de DT[...]." + +#: assign.c:279 +msgid "" +"Has getOption('datatable.alloccol') somehow become unset? It should be a " +"number, by default 1024." +msgstr "" +"Est-ce que getOption('datatable.alloccol') est devenu indéfini ? Il devrait " +"s'agir d'un nombre, par défaut 1024." + +#: assign.c:281 +#, c-format +msgid "" +"getOption('datatable.alloccol') should be a number, by default 1024. But its " +"type is '%s'." +msgstr "" +"getOption('datatable.alloccol') devrait être un nombre, par défaut 1024. " +"Mais son type est '%s'." + +#: assign.c:283 +#, c-format +msgid "" +"getOption('datatable.alloc') is a numeric vector ok but its length is %d. " +"Its length should be 1." +msgstr "" +"getOption('datatable.alloc') est un vecteur numérique ok mais sa longueur " +"est %d. Sa longueur devrait être de 1." + +#: assign.c:286 +#, c-format +msgid "getOption('datatable.alloc')==%d. It must be >=0 and not NA." +msgstr "getOption('datatable.alloc')==%d. Doit être >=0 et non NA." + +#: assign.c:292 between.c:16 between.c:22 frollR.c:41 frollR.c:95 fsort.c:105 +#: gsumm.c:346 gsumm.c:582 gsumm.c:728 gsumm.c:865 gsumm.c:1020 gsumm.c:1112 +#: nafill.c:103 openmp-utils.c:79 uniqlist.c:354 utils.c:107 utils.c:109 +#, c-format +msgid "%s must be TRUE or FALSE" +msgstr "%s doit être TRUE ou FALSE" + +#: assign.c:340 +msgid "assign has been passed a NULL dt" +msgstr "'assign' a reçu un dt NULL" + +#: assign.c:341 +msgid "dt passed to assign isn't type VECSXP" +msgstr "le dt transmis à 'assign' n'est pas du type VECSXP" + +#: assign.c:343 +msgid "" +".SD is locked. Updating .SD by reference using := or set are reserved for " +"future use. Use := in j directly. Or use copy(.SD) as a (slow) last resort, " +"until shallow() is exported." +msgstr "" +".SD est verrouillé. La mise à jour de .SD par référence à l'aide de := ou de " +"set est réservée pour une utilisation future. Utilisez directement := dans " +"j. Ou utilisez copy(.SD) en dernier recours (lent), jusqu'à ce que shallow() " +"soit exporté." + +#: assign.c:355 +msgid "dt passed to assign has no names" +msgstr "le dt transmis à 'assign' n'a pas de noms" + +#: assign.c:359 +msgid "" +"data.table is NULL; malformed. A null data.table should be an empty list. " +"typeof() should always return 'list' for data.table." +msgstr "" +"data.table est NULL ; malformé. Un data.table nul devrait être une liste " +"vide. typeof() devrait toujours retourner 'list' pour data.table." + +#: assign.c:369 +#, c-format +msgid "Assigning to all %d rows\n" +msgstr "Affectation à toutes les lignes %d\n" + +#: assign.c:374 +msgid "" +"Coerced i from numeric to integer. Please pass integer for efficiency; e.g., " +"2L rather than 2" +msgstr "" +"I a été converti automatiquement de numérique à entier. Par souci " +"d'efficacité, passez un entier ; par exemple, 2L au lieu de 2" + +#: assign.c:377 +#, c-format +msgid "" +"i is type '%s'. Must be integer, or numeric is coerced with warning. If i is " +"a logical subset, simply wrap with which(), and take the which() outside the " +"loop if possible for efficiency." +msgstr "" +"i est de type '%s'. Il doit s'agir d'un entier, ou un nombre est converti " +"automatiquement avec un avis. Si i est un sous-ensemble de booléens, il " +"suffit de l'envelopper avec which(), et de placer which() en dehors de la " +"boucle si possible pour plus d'efficacité." + +#: assign.c:383 subset.c:170 +#, c-format +msgid "i[%d] is %d which is out of range [1,nrow=%d]" +msgstr "i[%d] est %d, ce qui est en dehors de l'intervalle [1,nrow=%d]" + +#: assign.c:386 +#, c-format +msgid "Assigning to %d row subset of %d rows\n" +msgstr "Affectation à un sous-ensemble de %d lignes parmi %d lignes\n" + +#: assign.c:395 +#, c-format +msgid "Added %d new column%s initialized with all-NA\n" +msgstr "Ajout de %d nouvelle(s) colonne(s) initialisée%s avec all-NA\n" + +#: assign.c:400 +msgid "length(LHS)==0; no columns to delete or assign RHS to." +msgstr "" +"length(LHS)==0 ; aucune colonne à supprimer ou à laquelle assigner le membre " +"de droite (RHS)." + +#: assign.c:414 +msgid "" +"set() on a data.frame is for changing existing columns, not adding new ones. " +"Please use a data.table for that. data.table's are over-allocated and don't " +"shallow copy." +msgstr "" +"set() sur un data.frame sert à modifier les colonnes existantes, pas à en " +"ajouter de nouvelles. Veuillez utiliser un data.table pour cela. Les data." +"table sont sur-alloués et ne permettent pas de copier les données de façon " +"superficielle (shallow)." + +#: assign.c:425 +msgid "" +"Coerced j from numeric to integer. Please pass integer for efficiency; e.g., " +"2L rather than 2" +msgstr "" +"J converti automatiquement de numérique à entier. Par souci d'efficacité, " +"passez un entier ; par exemple, 2L au lieu de 2" + +#: assign.c:428 +#, c-format +msgid "" +"j is type '%s'. Must be integer, character, or numeric is coerced with " +"warning." +msgstr "" +"j est de type '%s'. Il doit être entier. Caractère, ou numérique sont " +"convertis automatiquement avec un avis." + +#: assign.c:430 +msgid "" +"Can't assign to the same column twice in the same query (duplicates " +"detected)." +msgstr "" +"Impossible d'affecter deux fois la même colonne dans la même requête " +"(détection des doublons)." + +#: assign.c:431 +msgid "newcolnames is supplied but isn't a character vector" +msgstr "newcolnames est fourni mais n'est pas un vecteur de caractères" + +#: assign.c:433 +msgid "" +"Values of type POSIXlt detected and converted to POSIXct. We do not " +"recommend the use of POSIXlt at all because it typically takes more than 6 " +"times the storage as an equivalent POSIXct column. Use as.POSIXct() to avoid " +"this warning." +msgstr "" +"Valeurs de type POSIXlt détectées et converties en POSIXct. Nous ne " +"recommandons pas du tout l'utilisation de POSIXlt car il prend généralement " +"plus de 6 fois l'espace de stockage qu’une colonne POSIXct équivalente. " +"Utilisez as.POSIXct() pour éviter cet avertissement." + +#: assign.c:437 +#, c-format +msgid "RHS_list_of_columns == %s\n" +msgstr "RHS_list_of_columns == %s\n" + +#: assign.c:442 +#, c-format +msgid "" +"RHS_list_of_columns revised to true because RHS list has 1 item which is " +"NULL, or whose length %d is either 1 or targetlen (%d). Please unwrap RHS.\n" +msgstr "" +"RHS_list_of_columns révisé à true car le membre de droite (RHS) de type list " +"a un élement NULL, ou dont la longueur %d est soit 1 soit targetlen (%d). " +"Veuillez déplier le RHS.\n" + +#: assign.c:447 +#, c-format +msgid "" +"Supplied %d columns to be assigned an empty list (which may be an empty data." +"table or data.frame since they are lists too). To delete multiple columns " +"use NULL instead. To add multiple empty list columns, use list(list())." +msgstr "" +"%d colonnes fournies auxquelles sera assigné une liste vide (qui peut être " +"un data.table ou un data.frame vide puisqu'il s'agit également de listes). " +"Pour supprimer plusieurs colonnes, utilisez NULL à la place. Pour ajouter " +"plusieurs colonnes vides de type liste, utilisez list(list())." + +#: assign.c:452 +#, c-format +msgid "Recycling single RHS list item across %d columns. Please unwrap RHS.\n" +msgstr "" +"Recyclage d'un seul élément de liste du membre de droite (RHS) sur %d " +"colonnes. Veuillez déplier le RHS.\n" + +#: assign.c:454 +#, c-format +msgid "" +"Supplied %d columns to be assigned %d items. Please see NEWS for v1.12.2." +msgstr "%d colonnes fournies à affecter à %d éléments. Voir NEWS pour v1.12.2." + +#: assign.c:462 +#, c-format +msgid "" +"Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. " +"set() on a data.frame is for changing existing columns, not adding new ones. " +"Please use a data.table for that." +msgstr "" +"L'élément %d des numéros de colonnes dans j est %d, ce qui est en dehors de " +"l'intervalle [1,ncol=%d]. set() sur un data.frame sert à modifier les " +"colonnes existantes, pas à en ajouter de nouvelles. Veuillez utiliser un " +"data.table pour cela." + +#: assign.c:463 +#, c-format +msgid "" +"Item %d of column numbers in j is %d which is outside range [1,ncol=%d]. Use " +"column names instead in j to add new columns." +msgstr "" +"L'élément %d des numéros de colonnes dans j est %d, ce qui est en dehors de " +"l'intervalle [1,ncol=%d]. Utilisez plutôt les noms de colonnes dans j pour " +"ajouter de nouvelles colonnes." + +#: assign.c:468 +msgid "When deleting columns, i should not be provided" +msgstr "Lors de la suppression de colonnes, i ne doit pas être fourni" + +#: assign.c:474 +#, c-format +msgid "" +"RHS of assignment to existing column '%s' is zero length but not NULL. If " +"you intend to delete the column use NULL. Otherwise, the RHS must have " +"length > 0; e.g., NA_integer_. If you are trying to change the column type " +"to be an empty list column then, as with all column type changes, provide a " +"full length RHS vector such as vector('list',nrow(DT)); i.e., 'plonk' in the " +"new column." +msgstr "" +"Le membre de droite (RHS) de l'affectation à la colonne existante '%s' est " +"de longueur nulle mais n'est pas NULL. Si vous voulez supprimer la colonne, " +"utilisez NULL. Sinon, l'élément d'affectation doit avoir une longueur > 0 ; " +"par exemple, NA_integer_. Si vous essayez de modifier le type de colonne " +"pour en faire une colonne de type liste vide, alors, comme pour tous les " +"changements de type de colonne, fournissez un vecteur de longueur complète " +"tel que vector('list',nrow(DT)) ; c'est-à-dire, remplacez ('plonk') la " +"nouvelle colonne." + +#: assign.c:481 +#, c-format +msgid "" +"Tried to assign NULL to column '%s', but this column does not exist to remove" +msgstr "" +"Tentative d’affectation de NULL à la colonne ‘%s’, mais cette colonne " +"n’existe pas et ne peut donc pas être éliminée" + +#: assign.c:489 +#, c-format +msgid "%d column matrix RHS of := will be treated as one vector" +msgstr "" +"%d la matrice colonne du membre de droite (RHS) de := sera traitée comme un " +"vecteur" + +#: assign.c:494 +#, c-format +msgid "" +"Can't assign to column '%s' (type 'factor') a value of type '%s' (not " +"character, factor, integer or numeric)" +msgstr "" +"Impossible d'affecter à la colonne '%s' (type 'factor') une valeur de type " +"'%s' (ni caractère, ni facteur, ni entier, ni numérique)" + +#: assign.c:500 +#, c-format +msgid "" +"Supplied %d items to be assigned to %d items of column '%s'. If you wish to " +"'recycle' the RHS please use rep() to make this intent clear to readers of " +"your code." +msgstr "" +"%d éléments fournis à affecter à %d éléments de la colonne '%s'. Si vous " +"souhaitez 'recycler' le membre de droite (RHS), veuillez utiliser rep() pour " +"indiquer clairement votre intention aux lecteurs de votre code." + +#: assign.c:510 +msgid "" +"This data.table has either been loaded from disk (e.g. using readRDS()/" +"load()) or constructed manually (e.g. using structure()). Please run setDT() " +"or setalloccol() on it first (to pre-allocate space for new columns) before " +"assigning by reference to it." +msgstr "" +"Ce data.table a été soit chargé depuis le disque (par exemple en utilisant " +"readRDS()/load()), soit construit manuellement (par exemple en utilisant " +"structure()). Veuillez d'abord exécuter setDT() ou setalloccol() sur ce " +"tableau (pour pré-allouer de l'espace pour les nouvelles colonnes) avant de " +"l'assigner par référence." + +#: assign.c:513 +#, c-format +msgid "" +"truelength (%d) is greater than 10,000 items over-allocated (length = %d). " +"See ?truelength. If you didn't set the datatable.alloccol option very large, " +"please report to data.table issue tracker including the result of " +"sessionInfo()." +msgstr "" +"truelength (%d) est supérieur à 10 000 éléments sur-alloués (length = %d). " +"Voir ?truelength. Si vous n'avez pas mis une très grande valeur à l'option " +"datatable.alloccol, veuillez rapporter ce problème dans le gestionnaire de " +"tickets (issue tracker) de data.table en incluant le résultat de " +"sessionInfo()." + +#: assign.c:517 +msgid "" +"It appears that at some earlier point, names of this data.table have been " +"reassigned. Please ensure to use setnames() rather than names<- or " +"colnames<-. Otherwise, please report to data.table issue tracker." +msgstr "" +"Il semble qu'à un moment donné, les noms de cette table data.table aient été " +"réattribués. Veillez à utiliser setnames() plutôt que names<- ou colnames<-. " +"Dans le cas contraire, signalez le problème dans le gestionnaire de tickets " +"(issue tracker) de data.table." + +#: assign.c:552 +#, c-format +msgid "" +"RHS for item %d has been duplicated because MAYBE_REFERENCED==%d " +"MAYBE_SHARED==%d, but then is being plonked. length(values)==%d; " +"length(cols)==%d)\n" +msgstr "" +"Le membre de droite (RHS) pour l'élément %d a été dupliqué parce que " +"MAYBE_REFERENCED==%d MAYBE_SHARED==%d, mais il est ensuite remplacé " +"('plonk'). length(values)==%d ; length(cols)==%d)\n" + +#: assign.c:557 +#, c-format +msgid "" +"Direct plonk of unnamed RHS, no copy. MAYBE_REFERENCED==%d, " +"MAYBE_SHARED==%d\n" +msgstr "" +"Remplacement ('plonk') du membre de droite (RHS) sans nom, pas de copie. " +"MAYBE_REFERENCED==%d, MAYBE_SHARED==%d\n" + +#: assign.c:626 +#, c-format +msgid "" +"Dropping index '%s' as it doesn't have '__' at the beginning of its name. It " +"was very likely created by v1.9.4 of data.table.\n" +msgstr "" +"Suppression de l'indice '%s' car il n'a pas '__' au début de son nom. Il a " +"très probablement été créé par la version 1.9.4 de data.table.\n" + +#: assign.c:671 assign.c:687 +#, c-format +msgid "Dropping index '%s' due to an update on a key column\n" +msgstr "" +"Suppression de l'indice '%s' suite à une mise à jour d'une colonne clé\n" + +#: assign.c:680 +#, c-format +msgid "Shortening index '%s' to '%s' due to an update on a key column\n" +msgstr "" +"Raccourcissement de l'indice '%s' en '%s' suite à une mise à jour d'une " +"colonne clé\n" + +#: assign.c:738 +#, c-format +msgid "target vector" +msgstr "vecteur cible" + +#: assign.c:738 +#, c-format +msgid "column %d named '%s'" +msgstr "colonne %d nommée '%s'" + +#: assign.c:772 +#, c-format +msgid "" +"Cannot assign 'factor' to '%s'. Factors can only be assigned to factor, " +"character or list columns." +msgstr "" +"Impossible d'affecter 'factor' à '%s'. Les facteurs ne peuvent être affectés " +"qu'à des colonnes de facteurs, de caractères ou de listes." + +#: assign.c:786 +#, c-format +msgid "" +"Assigning factor numbers to %s. But %d is outside the level range [1,%d]" +msgstr "" +"Attribution de numéros de facteurs à %s. Mais %d est en dehors de " +"l'intervalle [1,%d]" + +#: assign.c:795 +#, c-format +msgid "" +"Assigning factor numbers to %s. But %f is outside the level range [1,%d], or " +"is not a whole number." +msgstr "" +"Attribution de numéros de facteurs à %s. Mais %f est en dehors de " +"l'intervalle [1,%d], ou n'est pas un nombre entier." + +#: assign.c:801 +#, c-format +msgid "" +"Cannot assign '%s' to 'factor'. Factor columns can be assigned factor, " +"character, NA in any type, or level numbers." +msgstr "" +"Impossible d'attribuer '%s' à 'factor'. Les colonnes de facteurs peuvent " +"être assignées aux types facteur, caractère, NA dans n'importe quel type, ou " +"numéros de niveaux." + +#: assign.c:861 +msgid "Unable to allocate working memory of %zu bytes to combine factor levels" +msgstr "" +"Impossible d'allouer une mémoire de travail de %zu octets pour combiner les " +"niveaux de facteurs" + +#: assign.c:887 +#, c-format +msgid "Coercing 'character' RHS to '%s' to match the type of %s." +msgstr "" +"Le membre de droite (RHS) 'character' a été automatiquement converti en '%s' " +"pour qu'il corresponde au type de %s." + +#: assign.c:894 +#, c-format +msgid "Cannot coerce 'list' RHS to 'integer64' to match the type of %s." +msgstr "" +"Impossible de convertir le membre de droite (RHS) de 'list' à 'integer64' " +"pour qu'il corresponde au type de %s." + +#: assign.c:899 +#, c-format +msgid "Coercing 'list' RHS to '%s' to match the type of %s." +msgstr "" +"Le membre de droite (RHS) 'list' a été automatiquement converti en '%s' pour " +"qu'il corresponde au type de %s." + +#: assign.c:904 +#, c-format +msgid "Zero-copy coerce when assigning '%s' to '%s' %s.\n" +msgstr "Conversion sans copie lors de l'affectation de '%s' à '%s' %s.\n" + +#: assign.c:1006 +#, c-format +msgid "type '%s' cannot be coerced to '%s'" +msgstr "le type '%s' ne peut pas être converti automatiquement en '%s'" + +#: assign.c:1164 +#, c-format +msgid "Unsupported column type in assign.c:memrecycle '%s'" +msgstr "Type de colonne non pris en charge dans assign.c:memrecycle '%s'" + +#: assign.c:1249 +#, c-format +msgid "savetl_init checks failed (%d %d %p %p)" +msgstr "les vérifications de savetl_init ont échoué (%d %d %p %p)" + +#: assign.c:1258 +#, c-format +msgid "Failed to allocate initial %d items in savetl_init" +msgstr "Échec de l'allocation des éléments initiaux %d dans savetl_init" + +#: assign.c:1274 +#, c-format +msgid "Failed to realloc saveds to %d items in savetl" +msgstr "Échec de la réaffectation de saveds à %d éléments dans savetl" + +#: assign.c:1280 +#, c-format +msgid "Failed to realloc savedtl to %d items in savetl" +msgstr "Échec de la réaffectation de savedtl à %d éléments dans savetl" + +#: assign.c:1303 +msgid "x must be a character vector" +msgstr "x doit être un vecteur de caractères" + +#: assign.c:1304 +msgid "'which' must be an integer vector" +msgstr "'which' doit être un vecteur entier" + +#: assign.c:1305 +msgid "'new' must be a character vector" +msgstr "'new' doit être un vecteur de caractères" + +#: assign.c:1306 +#, c-format +msgid "'new' is length %d. Should be the same as length of 'which' (%d)" +msgstr "" +"La longueur de 'new' est de %d. Elle doit être identique à la longueur de " +"'which' (%d)" + +#: assign.c:1309 +#, c-format +msgid "" +"Item %d of 'which' is %d which is outside range of the length %d character " +"vector" +msgstr "" +"L'élément %d de 'which' est %d, ce qui est en dehors de la plage de valeurs " +"du vecteur de caractères qui est de longueur %d" + +#: between.c:12 +#, c-format +msgid "" +"Incompatible vector lengths: length(x)==%d length(lower)==%d " +"length(upper)==%d. Each should be either length 1 or the length of the " +"longest." +msgstr "" +"Longueurs de vecteurs incompatibles : length(x)==%d length(lower)==%d " +"length(upper)==%d. Chaque vecteur doit avoir la longueur 1 ou la longueur du " +"vecteur le plus long." + +#: between.c:19 +msgid "NAbounds must be TRUE or NA" +msgstr "NAbounds doit être TRUE ou NA" + +#: between.c:64 +#, c-format +msgid "Item %d of lower (%d) is greater than item %d of upper (%d)" +msgstr "L'élément %d de lower (%d) est supérieur à l'élément %d de upper (%d)" + +#: between.c:82 +#, c-format +msgid "between parallel processing of integer took %8.3fs\n" +msgstr "" +"le traitement parallèle par 'between' des nombres entiers a pris %8.3fs\n" + +#: between.c:88 +msgid "x is integer64 but lower and/or upper are not." +msgstr "x est un integer64 mais lower et/ou upper ne le sont pas." + +#: between.c:95 +#, c-format +msgid "" +"Item %d of lower (%) is greater than item %d of upper (%)" +msgstr "" +"L'élément %d de lower (%) est supérieur à l'élément %d de upper " +"(%)" + +#: between.c:112 +#, c-format +msgid "between parallel processing of integer64 took %8.3fs\n" +msgstr "" +"le traitement parallèle par 'between' des entiers 64 bits a pris %8.3fs\n" + +#: between.c:115 +msgid "" +"x is not integer64 but lower and/or upper is integer64. Please align classes." +msgstr "" +"x n'est pas un entier 64 bits mais lower et/ou upper en sont un. Veuillez " +"uniformiser les classes." + +#: between.c:122 +#, c-format +msgid "Item %d of lower (%f) is greater than item %d of upper (%f)" +msgstr "L'élément %d de lower (%f) est supérieur à l'élément %d de upper (%f)" + +#: between.c:140 +#, c-format +msgid "between parallel processing of double with open bounds took %8.3fs\n" +msgstr "" +"le traitement parallèle par 'between' des 'double' (nombres à virgule " +"flottante) avec des bornes ouvertes a pris %8.3fs\n" + +#: between.c:157 +#, c-format +msgid "between parallel processing of double with closed bounds took %8.3fs\n" +msgstr "" +"le traitement parallèle par 'between' des doubles (nombres à virgule " +"flottante) avec des bornes fermées a pris %8.3fs\n" + +#: between.c:172 +#, c-format +msgid "Item %d of lower ('%s') is greater than item %d of upper ('%s')" +msgstr "" +"L'élément %d de lower ('%s') est supérieur à l'élément %d de upper ('%s')" + +#: between.c:187 +#, c-format +msgid "between non-parallel processing of character took %8.3fs\n" +msgstr "" +"le traitement non parallèle par 'between' des caractères a pris %8.3fs\n" + +#: bmerge.c:65 +#, c-format +msgid "icols[%d]=%d outside range [1,length(i)=%d]" +msgstr "icols[%d]=%d en dehors de l'intervalle [1,length(i)=%d]" + +#: bmerge.c:66 +#, c-format +msgid "xcols[%d]=%d outside range [1,length(x)=%d]" +msgstr "xcols[%d]=%d en dehors de l'intervalle [1,length(x)=%d]" + +#: bmerge.c:69 +#, c-format +msgid "typeof x.%s (%s) != typeof i.%s (%s)" +msgstr "typeof x.%s (%s) != typeof i.%s (%s)" + +#: bmerge.c:71 bmerge.c:383 +#, c-format +msgid "Type '%s' is not supported for joining/merging" +msgstr "Le type '%s' n'est pas pris en charge pour la jonction/fusion" + +#: bmerge.c:77 +msgid "roll is character but not 'nearest'" +msgstr "'roll' est un caractère, mais pas 'nearest'" + +#: bmerge.c:78 +msgid "roll='nearest' can't be applied to a character column, yet." +msgstr "" +"roll='nearest' ne peut pas encore être appliqué à une colonne de caractères." + +#: bmerge.c:86 +msgid "rollends must be a length 2 logical vector" +msgstr "'rollends' doit être un vecteur booléen de longueur 2" + +#: bmerge.c:115 +msgid "Only '==' operator is supported for columns of type character." +msgstr "" +"Seul l'opérateur '==' est pris en charge pour les colonnes de type caractère." + +#: chmatch.c:5 +#, c-format +msgid "table is type '%s' (must be 'character' or NULL)" +msgstr "table est de type '%s' (doit être 'character' ou NULL)" + +#: chmatch.c:19 +#, c-format +msgid "x is type '%s' (must be 'character' or NULL)" +msgstr "x est le type '%s' (doit être 'character' ou NULL)" + +#: chmatch.c:105 +#, c-format +msgid "" +"Failed to allocate % bytes working memory in chmatchdup: " +"length(table)=%d length(unique(table))=%d" +msgstr "" +"Échec de l'allocation de % octets de mémoire de travail dans " +"chmatchdup : length(table)=%d length(unique(table))=%d" + +#: cj.c:89 +#, c-format +msgid "Type '%s' is not supported by CJ." +msgstr "Le type '%s' n'est pas pris en charge par CJ." + +#: coalesce.c:14 +msgid "" +"The first argument is a list, data.table or data.frame. In this case there " +"should be no other arguments provided." +msgstr "" +"Le premier argument est une liste, un data.table ou un data.frame. Dans ce " +"cas, aucun autre argument ne doit être fourni." + +#: coalesce.c:30 +#, c-format +msgid "" +"Item 1 is a factor but item %d is not a factor. When factors are involved, " +"all items must be factor." +msgstr "" +"L'élément 1 est un facteur mais l'élément %d n'en est pas un. Lorsqu'il " +"s'agit de facteurs, tous les éléments doivent être des facteurs." + +#: coalesce.c:32 +#, c-format +msgid "" +"Item %d is a factor but its levels are not identical to the first item's " +"levels." +msgstr "" +"L'élément %d est un facteur mais ses niveaux ne sont pas identiques à ceux " +"du premier élément." + +#: coalesce.c:36 +#, c-format +msgid "" +"Item %d is a factor but item 1 is not a factor. When factors are involved, " +"all items must be factor." +msgstr "" +"L'élément %d est un facteur mais l'élément 1 n'en est pas un. Lorsqu'il " +"s'agit de facteurs, tous les éléments doivent être des facteurs." + +#: coalesce.c:39 +#, c-format +msgid "" +"Item %d is type %s but the first item is type %s. Please coerce before " +"coalescing." +msgstr "" +"L'élément %d est de type %s mais le premier élément est de type %s. Veuillez " +"convertir avant la consolidation." + +#: coalesce.c:41 +#, c-format +msgid "Item %d has a different class than item 1." +msgstr "L'élément %d a une classe différente de celle de l'élément 1." + +#: coalesce.c:44 +#, c-format +msgid "" +"Item %d is length %d but the first item is length %d. Only singletons are " +"recycled." +msgstr "" +"L'élément %d est de longueur %d mais le premier élément est de longueur %d. " +"Seuls les singletons sont recyclés." + +#: coalesce.c:48 +msgid "coalesce copied first item (inplace=FALSE)\n" +msgstr "coalesce a copié le premier élément (inplace=FALSE)\n" + +#: coalesce.c:164 fifelse.c:193 shift.c:171 uniqlist.c:98 uniqlist.c:130 +#: uniqlist.c:211 uniqlist.c:248 uniqlist.c:321 +#, c-format +msgid "Type '%s' is not supported" +msgstr "Le type '%s' n'est pas pris en charge" + +#: dogroups.c:85 gsumm.c:43 +msgid "env is not an environment" +msgstr "env n'est pas un environnement" + +#: dogroups.c:109 +#, c-format +msgid "!length(bynames)[%d]==length(groups)[%d]==length(grpcols)[%d]" +msgstr "!length(bynames)[%d]==length(groups)[%d]==length(grpcols)[%d]" + +#: dogroups.c:131 +msgid "row.names attribute of .SD not found" +msgstr "l'attribut row.names de .SD n'a pas été trouvé" + +#: dogroups.c:133 +#, c-format +msgid "" +"row.names of .SD isn't integer length 2 with NA as first item; i.e., ." +"set_row_names(). [%s %d %d]" +msgstr "" +"row.names de .SD n'est pas un entier de longueur 2 avec NA comme premier " +"élément ; c'est-à-dire, .set_row_names(). [%s %d %d]" + +#: dogroups.c:138 +msgid "length(names)!=length(SD)" +msgstr "length(names)!=length(SD)" + +#: dogroups.c:154 +msgid "length(xknames)!=length(xSD)" +msgstr "length(xknames)!=length(xSD)" + +#: dogroups.c:162 +#, c-format +msgid "length(iSD)[%d] != length(jiscols)[%d]" +msgstr "length(iSD)[%d] != length(jiscols)[%d]" + +#: dogroups.c:163 +#, c-format +msgid "length(xSD)[%d] != length(xjiscols)[%d]" +msgstr "length(xSD)[%d] != length(xjiscols)[%d]" + +#: dogroups.c:274 +#, c-format +msgid "j evaluates to type '%s'. Must evaluate to atomic vector or list." +msgstr "" +"j évalue le type '%s'. Doit être évalué comme un vecteur atomique ou une " +"liste." + +#: dogroups.c:283 +#, c-format +msgid "" +"Entry %d for group %d in j=list(...) should be atomic vector or list. If you " +"are trying something like j=list(.SD,newcol=mean(colA)) then use := by group " +"instead (much quicker), or cbind or merge afterwards." +msgstr "" +"L’entrée %d du groupe %d de j=list(...) doit être un vecteur atomique ou une " +"liste. Si vous essayez quelque chose comme j=list(.SD,newcol=mean(colA)), " +"utilisez plutôt := par groupe (beaucoup plus rapide), ou cbind ou merge " +"ensuite." + +#: dogroups.c:290 +#, c-format +msgid "" +"Entry %d for group %d in j=list(...) is an array with %d dimensions > 1, " +"which is disallowed. \"Break\" the array yourself with c() or as.vector() if " +"that is intentional." +msgstr "" +"L'entrée %d pour le groupe %d dans j=list(...) est un tableau avec %d " +"dimensions > 1, ce qui est interdit. \"Déconstruisez\" vous-même le tableau " +"en un vecteur avec c() ou as.vector() si c'est intentionnel." + +#: dogroups.c:300 +msgid "" +"RHS of := is NULL during grouped assignment, but it's not possible to delete " +"parts of a column." +msgstr "" +"L'élement de droite (RHS) de := est NULL pendant l'affectation groupée, mais " +"il n'est pas possible de supprimer des parties d'une colonne." + +#: dogroups.c:304 +#, c-format +msgid "" +"Supplied %d items to be assigned to group %d of size %d in column '%s'. The " +"RHS length must either be 1 (single values are ok) or match the LHS length " +"exactly. If you wish to 'recycle' the RHS please use rep() explicitly to " +"make this intent clear to readers of your code." +msgstr "" +"Les éléments fournis %d doivent être affectés au groupe %d de taille %d dans " +"la colonne '%s'. La longueur de l'élément de droite (RHS) doit être égale à " +"1 (les valeurs uniques sont acceptées) ou correspondre exactement à la " +"longueur de l'élément de gauche (LHS). Si vous souhaitez 'recycler' " +"l'élément de droite, utilisez explicitement rep() pour que les lecteurs de " +"votre code comprennent bien votre intention." + +#: dogroups.c:336 +#, c-format +msgid "Group %d column '%s': %s" +msgstr "Groupe %d colonne '%s' : %s" + +#: dogroups.c:343 +msgid "j doesn't evaluate to the same number of columns for each group" +msgstr "j n'évalue pas le même nombre de colonnes pour chaque groupe" + +#: dogroups.c:377 +#, c-format +msgid "" +"Column %d of j's result for the first group is NULL. We rely on the column " +"types of the first result to decide the type expected for the remaining " +"groups (and require consistency). NULL columns are acceptable for later " +"groups (and those are replaced with NA of appropriate type and recycled) but " +"not for the first. Please use a typed empty vector instead, such as " +"integer() or numeric()." +msgstr "" +"La colonne %d du résultat de j pour le premier groupe est NULL. Nous nous " +"basons sur les types de colonnes du premier résultat pour décider du type " +"attendu pour les autres groupes (et exiger la cohérence). Les colonnes NULL " +"sont acceptables pour les groupes suivants (et elles sont remplacées par NA " +"du type approprié et recyclé) mais pas pour le premier. Veuillez utiliser un " +"vecteur vide typé à la place, comme integer() ou numeric()." + +#: dogroups.c:380 +msgid "" +"j appears to be a named vector. The same names will likely be created over " +"and over again for each group and slow things down. Try and pass a named " +"list (which data.table optimizes) or an unnamed list() instead.\n" +msgstr "" +"j semble être un vecteur nommé. Les mêmes noms seront probablement créés " +"encore et encore pour chaque groupe et ralentiront les choses. Essayez de " +"passer une liste nommée (que data.table optimise) ou une list() sans nom à " +"la place.\n" + +#: dogroups.c:382 +#, c-format +msgid "" +"Column %d of j is a named vector (each item down the rows is named, " +"somehow). Please remove those names for efficiency (to save creating them " +"over and over for each group). They are ignored anyway.\n" +msgstr "" +"La colonne %d de j est un vecteur nommé (chaque élément des lignes est " +"nommé, d'une manière ou d'une autre). Veuillez supprimer ces noms pour des " +"raisons d'efficacité (afin d'éviter de les créer à plusieurs reprises pour " +"chaque groupe). Ils sont de toute façon ignorés.\n" + +#: dogroups.c:390 +msgid "" +"The result of j is a named list. It's very inefficient to create the same " +"names over and over again for each group. When j=list(...), any names are " +"detected, removed and put back after grouping has completed, for efficiency. " +"Using j=transform(), for example, prevents that speedup (consider changing " +"to :=). This message may be upgraded to warning in future.\n" +msgstr "" +"Le résultat de j est une liste nommée. Il est très inefficace de créer les " +"mêmes noms encore et encore pour chaque groupe. Lorsque j=list(...), tous " +"les noms sont détectés, supprimés et remis en place une fois le regroupement " +"terminé, pour plus d'efficacité. L'utilisation de j=transform(), par " +"exemple, empêche cette accélération (envisagez de changer pour :=). Ce " +"message pourrait être transformé en avis à l'avenir.\n" + +#: dogroups.c:402 +#, c-format +msgid "dogroups: growing from %d to %d rows\n" +msgstr "dogroups : augmentation de %d à %d lignes\n" + +#: dogroups.c:403 +#, c-format +msgid "dogroups: length(ans)[%d]!=ngrpcols[%d]+njval[%d]" +msgstr "dogroups: length(ans)[%d]!=ngrpcols[%d]+njval[%d]" + +#: dogroups.c:421 +#, c-format +msgid "" +"Item %d of j's result for group %d is zero length. This will be filled with " +"%d NAs to match the longest column in this result. Later groups may have a " +"similar problem but only the first is reported to save filling the warning " +"buffer." +msgstr "" +"L'élément %d du résultat de j pour le groupe %d est de longueur zero. Il " +"sera rempli avec %d NA pour correspondre à la colonne la plus longue de ce " +"résultat. Les groupes suivants peuvent avoir un problème similaire, mais " +"seul le premier est signalé pour éviter de remplir le tampon d'avis." + +#: dogroups.c:428 +#, c-format +msgid "" +"Column %d of result for group %d is type '%s' but expecting type '%s'. " +"Column types must be consistent for each group." +msgstr "" +"La colonne %d du résultat pour le groupe %d est de type '%s' mais attend le " +"type '%s'. Les types de colonnes doivent être cohérents pour chaque groupe." + +#: dogroups.c:430 +#, c-format +msgid "" +"Supplied %d items for column %d of group %d which has %d rows. The RHS " +"length must either be 1 (single values are ok) or match the LHS length " +"exactly. If you wish to 'recycle' the RHS please use rep() explicitly to " +"make this intent clear to readers of your code." +msgstr "" +"%d éléments fournis pour la colonne %d du groupe %d qui comporte %d lignes. " +"La longueur de l'élément de droite (RHS) doit être égale à 1 (les valeurs " +"simples sont acceptables) ou correspondre exactement à la longueur de " +"l'élément de gauche (LHS). Si vous souhaitez 'recycler' l'élément de droite, " +"utilisez explicitement rep() pour que les lecteurs de votre code comprennent " +"bien votre intention." + +#: dogroups.c:448 fsort.c:250 fwrite.c:707 +msgid "\n" +msgstr "\n" + +#: dogroups.c:449 +#, c-format +msgid "" +"\rProcessed %d groups out of %d. %.0f%% done. Time elapsed: %ds. ETA: %ds." +msgstr "" +"\rTraitement de %d groupes sur %d. %.0f%% terminé. Temps écoulé : %ds. Heure " +"d'arrivée prévue : %ds." + +#: dogroups.c:462 +#, c-format +msgid "" +"\rProcessed %d groups out of %d. %.0f%% done. Time elapsed: %ds. ETA: %ds.\n" +msgstr "" +"\rTraitement de %d groupes sur %d. %.0f%% terminé. Temps écoulé : %ds. Heure " +"d'arrivée prévue : %ds.\n" + +#: dogroups.c:465 +#, c-format +msgid "Wrote less rows (%d) than allocated (%d).\n" +msgstr "Moins de lignes écrites (%d) que de lignes allouées (%d).\n" + +#: dogroups.c:489 +#, c-format +msgid "" +"\n" +" %s took %.3fs for %d groups\n" +msgstr "" +"\n" +" %s a pris %.3fs pour %d groupes\n" + +#: dogroups.c:491 +#, c-format +msgid " eval(j) took %.3fs for %d calls\n" +msgstr " eval(j) a pris %.3fs pour %d appels\n" + +#: dogroups.c:520 +msgid "growVector passed NULL" +msgstr "'growVector' transmis NULL" + +#: fastmean.c:39 rbindlist.c:8 rbindlist.c:12 +#, c-format +msgid "%s should be TRUE or FALSE" +msgstr "%s doit être TRUE ou FALSE" + +#: fastmean.c:45 +#, c-format +msgid "fastmean was passed type %s, not numeric or logical" +msgstr "'fastmean' a été transmis au type %s, non numérique ou booléen" + +#: fcast.c:101 +#, c-format +msgid "Unsupported column type in fcast val: '%s'" +msgstr "Type de colonne non pris en charge dans fcast val : '%s'" + +#: fifelse.c:5 +msgid "Argument 'test' must be logical." +msgstr "L'argument 'test' doit être de type booléen." + +#: fifelse.c:9 +msgid "S4 class objects (except nanotime) are not supported." +msgstr "Les objets de la classe S4 (sauf nanotime) ne sont pas pris en charge." + +#: fifelse.c:24 +#, c-format +msgid "" +"Length of 'yes' is % but must be 1 or length of 'test' (%)." +msgstr "" +"La longueur de 'yes' est % mais doit être égale à 1 ou à la longueur " +"de 'test' (%)." + +#: fifelse.c:26 +#, c-format +msgid "" +"Length of 'no' is % but must be 1 or length of 'test' (%)." +msgstr "" +"La longueur de 'no' est % mais doit être 1 ou la longueur de 'test' " +"(%)." + +#: fifelse.c:28 +#, c-format +msgid "" +"Length of 'na' is % but must be 1 or length of 'test' (%)." +msgstr "" +"La longueur de 'na' est % mais doit être 1 ou la longueur de 'test' " +"(%)." + +#: fifelse.c:46 +#, c-format +msgid "" +"'no' is of type %s but '%s' is %s. Please make all arguments have the same " +"type." +msgstr "" +"'no' est de type %s mais '%s' est de type %s. Veuillez faire en sorte que " +"tous les arguments aient le même type." + +#: fifelse.c:52 +#, c-format +msgid "" +"'na' is of type %s but '%s' is %s. Please make all arguments have the same " +"type." +msgstr "" +"'na' est de type %s mais '%s' est de type %s. Veuillez faire en sorte que " +"tous les arguments aient le même type." + +#: fifelse.c:57 +msgid "" +"'yes' has different class than 'no'. Please make sure that both arguments " +"have the same class." +msgstr "" +"la classe de 'yes' est différente de celle de 'no'. Veuillez vous assurer " +"que les deux arguments ont la même classe." + +#: fifelse.c:62 +msgid "" +"'yes' has different class than 'na'. Please make sure that both arguments " +"have the same class." +msgstr "" +"la classe de 'yes' est différente de celle de 'na'. Veuillez vous assurer " +"que les deux arguments ont la même classe." + +#: fifelse.c:67 +msgid "" +"'no' has different class than 'na'. Please make sure that both arguments " +"have the same class." +msgstr "" +"la classe de 'no' est différente de celle de 'na'. Veuillez vous assurer que " +"les deux arguments ont la même classe." + +#: fifelse.c:74 +msgid "'yes' and 'no' are both type factor but their levels are different." +msgstr "" +"'oui' et 'non' sont tous les deux de type facteur, mais leurs niveaux sont " +"différents." + +#: fifelse.c:79 +msgid "'yes' and 'na' are both type factor but their levels are different." +msgstr "" +"'oui' et 'na' sont tous les deux de type facteur, mais leurs niveaux sont " +"différents." + +#: fifelse.c:84 +msgid "'no' and 'na' are both type factor but their levels are different." +msgstr "" +"'no' et 'na' sont tous les deux de type facteur, mais leurs niveaux sont " +"différents." + +#: fifelse.c:207 +#, c-format +msgid "" +"Received %d inputs; please supply an even number of arguments in ..., " +"consisting of logical condition, resulting value pairs (in that order). Note " +"that the default argument must be named explicitly, e.g., default=0" +msgstr "" +"A reçu %d entrées ; veuillez fournir un nombre pair d'arguments dans ..., " +"consistant en une condition logique, et des paires de valeur de résultats " +"(dans cet ordre). Notez que l'argument par défaut doit être nommé " +"explicitement, par exemple, default=0" + +#: fifelse.c:227 +msgid "" +"S4 class objects (except nanotime) are not supported. Please see https://" +"github.com/Rdatatable/data.table/issues/4131." +msgstr "" +"Les objets de la classe S4 (sauf nanotime) ne sont pas pris en charge. " +"Veuillez consulter https://github.com/Rdatatable/data.table/issues/4131." + +#: fifelse.c:230 +#, c-format +msgid "Argument #%d must be logical but was of type %s." +msgstr "L'argument #%d doit être booléen, mais il est de type %s." + +#: fifelse.c:248 +#, c-format +msgid "" +"Argument #%d has length %lld which differs from that of argument #1 (%lld). " +"Please make sure all logical conditions have the same length." +msgstr "" +"L'argument #%d a une longueur %lld différente de l'argument #1 (%lld). " +"Veillez à ce que toutes les conditions logiques aient la même longueur." + +#: fifelse.c:254 +#, c-format +msgid "" +"Resulting value is of type %s but 'default' is of type %s. Please make sure " +"that both arguments have the same type." +msgstr "" +"La valeur résultat est de type %s mais 'default' est de type %s. Veuillez " +"vous assurer que les deux arguments ont le même type." + +#: fifelse.c:257 +#, c-format +msgid "" +"Argument #%d is of type %s, however argument #2 is of type %s. Please make " +"sure all output values have the same type." +msgstr "" +"L'argument #%d est de type %s, mais l'argument #2 est de type %s. Veuillez " +"vous assurer que toutes les valeurs de sortie ont le même type." + +#: fifelse.c:265 +msgid "" +"Resulting value has different class than 'default'. Please make sure that " +"both arguments have the same class." +msgstr "" +"La valeur résultat a une classe différente de celle de 'default'. Veuillez " +"vous assurer que les deux arguments ont la même classe." + +#: fifelse.c:268 +#, c-format +msgid "" +"Argument #%d has different class than argument #2, Please make sure all " +"output values have the same class." +msgstr "" +"L'argument #%d n'est pas de la même classe que l'argument #2, veuillez vous " +"assurer que toutes les valeurs de sortie ont la même classe." + +#: fifelse.c:277 +msgid "" +"Resulting value and 'default' are both type factor but their levels are " +"different." +msgstr "" +"La valeur résultat et la valeur 'default' sont toutes deux des facteurs, " +"mais leurs niveaux sont différents." + +#: fifelse.c:279 +#, c-format +msgid "" +"Argument #2 and argument #%d are both factor but their levels are different." +msgstr "" +"L'argument #2 et l'argument #%d sont tous deux des facteurs, mais leurs " +"niveaux sont différents." + +#: fifelse.c:288 +#, c-format +msgid "Length of 'default' must be 1 or %lld." +msgstr "La longueur de 'default' doit être de 1 ou %lld." + +#: fifelse.c:290 +#, c-format +msgid "" +"Length of output value #%d (%lld) must either be 1 or match the length of " +"the logical condition (%lld)." +msgstr "" +"La longueur de la valeur de sortie #%d (%lld) doit être soit 1, soit la " +"longueur de la condition logique (%lld)." + +#: fifelse.c:395 +#, c-format +msgid "Type '%s' is not supported." +msgstr "Le type '%s' n'est pas pris en charge." + +#: fmelt.c:18 +msgid "'x' must be an integer" +msgstr "'x' doit être un nombre entier" + +#: fmelt.c:19 +msgid "'n' must be a positive integer" +msgstr "'n' doit être un nombre entier positif" + +#: fmelt.c:41 +msgid "Argument to 'which' must be logical" +msgstr "L'argument passé à 'which' doit être booléen" + +#: fmelt.c:65 +msgid "concat: 'vec' must be a character vector" +msgstr "concat : 'vec' doit être un vecteur de caractères" + +#: fmelt.c:66 +msgid "concat: 'idx' must be an integer vector of length >= 0" +msgstr "concat : 'idx' doit être un vecteur entier de longueur >= 0" + +#: fmelt.c:134 +#, c-format +msgid "Unknown 'measure.vars' type %s at index %d of list" +msgstr "Type inconnu de 'measure.vars' %s à l'indice %d de la liste" + +#: fmelt.c:187 +msgid "One or more values in 'measure.vars' is invalid." +msgstr "Une ou plusieurs valeurs de 'measure.vars' ne sont pas valides." + +#: fmelt.c:189 +msgid "One or more values in 'id.vars' is invalid." +msgstr "Une ou plusieurs valeurs de 'id.vars' ne sont pas valides." + +#: fmelt.c:213 +#, c-format +msgid "" +"Unknown 'measure.vars' type %s, must be character or integer vector/list" +msgstr "" +"Le type de 'measure.vars' %s est inconnu, ça doit être un vecteur/list de " +"caractères ou d'entiers" + +#: fmelt.c:215 +#, c-format +msgid "Unknown 'id.vars' type %s, must be character or integer vector" +msgstr "" +"Le type de 'id.vars' %s est inconnu, ça doit être un vecteur de caractères " +"ou d'entiers" + +#: fmelt.c:240 +#, c-format +msgid "" +"id.vars and measure.vars are internally guessed when both are 'NULL'. All " +"non-numeric/integer/logical type columns are considered id.vars, which in " +"this case are columns [%s]. Consider providing at least one of 'id' or " +"'measure' vars in future." +msgstr "" +"id.vars et measure.vars sont devinés en interne lorsqu'ils sont tous deux " +"'NULL'. Toutes les colonnes de type non numérique/entier/booléen sont " +"considérées comme des id.vars, qui dans ce cas sont des colonnes [%s]. " +"Envisagez de fournir au moins l'une des variables 'id' ou 'measure' à " +"l'avenir." + +#: fmelt.c:246 +msgid "" +"'measure.vars' is missing. Assigning all columns other than 'id.vars' " +"columns as 'measure.vars'.\n" +msgstr "" +"'measure.vars' est manquant. Affectation de toutes les colonnes autres que " +"les colonnes 'id.vars' à 'measure.vars'.\n" + +#: fmelt.c:248 +#, c-format +msgid "Assigned 'measure.vars' are [%s].\n" +msgstr "Les 'measure.vars' attribués sont [%s].\n" + +#: fmelt.c:259 +msgid "" +"'id.vars' is missing. Assigning all columns other than 'measure.vars' " +"columns as 'id.vars'.\n" +msgstr "" +"'id.vars' est manquant. Affectation de toutes les colonnes autres que les " +"colonnes 'measure.vars' à 'id.vars'.\n" + +#: fmelt.c:260 +#, c-format +msgid "Assigned 'id.vars' are [%s].\n" +msgstr "Les 'id.vars' attribués sont [%s].\n" + +#: fmelt.c:314 +msgid "" +"When 'measure.vars' is a list, 'value.name' must be a character vector of " +"length =1 or =length(measure.vars)." +msgstr "" +"Lorsque 'measure.vars' est une liste, 'value.name' doit être un vecteur de " +"caractères de longueur =1 ou =length(measure.vars)." + +#: fmelt.c:315 +msgid "" +"When 'measure.vars' is either not specified or a character/integer vector, " +"'value.name' must be a character vector of length =1." +msgstr "" +"Lorsque 'measure.vars' n'est pas spécifié ou qu'il s'agit d'un vecteur de " +"caractères/de nombres entiers, 'value.name' doit être un vecteur de " +"caractères de longueur =1." + +#: fmelt.c:318 +msgid "'variable.name' must be a character/integer vector of length 1." +msgstr "" +"'variable.name' doit être un vecteur de caractères/entiers de longueur 1." + +#: fmelt.c:371 +msgid "" +"variable_table attribute of measure.vars should be a data table with at " +"least one column" +msgstr "" +"l'attribut variable_table de measure.vars doit être un tableau de données " +"comportant au moins une colonne" + +#: fmelt.c:376 +#, c-format +msgid "" +"variable_table attribute of measure.vars should be a data table with same " +"number of rows as max length of measure.vars vectors =%d" +msgstr "" +"l'attribut variable_table de measure.vars doit être un tableau de données " +"avec le même nombre de lignes que la longueur maximale de measure.vars " +"vectors =%d" + +#: fmelt.c:380 +msgid "" +"variable_table attribute of measure.vars should be either NULL or a data " +"table" +msgstr "" +"l'attribut variable_table de measure.vars doit être soit NULL, soit un " +"tableau de données" + +#: fmelt.c:463 +#, c-format +msgid "" +"'measure.vars' [%s] are not all of the same type. By order of hierarchy, the " +"molten data value column will be of type '%s'. All measure variables not of " +"type '%s' will be coerced too. Check DETAILS in ?melt.data.table for more on " +"coercion.\n" +msgstr "" +"les colonnes 'measure.vars' [%s] ne sont pas toutes du même type. Par ordre " +"hiérarchique, la colonne de valeurs des données transformée sera de type " +"'%s'. Toutes les variables de mesure qui ne sont pas de type '%s' seront " +"également converties automatiquement. Consultez DETAILS dans ?melt.data." +"table pour en savoir plus sur la conversion automatique.\n" + +#: fmelt.c:575 +#, c-format +msgid "Unknown column type '%s' for column '%s'." +msgstr "Type de colonne inconnu '%s' pour la colonne '%s'." + +#: fmelt.c:685 +#, c-format +msgid "variable_table does not support column type '%s' for column '%s'." +msgstr "" +"variable_table ne prend pas en charge le type de colonne '%s' pour la " +"colonne '%s'." + +#: fmelt.c:779 +#, c-format +msgid "Unknown column type '%s' for column '%s' in 'data'" +msgstr "Type de colonne inconnu '%s' pour la colonne '%s' dans 'data'" + +#: fmelt.c:790 +msgid "Input is not of type VECSXP, expected a data.table, data.frame or list" +msgstr "" +"L'entrée n'est pas de type VECSXP, un data.table, un data.frame ou une liste " +"est attendu" + +#: fmelt.c:791 +msgid "Argument 'value.factor' should be logical TRUE/FALSE" +msgstr "L'argument 'value.factor' doit être booléen TRUE/FALSE" + +#: fmelt.c:792 +msgid "Argument 'variable.factor' should be logical TRUE/FALSE" +msgstr "L'argument 'variable.factor' doit être booléen TRUE/FALSE" + +#: fmelt.c:793 +msgid "Argument 'na.rm' should be logical TRUE/FALSE." +msgstr "L'argument 'na.rm' doit être booléen TRUE/FALSE." + +#: fmelt.c:794 +msgid "Argument 'variable.name' must be a character vector" +msgstr "L'argument 'variable.name' doit être un vecteur de caractères" + +#: fmelt.c:795 +msgid "Argument 'value.name' must be a character vector" +msgstr "L'argument 'value.name' doit être un vecteur de caractères" + +#: fmelt.c:796 +msgid "Argument 'verbose' should be logical TRUE/FALSE" +msgstr "L'argument 'verbose' doit être un booléen TRUE/FALSE" + +#: fmelt.c:800 +msgid "ncol(data) is 0. Nothing to melt. Returning original data.table." +msgstr "" +"ncol(data) est 0. Rien à transformer. Renvoi du tableau de données original." + +#: fmelt.c:805 +msgid "names(data) is NULL. Please report to data.table-help" +msgstr "names(data) est NULL. Veuillez signaler ce problème à data.table-help" + +#: forder.c:111 fread.c:2587 utils.c:446 +msgid "Internal error in" +msgstr "Erreur interne dans" + +#: forder.c:111 utils.c:446 +msgid "Please report to the data.table issues tracker." +msgstr "" +"Veuillez signaler l'erreur au gestionnaire de tickets (issue tracker) de " +"data.table." + +#: forder.c:121 +#, c-format +msgid "Failed to realloc thread private group size buffer to %d*4bytes" +msgstr "" +"Échec de la réallocation à %d*4 octets de la mémoire tampon du thread du " +"groupe privé" + +#: forder.c:135 +#, c-format +msgid "Failed to realloc group size result to %d*4bytes" +msgstr "" +"Échec de la réallocation du résultat de la taille du groupe à %d*4 octets" + +#: forder.c:269 +#, c-format +msgid "" +"Logical error. counts[0]=%d in cradix but should have been decremented to 0. " +"radix=%d" +msgstr "" +"Erreur logique. counts[0]=%d dans cradix mais aurait dû être décrémenté à 0. " +"radix=%d" + +#: forder.c:287 +msgid "Failed to alloc cradix_counts and/or cradix_tmp" +msgstr "Échec de l'allocation de cradix_counts et/ou cradix_tmp" + +#: forder.c:320 +#, c-format +msgid "Unable to realloc %d * %d bytes in range_str" +msgstr "Impossible de réallouer %d * %d octets dans range_str" + +#: forder.c:347 +msgid "Failed to alloc ustr3 when converting strings to UTF8" +msgstr "" +"Échec de l'allocation de ustr3 lors de la conversion de chaînes de " +"caractères en UTF8" + +#: forder.c:366 +msgid "Failed to alloc tl when converting strings to UTF8" +msgstr "" +"Échec de l'allocation de tl lors de la conversion de chaînes de caractères " +"en UTF8" + +#: forder.c:395 +msgid "Must an integer or numeric vector length 1" +msgstr "Doit être un entier ou un tableau numérique de longueur 1" + +#: forder.c:396 +msgid "Must be 2, 1 or 0" +msgstr "Doit être égal à 2, 1 ou 0" + +#: forder.c:431 +msgid "Unknown non-finite value; not NA, NaN, -Inf or +Inf" +msgstr "Valeur inconnue (non-finie) ; pas NA, NaN, -Inf ou +Inf" + +#: forder.c:457 +msgid "" +"Input is an atomic vector (not a list of columns) but order= is not a length " +"1 integer" +msgstr "" +"L'entrée est un vecteur atomique (pas une liste de colonnes) mais order= " +"n'est pas un entier de longueur 1" + +#: forder.c:459 +#, c-format +msgid "forder.c received a vector type '%s' length %d\n" +msgstr "forder.c a reçu un vecteur de type '%s' de longueur %d\n" + +#: forder.c:467 +#, c-format +msgid "forder.c received %d rows and %d columns\n" +msgstr "forder.c a reçu %d lignes et %d colonnes\n" + +#: forder.c:477 +#, c-format +msgid "'order' length (%d) is different to by='s length (%d)" +msgstr "La longueur de 'order' (%d) est différente de la longueur de by= (%d)" + +#: forder.c:491 +#, c-format +msgid "" +"Column %d is length %d which differs from length of column 1 (%d), are you " +"attempting to order by a list column?\n" +msgstr "" +"La colonne %d a une longueur %d qui diffère de la longueur de la colonne 1 " +"(%d), essayez-vous d'ordonner par une colonne de type liste ?\n" + +#: forder.c:495 +msgid "retGrp must be TRUE or FALSE" +msgstr "retGrp doit être TRUE ou FALSE" + +#: forder.c:498 +msgid "retStats must be TRUE or FALSE" +msgstr "retStats doit être TRUE ou FALSE" + +#: forder.c:503 +msgid "sort must be TRUE or FALSE" +msgstr "sort doit être TRUE ou FALSE" + +#: forder.c:506 +msgid "At least one of retGrp= or sort= must be TRUE" +msgstr "Au moins l'un des deux, retGrp= ou sort=, doit être TRUE" + +#: forder.c:508 +msgid "na.last must be logical TRUE, FALSE or NA of length 1" +msgstr "na.last doit être un booléen TRUE, FALSE ou NA de longueur 1" + +#: forder.c:542 forder.c:656 +#, c-format +msgid "Unable to allocate % bytes of working memory" +msgstr "Impossible d'allouer % octets de mémoire de travail" + +#: forder.c:560 +#, c-format +msgid "Item %d of order (ascending/descending) is %d. Must be +1 or -1." +msgstr "" +"L'élément %d dans l’ordre (croissant/décroissant) est %d. Il doit être égale " +"à +1 ou -1." + +#: forder.c:586 +#, c-format +msgid "" +"\n" +"*** Column %d passed to forder is a date stored as an 8 byte double but no " +"fractions are present. Please consider a 4 byte integer date such as IDate " +"to save space and time.\n" +msgstr "" +"\n" +"*** La colonne %d transmise à ‘forder’ est une date stockée sous la forme " +"d'un ‘double’ (nombre à virgule flottante) de 8 octets, mais aucune fraction " +"n'est présente. Pour gagner du temps et de l'espace mémoire, il est " +"préférable d'utiliser une date entière sur 4 octets, telle que IDate.\n" + +#: forder.c:602 +#, c-format +msgid "Column %d passed to [f]order is type '%s', not yet supported." +msgstr "" +"La colonne %d transmise à '[f]order' est de type '%s', type non encore pris " +"en charge." + +#: forder.c:771 +#, c-format +msgid "nradix=%d\n" +msgstr "nradix=%d\n" + +#: forder.c:780 +#, c-format +msgid "" +"Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d" +msgstr "" +"Échec de l'allocation de TMP ou UGRP ou ils n'étaient pas alignés sur la " +"ligne de cache : nth=%d" + +#: forder.c:789 +msgid "Could not allocate (very tiny) group size thread buffers" +msgstr "" +"Impossible d’allouer la mémoire tampon du thread pour des (très petites) " +"tailles de groupes" + +#: forder.c:857 +#, c-format +msgid "Timing block %2d%s = %8.3f %8d\n" +msgstr "Bloc de synchronisation %2d%s = %8.3f %8d\n" + +#: forder.c:860 +#, c-format +msgid "stat[%03d]==%20\n" +msgstr "stat[%03d]==%20\n" + +#: forder.c:908 forder.c:978 forder.c:1000 forder.c:1102 forder.c:1233 +#: forder.c:1289 fread.c:2573 +#, c-format +msgid "Failed to allocate %d bytes for '%s'." +msgstr "Échec de l'allocation de %d octets pour '%s'." + +#: forder.c:1133 +#, c-format +msgid "Failed to allocate parallel counts. my_n=%d, nBatch=%d" +msgstr "Échec de l'allocation des comptages parallèles. my_n=%d, nBatch=%d" + +#: forder.c:1145 +#, c-format +msgid "Failed to allocate 'my_otmp' and/or 'my_ktmp' arrays (%d bytes)." +msgstr "" +"Échec de l'allocation des tableaux 'my_otmp' et/ou 'my_ktmp' (%d octets)." + +#: forder.c:1250 +#, c-format +msgid "Unable to allocate TMP for my_n=%d items in parallel batch counting" +msgstr "" +"Impossible d'allouer un TMP pour my_n=%d éléments dans le comptage par lots " +"en parallèle" + +#: forder.c:1365 forder.c:1416 +#, c-format +msgid "issorted 'by' [%d] out of range [1,%d]" +msgstr "issorted 'by' [%d] en dehors de l’intervalle [1,%d]" + +#: forder.c:1370 +msgid "is.sorted does not work on list columns" +msgstr "is.sorted ne fonctionne pas sur les colonnes de type liste" + +#: forder.c:1403 forder.c:1433 forder.c:1467 +#, c-format +msgid "type '%s' is not yet supported" +msgstr "le type '%s' n'est pas encore pris en charge" + +#: forder.c:1480 +msgid "x must be either NULL or an integer vector" +msgstr "x doit être NULL ou un vecteur entier" + +#: forder.c:1482 +msgid "nrow must be integer vector length 1" +msgstr "nrow doit être un vecteur d’entiers de longueur 1" + +#: forder.c:1484 +#, c-format +msgid "nrow==%d but must be >=0" +msgstr "nrow==%d mais doit être >=0" + +#: forder.c:1501 +msgid "x must be type 'double'" +msgstr "x doit être de type ‘double’ (nombre à virgule flottante)" + +#: frank.c:14 frank.c:192 +#, c-format +msgid "Item %d of 'cols' is %d which is outside 1-based range [1,ncol(x)=%d]" +msgstr "" +"L'élément %d de 'cols' est %d, ce qui est en dehors de l'intervalle [1," +"ncol(x)=%d]" + +#: frank.c:24 frank.c:200 +#, c-format +msgid "" +"Column %d of input list x is length %d, inconsistent with first column of " +"that item which is length %d." +msgstr "" +"La colonne %d de la liste d'entrée x est de longueur %d, ce qui est " +"incompatible avec la première colonne de cet élément qui est de longueur %d." + +#: frank.c:101 frank.c:234 transpose.c:97 +#, c-format +msgid "Unsupported column type '%s'" +msgstr "Type de colonne non prise en charge ‘%s’" + +#: fread.c:154 +#, c-format +msgid "System error %lu unmapping view of file\n" +msgstr "Erreur système %lu : annulation du mappage de la vue du fichier\n" + +#: fread.c:157 +#, c-format +msgid "System errno %d unmapping file: %s\n" +msgstr "Erreur système %d annulation du mappage du fichier : %s\n" + +#: fread.c:446 +#, c-format +msgid "Unable to allocate %s of contiguous virtual RAM. %s allocation." +msgstr "Impossible d'allouer %s de RAM virtuelle contiguë. Allocation de %s." + +#: fread.c:451 +#, c-format +msgid "Avoidable %.3f seconds. %s time to copy.\n" +msgstr "%.3f secondes évitables. %s temps de copie.\n" + +#: fread.c:452 +#, c-format +msgid " File copy in RAM took %.3f seconds.\n" +msgstr " La copie du fichier dans la RAM a pris %.3f secondes.\n" + +#: fread.c:1283 +msgid "" +"Previous fread() session was not cleaned up properly. Cleaned up ok at the " +"beginning of this fread() call.\n" +msgstr "" +"La session fread() précédente n'a pas été nettoyée correctement. Elle a été " +"correctement nettoyé au début de cet appel à fread().\n" + +#: fread.c:1286 +msgid "[01] Check arguments\n" +msgstr "[01] Vérifier les arguments\n" + +#: fread.c:1293 +#, c-format +msgid " Using %d threads (omp_get_max_threads()=%d, nth=%d)\n" +msgstr " Utilisation de %d threads (omp_get_max_threads()=%d, nth=%d)\n" + +#: fread.c:1315 +#, c-format +msgid "freadMain: NAstring <<%s>> has whitespace at the beginning or end" +msgstr "freadMain : NAstring <<%s>> contient des espaces au début ou à la fin" + +#: fread.c:1319 +#, c-format +msgid "" +"freadMain: NAstring <<%s>> is recognized as type boolean, this is not " +"permitted." +msgstr "" +"freadMain : NAstring <<%s>> est reconnu comme étant de type booléen, ce qui " +"n'est pas autorisé." + +#: fread.c:1321 +#, c-format +msgid "freadMain: NAstring <<%s>> and logical01=TRUE, this is not permitted." +msgstr "freadMain : NAstring <<%s>> et logical01=TRUE, ce n'est pas autorisé." + +#: fread.c:1333 +msgid " No NAstrings provided.\n" +msgstr " Aucun NAstrings n'est fourni.\n" + +#: fread.c:1335 +msgid " NAstrings = [" +msgstr " NAstrings = [" + +#: fread.c:1338 +msgid "]\n" +msgstr "]\n" + +#: fread.c:1340 +msgid " One or more of the NAstrings looks like a number.\n" +msgstr " Une ou plusieurs des NAstrings ressemblent à un nombre.\n" + +#: fread.c:1342 +msgid " None of the NAstrings look like numbers.\n" +msgstr " Aucun des NAstrings ne ressemble à un nombre.\n" + +#: fread.c:1344 +#, c-format +msgid " skip num lines = %\n" +msgstr " saute au numéro de lignes = %\n" + +#: fread.c:1345 +#, c-format +msgid " skip to string = <<%s>>\n" +msgstr " passer à la chaîne de caractères = <<%s>>\n" + +#: fread.c:1346 +#, c-format +msgid " show progress = %d\n" +msgstr " afficher l'état d'avancement = %d\n" + +#: fread.c:1347 +#, c-format +msgid " 0/1 column will be read as %s\n" +msgstr " la colonne 0/1 sera lue comme %s\n" + +#: fread.c:1359 +#, c-format +msgid "sep == quote ('%c') is not allowed" +msgstr "sep == quote ('%c') n'est pas autorisé" + +#: fread.c:1360 +#, c-format +msgid "sep == dec ('%c') is not allowed" +msgstr "sep == dec ('%c') n'est pas autorisé" + +#: fread.c:1361 +#, c-format +msgid "quote == dec ('%c') is not allowed" +msgstr "quote == dec ('%c') n'est pas autorisé" + +#: fread.c:1378 +msgid "[02] Opening the file\n" +msgstr "[02] Ouverture du fichier\n" + +#: fread.c:1381 +msgid "" +" `input` argument is provided rather than a file name, interpreting as raw " +"text to read\n" +msgstr "" +" l'argument ‘input’ est fourni au lieu d'un nom de fichier, ce qui est " +"interprété comme du texte brut à lire\n" + +#: fread.c:1388 +#, c-format +msgid " Opening file %s\n" +msgstr " Ouverture du fichier %s\n" + +#: fread.c:1392 fread.c:1421 +#, c-format +msgid "File not found: %s" +msgstr "Le fichier n'a pas été trouvé : %s" + +#: fread.c:1396 +#, c-format +msgid "Opened file ok but couldn't obtain its size: %s" +msgstr "" +"Ouverture du fichier correcte mais impossibilité d'obtenir sa taille : %s" + +#: fread.c:1399 fread.c:1431 +#, c-format +msgid "File is empty: %s" +msgstr "Le fichier est vide : %s" + +#: fread.c:1400 fread.c:1432 +#, c-format +msgid " File opened, size = %s.\n" +msgstr " Fichier ouvert, taille = %s.\n" + +#: fread.c:1427 +#, c-format +msgid "Unable to open file after %d attempts (error %lu): %s" +msgstr "Impossible d'ouvrir le fichier après %d tentatives (erreur %lu) : %s" + +#: fread.c:1429 +#, c-format +msgid "GetFileSizeEx failed (returned 0) on file: %s" +msgstr "GetFileSizeEx a échoué (a retourné 0) sur le fichier : %s" + +#: fread.c:1434 +#, c-format +msgid "This is Windows, CreateFileMapping returned error %lu for file %s" +msgstr "" +"C'est Windows, CreateFileMapping a renvoyé l'erreur %lu pour le fichier %s" + +#: fread.c:1441 +#, c-format +msgid "" +"Opened %s file ok but could not memory map it. This is a %dbit process. %s." +msgstr "" +"Le fichier %s s'est ouvert correctement, mais il n'a pas été possible de le " +"mapper avec la mémoire. Il s'agit d'un processus %dbit. %s." + +#: fread.c:1442 +msgid "Please upgrade to 64bit" +msgstr "Veuillez passer à la version 64 bits" + +#: fread.c:1442 +msgid "There is probably not enough contiguous virtual memory available" +msgstr "" +"Il n'y a probablement pas assez de mémoire virtuelle contiguë disponible" + +#: fread.c:1445 +msgid " Memory mapped ok\n" +msgstr " Mémoire mappée ok\n" + +#: fread.c:1464 +msgid "[03] Detect and skip BOM\n" +msgstr "[03] Détecte et saute le BOM (indicateur d’ordre des octets)\n" + +#: fread.c:1468 +msgid "" +" UTF-8 byte order mark EF BB BF found at the start of the file and " +"skipped.\n" +msgstr "" +" UTF-8 BOM (indicateur d’ordre des octets) EF BB BF trouvé au début du " +"fichier et ignoré.\n" + +#: fread.c:1473 +msgid "" +"GB-18030 encoding detected, however fread() is unable to decode it. Some " +"character fields may be garbled.\n" +msgstr "" +"L'encodage GB-18030 a été détecté, mais fread() n'est pas en mesure de le " +"décoder. Certains champs de caractères peuvent être corrompus.\n" + +#: fread.c:1476 +msgid "" +"File is encoded in UTF-16, this encoding is not supported by fread(). Please " +"recode the file to UTF-8." +msgstr "" +"Le fichier est encodé en UTF-16, cet encodage n'est pas supporté par " +"fread(). Veuillez réencoder le fichier en UTF-8." + +#: fread.c:1481 +#, c-format +msgid " Last byte(s) of input found to be %s and removed.\n" +msgstr "" +" Le(s) dernier(s) octet(s) de l'entrée est (sont) %s et a (ont) été " +"supprimé(s).\n" + +#: fread.c:1484 +msgid "Input is empty or only contains BOM or terminal control characters" +msgstr "" +"L'entrée est vide ou ne contient que le BOM (indicateur d’ordre des octets) " +"ou des caractères de séquence d’échappement" + +#: fread.c:1491 +msgid "[04] Arrange mmap to be \\0 terminated\n" +msgstr "[04] Organiser mmap pour être terminé par \\0 \n" + +#: fread.c:1498 +msgid "" +" No \\n exists in the file at all, so single \\r (if any) will be taken as " +"one line ending. This is unusual but will happen normally when there is no " +"\\r either; e.g. a single line missing its end of line.\n" +msgstr "" +" Il n'y a aucun \\n dans le fichier, de sorte qu'un \\r seul (s'il y en a " +"un) sera considéré comme une fin de ligne. Ceci est inhabituel mais se " +"produit normalement lorsqu'il n'y a pas non plus de \\r ; par exemple, une " +"seule ligne qui n'a pas de fin de ligne.\n" + +#: fread.c:1499 +msgid "" +" \\n has been found in the input and different lines can end with different " +"line endings (e.g. mixed \\n and \\r\\n in one file). This is common and " +"ideal.\n" +msgstr "" +" \\n a été trouvé dans l'entrée et différentes lignes peuvent se terminer " +"par des fins de ligne différentes (par exemple, \\n et \\r\\n mélangés dans " +"un fichier). Cette situation est courante et idéale.\n" + +#: fread.c:1523 +#, c-format +msgid "" +" File ends abruptly with '%c'. Final end-of-line is missing. Using cow page " +"to write 0 to the last byte.\n" +msgstr "" +" Le fichier se termine brusquement par '%c'. La fin de ligne est manquante. " +"Utilisation d'une page ‘Copy-On-Write’ pour écrire 0 sur le dernier octet.\n" + +#: fread.c:1529 +msgid "" +"This file is very unusual: it ends abruptly without a final newline, and " +"also its size is a multiple of 4096 bytes. Please properly end the last row " +"with a newline using for example 'echo >> file' to avoid this " +msgstr "" +"Ce fichier est très inhabituel : il se termine brusquement sans nouvelle " +"ligne finale et sa taille est un multiple de 4096 octets. Veuillez terminer " +"correctement la dernière ligne par une nouvelle ligne en utilisant par " +"exemple 'echo >> file’ pour éviter ce problème " + +#: fread.c:1530 +#, c-format +msgid " File ends abruptly with '%c'. Copying file in RAM. %s copy.\n" +msgstr "" +" Le fichier se termine brusquement par '%c'. Copie d'un fichier en RAM. %s " +"copie.\n" + +#: fread.c:1564 +msgid "[05] Skipping initial rows if needed\n" +msgstr "[05] Sauter les premières lignes si nécessaire\n" + +#: fread.c:1570 +#, c-format +msgid "" +"skip='%s' not found in input (it is case sensitive and literal; i.e., no " +"patterns, wildcards or regex)" +msgstr "" +"skip='%s' n'a pas été trouvé dans l'entrée (il est sensible à la casse et " +"littéral, c'est-à-dire qu'il n'y a pas de motifs, de caractères génériques " +"ou d'expressions rationnelles)" + +#: fread.c:1576 +#, c-format +msgid "" +"Found skip='%s' on line %. Taking this to be header row or first row " +"of data.\n" +msgstr "" +"A trouvé skip='%s' sur la ligne %. Il s'agit de la ligne d'en-tête " +"ou de la première ligne de données.\n" + +#: fread.c:1589 +#, c-format +msgid " Skipped to line % in the file" +msgstr " A Sauté à la ligne % dans le fichier" + +#: fread.c:1590 +#, c-format +msgid "skip=% but the input only has % line%s" +msgstr "skip=% mais l'entrée ne contient que la ligne %%s" + +#: fread.c:1599 +msgid "" +"Input is either empty, fully whitespace, or skip has been set after the last " +"non-whitespace." +msgstr "" +"L'entrée est soit vide, soit pleine d'espaces blancs, soit le saut a été " +"activé après le dernier espace non blanc." + +#: fread.c:1601 +#, c-format +msgid " Moved forward to first non-blank line (%d)\n" +msgstr " A avancé à la première ligne non vide (%d)\n" + +#: fread.c:1602 +#, c-format +msgid " Positioned on line %d starting: <<%s>>\n" +msgstr " Positionné sur la ligne %d à partir de : <<%s>>\n" + +#: fread.c:1624 +msgid "[06] Detect separator, quoting rule, and ncolumns\n" +msgstr "[06] Détecte le séparateur, la règle des guillemets et ‘ncolumns’\n" + +#: fread.c:1628 +msgid " sep='\\n' passed in meaning read lines as single character column\n" +msgstr "" +" sep='\\n' passé en argument, ce qui signifie que les lignes sont lues " +"comme une seule colonne de caractères\n" + +#: fread.c:1647 +msgid " Detecting sep automatically ...\n" +msgstr " Détection automatique du séparateur ...\n" + +#: fread.c:1654 +#, c-format +msgid " Using supplied sep '%s'\n" +msgstr " Utilisation du séparateur fourni '%s'\n" + +#: fread.c:1688 +#, c-format +msgid " with %d fields using quote rule %d\n" +msgstr " avec des champs %d en utilisant la règle des guillemets %d\n" + +#: fread.c:1738 +#, c-format +msgid " with %d lines of %d fields using quote rule %d\n" +msgstr "" +" avec %d lignes de %d champs en utilisant la règle des guillemets %d\n" + +#: fread.c:1745 +msgid "" +" No sep and quote rule found a block of 2x2 or greater. Single column " +"input.\n" +msgstr "" +" Aucune règle de séparateur et de guillemets n'a été trouvée dans un bloc " +"de taille 2 x 2 ou plus. Saisie d'une seule colonne.\n" + +#: fread.c:1761 +msgid "" +"Single column input contains invalid quotes. Self healing only effective " +"when ncol>1" +msgstr "" +"La saisie d'une seule colonne contient des guillemets non valides. L'auto-" +"réparation n'est effective que lorsque ncol>1" + +#: fread.c:1766 +#, c-format +msgid "" +"Found and resolved improper quoting in first %d rows. If the fields are not " +"quoted (e.g. field separator does not appear within any field), try " +"quote=\"\" to avoid this warning." +msgstr "" +"Une erreur de guillemets a été détectée et résolue dans les %d premières " +"lignes. Si les champs ne sont pas entre guillemets (par exemple, le " +"séparateur de champ n'apparaît dans aucun champ), essayez quote=\"\" pour " +"éviter cet avis." + +#: fread.c:1787 +#, c-format +msgid "" +" Detected %d columns on line %d. This line is either column names or first " +"data row. Line starts as: <<%s>>\n" +msgstr "" +" Détection de %d colonnes sur la ligne %d. Cette ligne est soit le nom des " +"colonnes, soit la première ligne des données. La ligne commence comme suit : " +"<<%s>>\n" + +#: fread.c:1789 +#, c-format +msgid " Quote rule picked = %d\n" +msgstr " Règle de guillemets choisie = %d\n" + +#: fread.c:1790 +#, c-format +msgid " fill=%s and the most number of columns found is %d\n" +msgstr " fill=%s et le plus grand nombre de colonnes trouvées est %d\n" + +#: fread.c:1796 +msgid "" +"This file is very unusual: it's one single column, ends with 2 or more end-" +"of-line (representing several NA at the end), and is a multiple of 4096, too." +msgstr "" +"Ce fichier est très inhabituel : il ne comporte qu'une seule colonne, se " +"termine par 2 ou plusieurs fins de ligne (représentant plusieurs NA à la " +"fin), et est également un multiple de 4096." + +#: fread.c:1797 +#, c-format +msgid " Copying file in RAM. %s\n" +msgstr " Copie du fichier dans la RAM. %s\n" + +#: fread.c:1803 +msgid "" +" 1-column file ends with 2 or more end-of-line. Restoring last eol using " +"extra byte in cow page.\n" +msgstr "" +" un fichier à 1 colonne se termine par 2 fins de ligne ou plus. " +"Restauration de la dernière ligne en utilisant un octet supplémentaire dans " +"la page ‘Copy-On-Write’.\n" + +#: fread.c:1822 +msgid "" +"[07] Detect column types, dec, good nrow estimate and whether first row is " +"column names\n" +msgstr "" +"[07] Détecte les types des colonnes, le séparateur dec, une bonne estimation " +"de nrows et si la première ligne est constituée de noms de colonnes\n" + +#: fread.c:1823 +#, c-format +msgid " 'header' changed by user from 'auto' to %s\n" +msgstr " 'header' changé par l'utilisateur de 'auto' à %s\n" + +#: fread.c:1829 +#, c-format +msgid "Failed to allocate 2 x %d bytes for type and tmpType: %s" +msgstr "Échec de l'allocation de 2 x %d octets pour le type et tmpType : %s" + +#: fread.c:1834 +msgid " sep=',' so dec set to '.'\n" +msgstr " sep=',' donc dec est fixé à '.'\n" + +#: fread.c:1858 +#, c-format +msgid " Number of sampling jump points = %d because " +msgstr " Nombre de points de saut d'échantillonnage = %d car " + +#: fread.c:1859 +#, c-format +msgid "nrow limit (%) supplied\n" +msgstr "limite pour nrow (%) fournie\n" + +#: fread.c:1860 +msgid "jump0size==0\n" +msgstr "jump0size==0\n" + +#: fread.c:1861 +#, c-format +msgid "" +"(% bytes from row 1 to eof) / (2 * % jump0size) == " +"%\n" +msgstr "" +"(% octets de la ligne 1 à eof) / (2 * % jump0size) == " +"%\n" + +#: fread.c:1900 +#, c-format +msgid "" +" A line with too-%s fields (%d/%d) was found on line %d of sample jump %d. " +"%s\n" +msgstr "" +" Une ligne avec trop de champs %s (%d/%d) a été trouvée sur la ligne %d du " +"saut d'échantillon %d. %s\n" + +#: fread.c:1901 +msgid "few" +msgstr "peu" + +#: fread.c:1901 +msgid "many" +msgstr "beaucoup" + +#: fread.c:1901 +msgid "" +"Most likely this jump landed awkwardly so type bumps here will be skipped." +msgstr "" +"Il est probable que ce saut soit présent par erreur, les changements de type " +"seront donc ignorés." + +#: fread.c:1924 fread.c:1950 +#, c-format +msgid " dec='%c' detected based on a balance of %d parsed fields\n" +msgstr " dec='%c' détecté sur la base d'un solde de %d champs analysés\n" + +#: fread.c:1934 +#, c-format +msgid " Type codes (jump %03d) : %s Quote rule %d\n" +msgstr " Codes de type (saut %03d) : %s guillemets %d\n" + +#: fread.c:1956 +#, c-format +msgid "" +" 'header' determined to be true due to column %d containing a string on row " +"1 and a lower type (%s) in the rest of the % sample rows\n" +msgstr "" +" ‘header’ défini à TRUE parce que la colonne %d contient une chaîne de " +"caractères à la ligne 1 et un type inférieur (%s) dans le reste des lignes " +"de l'échantillon % \n" + +#: fread.c:1970 +#, c-format +msgid "" +"Types in 1st data row match types in 2nd data row but previous row has %d " +"fields. Taking previous row as column names." +msgstr "" +"Les types de la première ligne de données correspondent aux types de la " +"deuxième ligne de données, mais la ligne précédente comporte %d champs. " +"Prendre la ligne précédente comme celle des noms de colonne." + +#: fread.c:1973 +#, c-format +msgid "" +"Detected %d column names but the data has %d columns (i.e. invalid file). " +"Added %d extra default column name%s\n" +msgstr "" +"A détecté %d noms de colonnes mais les données ont %d colonnes (c.-à-d. " +"fichier invalide). Ajout de %d noms de colonnes supplémentaires par " +"défaut%s\n" + +#: fread.c:1974 +msgid "" +" for the first column which is guessed to be row names or an index. Use " +"setnames() afterwards if this guess is not correct, or fix the file write " +"command that created the file to create a valid file." +msgstr "" +" pour la première colonne qui est supposée être un nom de ligne ou un " +"indice. Utilisez setnames() par la suite si cette proposition n'est pas " +"correcte, ou corrigez la commande d'écriture du fichier qui a créé le " +"fichier afin de créer un fichier valide." + +#: fread.c:1974 +msgid "s at the end." +msgstr "’s’ à la fin." + +#: fread.c:1977 +#, c-format +msgid "" +"Detected %d column names but the data has %d columns. Filling rows " +"automatically. Set fill=TRUE explicitly to avoid this warning.\n" +msgstr "" +"A détecté %d noms de colonnes mais les données ont %d colonnes. Remplissage " +"automatique des lignes. Définir explicitement fill=TRUE pour éviter cet " +"avis.\n" + +#: fread.c:1981 +#, c-format +msgid "Failed to realloc 2 x %d bytes for type and tmpType: %s" +msgstr "Échec de la réallocation de 2 x %d octets pour type et tmpType : %s" + +#: fread.c:2001 +#, c-format +msgid "" +" 'header' determined to be %s because there are%s number fields in the " +"first and only row\n" +msgstr "" +" l'en-tête est déterminé comme étant %s parce qu'il y a des champs " +"numériques %s dans la première et unique ligne\n" + +#: fread.c:2001 +msgid " no" +msgstr " non" + +#: fread.c:2004 +msgid "" +" 'header' determined to be true because all columns are type string and a " +"better guess is not possible\n" +msgstr "" +" 'header' défini à comme TRUE parce que toutes les colonnes sont de type " +"string et un meilleur choix n'est pas possible\n" + +#: fread.c:2006 +msgid "" +" 'header' determined to be false because there are some number columns and " +"those columns do not have a string field at the top of them\n" +msgstr "" +" 'header' défini à FALSE parce qu'il y a des colonnes de nombres et que ces " +"colonnes n'ont pas de champ de type 'string' en haut de celles-ci\n" + +#: fread.c:2022 +#, c-format +msgid " Type codes (first row) : %s Quote rule %d\n" +msgstr " Codes de type (première ligne) : %s Règle des guillemets %d\n" + +#: fread.c:2031 +#, c-format +msgid "" +" All rows were sampled since file is small so we know nrow=% " +"exactly\n" +msgstr "" +" Toutes les lignes ont été échantillonnées car le fichier est petit et nous " +"savons exactement que nrow=% \n" + +#: fread.c:2043 fread.c:2050 +msgid " =====\n" +msgstr " =====\n" + +#: fread.c:2044 +#, c-format +msgid "" +" Sampled % rows (handled \\n inside quoted fields) at %d jump " +"points\n" +msgstr "" +" % lignes échantillonnés (traitées à l'intérieur de champs entre " +"guillemets) aux %d points de saut \n" + +#: fread.c:2045 +#, c-format +msgid "" +" Bytes from first data row on line %d to the end of last row: %\n" +msgstr "" +" Octets de la première ligne de données de la ligne %d à la fin de la " +"dernière ligne : %\n" + +#: fread.c:2046 +#, c-format +msgid " Line length: mean=%.2f sd=%.2f min=%d max=%d\n" +msgstr " Longueur de la ligne : mean=%.2f sd=%.2f min=%d max=%d\n" + +#: fread.c:2047 +#, c-format +msgid " Estimated number of rows: % / %.2f = %\n" +msgstr " Nombre estimé de lignes : % / %.2f = %\n" + +#: fread.c:2048 +#, c-format +msgid "" +" Initial alloc = % rows (% + %d%%) using bytes/" +"max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]\n" +msgstr "" +" Allocation initiale = % lignes (% + %d%%) en utilisant des " +"octets/max(mean-2*sd,min), restreint à l’intervalle [1.1*estn, 2.0*estn]\n" + +#: fread.c:2056 +#, c-format +msgid " Alloc limited to lower nrows=% passed in.\n" +msgstr "" +" Allocation limitée aux nrows inférieurs=% passé en argument.\n" + +#: fread.c:2068 +msgid "[08] Assign column names\n" +msgstr "[08] Attribuez des noms de colonnes\n" + +#: fread.c:2077 +#, c-format +msgid "Unable to allocate %d*%d bytes for column name pointers: %s" +msgstr "" +"Impossible d'allouer %d*%d octets pour les pointeurs des noms de colonnes : " +"%s" + +#: fread.c:2117 +msgid "[09] Apply user overrides on column types\n" +msgstr "" +"[09] Appliquer les substitutions de l'utilisateur aux types de colonnes\n" + +#: fread.c:2121 +msgid " Cancelled by user: userOverride() returned false." +msgstr " Annulé par l'utilisateur : userOverride() a retourné false." + +#: fread.c:2132 +#, c-format +msgid "Failed to allocate %d bytes for '%s': %s" +msgstr "Échec de l'allocation de %d octets pour '%s' : %s" + +#: fread.c:2139 +#, c-format +msgid "" +"Attempt to override column %d%s%.*s%s of inherent type '%s' down to '%s' " +"ignored. Only overrides to a higher type are currently supported. If this " +"was intended, please coerce to the lower type afterwards." +msgstr "" +"Tentative de remplacer la colonne %d%s%.*s%s du type inhérent '%s' vers '%s' " +"ignorée. Seules les remplacements vers un type supérieur sont actuellement " +"prises en charge. Si c'est ce qui était prévu, veuillez contraindre un type " +"inférieur par la suite." + +#: fread.c:2154 +#, c-format +msgid " After %d type and %d drop user overrides : %s\n" +msgstr "" +" Après %d remplacements de type et %d suppressions par l’utilisateur : %s\n" + +#: fread.c:2162 +msgid "[10] Allocate memory for the datatable\n" +msgstr "[10] Allouer de la mémoire pour le tableau de données\n" + +#: fread.c:2163 +#, c-format +msgid " Allocating %d column slots (%d - %d dropped) with % rows\n" +msgstr "" +" Attribution des emplacements de colonne %d (%d - %d abandonnés) avec " +"% lignes \n" + +#: fread.c:2218 +#, c-format +msgid "Buffer size % is too large\n" +msgstr "La taille de la mémoire tampon % est trop grande\n" + +#: fread.c:2221 +msgid "[11] Read the data\n" +msgstr "[11] Lire les données\n" + +#: fread.c:2224 +#, c-format +msgid " jumps=[%d..%d), chunk_size=%, total_size=%\n" +msgstr " jumps=[%d..%d), chunk_size=%, total_size=%\n" + +#: fread.c:2450 +#, c-format +msgid "" +"Column %d%s%.*s%s bumped from '%s' to '%s' due to <<%.*s>> on row %\n" +msgstr "" +"La colonne %d%s%.*s%s a été augmentée de ‘%s’ à ‘%s’ en raison de <<%.*s>> à " +"la ligne %\n" + +#: fread.c:2568 +#, c-format +msgid " Provided number of fill columns: %d but only found %d\n" +msgstr "" +" Nombre de colonnes \"fill\" fournies : %d, mais je n’en ai rencontré que " +"%d\n" + +#: fread.c:2569 +#, c-format +msgid " Dropping %d overallocated columns\n" +msgstr " Suppression de %d colonnes surallouées\n" + +#: fread.c:2587 +msgid "Please report to the data.table issues tracker" +msgstr "" +"Veuillez signaler l'erreur au gestionnaire de tickets (issue tracker) de " +"data.table" + +#: fread.c:2594 +#, c-format +msgid "" +" Too few rows allocated. Allocating additional % rows (now " +"nrows=%) and continue reading from jump %d\n" +msgstr "" +" Trop peu de lignes allouées. Allocation de % lignes " +"supplémentaires (maintenant nrows=%) et poursuite de la lecture à " +"partir du saut %d\n" + +#: fread.c:2601 +#, c-format +msgid " Restarting team from jump %d. nSwept==%d quoteRule==%d\n" +msgstr "" +" Redémarrage de ‘team’ à partir du saut %d. nSwept==%d quoteRule==%d\n" + +#: fread.c:2621 +#, c-format +msgid " %d out-of-sample type bumps: %s\n" +msgstr " %d changement de type hors échantillon : %s\n" + +#: fread.c:2656 +#, c-format +msgid "" +"Read % rows x %d columns from %s file in %02d:%06.3f wall clock " +"time\n" +msgstr "" +"Lire % lignes x %d colonnes du fichier %s dans %02d:%06.3f heure de " +"l'horloge\n" + +#: fread.c:2663 +msgid "[12] Finalizing the datatable\n" +msgstr "[12] Finalisation de la table de données\n" + +#: fread.c:2664 +msgid " Type counts:\n" +msgstr " Comptage des types :\n" + +#: fread.c:2666 +#, c-format +msgid "%10d : %-9s '%c'\n" +msgstr "%10d : %-9s '%c'\n" + +#: fread.c:2682 +#, c-format +msgid "Discarded single-line footer: <<%s>>" +msgstr "Pied de page d'une seule ligne supprimé : <<%s>>" + +#: fread.c:2688 +#, c-format +msgid "" +"Stopped early on line %. Expected %d fields but found %d. Consider " +"fill=%d or even more based on your knowledge of the input file. Use fill=Inf " +"for reading the whole file for detecting the number of fields. First " +"discarded non-empty line: <<%s>>" +msgstr "" +"Arrêt prématuré à la ligne %. %d champs attendus mais %d sont " +"rencontrés. Considérez fill=%d ou même plus, en fonction de ce que vous " +"connaissez sur le fichier en entrée. Utilisez fill=Inf pour lire tout le " +"fichier afin de détecter le nombre de champs. Première ligne non vide " +"supprimée : <<%s>>" + +#: fread.c:2691 +#, c-format +msgid "" +"Stopped early on line %. Expected %d fields but found %d. Consider " +"fill=TRUE and comment.char=. First discarded non-empty line: <<%s>>" +msgstr "" +"Arrêt prématuré à la ligne %. %d champs attendus mais a trouvé %d. " +"Considérer fill=TRUE et comment.char=. Première ligne non vide supprimée : " +"<<%s>" + +#: fread.c:2698 +#, c-format +msgid "" +"Found and resolved improper quoting out-of-sample. First healed line " +"%: <<%s>>. If the fields are not quoted (e.g. field separator does " +"not appear within any field), try quote=\"\" to avoid this warning." +msgstr "" +"Une recherche hors de l'échantillon a été trouvé et corrigé. Première ligne " +"transformée %: <<%s>>. Si les champs ne sont pas entre guillemets " +"(par exemple, le séparateur de champ n'apparaît dans aucun champ), essayez " +"quote=\"\" pour éviter cet avis." + +#: fread.c:2702 +msgid "=============================\n" +msgstr "=============================\n" + +#: fread.c:2704 +#, c-format +msgid "%8.3fs (%3.0f%%) Memory map %.3fGB file\n" +msgstr "%8.3fs (%3.0f%%) mappage de mémoire du fichier %.3fGo\n" + +#: fread.c:2705 +#, c-format +msgid "%8.3fs (%3.0f%%) sep=" +msgstr "%8.3fs (%3.0f%%) sep=" + +#: fread.c:2707 +#, c-format +msgid " ncol=%d and header detection\n" +msgstr " ncol=%d et détection de l'en-tête\n" + +#: fread.c:2708 +#, c-format +msgid "%8.3fs (%3.0f%%) Column type detection using % sample rows\n" +msgstr "" +"%8.3fs (%3.0f%%) Détection du type de colonne à l'aide de % lignes " +"d'échantillons\n" + +#: fread.c:2710 +#, c-format +msgid "" +"%8.3fs (%3.0f%%) Allocation of % rows x %d cols (%.3fGB) of which " +"% (%3.0f%%) rows used\n" +msgstr "" +"%8.3fs (%3.0f%%) Allocation de % lignes x %d colonnes (%.3fGB) dont " +"% (%3.0f%%) lignes utilisées\n" + +#: fread.c:2714 +#, c-format +msgid "" +"%8.3fs (%3.0f%%) Reading %d chunks (%d swept) of %.3fMB (each chunk %d rows) " +"using %d threads\n" +msgstr "" +"%8.3fs (%3.0f%%) Lecture de %d morceaux (%d balayés) de %.3fMo (chaque " +"morceau comporte %d lignes) à l'aide de %d threads\n" + +#: fread.c:2716 +#, c-format +msgid "" +" + %8.3fs (%3.0f%%) Parse to row-major thread buffers (grown %d times)\n" +msgstr "" +" + %8.3fs (%3.0f%%) Analyse en mémoire tampons de threads en format 'row-" +"major' (augmenté %d fois)\n" + +#: fread.c:2717 +#, c-format +msgid " + %8.3fs (%3.0f%%) Transpose\n" +msgstr " + %8.3fs (%3.0f%%) Transposition\n" + +#: fread.c:2718 +#, c-format +msgid " + %8.3fs (%3.0f%%) Waiting\n" +msgstr " + %8.3fs (%3.0f%%) Attente\n" + +#: fread.c:2719 +#, c-format +msgid "" +"%8.3fs (%3.0f%%) Rereading %d columns due to out-of-sample type exceptions\n" +msgstr "" +"%8.3fs (%3.0f%%) Relecture de %d colonnes en raison d'exceptions de type " +"hors échantillon\n" + +#: fread.c:2721 +#, c-format +msgid "%8.3fs Total\n" +msgstr "%8.3fs Total\n" + +#: freadR.c:92 +#, c-format +msgid "freadR.c has been passed a filename: %s\n" +msgstr "'freadR.c' a reçu pour argument un nom de fichier : %s\n" + +#: freadR.c:96 +msgid "freadR.c has been passed the data as text input (not a filename)\n" +msgstr "" +"'freadR.c' a reçu pour argument les données sous forme de texte (et non pas " +"un nom de fichier)\n" + +#: freadR.c:114 +msgid "quote= must be a single character, blank \"\", or FALSE" +msgstr "quote= doit être un caractère unique, un blanc \"\", ou FALSE" + +#: freadR.c:158 +#, c-format +msgid "nThread(%d)<1" +msgstr "nThread(%d)<1" + +#: freadR.c:166 +msgid "'integer64' must be a single character string" +msgstr "'integer64' doit être une chaîne de caractères unique" + +#: freadR.c:174 +#, c-format +msgid "" +"Invalid value integer64='%s'. Must be 'integer64', 'character', 'double' or " +"'numeric'" +msgstr "" +"Valeur non valide integer64='%s'. Doit être 'integer64', 'character', " +"'double' (nombre à virgule flottante) ou 'numeric'" + +#: freadR.c:182 +msgid "Use either select= or drop= but not both." +msgstr "Utilisez soit select=, soit drop=, mais pas les deux." + +#: freadR.c:185 +msgid "" +"select= is type list for specifying types in select=, but colClasses= has " +"been provided as well. Please remove colClasses=." +msgstr "" +"select= est de type list permettant de spécifier des types dans select=, " +"mais colClasses= a également été fourni. Veuillez supprimer colClasses=." + +#: freadR.c:187 +msgid "" +"select= is type list but has no names; expecting list(type1=cols1, " +"type2=cols2, ...)" +msgstr "" +"select= est de type list mais n'a pas de nom ; il est attendu " +"list(type1=cols1, type2=cols2, ...)" + +#: freadR.c:194 +msgid "" +"select= is a named vector specifying the columns to select and their types, " +"but colClasses= has been provided as well. Please remove colClasses=." +msgstr "" +"select= est un vecteur spécifiant les colonnes à sélectionner et leurs " +"types, mais colClasses= a également été fourni. Veuillez supprimer " +"colClasses=." + +#: freadR.c:202 freadR.c:368 +msgid "colClasses is type list but has no names" +msgstr "colClasses est de type list mais n'a pas de nom" + +#: freadR.c:212 +#, c-format +msgid "encoding='%s' invalid. Must be 'unknown', 'Latin-1' or 'UTF-8'" +msgstr "encoding='%s' invalide. Doit être 'unknown', 'Latin-1' ou 'UTF-8'" + +#: freadR.c:235 +#, c-format +msgid "Column name '%s' (%s) not found" +msgstr "Nom de colonne '%s' (%s) introuvable" + +#: freadR.c:237 +#, c-format +msgid "%s is NA" +msgstr "%s est NA" + +#: freadR.c:239 +#, c-format +msgid "%s is %d which is out of range [1,ncol=%d]" +msgstr "%s est %d, ce qui est en dehors de l’intervalle [1,ncol=%d]" + +#: freadR.c:288 +#, c-format +msgid "" +"Column name '%s' not found in column name header (case sensitive), skipping." +msgstr "" +"Le nom de colonne '%s' n'a pas été trouvé dans l'en-tête du nom de colonne " +"(sensible à la casse), il est ignoré." + +#: freadR.c:298 +#, c-format +msgid "" +"Column number %d (select[%d]) is negative but should be in the range [1," +"ncol=%d]. Consider drop= for column exclusion." +msgstr "" +"Le numéro de colonne %d (select[%d]) est négatif mais devrait être compris " +"dans l'intervalle [1,ncol=%d]. Envisager drop= pour l'exclusion de colonnes." + +#: freadR.c:299 +#, c-format +msgid "" +"select = 0 (select[%d]) has no meaning. All values of select should be in " +"the range [1,ncol=%d]." +msgstr "" +"select = 0 (select[%d]) n'a aucune signification. Toutes les valeurs de " +"select doivent être comprises dans l'intervalle [1,ncol=%d]." + +#: freadR.c:300 +#, c-format +msgid "" +"Column number %d (select[%d]) is too large for this table, which only has %d " +"columns." +msgstr "" +"Le numéro de colonne %d (select[%d]) est trop grand pour ce tableau, il ne " +"comporte que %d colonnes." + +#: freadR.c:301 +#, c-format +msgid "Column number %d ('%s') has been selected twice by select=" +msgstr "Le numéro de colonne %d ('%s') a été sélectionné deux fois par select=" + +#: freadR.c:324 +#, c-format +msgid "" +"colClasses= is an unnamed vector of types, length %d, but there are %d " +"columns in the input. To specify types for a subset of columns, you can use " +"a named vector, list format, or specify types using select= instead of " +"colClasses=. Please see examples in ?fread." +msgstr "" +"colClasses= est un vecteur de types sans nom, de longueur %d, mais il y a %d " +"colonnes dans l'entrée. Pour spécifier des types pour un sous-ensemble de " +"colonnes, vous pouvez utiliser un vecteur nommé, un format de liste ou " +"spécifier des types en utilisant select= au lieu de colClasses=. Voir les " +"exemples dans ?fread." + +#: freadR.c:366 +#, c-format +msgid "colClasses is type '%s' but should be list or character" +msgstr "" +"colClasses est de type '%s' mais devrait être une liste ou un caractère" + +#: freadR.c:390 +#, c-format +msgid "Column name '%s' (colClasses[[%d]][%d]) not found" +msgstr "Nom de colonne '%s' (colClasses[[%d]][%d]) introuvable" + +#: freadR.c:392 +#, c-format +msgid "colClasses[[%d]][%d] is NA" +msgstr "colClasses[[%d]][%d] est NA" + +#: freadR.c:396 +#, c-format +msgid "Column number %d (colClasses[[%d]][%d]) is out of range [1,ncol=%d]" +msgstr "" +"Le numéro de colonne %d (colClasses[[%d]][%d]) est en dehors de l’intervalle " +"[1,ncol=%d]" + +#: freadR.c:400 +#, c-format +msgid "" +"Column %d ('%s') appears more than once in colClasses. The second time is " +"colClasses[[%d]][%d]." +msgstr "" +"La colonne %d ('%s') apparaît plusieurs fois dans colClasses. La deuxième " +"fois est colClasses[[%d]][%d]." + +#: freadR.c:640 +#, c-format +msgid "Field size is 1 but the field is of type %d\n" +msgstr "La taille du champ est de 1 mais le champ est de type %d\n" + +#: freadR.c:717 utils.c:387 +#, c-format +msgid "%s" +msgstr "%s" + +#: froll.c:14 froll.c:223 froll.c:407 +#, c-format +msgid "%s: window width longer than input vector, returning all NA vector\n" +msgstr "" +"%s : la largeur de la fenêtre est supérieure au vecteur d'entrée, ce qui " +"renvoie tout le vecteur en NA\n" + +#: froll.c:32 froll.c:240 froll.c:456 +#, c-format +msgid "%s: align %d, shift answer by %d\n" +msgstr "%s : aligner %d, décaler la réponse de %d\n" + +#: froll.c:39 froll.c:247 frolladaptive.c:19 frolladaptive.c:214 +#, c-format +msgid "%s: processing algo %u took %.3fs\n" +msgstr "%s : le traitement de l'algo %u a pris %.3fs\n" + +#: froll.c:48 froll.c:251 +#, c-format +msgid "%s: running for input length %, window %d, hasna %d, narm %d\n" +msgstr "" +"%s: exécution pour la longueur de l'entrée %, window %d, hasna %d, " +"narm %d\n" + +#: froll.c:68 froll.c:78 froll.c:169 froll.c:271 froll.c:281 froll.c:362 +#: frolladaptive.c:58 frolladaptive.c:147 frolladaptive.c:247 +#: frolladaptive.c:326 +#, c-format +msgid "" +"%s: hasNA=FALSE used but NA (or other non-finite) value(s) are present in " +"input, use default hasNA=NA to avoid this warning" +msgstr "" +"%s : hasNA=FALSE utilisé mais des valeurs NA (ou autres valeurs non finies) " +"sont présentes dans l'entrée, utiliser la valeur par défaut hasNA=NA pour " +"éviter cet avis" + +#: froll.c:71 froll.c:173 froll.c:274 froll.c:366 frolladaptive.c:61 +#: frolladaptive.c:151 frolladaptive.c:250 frolladaptive.c:330 +#, c-format +msgid "" +"%s: NA (or other non-finite) value(s) are present in input, re-running with " +"extra care for NAs\n" +msgstr "" +"%s : Des NA (ou autre(s) valeur(s) non finie(s)) sont présentes dans " +"l'entrée, ré-exécution avec une attention particulière pour les NA\n" + +#: froll.c:81 froll.c:284 +#, c-format +msgid "" +"%s: NA (or other non-finite) value(s) are present in input, skip non-NA " +"attempt and run with extra care for NAs\n" +msgstr "" +"%s :Des NA (ou autre(s) valeur(s) non finie(s)) sont présentes dans " +"l'entrée, ignorer la tentative sans NA et exécuter avec une attention " +"particulière pour les NA\n" + +#: froll.c:137 froll.c:335 +#, c-format +msgid "" +"%s: running in parallel for input length %, window %d, hasna %d, " +"narm %d\n" +msgstr "" +"%s: exécution en parallèle pour une longueur d'entrée %, window %d, " +"hasna %d, narm %d\n" + +#: froll.c:175 froll.c:368 frolladaptive.c:153 frolladaptive.c:332 +#, c-format +msgid "" +"%s: NA (or other non-finite) value(s) are present in input, na.rm was FALSE " +"so in 'exact' implementation NAs were handled already, no need to re-run\n" +msgstr "" +"%s : Des valeurs NA (ou autre(s) valeur(s) non finie(s)) sont présentes dans " +"l'entrée, na.rm était FALSE donc dans l'implémentation ‘exacte’ les NA ont " +"déjà été traités, pas besoin de ré-exécuter\n" + +#: froll.c:424 +#, c-format +msgid "%s: results from provided FUN are not length 1" +msgstr "%s : les résultats de FUN obtenus ne sont pas de longueur 1" + +#: froll.c:431 +#, c-format +msgid "" +"%s: results from provided FUN are not of type double, coercion from integer " +"or logical will be applied on each iteration\n" +msgstr "" +"%s : les résultats de FUN obtenus ne sont pas de type 'double' (nombre à " +"virgule flottante), un forçage pour les types entier et booléen sera " +"appliquée à chaque itération\n" + +#: froll.c:434 +#, c-format +msgid "%s: results from provided FUN are not of type double" +msgstr "" +"%s : les résultats de FUN obtenus ne sont pas de type ‘double’ (nombre à " +"virgule flottante)" + +#: froll.c:463 nafill.c:87 +#, c-format +msgid "%s: took %.3fs\n" +msgstr "%s : a pris %.3fs\n" + +#: frollR.c:17 +msgid "" +"x must be of type numeric or logical, or a list, data.frame or data.table of " +"such" +msgstr "" +"x doit être de type numérique ou booléen, ou une liste, un data.frame ou un " +"data.table de ce type" + +#: frollR.c:38 frollR.c:244 +msgid "n must be non 0 length" +msgstr "n doit pas être de longueur 0" + +#: frollR.c:49 +msgid "n must be integer, list is accepted for adaptive TRUE" +msgstr "n doit être un entier, la liste est acceptée pour adaptative TRUE" + +#: frollR.c:56 frollR.c:236 frollR.c:239 +msgid "n must be integer" +msgstr "n doit être un nombre entier" + +#: frollR.c:63 +msgid "n must be positive integer values (> 0)" +msgstr "n doit être un nombre entier positif (> 0)" + +#: frollR.c:72 frollR.c:84 +msgid "n must be integer vector or list of integer vectors" +msgstr "n doit être un vecteur d’entiers ou une liste de vecteurs d’entiers" + +#: frollR.c:98 +msgid "hasNA must be TRUE, FALSE or NA" +msgstr "hasNA doit être TRUE, FALSE ou NA" + +#: frollR.c:100 +msgid "" +"using hasNA FALSE and na.rm TRUE does not make sense, if you know there are " +"NA values use hasNA TRUE, otherwise leave it as default NA" +msgstr "" +"utiliser hasNA FALSE et na.rm TRUE n'a pas de sens, si vous savez qu'il y a " +"des valeurs NA, utilisez hasNA TRUE, sinon laissez la valeur NA par défaut" + +#: frollR.c:113 +msgid "" +"using adaptive TRUE and align argument different than 'right' is not " +"implemented" +msgstr "" +"l'utilisation de adaptative TRUE et d'un argument align différent de ‘right’ " +"n'est pas implémentée" + +#: frollR.c:117 frollR.c:267 types.c:64 +#, c-format +msgid "%s: allocating memory for results %dx%d\n" +msgstr "%s : allocation de mémoire pour les résultats %dx%d\n" + +#: frollR.c:126 +msgid "" +"adaptive rolling function can only process 'x' having equal length of " +"elements, like data.table or data.frame; If you want to call rolling " +"function on list having variable length of elements call it for each field " +"separately" +msgstr "" +"la fonction de roulement adaptative ne peut traiter que des 'x' ayant une " +"longueur égale d'éléments, comme data.table ou data.frame ; si vous voulez " +"appeler la fonction de roulement sur une liste ayant une longueur variable " +"d'éléments, appelez-la pour chaque champ séparément" + +#: frollR.c:128 +msgid "" +"length of integer vector(s) provided as list to 'n' argument must be equal " +"to number of observations provided in 'x'" +msgstr "" +"la longueur du (des) vecteur(s) d’entier(s) fourni(s) sous forme de liste à " +"l'argument ’n’ doit être égale au nombre d'observations fourni dans 'x'" + +#: frollR.c:146 frollR.c:259 gsumm.c:1198 shift.c:21 +msgid "fill must be a vector of length 1" +msgstr "fill doit être un vecteur de longueur 1" + +#: frollR.c:148 frollR.c:261 +msgid "fill must be numeric or logical" +msgstr "fill doit être numérique ou booléen" + +#: frollR.c:178 +#, c-format +msgid "" +"%s: %d column(s) and %d window(s), if product > 1 then entering parallel " +"execution\n" +msgstr "" +"%s : %d colonne(s) et %d fenêtre(s), si produit > 1, entrer dans l'exécution " +"parallèle\n" + +#: frollR.c:180 +#, c-format +msgid "" +"%s: %d column(s) and %d window(s), not entering parallel execution here " +"because algo='exact' will compute results in parallel\n" +msgstr "" +"%s : %d colonne(s) et %d fenêtre(s), pas d'exécution parallèle ici car " +"algo='exact' calculera les résultats en parallèle\n" + +#: frollR.c:207 frollR.c:299 +#, c-format +msgid "%s: processing of %d column(s) and %d window(s) took %.3fs\n" +msgstr "%s : le traitement de %d colonne(s) et de %d fenêtre(s) a pris %.3fs\n" + +#: frolladaptive.c:29 frolladaptive.c:218 +#, c-format +msgid "%s: running for input length %, hasna %d, narm %d\n" +msgstr "" +"%s: recherche de la longueur de l'entrée %, hasna %d, narm %d\n" + +#: frolladaptive.c:35 frolladaptive.c:224 +#, c-format +msgid "%s: Unable to allocate memory for cumsum" +msgstr "%s : Impossible d'allouer de la mémoire pour le cumsum (somme cumulée)" + +#: frolladaptive.c:71 frolladaptive.c:260 +#, c-format +msgid "%s: Unable to allocate memory for cum NA counter" +msgstr "" +"%s : Impossible d'allouer de la mémoire pour le compteur de valeurs " +"manquantes (NA)" + +#: frolladaptive.c:114 frolladaptive.c:298 +#, c-format +msgid "%s: running in parallel for input length %, hasna %d, narm %d\n" +msgstr "" +"%s: exécution en parallèle pour la longueur de l'entrée %, hasna %d, " +"narm %d\n" + +# Doit-t-on traduire le currently, le test est isNumeric(x) +#: fsort.c:107 +msgid "x must be a vector of type double currently" +msgstr "x doit être un vecteur de type 'double' (nombre à virgule flottante)" + +#: fsort.c:118 +#, c-format +msgid "nth=%d, nBatch=%d\n" +msgstr "nth=%d, nBatch=%d\n" + +#: fsort.c:132 +#, c-format +msgid "Failed to allocate %d bytes in fsort()." +msgstr "Échec de l'allocation de %d octets dans fsort()." + +#: fsort.c:158 +#, c-format +msgid "Range = [%g,%g]\n" +msgstr "Intervalle = [%g,%g]\n" + +#: fsort.c:159 +msgid "Cannot yet handle negatives." +msgstr "Ne peux pas encore gérer les valeurs négatives." + +#: fsort.c:174 +#, c-format +msgid "maxBit=%d; MSBNbits=%d; shift=%d; MSBsize=%zu\n" +msgstr "maxBit=%d ; MSBNbits=%d ; shift=%d ; MSBsize=%zu\n" + +#: fsort.c:180 +#, c-format +msgid "" +"counts is %dMB (%d pages per nBatch=%d, batchSize=%, " +"lastBatchSize=%)\n" +msgstr "" +"le comptage est %dMB (%d pages par nBatch=%d, batchSize=%, " +"lastBatchSize=%)\n" + +#: fsort.c:250 +msgid "Top 20 MSB counts: " +msgstr "Top 20 des bits de poids fort (MSB) : " + +#: fsort.c:250 +#, c-format +msgid "% " +msgstr "% " + +#: fsort.c:251 +msgid "Reduced MSBsize from %zu to " +msgstr "Réduction de MSBsize de %zu à " + +#: fsort.c:255 +msgid "%zu by excluding 0 and 1 counts\n" +msgstr "%zu en excluant les comptages pour 0 et 1\n" + +#: fsort.c:321 +#, c-format +msgid "" +"OpenMP %d did not assign threads to iterations monotonically. Please search " +"Stack Overflow for this message." +msgstr "" +"OpenMP %d n'a pas assigné les threads aux itérations de manière monotone. " +"Veuillez rechercher ce message sur Stack Overflow." + +#: fsort.c:323 +msgid "Unable to allocate working memory" +msgstr "Impossible d'allouer de la mémoire de travail" + +#: fsort.c:333 +#, c-format +msgid "%d: %.3f (%4.1f%%)\n" +msgstr "%d : %.3f (%4.1f%%)\n" + +#: fwrite.c:612 +#, c-format +msgid "buffMB=%d outside [1,1024]" +msgstr "buffMB=%d hors limites [1,1024]" + +#: fwrite.c:619 +#, c-format +msgid "" +"eol must be 1 or more bytes (usually either \\n or \\r\\n) but is length %d" +msgstr "" +"eol doit être de taille 1 ou plusieurs octets (généralement \\n ou \\r\\n) " +"mais est de longueur %d" + +#: fwrite.c:622 +msgid "Column writers: " +msgstr "Créateur de colonne : " + +#: fwrite.c:624 fwrite.c:626 fwrite.c:628 +#, c-format +msgid "%d " +msgstr "%d " + +#: fwrite.c:627 +msgid "... " +msgstr "... " + +#: fwrite.c:630 +#, c-format +msgid "" +"\n" +"args.doRowNames=%d args.rowNames=%p args.rowNameFun=%d doQuote=%d args." +"nrow=% args.ncol=%d eolLen=%d\n" +msgstr "" +"\n" +"args.doRowNames=%d args.rowNames=%p args.rowNameFun=%d doQuote=%d args." +"nrow=% args.ncol=%d eolLen=%d\n" + +#: fwrite.c:672 +#, c-format +msgid "maxLineLen=%. Found in %.3fs\n" +msgstr "maxLineLen=%. Trouvé dans %.3fs\n" + +#: fwrite.c:692 +#, c-format +msgid "" +"%s: '%s'. Failed to open existing file for writing. Do you have write " +"permission to it? Is this Windows and does another process such as Excel " +"have it open?" +msgstr "" +"%s : '%s'. Échec de l'ouverture d'un fichier existant en écriture. Avez-vous " +"l'autorisation d'écrire dans ce fichier ? Êtes-vous sur Windows et un autre " +"processus tel qu'Excel l'a-t-il ouvert ?" + +#: fwrite.c:693 +#, c-format +msgid "" +"%s: '%s'. Unable to create new file for writing (it does not exist already). " +"Do you have permission to write here, is there space on the disk and does " +"the path exist?" +msgstr "" +"%s : '%s'. Impossible de créer un nouveau fichier pour l'écriture (il " +"n'existe pas déjà). Avez-vous la permission d'écrire dans le fichier, y a-t-" +"il de l'espace sur le disque et le chemin d'accès existe-t-il ?" + +#: fwrite.c:700 +msgid "" +"Compression in fwrite uses zlib library. Its header files were not found at " +"the time data.table was compiled. To enable fwrite compression, please " +"reinstall data.table and study the output for further guidance." +msgstr "" +"La compression dans fwrite utilise la bibliothèque zlib. Ses fichiers d'en-" +"tête n'ont pas été trouvés au moment de la compilation de data.table. Pour " +"activer la compression de fwrite, veuillez réinstaller data.table et étudier " +"la sortie console pour plus d'informations." + +#: fwrite.c:705 +#, c-format +msgid "Writing bom (%s), yaml (%d characters) and column names (%s) ... " +msgstr "" +"Écriture de BOM (indicateur d’ordre des octets) (%s), yaml (%d caractères) " +"et noms de colonnes (%s) ... " + +#: fwrite.c:719 +#, c-format +msgid "Unable to allocate %zu MiB for header: %s" +msgstr "Impossible d'allouer %zu mébioctets (MiB) pour l'en-tête : %s" + +#: fwrite.c:753 fwrite.c:817 +msgid "Can't allocate gzip stream structure" +msgstr "Impossible d'allouer une structure de flux gzip" + +#: fwrite.c:761 +#, c-format +msgid "Unable to allocate %zu MiB for zbuffer: %s" +msgstr "" +"Impossible d'allouer %zu mébioctets (MiB) pour la mémoire tampon de zlib " +"(zbuffer) : %s" + +#: fwrite.c:777 +#, c-format +msgid "Compress gzip error: %d" +msgstr "Erreur de compression gzip : %d" + +#: fwrite.c:778 fwrite.c:786 +#, c-format +msgid "%s: '%s'" +msgstr "%s : '%s'" + +#: fwrite.c:783 +#, c-format +msgid "done in %.3fs\n" +msgstr "fait en %.3fs\n" + +#: fwrite.c:785 +msgid "No data rows present (nrow==0)\n" +msgstr "Aucune ligne de données présente\n" + +#: fwrite.c:803 +#, c-format +msgid "" +"Writing % rows in %d batches of %d rows (each buffer size %dMB, " +"showProgress=%d, nth=%d)\n" +msgstr "" +"Écriture de % lignes en %d lots de %d lignes (taille de chaque " +"tampon %d Mo, showProgress=%d, nth=%d)\n" + +#: fwrite.c:819 +#, c-format +msgid "zbuffSize=%d returned from deflateBound\n" +msgstr "zbuffSize=%d renvoyé par deflateBound\n" + +#: fwrite.c:828 +#, c-format +msgid "" +"Unable to allocate %zu MB * %d thread buffers; '%d: %s'. Please read ?fwrite " +"for nThread, buffMB and verbose options." +msgstr "" +"Impossible d'allouer %zu Mo * %d pour la mémoire tampon des threads; '%d : " +"%s'. Veuillez lire ?fwrite pour les options nThread, buffMB et verbose." + +#: fwrite.c:839 +#, c-format +msgid "" +"Unable to allocate %zu MB * %d thread compressed buffers; '%d: %s'. Please " +"read ?fwrite for nThread, buffMB and verbose options." +msgstr "" +"Impossible d'allouer %zu Mo * %d pour la mémoire tampon compressée des " +"threads; '%d : %s'. Veuillez lire ?fwrite pour les options nThread, buffMB " +"et verbose." + +#: fwrite.c:853 +#, c-format +msgid "Failed to allocated %d bytes for '%s'." +msgstr "Échec de l'allocation de %d octets pour ‘%s’." + +#: fwrite.c:1019 +#, c-format +msgid "" +"zlib %s (zlib.h %s) deflate() returned error %d with z_stream->msg==\"%s\" " +"Z_FINISH=%d Z_BLOCK=%d. %s" +msgstr "" +"zlib %s (zlib.h %s) deflate() renvoie l'erreur %d avec z_stream->msg==\"%s\" " +"Z_FINISH=%d Z_BLOCK=%d. %s" + +#: fwrite.c:1021 +msgid "" +"Please include the full output above and below this message in your data." +"table bug report." +msgstr "" +"Veuillez inclure la sortie complète au-dessus et au-dessous de ce message " +"dans votre rapport de bogue data.table." + +#: fwrite.c:1022 +msgid "" +"Please retry fwrite() with verbose=TRUE and include the full output with " +"your data.table bug report." +msgstr "" +"Veuillez réutiliser fwrite() avec verbose=TRUE et incluez la sortie complète " +"dans votre rapport de bogue data.table." + +#: fwriteR.c:103 +#, c-format +msgid "" +"Row % of list column is type '%s' - not yet implemented. fwrite() " +"can write list columns containing items which are atomic vectors of type " +"logical, integer, integer64, double, complex and character." +msgstr "" +"La ligne % de la colonne de type liste est de type '%s' - pas encore " +"implémenté. fwrite() peut écrire des colonnes de liste contenant des " +"éléments qui sont des vecteurs atomiques de type booléen, entier, integer64, " +"double, complexe et caractère." + +#: fwriteR.c:176 +msgid "" +"fwrite must be passed an object of type list; e.g. data.frame, data.table" +msgstr "" +"'fwrite' doit recevoir un objet de type liste ; par exemple data.frame, data." +"table" + +#: fwriteR.c:186 +msgid "fwrite was passed an empty list of no columns. Nothing to write." +msgstr "'fwrite' a reçu une liste vide sans colonnes. Rien à écrire." + +#: fwriteR.c:240 +#, c-format +msgid "" +"Column %d's length (%d) is not the same as column 1's length (%)" +msgstr "" +"La longueur de la colonne %d(%d) n'est pas la même que celle de la colonne 1 " +"(%)" + +#: fwriteR.c:244 +#, c-format +msgid "Column %d's type is '%s' - not yet implemented in fwrite." +msgstr "Le type de la colonne %d est '%s' - pas encore implémenté dans fwrite." + +#: fwriteR.c:267 +#, c-format +msgid "" +"input has specific integer rownames but their length (%lld) != nrow " +"(%)" +msgstr "" +"l'entrée a des entiers comme noms de lignes mais leur longueur (%lld) != " +"nrow (%)" + +#: fwriteR.c:282 +msgid "" +"No list columns are present. Setting sep2='' otherwise quote='auto' would " +"quote fields containing sep2.\n" +msgstr "" +"Aucune colonne de type liste n'est présente. Si l'on définit sep2='' ou " +"quote='auto', les champs contenant sep2 seront mis entre guillemets.\n" + +#: fwriteR.c:286 +#, c-format +msgid "" +"If quote='auto', fields will be quoted if the field contains either sep " +"('%c') or sep2 ('%c') because column %d is a list column.\n" +msgstr "" +"Si quote='auto', les champs seront avec des guillemets si le champ contient " +"soit sep ('%c') soit sep2 ('%c') parce que la colonne %d est une colonne de " +"type liste.\n" + +#: fwriteR.c:290 +#, c-format +msgid "" +"sep ('%c'), sep2 ('%c') and dec ('%c') must all be different. Column %d is a " +"list column." +msgstr "" +"sep ('%c'), sep2 ('%c') et dec ('%c') doivent tous être différents. La " +"colonne %d est une colonne de type liste." + +#: gsumm.c:45 gsumm.c:46 gsumm.c:47 +#, c-format +msgid "%s is not an integer vector" +msgstr "%s n'est pas un vecteur entier" + +#: gsumm.c:56 +msgid "irowsArg is neither an integer vector nor NULL" +msgstr "irowsArg n'est ni un vecteur d'entiers ni NULL" + +#: gsumm.c:58 +#, c-format +msgid "length(f)=%d != length(l)=%d" +msgstr "length(f)=%d != length(l)=%d" + +#: gsumm.c:66 +#, c-format +msgid "o has length %d but sum(l)=%d" +msgstr "o a la longueur %d mais sum(l)=%d" + +#: gsumm.c:98 +#, c-format +msgid "gforce initial population of grp took %.3f\n" +msgstr "la population initiale de grp dans gforce a pris %.3f\n" + +#: gsumm.c:118 +msgid "Failed to allocate counts or TMP when assigning g in gforce" +msgstr "" +"Échec de l'allocation de comptages ou de TMP lors de l'affectation de g dans " +"gforce" + +#: gsumm.c:197 +#, c-format +msgid "gforce assign high and low took %.3f\n" +msgstr "l'assignation de high et low dans a pris %.3f\n" + +#: gsumm.c:203 +#, c-format +msgid "gforce eval took %.3f\n" +msgstr "l'évaluation de gforce a pris %.3f\n" + +#: gsumm.c:219 +msgid "gather took ... " +msgstr "gather a pris ... " + +#: gsumm.c:337 +#, c-format +msgid "gather implemented for INTSXP, REALSXP, and CPLXSXP but not '%s'" +msgstr "" +"gather mis en œuvre pour INTSXP, REALSXP et CPLXSXP, mais pas pour '%s'" + +#: gsumm.c:339 gsumm.c:572 gsumm.c:720 +#, c-format +msgid "%.3fs\n" +msgstr "%.3fs\n" + +#: gsumm.c:349 gsumm.c:580 gsumm.c:731 gsumm.c:868 gsumm.c:1023 gsumm.c:1117 +#, c-format +msgid "%s is not meaningful for factors." +msgstr "%s n'a pas de sens pour les facteurs." + +#: gsumm.c:353 +#, c-format +msgid "This gsum (narm=%s) took ... " +msgstr "Ce gsum (narm=%s) a pris ... " + +#: gsumm.c:354 gsumm.c:588 gsumm.c:736 gsumm.c:871 gsumm.c:923 gsumm.c:1025 +#: gsumm.c:1121 +#, c-format +msgid "nrow [%d] != length(x) [%d] in %s" +msgstr "nrow [%d] != length(x) [%d] in %s" + +#: gsumm.c:408 +msgid "" +"The sum of an integer column for a group was more than type 'integer' can " +"hold so the result has been coerced to 'numeric' automatically for " +"convenience." +msgstr "" +"La somme d'une colonne d'entiers pour un groupe a dépassé la capacité du " +"type 'integer', donc le résultat a été automatiquement converti en 'numeric' " +"pour plus de commodité." + +#: gsumm.c:569 gsumm.c:843 gsumm.c:909 gsumm.c:1094 gsumm.c:1166 +#, c-format +msgid "" +"Type '%s' is not supported by GForce %s. Either add the prefix %s or turn " +"off GForce optimization using options(datatable.optimize=1)" +msgstr "" +"Le type '%s' n'est pas supporté par GForce %s. Ajoutez le préfixe %s ou " +"désactivez l'optimisation de GForce en utilisant options(datatable." +"optimize=1)" + +#: gsumm.c:587 +#, c-format +msgid "This gmean took (narm=%s) ... " +msgstr "Ce gmean a pris (narm=%s) ... " + +#: gsumm.c:625 gsumm.c:681 +#, c-format +msgid "Unable to allocate %d * %zu bytes for non-NA counts in gmean na.rm=TRUE" +msgstr "" +"Impossible d'allouer %d * %zu octets pour les comptages non NA dans gmean na." +"rm=TRUE" + +#: gsumm.c:717 +#, c-format +msgid "" +"Type '%s' not supported by GForce mean (gmean). Either add the prefix base::" +"mean(.) or turn off GForce optimization using options(datatable.optimize=1)" +msgstr "" +"Le type '%s' n'est pas supporté par GForce mean (gmean). Ajoutez le préfixe " +"base::mean(.) ou désactivez l'optimisation de GForce en utilisant " +"options(datatable.optimize=1)" + +#: gsumm.c:729 +msgid "" +"GForce min/max can only be applied to columns, not .SD or similar. To find " +"min/max of all items in a list such as .SD, either add the prefix base::min(." +"SD) or turn off GForce optimization using options(datatable.optimize=1). " +"More likely, you may be looking for 'DT[,lapply(.SD,min),by=,.SDcols=]'" +msgstr "" +"GForce min/max ne peut être appliqué qu'aux colonnes, pas aux .SD ou " +"équivalent. Pour trouver le min/max de tous les éléments d'une liste telle " +"que .SD, ajoutez le préfixe base::min(.SD) ou désactivez l'optimisation " +"GForce en utilisant options(datatable.optimize=1). Il est plus probable que " +"vous recherchiez 'DT[,lapply(.SD,min),by=,.SDcols=]'" + +#: gsumm.c:840 +msgid "Type 'complex' has no well-defined min/max" +msgstr "Le type 'complexe' n'a pas de valeur min/max bien définie" + +#: gsumm.c:866 +msgid "" +"GForce median can only be applied to columns, not .SD or similar. To find " +"median of all items in a list such as .SD, either add the prefix stats::" +"median(.SD) or turn off GForce optimization using options(datatable." +"optimize=1). More likely, you may be looking for 'DT[,lapply(.SD,median)," +"by=,.SDcols=]'" +msgstr "" +"GForce median ne peut être appliqué qu'aux colonnes, pas aux .SD ou " +"similaires. Pour trouver la médiane de tous les éléments d'une liste telle " +"que .SD, ajoutez le préfixe stats::median(.SD) ou désactivez l'optimisation " +"GForce en utilisant options(datatable.optimize=1). Il est plus probable que " +"vous recherchiez 'DT[,lapply(.SD,median),by=,.SDcols=]'" + +#: gsumm.c:983 +#, c-format +msgid "" +"Type '%s' is not supported by GForce head/tail/first/last/`[`. Either add " +"the namespace prefix (e.g. utils::head(.)) or turn off GForce optimization " +"using options(datatable.optimize=1)" +msgstr "" +"Le type '%s' n'est pas supporté par GForce head/tail/first/last/`[`. Soit " +"vous ajoutez le préfixe de l'espace de noms (par exemple utils::head(.)), " +"soit vous désactivez l'optimisation de GForce en utilisant options(datatable." +"optimize=1)" + +#: gsumm.c:1021 +msgid "" +"GForce var/sd can only be applied to columns, not .SD or similar. For the " +"full covariance matrix of all items in a list such as .SD, either add the " +"prefix stats::var(.SD) (or stats::sd(.SD)) or turn off GForce optimization " +"using options(datatable.optimize=1). Alternatively, if you only need the " +"diagonal elements, 'DT[,lapply(.SD,var),by=,.SDcols=]' is the optimized way " +"to do this." +msgstr "" +"GForce var/sd ne peut être appliqué qu'aux colonnes, pas aux .SD ou " +"similaires. Pour obtenir la matrice de covariance complète de tous les " +"éléments d'une liste telle que .SD, ajoutez le préfixe stats::var(.SD) (ou " +"stats::sd(.SD)) ou désactivez l'optimisation GForce en utilisant " +"options(datatable.optimize=1). Sinon, si vous n'avez besoin que des éléments " +"diagonaux, 'DT[,lapply(.SD,var),by=,.SDcols=]' est la manière optimisée de " +"procéder." + +#: gsumm.c:1115 +msgid "" +"GForce prod can only be applied to columns, not .SD or similar. To multiply " +"all items in a list such as .SD, either add the prefix base::prod(.SD) or " +"turn off GForce optimization using options(datatable.optimize=1). More " +"likely, you may be looking for 'DT[,lapply(.SD,prod),by=,.SDcols=]'" +msgstr "" +"GForce prod ne peut être appliqué qu'aux colonnes, et non aux .SD ou " +"similaires. Pour multiplier tous les éléments d'une liste telle que .SD, " +"ajoutez le préfixe base::prod(.SD) ou désactivez l'optimisation GForce en " +"utilisant options(datatable.optimize=1). Il est plus probable que vous " +"recherchiez 'DT[,lapply(.SD,prod),by=,.SDcols=]'" + +#: gsumm.c:1124 +#, c-format +msgid "Unable to allocate %d * %zu bytes for gprod" +msgstr "Impossible d'allouer %d * %zu octets pour gprod" + +#: gsumm.c:1215 shift.c:34 +#, c-format +msgid "Item %d of n is NA" +msgstr "L'élément %d de n est NA" + +#: gsumm.c:1272 +#, c-format +msgid "" +"Type '%s' is not supported by GForce gshift. Either add the namespace prefix " +"(e.g. data.table::shift(.)) or turn off GForce optimization using " +"options(datatable.optimize=1)" +msgstr "" +"Le type '%s' n'est pas supporté par GForce gshift. Il faut soit ajouter le " +"préfixe de l'espace de noms (par exemple data.table::shift(.)), soit " +"désactiver l'optimisation de GForce en utilisant options(datatable." +"optimize=1)" + +#: idatetime.c:126 vecseq.c:13 +msgid "x must be an integer vector" +msgstr "x doit être un vecteur entier" + +#: ijoin.c:128 +#, c-format +msgid "First pass on calculating lengths in lookup ... done in %8.3f seconds\n" +msgstr "" +"Première passe sur le calcul des tailles dans la recherche ... fait en %8.3f " +"secondes\n" + +#: ijoin.c:141 +#, c-format +msgid "Second pass on allocation in lookup ... done in %8.3f seconds\n" +msgstr "" +"Deuxième passage sur l'allocation dans la recherche ... fait en %8.3f " +"secondes\n" + +#: ijoin.c:220 +#, c-format +msgid "Final step in generating lookup ... done in %8.3f seconds\n" +msgstr "" +"Dernière étape de la génération de la recherche ... effectuée en %8.3f " +"secondes\n" + +#: ijoin.c:330 +#, c-format +msgid "" +"First pass on calculating lengths in overlaps ... done in %8.3f seconds\n" +msgstr "" +"Première passe sur le calcul des longueurs dans les chevauchements ... fait " +"en %8.3f secondes\n" + +#: ijoin.c:729 +#, c-format +msgid "Final step, fetching indices in overlaps ... done in %8.3f seconds\n" +msgstr "" +"Dernière étape, récupération des indices dans les chevauchements ... fait en " +"%8.3f secondes\n" + +#: init.c:172 +msgid "" +"Pointers are %zu bytes, greater than 8. We have not tested on any " +"architecture greater than 64bit yet." +msgstr "" +"Les pointeurs sont des octets %zu, supérieurs à 8. Nous n'avons pas encore " +"testé sur une architecture supérieure à 64 bits." + +#: init.c:186 +msgid "... failed. Please forward this message to maintainer('data.table')." +msgstr "" +"... a échoué. Veuillez transmettre ce message à maintainer('data.table')." + +#: init.c:187 +#, c-format +msgid "Checking NA_INTEGER [%d] == INT_MIN [%d] %s" +msgstr "Vérification de NA_INTEGER [%d] == INT_MIN [%d] %s" + +#: init.c:188 +#, c-format +msgid "Checking NA_INTEGER [%d] == NA_LOGICAL [%d] %s" +msgstr "Vérification de NA_INTEGER [%d] == NA_LOGICAL [%d] %s" + +#: init.c:189 init.c:190 init.c:192 init.c:195 init.c:196 init.c:197 init.c:198 +#: init.c:199 init.c:200 init.c:201 +#, c-format +msgid "Checking sizeof(%s) [%zu] is %d %s" +msgstr "Vérification que sizeof(%s) [%zu] est %d %s" + +#: init.c:193 +#, c-format +msgid "Checking sizeof(pointer) [%zu] is 4 or 8 %s" +msgstr "Vérification que sizeof(pointeur) [%zu] est 4 ou 8 %s" + +#: init.c:194 +#, c-format +msgid "Checking sizeof(SEXP) [%zu] == sizeof(pointer) [%zu] %s" +msgstr "Vérification de sizeof(SEXP) [%zu] == sizeof(pointeur) [%zu] %s" + +#: init.c:204 +#, c-format +msgid "Checking LENGTH(allocVector(INTSXP,2)) [%d] is 2 %s" +msgstr "Vérification que LENGTH(allocVector(INTSXP,2)) [%d] est 2 %s" + +#: init.c:206 +#, c-format +msgid "Checking TRUELENGTH(allocVector(INTSXP,2)) [%lld] is 0 %s" +msgstr "Vérification que TRUELENGTH(allocVector(INTSXP,2)) [%lld] est 0 %s" + +#: init.c:213 +#, c-format +msgid "Checking memset(&i,0,sizeof(int)); i == (int)0 %s" +msgstr "Vérification que memset(&i,0,sizeof(int)) ; i == (int)0 %s" + +#: init.c:216 +#, c-format +msgid "Checking memset(&ui, 0, sizeof(unsigned int)); ui == (unsigned int)0 %s" +msgstr "" +"Vérification que memset(&ui, 0, sizeof(unsigned int)) ; ui == (unsigned " +"int)0 %s" + +#: init.c:219 +#, c-format +msgid "Checking memset(&d, 0, sizeof(double)); d == (double)0.0 %s" +msgstr "Vérification que memset(&d, 0, sizeof(double)) ; d == (double)0.0 %s" + +#: init.c:222 +#, c-format +msgid "Checking memset(&ld, 0, sizeof(long double)); ld == (long double)0.0 %s" +msgstr "" +"Vérification que memset(&ld, 0, sizeof(long double)) ; ld == (long " +"double)0.0 %s" + +#: init.c:225 +msgid "The ascii character '/' is not just before '0'" +msgstr "Le caractère ascii '/' ne se trouve pas juste avant '0'" + +#: init.c:226 +msgid "The C expression (uint_fast8_t)('/'-'0')<10 is true. Should be false." +msgstr "" +"L'expression C (uint_fast8_t)('/'-'0')<10 est vraie. Elle devrait être " +"fausse." + +#: init.c:227 +msgid "The ascii character ':' is not just after '9'" +msgstr "Le caractère ascii ':' n'est pas juste après '9'" + +#: init.c:228 +msgid "The C expression (uint_fast8_t)('9'-':')<10 is true. Should be false." +msgstr "" +"L'expression C (uint_fast8_t)('9'-':')<10 est vraie. Elle devrait être " +"fausse." + +#: init.c:233 +#, c-format +msgid "Conversion of NA_INT64 via double failed %!=%" +msgstr "" +"La conversion de NA_INT64 via 'double' (nombre à virgule flottante) a échoué " +"%!=%" + +#: init.c:237 +msgid "NA_INT64_D (negative -0.0) is not == 0.0." +msgstr "NA_INT64_D (négatif -0,0) n'est pas == 0,0." + +#: init.c:238 +msgid "NA_INT64_D (negative -0.0) is not ==-0.0." +msgstr "NA_INT64_D (négatif -0,0) n'est pas ==-0,0." + +#: init.c:239 +msgid "ISNAN(NA_INT64_D) is TRUE but should not be" +msgstr "ISNAN(NA_INT64_D) est TRUE mais ne devrait pas l'être" + +#: init.c:240 +msgid "isnan(NA_INT64_D) is TRUE but should not be" +msgstr "isnan(NA_INT64_D) est TRUE mais ne devrait pas l'être" + +#: init.c:274 +#, c-format +msgid "PRINTNAME(install(\"integer64\")) has returned %s not %s" +msgstr "PRINTNAME(install(\"integer64\")) a retourné %s et non %s" + +#: init.c:333 +msgid "verbose option must be length 1 non-NA logical or integer" +msgstr "" +"l'option verbose doit être de longueur 1 et de type booléen non-NA ou entier" + +#: init.c:367 +msgid ".Last.value in namespace is not a length 1 integer" +msgstr ".Last.value dans l'espace des noms n'est pas un entier de longueur 1" + +#: nafill.c:110 +msgid "" +"'x' argument is atomic vector, in-place update is supported only for list/" +"data.table" +msgstr "" +"l'argument 'x' est un vecteur atomique, la mise à jour sur place n'est " +"possible que pour list/data.table" + +#: nafill.c:112 nafill.c:123 +msgid "'x' argument must be numeric type, or list/data.table of numeric types" +msgstr "" +"l'argument 'x' doit être un type numérique ou une liste/data.table de types " +"numériques" + +#: nafill.c:179 +msgid "fill must be a vector of length 1 or a list of length of x" +msgstr "fill doit être un vecteur de longueur 1 ou une liste de longueur x" + +#: nafill.c:226 +#, c-format +msgid "%s: parallel processing of %d column(s) took %.3fs\n" +msgstr "" +"%s : le traitement en parallèle de %d colonne(s) a pris %.3f secondes\n" + +#: openmp-utils.c:23 +#, c-format +msgid "" +"Ignoring invalid %s==\"%s\". Not an integer >= 1. Please remove any " +"characters that are not a digit [0-9]. See ?data.table::setDTthreads." +msgstr "" +"Ignore le test %s= \"%s\" invalide. Ce n'est pas un nombre entier >= 1. " +"Veuillez supprimer tous les caractères qui ne sont pas des chiffres [0-9]. " +"Voir ?data.table::setDTthreads." + +#: openmp-utils.c:44 +#, c-format +msgid "" +"Ignoring invalid R_DATATABLE_NUM_PROCS_PERCENT==%d. If used it must be an " +"integer between 2 and 100. Default is 50. See ?setDTtheads." +msgstr "" +"Ignore le test R_DATATABLE_NUM_PROCS_PERCENT==%d invalide. S'il est utilisé, " +"il doit s'agir d'un entier compris entre 2 et 100. La valeur par défaut est " +"50. Voir ?setDTtheads." + +#: openmp-utils.c:82 +msgid "" +"This installation of data.table has not been compiled with OpenMP support.\n" +msgstr "" +"Cette installation de data.table n'a pas été compilée avec le support pour " +"OpenMP.\n" + +#: openmp-utils.c:84 +#, c-format +msgid " OpenMP version (_OPENMP) %d\n" +msgstr " Version OpenMP (_OPENMP) %d\n" + +#: openmp-utils.c:89 +#, c-format +msgid " omp_get_num_procs() %d\n" +msgstr " omp_get_num_procs() %d\n" + +#: openmp-utils.c:90 +#, c-format +msgid " R_DATATABLE_NUM_PROCS_PERCENT %s\n" +msgstr " R_DATABLE_NUM_PROCS_PERCENT %s\n" + +#: openmp-utils.c:91 +#, c-format +msgid " R_DATATABLE_NUM_THREADS %s\n" +msgstr " R_DATABLE_NUM_THREADS %s\n" + +#: openmp-utils.c:92 +#, c-format +msgid " R_DATATABLE_THROTTLE %s\n" +msgstr " R_DATABLE_THROTTLE %s\n" + +#: openmp-utils.c:93 +#, c-format +msgid " omp_get_thread_limit() %d\n" +msgstr " omp_get_thread_limit() %d\n" + +#: openmp-utils.c:94 +#, c-format +msgid " omp_get_max_threads() %d\n" +msgstr " omp_get_max_threads() %d\n" + +#: openmp-utils.c:95 +#, c-format +msgid " OMP_THREAD_LIMIT %s\n" +msgstr " OMP_THREAD_LIMIT %s\n" + +#: openmp-utils.c:96 +#, c-format +msgid " OMP_NUM_THREADS %s\n" +msgstr " OMP_NUM_THREADS %s\n" + +#: openmp-utils.c:97 +#, c-format +msgid " RestoreAfterFork %s\n" +msgstr " RestoreAfterFork %s\n" + +#: openmp-utils.c:98 +#, c-format +msgid "" +" data.table is using %d threads with throttle==%d. See ?setDTthreads.\n" +msgstr "" +" data.table utilise %d threads avec throttle==%d. Voir ?setDTthreads.\n" + +#: openmp-utils.c:106 +msgid "" +"restore_after_fork= must be TRUE, FALSE, or NULL (default). " +"getDTthreads(verbose=TRUE) reports the current setting.\n" +msgstr "" +"restore_after_fork= doit être TRUE, FALSE ou NULL (par défaut). " +"getDTthreads(verbose=TRUE) indique la configuration actuelle.\n" + +#: openmp-utils.c:112 +msgid "'throttle' must be a single number, non-NA, and >=1" +msgstr "'throttle' doit être un nombre unique, non NA, et >=1" + +#: openmp-utils.c:126 +msgid "" +"threads= must be either NULL or a single number >= 0. See ?setDTthreads." +msgstr "" +"threads= doit être soit NULL soit un nombre unique >= 0. Voir ?setDTthreads." + +#: programming.c:16 +#, c-format +msgid "" +"Attempting to substitute '%s' element with object of type '%s' but it has to " +"be 'symbol' type when substituting name of the call argument, functions 'as." +"name' and 'I' can be used to work out proper substitution, see ?substitute2 " +"examples." +msgstr "" +"Tentative de substitution de l'élément '%s' par un objet de type '%s' mais " +"il doit être de type 'symbole' lors de la substitution du nom de l'argument " +"d'appel. Les fonctions 'as.name' et 'I' peuvent être utilisées pour " +"déterminer la substitution appropriée, voir les exemples ?substitute2." + +#: rbindlist.c:10 +msgid "use.names= should be TRUE, FALSE, or not used (\"check\" by default)" +msgstr "" +"use.names= doit être TRUE, FALSE, ou non utilisé (\"check\" par défaut)" + +#: rbindlist.c:14 +msgid "" +"Input to rbindlist must be a list. This list can contain data.tables, data." +"frames or plain lists." +msgstr "" +"L'entrée de rbindlist doit être une liste. Cette liste peut contenir des " +"data.tables, des data.frames ou des listes simples." + +#: rbindlist.c:33 +#, c-format +msgid "Item %d of input is not a data.frame, data.table or list" +msgstr "" +"L'élément %d de l'entrée n'est pas un data.frame, data.table ou une liste" + +#: rbindlist.c:41 +#, c-format +msgid "" +"Item %d has %d columns, inconsistent with item %d which has %d columns. To " +"fill missing columns use fill=TRUE." +msgstr "" +"L'élément %d comporte %d colonnes, ce qui est incompatible avec l'élément %d " +"qui comporte %d colonnes. Pour remplir les colonnes manquantes, utilisez " +"fill=TRUE." + +#: rbindlist.c:44 +#, c-format +msgid "Item %d has %d columns but %d column names. Invalid object." +msgstr "L'élément %d a %d colonnes mais %d noms de colonnes. Objet non valide." + +#: rbindlist.c:51 +#, c-format +msgid "" +"Column %d of item %d is length %d inconsistent with column %d which is " +"length %d. Only length-1 columns are recycled." +msgstr "" +"La colonne %d de l'élément %d a une longueur %d incompatible avec la colonne " +"%d qui a une longueur %d. Seules les colonnes de longueur 1 sont recyclées." + +#: rbindlist.c:60 +#, c-format +msgid "" +"Column %d ['%s'] of item %d is length 0. This (and %d other%s like it) has " +"been filled with NA (NULL for list columns) to make each item uniform." +msgstr "" +"La colonne %d ['%s'] de l'élément %d a une longueur de 0. Cette colonne (et " +"les %d autres %s similaires) a été remplie avec NA (NULL pour les colonnes " +"de type liste) afin d'uniformiser chaque élément." + +#: rbindlist.c:64 +#, c-format +msgid "" +"Total rows in the list is % which is larger than the maximum number " +"of rows, currently %d" +msgstr "" +"Le nombre total de lignes dans la liste est %, ce qui est supérieur " +"au nombre maximum de lignes, actuellement de %d" + +#: rbindlist.c:65 +msgid "use.names=TRUE but no item of input list has any names" +msgstr "use.names=TRUE mais aucun élément de la liste d'entrée n'a de nom" + +#: rbindlist.c:74 +#, c-format +msgid "" +"Failed to allocate upper bound of % unique column names " +"[sum(lapply(l,ncol))]" +msgstr "" +"Échec de l'allocation de la borne supérieure de % noms de colonnes " +"uniques [sum(lapply(l,ncol))]" + +#: rbindlist.c:105 +#, c-format +msgid "Failed to allocate nuniq=%d items working memory in rbindlist.c" +msgstr "" +"Échec de l'allocation de la mémoire de travail pour nuniq=%d éléments dans " +"rbindlist.c" + +#: rbindlist.c:139 +#, c-format +msgid "Failed to allocate ncol=%d items working memory in rbindlist.c" +msgstr "" +"Échec de l'allocation de la mémoire de travail pour ncol=%d éléments dans " +"rbindlist.c" + +#: rbindlist.c:199 +msgid "" +" use.names='check' (default from v1.12.2) emits this message and proceeds as " +"if use.names=FALSE for backwards compatibility. See news item 5 in v1.12.2 " +"for options to control this message." +msgstr "" +" use.names='check' (par défaut à partir de la version 1.12.2) émet ce " +"message et procède comme si use.names=FALSE pour des raisons de " +"rétrocompatibilité. Voir le point 5 dans les nouveautés de la version 1.12.2 " +"pour les options permettant de contrôler ce message." + +#: rbindlist.c:213 +#, c-format +msgid "" +"Column %d ['%s'] of item %d is missing in item %d. Use fill=TRUE to fill " +"with NA (NULL for list columns), or use.names=FALSE to ignore column names.%s" +msgstr "" +"La colonne %d ['%s'] de l'élément %d est manquante dans l'élément %d. " +"Utilisez fill=TRUE pour remplir avec NA (NULL pour les colonnes de type " +"liste), ou use.names=FALSE pour ignorer les noms de colonnes.%s" + +#: rbindlist.c:222 +#, c-format +msgid "" +"Column %d ['%s'] of item %d appears in position %d in item %d. Set use." +"names=TRUE to match by column name, or use.names=FALSE to ignore column " +"names.%s" +msgstr "" +"La colonne %d ['%s'] de l'élément %d apparaît en position %d dans l'élément " +"%d. Définissez use.names=TRUE pour une correspondance par nom de colonne, ou " +"use.names=FALSE pour ignorer les noms de colonnes.%s" + +#: rbindlist.c:231 +msgid "" +"options()$datatable.rbindlist.check is set but is not a single string. See " +"news item 5 in v1.12.2." +msgstr "" +"options()$datable.rbindlist.check est défini mais n'est pas une chaîne " +"unique. Voir le point 5 dans les nouveautés de la v1.12.2." + +#: rbindlist.c:238 +#, c-format +msgid "" +"options()$datatable.rbindlist.check=='%s' which is not " +"'message'|'warning'|'error'|'none'. See news item 5 in v1.12.2." +msgstr "" +"options()$datable.rbindlist.check=='%s' qui n'est pas " +"'message'|'warning'|'error'|'none'. Voir le point 5 dans les nouveautés de " +"la v1.12.2." + +#: rbindlist.c:301 +#, c-format +msgid "" +"Column %d of item %d has type 'factor' but has no levels; i.e. malformed." +msgstr "" +"La colonne %d de l'élément %d est de type 'facteur' mais n'a pas de niveaux, " +"c'est-à-dire qu'il est malformé." + +#: rbindlist.c:330 +#, c-format +msgid "" +"Class attribute on column %d of item %d does not match with column %d of " +"item %d. You can deactivate this safety-check by using ignore.attr=TRUE" +msgstr "" +"L'attribut de classe de la colonne %d de l'élément %d ne correspond pas à la " +"colonne %d de l'élément %d. Vous pouvez désactiver cette vérification en " +"utilisant ignore.attr=TRUE" + +#: rbindlist.c:380 +#, c-format +msgid "" +"Failed to allocate working memory for %d ordered factor levels of result " +"column %d" +msgstr "" +"Échec de l'allocation de la mémoire de travail pour %d niveaux de facteurs " +"ordonnés pour la colonne de résultats %d" + +#: rbindlist.c:403 +#, c-format +msgid "" +"Column %d of item %d is an ordered factor but level %d ['%s'] is missing " +"from the ordered levels from column %d of item %d. Each set of ordered " +"factor levels should be an ordered subset of the first longest. A regular " +"factor will be created for this column." +msgstr "" +"La colonne %d de l'élément %d est un facteur ordonné, mais le niveau %d " +"['%s'] manque parmi les niveaux ordonnés de la colonne %d de l'élément %d. " +"Chaque ensemble de niveaux de facteur ordonné doit être un sous-ensemble " +"ordonné du premier et plus long. Un facteur régulier sera créé pour cette " +"colonne." + +#: rbindlist.c:408 +#, c-format +msgid "" +"Column %d of item %d is an ordered factor with '%s'<'%s' in its levels. But " +"'%s'<'%s' in the ordered levels from column %d of item %d. A regular factor " +"will be created for this column due to this ambiguity." +msgstr "" +"La colonne %d de l'élément %d est un facteur ordonné dont les niveaux sont " +"'%s'<'%s'. Cependant, '%s'<'%s' dans les niveaux ordonnés de la colonne %d " +"de l'élément %d. Un facteur régulier sera créé pour cette colonne en raison " +"de cette ambiguïté." + +#: rbindlist.c:453 +#, c-format +msgid "" +"Failed to allocate working memory for %d factor levels of result column %d " +"when reading item %d of item %d" +msgstr "" +"Échec de l'allocation de la mémoire de travail pour %d niveaux de facteurs " +"de la colonne de résultats %d lors de la lecture de l'élément %d de " +"l'élément %d" + +#: rbindlist.c:544 rbindlist.c:547 +#, c-format +msgid "Column %d of item %d: %s" +msgstr "Colonne %d de l'élément %d : %s" + +#: reorder.c:17 +#, c-format +msgid "Item %d of list is type '%s' which isn't yet supported (SIZEOF=%zu)" +msgstr "" +"L'élément %d de la liste est du type '%s' qui n'est pas encore pris en " +"charge (SIZEOF=%zu)" + +#: reorder.c:19 +#, c-format +msgid "" +"Column %d is length %d which differs from length of column 1 (%d). Invalid " +"data.table." +msgstr "" +"La colonne %d est de longueur %d, ce qui diffère de la longueur de la " +"colonne 1 (%d). Objet data.table invalide." + +#: reorder.c:27 +#, c-format +msgid "" +"reorder accepts vectors but this non-VECSXP is type '%s' which isn't yet " +"supported (SIZEOF=%zu)" +msgstr "" +"reorder accepte les vecteurs mais non-VECSXP est de type '%s' qui n'est pas " +"encore supporté (SIZEOF=%zu)" + +#: reorder.c:33 +msgid "order must be an integer vector" +msgstr "l'ordre doit être un vecteur entier" + +#: reorder.c:34 +#, c-format +msgid "nrow(x)[%d]!=length(order)[%d]" +msgstr "nrow(x)[%d]!=length(order)[%d]" + +#: reorder.c:51 +#, c-format +msgid "" +"Item %d of order (%d) is either NA, out of range [1,%d], or is duplicated. " +"The new order must be a strict permutation of 1:n" +msgstr "" +"L'élément %d de l'ordre (%d) est soit NA, soit hors de l'intervalle [1,%d], " +"soit dupliqué. Le nouvel ordre doit être une permutation stricte de 1:n" + +#: reorder.c:111 +msgid "dt passed to setcolorder has no names" +msgstr "dt transmis à 'setcolorder' n'a pas de noms" + +#: shift.c:12 +msgid "" +"shift input must not be matrix or array, consider wrapping it into data." +"table() or c()" +msgstr "" +"l'entrée de la fonction shift ne doit pas être une matrice ou un tableau, " +"envisagez de l'intégrer dans data.table() ou c()" + +#: shift.c:17 +#, c-format +msgid "" +"type '%s' passed to shift(). Must be a vector, list, data.frame or data.table" +msgstr "" +"type '%s' transmis à 'shift()'. Il doit s'agir d'un vecteur, d'une liste, " +"d'un data.frame ou d'un data.table" + +#: snprintf.c:193 snprintf.c:196 snprintf.c:199 snprintf.c:202 snprintf.c:205 +#: snprintf.c:208 snprintf.c:211 snprintf.c:214 snprintf.c:217 snprintf.c:221 +#: snprintf.c:224 snprintf.c:227 snprintf.c:230 snprintf.c:233 snprintf.c:236 +#: snprintf.c:239 snprintf.c:242 snprintf.c:245 +#, c-format +msgid "dt_win_snprintf test %d failed: %s" +msgstr "le test dt_win_snprintf %d a échoué : %s" + +#: snprintf.c:218 +#, c-format +msgid "dt_win_snprintf test %d failed: %d" +msgstr "le test dt_win_snprintf %d a échoué : %d" + +#: subset.c:182 +#, c-format +msgid "" +"Item %d of i is %d and item %d is %d. Cannot mix positives and negatives." +msgstr "" +"L'élément %d de i est %d et l'élément %d est %d. Il n'est pas possible de " +"mélanger les positifs et les négatifs." + +#: subset.c:192 +#, c-format +msgid "Item %d of i is %d and item %d is NA. Cannot mix negatives and NA." +msgstr "" +"L'élément %d de i est %d et l'élément %d est NA. Il n'est pas possible de " +"mélanger des négatifs et des NA." + +#: subset.c:239 +#, c-format +msgid "" +"Item %d of i is %d but there are only %d rows. Ignoring this and %d more " +"like it out of %d." +msgstr "" +"L'élément %d de i est %d mais il n'y a que %d lignes. Cela sera ignoré, " +"ainsi que %d autres similaires sur un total de %d." + +#: subset.c:241 +#, c-format +msgid "" +"Item %d of i is %d which removes that item but that has occurred before. " +"Ignoring this dup and %d other dups." +msgstr "" +"L'élément %d de i est %d, ce qui supprime cet élément, mais cela s'est déjà " +"produit auparavant. Ce doublon sera ignoré ainsi que %d autres doublons." + +#: subset.c:255 +#, c-format +msgid "Column %d is NULL; malformed data.table." +msgstr "La colonne %d est NULL ; data.table malformé." + +#: subset.c:258 +#, c-format +msgid "Column %d ['%s'] is a data.frame or data.table; malformed data.table." +msgstr "" +"La colonne %d ['%s'] est un data.frame ou un data.table ; data.table " +"malformé." + +#: subset.c:263 +#, c-format +msgid "" +"Column %d ['%s'] is length %d but column 1 is length %d; malformed data." +"table." +msgstr "" +"La colonne %d ['%s'] est de longueur %d mais la colonne 1 est de longueur " +"%d ; data.table malformé." + +#: subset.c:295 +#, c-format +msgid "Item %d of cols is %d which is outside the range [1,ncol(x)=%d]" +msgstr "" +"L'élément %d des colonnes est %d, ce qui est en dehors de l'intervalle [1," +"ncol(x)=%d]" + +#: transpose.c:9 +msgid "l must be a list." +msgstr "l doit être une liste." + +#: transpose.c:13 +msgid "ignore.empty should be logical TRUE/FALSE." +msgstr "ignore.empty doit être de type booléen TRUE/FALSE." + +#: transpose.c:16 +msgid "" +"keep.names should be either NULL, or the name of the first column of the " +"result in which to place the names of the input" +msgstr "" +"keep.names doit être soit NULL, soit le nom de la première colonne du " +"résultat dans laquelle placer les noms de l'entrée" + +#: transpose.c:19 +msgid "fill must be a length 1 vector, such as the default NA" +msgstr "fill doit être un vecteur de longueur 1, tel que NA par defaut" + +#: transpose.c:22 +msgid "list.cols should be logical TRUE/FALSE." +msgstr "list.cols doit être de type booléen TRUE/FALSE." + +#: transpose.c:31 +#, c-format +msgid "Item %d of list input is not either an atomic vector, or a list" +msgstr "" +"L'élément %d de la liste d'entrée n'est pas un vecteur atomique, ou une liste" + +#: uniqlist.c:151 +msgid "Input argument 'x' to 'uniqlengths' must be an integer vector" +msgstr "" +"L'argument d'entrée 'x' de 'uniqlengths' doit être un vecteur d'entiers" + +#: uniqlist.c:152 +msgid "" +"Input argument 'n' to 'uniqlengths' must be an integer vector of length 1" +msgstr "" +"L'argument d'entrée 'n' de 'uniqlengths' doit être un vecteur entier de " +"longueur 1" + +#: uniqlist.c:170 uniqlist.c:267 +msgid "cols must be an integer vector with length >= 1" +msgstr "cols doit être un vecteur d'entier de longueur >= 1" + +#: uniqlist.c:174 +#, c-format +msgid "Item %d of cols is %d which is outside the range [1,length(l)=%d]" +msgstr "" +"L'élément %d de cols est %d, ce qui est en dehors de l'intervalle [1," +"length(l)=%d]" + +#: uniqlist.c:177 +#, c-format +msgid "" +"All elements to input list must be of same length. Element [%d] has length " +"% != length of first element = %." +msgstr "" +"Tous les éléments de la liste d'entrée doivent être de même longueur. " +"L'élément [%d] a une longueur de %!= longueur du premier élément = " +"%." + +#: uniqlist.c:352 +msgid "x is not a logical vector" +msgstr "x n'est pas un vecteur de booléens" + +#: utils.c:85 +#, c-format +msgid "Unsupported type '%s' passed to allNA()" +msgstr "Type '%s' non pris en charge dans allNA()" + +#: utils.c:105 +msgid "'x' argument must be data.table compatible" +msgstr "l'argument 'x' doit être compatible avec data.table" + +#: utils.c:129 +msgid "" +"argument specifying columns is type 'double' and one or more items in it are " +"not whole integers" +msgstr "" +"l'argument spécifiant les colonnes est de type 'double' (nombre à virgule " +"flottante) et un ou plusieurs éléments ne sont pas des entiers" + +#: utils.c:135 +#, c-format +msgid "" +"argument specifying columns received non-existing column(s): cols[%d]=%d" +msgstr "" +"l'argument spécifiant les colonnes a reçu des colonnes inexistantes : " +"cols[%d]=%d" + +#: utils.c:142 +msgid "'x' argument data.table has no names" +msgstr "l'argument 'x' de data.table n'a pas de nom" + +#: utils.c:148 +#, c-format +msgid "" +"argument specifying columns received non-existing column(s): cols[%d]='%s'" +msgstr "" +"l'argument spécifiant les colonnes a reçu des colonnes inexistantes : " +"cols[%d]='%s'" + +#: utils.c:152 +msgid "argument specifying columns must be character or numeric" +msgstr "l'argument spécifiant les colonnes doit être un caractère ou un nombre" + +#: utils.c:155 +msgid "argument specifying columns received duplicate column(s)" +msgstr "" +"l'argument spécifiant les colonnes a reçu une ou plusieurs colonnes " +"dupliquée(s)" + +#: utils.c:289 +#, c-format +msgid "Found and copied %d column%s with a shared memory address\n" +msgstr "" +"Trouvé et copié la colonne %d %s avec une adresse de mémoire partagée\n" + +#: utils.c:369 +msgid "'x' is not atomic" +msgstr "'x' n'est pas un vecteur atomique" + +#: utils.c:371 +msgid "'x' must not be matrix or array" +msgstr "'x' ne doit pas être une matrice ou un tableau" + +#: utils.c:373 +msgid "input must not be matrix or array" +msgstr "l'entrée ne doit pas être une matrice ou un tableau" + +#: utils.c:377 +#, c-format +msgid "copy=false and input already of expected type and class %s[%s]\n" +msgstr "" +"copy=false et l'entrée est déjà du type et de la classe attendus %s[%s]\n" + +#: utils.c:384 +#, c-format +msgid "Coercing %s[%s] into %s[%s]\n" +msgstr "Conversion de %s[%s] en %s[%s]\n" + +#: utils.c:400 +#, c-format +msgid "zlib header files were not found when data.table was compiled" +msgstr "" +"les fichiers d'en-tête de zlib n'ont pas été trouvés lors de la compilation " +"de data.table" + +#: vecseq.c:14 +msgid "len must be an integer vector" +msgstr "len doit être un vecteur d'entier" + +#: vecseq.c:15 +msgid "x and len must be the same length" +msgstr "x et len doivent être de même longueur" + +#: vecseq.c:21 +msgid "" +"Join results in more than 2^31 rows (internal vecseq reached physical " +"limit). Very likely misspecified join. Check for duplicate key values in i " +"each of which join to the same group in x over and over again. If that's ok, " +"try by=.EACHI to run j for each group to avoid the large allocation. " +"Otherwise, please search for this error message in the FAQ, Wiki, Stack " +"Overflow and data.table issue tracker for advice." +msgstr "" +"La jointure donne plus de 2^31 lignes (vecseq a atteint la limite physique). " +"Très probablement une mauvaise spécification de la jointure. Vérifiez s'il y " +"a des valeurs de clés dupliquées dans i, chacune d'entre elles rejoignant le " +"même groupe dans x, encore et encore. Si c'est correct, essayez by=.EACHI " +"pour exécuter j pour chaque groupe afin d'éviter une allocation importante. " +"Sinon, recherchez ce message d'erreur dans la FAQ, le Wiki, Stack Overflow " +"et le gestionnaire de tickets (issue tracker) de data.table pour obtenir des " +"conseils." + +#: vecseq.c:25 +msgid "clamp must be a double vector length 1" +msgstr "" +"clamp doit être un vecteur 'double' (nombre à virgule flottante) de longueur " +"1" + +#: vecseq.c:27 +msgid "clamp must be positive" +msgstr "clamp doit être positive" + +#: vecseq.c:28 +#, c-format +msgid "" +"Join results in %d rows; more than %d = nrow(x)+nrow(i). Check for duplicate " +"key values in i each of which join to the same group in x over and over " +"again. If that's ok, try by=.EACHI to run j for each group to avoid the " +"large allocation. If you are sure you wish to proceed, rerun with allow." +"cartesian=TRUE. Otherwise, please search for this error message in the FAQ, " +"Wiki, Stack Overflow and data.table issue tracker for advice." +msgstr "" +"La jointure donne %d lignes ; plus de %d = nrow(x)+nrow(i). Vérifiez s'il y " +"a des valeurs de clés dupliquées dans i, chacune d'entre elles rejoignant le " +"même groupe dans x, encore et encore. Si c'est correct, essayez by=.EACHI " +"pour exécuter j pour chaque groupe afin d'éviter une allocation importante. " +"Sinon, recherchez ce message d'erreur dans la FAQ, le Wiki, Stack Overflow " +"et le gestionnaire de tickets (issue tracker) de data.table pour obtenir des " +"conseils." + +#: wrappers.c:11 +msgid "Attribute name must be a character vector of length 1" +msgstr "Le nom de l'attribut doit être un vecteur de caractères de longueur 1" + +#: wrappers.c:16 +msgid "" +"Internal structure doesn't seem to be a list. Can't set class to be 'data." +"table' or 'data.frame'. Use 'as.data.table()' or 'as.data.frame()' methods " +"instead." +msgstr "" +"La structure interne ne semble pas être une liste. Impossible de définir la " +"classe comme étant 'data.table' ou 'data.frame'. Utilisez plutôt les " +"méthodes 'as.data.table()' ou 'as.data.frame()'." + +#: wrappers.c:66 +msgid "First argument to setlistelt must be a list()" +msgstr "Le premier argument de setlistelt doit être de type list()" + +#: wrappers.c:67 +msgid "Second argument to setlistelt must a length 1 integer vector" +msgstr "" +"Le deuxième argument de setlistelt doit être un vecteur d'entier de longueur " +"1" + +#: wrappers.c:69 +#, c-format +msgid "i (%d) is outside the range of items [1,%d]" +msgstr "i (%d) est en dehors de l'intervalle des éléments [1,%d]" + +#: wrappers.c:91 +msgid "x isn't a VECSXP" +msgstr "x n'est pas un VECSXP" + +#: wrappers.c:106 +#, c-format +msgid "" +"dim.data.table expects a data.table as input (which is a list), but seems to " +"be of type %s" +msgstr "" +"dim.data.table attend un data.table en entrée (qui est de type liste), mais " +"semble être de type %s" + +#~ msgid "Internal error: finalizer hasn't received an ExternalPtr" +#~ msgstr "Erreur interne : le finalisateur n'a pas reçu de ExternalPtr" + +#~ msgid "Internal error: finalizer's ExternalPtr doesn't see names in tag" +#~ msgstr "" +#~ "Erreur interne : le ExternalPtr du finalisateur ne voit pas les noms dans " +#~ "la balise" + +#, c-format +#~ msgid "Internal error: finalizer sees l=%d, tl=%d" +#~ msgstr "Erreur interne : le finalisateur voit l=%d, tl=%d" + +#~ msgid "Internal error: .internal.selfref ptr is neither NULL nor R_NilValue" +#~ msgstr "Erreur interne : .internal.selfref ptr n'est ni NULL ni R_NilValue" + +#~ msgid "" +#~ "Internal error: .internal.selfref tag is neither NULL nor a character " +#~ "vector" +#~ msgstr "" +#~ "Erreur interne : la balise .internal.selfref n'est ni NULL ni un vecteur " +#~ "de caractères" + +#~ msgid "Internal error: length(names)>0 but 0 mais length(xcols) [%d]" +#~ msgstr "Erreur interne : length(icols) [%d] > length(xcols) [%d]" + +#, c-format +#~ msgid "Internal error. icols[%d] is NA" +#~ msgstr "Erreur interne. icols[%d] est NA" + +#, c-format +#~ msgid "Internal error. xcols[%d] is NA" +#~ msgstr "Erreur interne. xcols[%d] est NA" + +#~ msgid "Internal error: roll is not character or double" +#~ msgstr "" +#~ "Erreur interne : 'roll' n'est pas un caractère ou un 'double' (nombre à " +#~ "virgule flottante)" + +#~ msgid "Internal error: nomatchArg must be NULL or length-1 logical/integer" +#~ msgstr "" +#~ "Erreur interne : 'nomatchArg' doit être NULL ou un entier ou booléen de " +#~ "longueur 1" + +#~ msgid "Internal error: nomatchArg must be NULL, NA, NA_integer_ or 0L" +#~ msgstr "Erreur interne : nomatchArg doit être NULL, NA, NA_integer_ ou 0L" + +#~ msgid "" +#~ "Internal error: opArg is not an integer vector of length equal to " +#~ "length(on)" +#~ msgstr "" +#~ "Erreur interne : opArg n'est pas un vecteur entier de longueur égale à " +#~ "length(on)" + +#, c-format +#~ msgid "Internal error in bmerge_r for x.'%s'. Unrecognized value op[col]=%d" +#~ msgstr "" +#~ "Erreur interne dans bmerge_r pour x.'%s'. Valeur non reconnue op[col]=%d" + +#~ msgid "Internal error: nqgrpArg must be an integer vector" +#~ msgstr "Erreur interne : nqgrpArg doit être un vecteur de nombre entiers" + +#~ msgid "Intrnal error: nqmaxgrpArg is not a positive length-1 integer vector" +#~ msgstr "" +#~ "Erreur interne : nqmaxgrpArg n'est pas un vecteur de nombres entiers " +#~ "positif de longueur 1" + +#~ msgid "Internal error in allocating memory for non-equi join" +#~ msgstr "" +#~ "Erreur interne lors de l'allocation de mémoire pour une jointure non-équi" + +#~ msgid "Internal error: xoArg is not an integer vector" +#~ msgstr "Erreur interne : xoArg n'est pas un vecteur de nombres entiers" + +#~ msgid "Internal error: either chin or chmatchdup should be true not both" +#~ msgstr "Erreur interne : chin ou chmatchdup doit être true, pas les deux" + +#, c-format +#~ msgid "Internal error: length of SYMSXP is %d not 1" +#~ msgstr "Erreur interne : la longueur de SYMSXP est %d et non 1" + +#, c-format +#~ msgid "" +#~ "Internal error: CHARSXP '%s' has a negative truelength (%d). Please file " +#~ "an issue on the data.table tracker." +#~ msgstr "" +#~ "Erreur interne : CHARSXP '%s' a une truelength négative (%d). Veuillez " +#~ "rapporter le problème sur le gestionnaire de tickets (issue tracker) de " +#~ "data.table." + +#~ msgid "Internal error in coalesce.c: input is list(...) at R level" +#~ msgstr "" +#~ "Erreur interne dans coalesce.c : la valeur fournie est list(...) au " +#~ "niveau R" + +#~ msgid "" +#~ "Internal error in coalesce.c: argument 'inplaceArg' must be TRUE or FALSE" +#~ msgstr "" +#~ "Erreur interne dans coalesce.c : l'argument 'inplaceArg' doit être TRUE " +#~ "ou FALSE" + +#~ msgid "Internal error: order not integer vector" +#~ msgstr "Erreur interne : order n'est pas un vecteur de nombres entiers" + +#~ msgid "Internal error: starts not integer" +#~ msgstr "Erreur interne : starts n'est pas un entier" + +#~ msgid "Internal error: jiscols not NULL but o__ has length" +#~ msgstr "Erreur interne : jiscols n'est pas NULL mais o__ a une longueur" + +#~ msgid "Internal error: xjiscols not NULL but o__ has length" +#~ msgstr "Erreur interne : xjiscols n'est pas NULL but o__ a une longueur" + +#, c-format +#~ msgid "" +#~ "Internal error: unsupported size-0 type '%s' in column %d of 'by' should " +#~ "have been caught earlier" +#~ msgstr "" +#~ "Erreur interne : le type '%s' de taille 0 non pris en charge dans la " +#~ "colonne %d de 'by' aurait dû être détecté plus tôt" + +#, c-format +#~ msgid "" +#~ "Internal error: size-0 type %d in .SD column %d should have been caught " +#~ "earlier" +#~ msgstr "" +#~ "Erreur interne : le type de taille 0 %d dans la colonne .SD %d aurait dû " +#~ "être détecté plus tôt" + +#, c-format +#~ msgid "Internal error: SDall %d length = %d != %d" +#~ msgstr "Erreur interne : SDall %d length = %d != %d" + +#, c-format +#~ msgid "" +#~ "Internal error: type %d in .xSD column %d should have been caught by now" +#~ msgstr "" +#~ "Erreur interne : le type %d dans la colonne .xSD %d aurait déjà dû être " +#~ "détecté" + +#~ msgid "" +#~ "Internal error: Trying to add new column by reference but tl is full; " +#~ "setalloccol should have run first at R level before getting to this point " +#~ "in dogroups" +#~ msgstr "" +#~ "Erreur interne : essai d'ajout de nouvelle colonne par référence mais la " +#~ "taille préallouée (tl) est pleine ; setalloccol aurait du être exécuté " +#~ "d'abord au niveau de R avant d'en arriver à ce point dans dogroups" + +#, c-format +#~ msgid "Internal error: block 0 [%d] and block 1 [%d] have both run" +#~ msgstr "" +#~ "Erreur interne : le bloc 0 [%d] et le bloc 1 [%d] ont tous deux été " +#~ "exécutés" + +#, c-format +#~ msgid "Internal error: growVector doesn't support type '%s'" +#~ msgstr "Erreur interne : growVector ne prends pas en charge le type '%s'" + +#, c-format +#~ msgid "Internal error: type '%s' not caught earlier in fastmean" +#~ msgstr "" +#~ "Erreur interne : le type '%s' n'a pas été détecté plus tôt dans fastmean" + +#, c-format +#~ msgid "" +#~ "Internal error in concat: 'idx' must take values between 1 and " +#~ "length(vec); 1 <= idx <= %d" +#~ msgstr "" +#~ "Erreur interne dans concat : 'idx' doit prendre des valeurs comprises " +#~ "entre 1 et length(vec) ; 1 <= idx <= %d" + +#~ msgid "" +#~ "Internal error: combineFactorLevels in fmelt.c expects all-character input" +#~ msgstr "" +#~ "Erreur interne : dans fmelt.c, combineFactorLevels attend entrées " +#~ "entièrement composées de caractères" + +#~ msgid "" +#~ "Internal error: combineFactorLevels in fmelt.c expects a character target " +#~ "to factorize" +#~ msgstr "" +#~ "Erreur interne : dans fmelt.c, combineFactorLevels attend un caractère " +#~ "target à factoriser" + +#, c-format +#~ msgid "Internal error: fmelt.c:getvarcols %d %d" +#~ msgstr "Erreur interne : fmelt.c:getvarcols %d %d" + +#~ msgid "Failed to alloc cradix_tmp" +#~ msgstr "Échec de l'allocation de cradix_tmp" + +#, c-format +#~ msgid "" +#~ "Internal error: ustr isn't empty when starting range_str: ustr_n=%d, " +#~ "ustr_alloc=%d" +#~ msgstr "" +#~ "Erreur interne : ustr n'est pas vide au démarrage de range_str : " +#~ "ustr_n=%d, ustr_alloc=%d" + +#~ msgid "Internal error: ustr_maxlen isn't 0 when starting range_str" +#~ msgstr "Erreur interne : ustr_maxlen n'est pas 0 au démarrage de range_str" + +#~ msgid "" +#~ "Internal error: input is not either a list of columns, or an atomic " +#~ "vector." +#~ msgstr "" +#~ "Erreur interne : l'entrée n'est ni une liste de colonnes, ni un vecteur " +#~ "atomique." + +#~ msgid "" +#~ "Internal error: input is an atomic vector (not a list of columns) but by= " +#~ "is not NULL" +#~ msgstr "" +#~ "Erreur interne : l’entrée est un vecteur atomique (pas une liste de " +#~ "colonnes) mais by= n'est pas NULL" + +#~ msgid "Internal error: DT is an empty list() of 0 columns" +#~ msgstr "Erreur interne : DT est une liste vide() de 0 colonne" + +#, c-format +#~ msgid "" +#~ "Internal error: DT has %d columns but 'by' is either not integer or is " +#~ "length 0" +#~ msgstr "" +#~ "Erreur interne : DT a %d colonnes mais 'by' n'est pas un entier ou est de " +#~ "longueur nulle" + +#, c-format +#~ msgid "internal error: 'by' value %d out of range [1,%d]" +#~ msgstr "erreur interne : valeur 'by' %d en dehors de l’intervalle [1,%d]" + +#~ msgid "Internal error: column not supported, not caught earlier" +#~ msgstr "" +#~ "Erreur interne : la colonne n'est pas prise en charge, non détecté plus " +#~ "tôt" + +#~ msgid "Internal error: issorted 'by' must be NULL or integer vector" +#~ msgstr "" +#~ "Erreur interne : issorted 'by' doit être NULL ou un vecteur d’entier" + +#, c-format +#~ msgid "Internal error. Argument '%s' to %s is type '%s' not '%s'" +#~ msgstr "" +#~ "Erreur interne. L'argument '%s' à %s est de type '%s' et non pas %s’" + +#~ msgid "" +#~ "Internal error: invalid ties.method for frankv(), should have been caught " +#~ "before. please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : ties.method est invalide pour frankv(), cela aurait dû " +#~ "être détecté auparavant. Veuillez signaler l'erreur au gestionnaire de " +#~ "tickets (issue tracker) de data.table" + +#, c-format +#~ msgid "Internal error: unknown ties value in frank: %d" +#~ msgstr "Erreur interne : valeur de ties inconnue dans frank : %d" + +#, c-format +#~ msgid "" +#~ "Internal error in line %d of fread.c, please report on data.table " +#~ "GitHub: " +#~ msgstr "" +#~ "Erreur interne à la ligne %d de fread.c, à signaler sur le GitHub de data." +#~ "table : " + +#, c-format +#~ msgid "Internal error: NUMTYPE(%d) > nLetters(%d)" +#~ msgstr "Erreur interne : NUMTYPE(%d) > nLetters(%d)" + +#~ msgid "" +#~ "Internal error: NAstrings is itself NULL. When empty it should be pointer " +#~ "to NULL." +#~ msgstr "" +#~ "Erreur interne : NAstrings est lui-même NULL. Lorsqu’il est vide, il doit " +#~ "être un pointeur sur NULL." + +#~ msgid "dec='' not allowed. Should be '.' or ','" +#~ msgstr "dec='' non autorisé. Doit être '.' ou ','" + +#~ msgid "Internal error: last byte of character input isn't \\0" +#~ msgstr "" +#~ "Erreur interne : le dernier octet de l'entrée de caractère n'est pas \\0" + +#~ msgid "" +#~ "Internal error: Neither `input` nor `filename` are given, nothing to read." +#~ msgstr "" +#~ "Erreur interne : Ni ‘input’ ni ‘filename’ ne sont donnés, rien à lire." + +#, c-format +#~ msgid "" +#~ "Internal error: ncol==%d line==%d after detecting sep, ncol and first line" +#~ msgstr "" +#~ "Erreur interne : ncol==%d line==%d après détection de sep, ncol et " +#~ "première ligne" + +#, c-format +#~ msgid "Internal error: first line has field count %d but expecting %d" +#~ msgstr "" +#~ "Erreur interne : la première ligne a un nombre %d de champs mais %d est " +#~ "attendu" + +#~ msgid "" +#~ "Internal error: row before first data row has the same number of fields " +#~ "but we're not using it." +#~ msgstr "" +#~ "Erreur interne : la ligne précédant la première ligne des données a le " +#~ "même nombre de champs mais nous ne l'utilisons pas." + +#~ msgid "" +#~ "Internal error: ch!=pos after counting fields in the line before the " +#~ "first data row." +#~ msgstr "" +#~ "Erreur interne : ch!=pos après avoir compté les champs de la ligne " +#~ "précédant la première ligne des données." + +#~ msgid "" +#~ "Internal error: fill=true but there is a previous row which should " +#~ "already have been filled." +#~ msgstr "" +#~ "Erreur interne : fill=true mais il y a une ligne précédente qui aurait " +#~ "déjà dû être remplie." + +#, c-format +#~ msgid "Internal error: sampleLines(%) > allocnrow(%)" +#~ msgstr "Erreur interne : sampleLines(%) > allocnrow(%)" + +#, c-format +#~ msgid "Internal error: reading colnames ending on '%c'" +#~ msgstr "Erreur interne : lecture des noms de colonnes se terminant par '%c'" + +#, c-format +#~ msgid "Internal error: Master thread is not thread 0 but thread %d.\n" +#~ msgstr "" +#~ "Erreur interne : Le thread principal n'est pas le thread 0 mais le thread " +#~ "%d.\n" + +#, c-format +#~ msgid "" +#~ "Internal error: invalid head position. jump=%d, headPos=%p, " +#~ "thisJumpStart=%p, sof=%p" +#~ msgstr "" +#~ "Erreur interne : position de tête non valide. jump=%d, headPos=%p, " +#~ "thisJumpStart=%p, sof=%p" + +#~ msgid "" +#~ "Internal error: freadR input not a single character string: a filename or " +#~ "the data itself. Should have been caught at R level." +#~ msgstr "" +#~ "Erreur interne : l’entrée de freadR n’est pas un caractère unique: c’est " +#~ "un nom de fichier ou les données elles-mêmes. Cette erreur aurait dû être " +#~ "détectée par R." + +#~ msgid "Internal error: freadR isFileNameArg not TRUE or FALSE" +#~ msgstr "Erreur interne : freadR isFileNameArg ni TRUE ou FALSE" + +#~ msgid "" +#~ "Internal error: freadR sep not a single character. R level catches this." +#~ msgstr "" +#~ "Erreur interne : freadR sep n'est pas un caractère unique. Le code R " +#~ "associé détecte cette erreur." + +#~ msgid "" +#~ "Internal error: freadR dec not a single character. R level catches this." +#~ msgstr "" +#~ "Erreur interne : freadR dec n’est pas un caractère unique. Le code R " +#~ "associé détecte cette erreur." + +#~ msgid "" +#~ "Internal error: freadR nrows not a single real. R level catches this." +#~ msgstr "" +#~ "Erreur interne : freadR nrows pas un unique réel. Le code R associé " +#~ "détecte cette erreur." + +#~ msgid "Internal error: skip not integer or string in freadR.c" +#~ msgstr "" +#~ "Erreur interne : skip n’est pas un entier ou une chaîne de caractère dans " +#~ "freadR.c" + +#, c-format +#~ msgid "Internal error: NAstringsArg is type '%s'. R level catches this" +#~ msgstr "" +#~ "Erreur interne : NAstringsArg est de type '%s'. Le code R associé détecte " +#~ "cette erreur" + +#~ msgid "Internal error: typeSize[CT_BOOL8_N] != 1" +#~ msgstr "Erreur interne : typeSize[CT_BOOL8_N] != 1" + +#~ msgid "Internal error: typeSize[CT_STRING] != 1" +#~ msgstr "Erreur interne : typeSize[CT_STRING] != 1" + +#~ msgid "Internal error: selectInts is NULL but selectColClasses is true" +#~ msgstr "Erreur interne : selectInts est NULL mais selectColClasses est true" + +#~ msgid "" +#~ "Internal error: length(selectSxp)!=length(colClassesSxp) but " +#~ "selectColClasses is true" +#~ msgstr "" +#~ "Erreur interne : length(selectSxp)!=length(colClassesSxp) mais " +#~ "selectColClasses est true" + +#, c-format +#~ msgid "Internal error: unexpected field of size %d\n" +#~ msgstr "Erreur interne : champ inattendu de taille %d\n" + +#, c-format +#~ msgid "" +#~ "Internal error: invalid %s argument in %s function should have been " +#~ "caught earlier. Please report to the data.table issue tracker." +#~ msgstr "" +#~ "Erreur interne : argument %s invalide dans la fonction %s qui aurait dû " +#~ "être détecté plus tôt. Veuillez signaler cette erreur au gestionnaire de " +#~ "tickets (issue tracker) de data.table." + +#, c-format +#~ msgid "Internal error: badaptive=%d but ik is not integer" +#~ msgstr "Erreur interne : badaptive=%d mais ik n'est pas un entier" + +#, c-format +#~ msgid "Internal error: Unknown sfun value in froll: %d" +#~ msgstr "Erreur interne : Valeur inconnue de sfun dans froll : %d" + +#~ msgid "internal error: 'fun' must be a function" +#~ msgstr "erreur interne : 'fun' doit être une fonction" + +#~ msgid "internal error: 'rho' should be an environment" +#~ msgstr "erreur interne : 'rho' devrait être un environnement" + +#~ msgid "Internal error: counts[nBatch-1][MSBsize-1] != length(x)" +#~ msgstr "Erreur interne : counts[nBatch-1][MSBsize-1] != length(x)" + +#, c-format +#~ msgid "Internal error: type %d has no max length method implemented" +#~ msgstr "" +#~ "Erreur interne : le type %d n'a pas de méthode implémentée pour calculer " +#~ "la taille maximale" + +#~ msgid "Internal error: col passed to getMaxCategLen is missing levels" +#~ msgstr "" +#~ "Erreur interne : la colonne transmise à 'getMaxCategLen' manque de niveaux" + +#~ msgid "Internal error: getMaxListItemLen should have caught this up front." +#~ msgstr "" +#~ "Erreur interne : getMaxListItemLen aurait dû détecter cela dès le début." + +#, c-format +#~ msgid "" +#~ "Internal error: row % of list column has no max length method " +#~ "implemented" +#~ msgstr "" +#~ "Erreur interne : la ligne % de la colonne de type liste n'a pas " +#~ "de méthode implémentée pour calculer la taille maximale" + +#~ msgid "" +#~ "Internal error: o's maxgrpn attribute mismatches recalculated maxgrpn" +#~ msgstr "" +#~ "Erreur interne : l'attribut maxgrpn de o ne correspond pas au maxgrpn " +#~ "recalculé" + +#, c-format +#~ msgid "" +#~ "Internal error: nrow=%d ngrp=%d nbit=%d bitshift=%d highSize=%zu " +#~ "nBatch=%zu batchSize=%zu lastBatchSize=%zu\n" +#~ msgstr "" +#~ "Erreur interne : nrow=%d ngrp=%d nbit=%d bitshift=%d highSize=%zu " +#~ "nBatch=%zu batchSize=%zu lastBatchSize=%zu\n" + +#~ msgid "Internal error: gfirstlast headw should only be true when w>1" +#~ msgstr "Erreur interne : gfirstlast headw ne devrait être vrai que si w>1" + +#, c-format +#~ msgid "" +#~ "Internal error: unanticipated case in gfirstlast first=%d w=%d headw=%d" +#~ msgstr "" +#~ "Erreur interne : cas non prévu dans gfirstlast first=%d w=%d headw=%d" + +#~ msgid "" +#~ "Internal error, gtail is only implemented for n>0. This should have been " +#~ "caught before. please report to data.table issue tracker." +#~ msgstr "" +#~ "Erreur interne, gtail n'est implémenté que pour n>0. Cela aurait dû être " +#~ "détecté auparavant. Veuillez signaler ce problème au gestionnaire de " +#~ "tickets (issue tracker) de data.table." + +#~ msgid "" +#~ "Internal error, `g[` (gnthvalue) is only implemented single value subsets " +#~ "with positive index, e.g., .SD[2]. This should have been caught before. " +#~ "please report to data.table issue tracker." +#~ msgstr "" +#~ "Erreur interne, `g[` (gnthvalue) n'est implémenté que pour les sous-" +#~ "ensembles à valeur unique avec un indice positif, par exemple, .SD[2]. " +#~ "Cette erreur aurait dû être détectée auparavant. Veuillez signaler ce " +#~ "problème au gestionnaire de tickets (issue tracker) de data.table." + +#, c-format +#~ msgid "Internal error: nrow [%d] != length(x) [%d] in %s" +#~ msgstr "Erreur interne : nrow [%d] != length(x) [%d] in %s" + +#~ msgid "" +#~ "Internal error: invalid type for gshift(), should have been caught " +#~ "before. please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : type invalide pour gshift(). Cela aurait dû être détecté " +#~ "auparavant. Veuillez signaler ce problème au gestionnaire de tickets " +#~ "(issue tracker) de data.table" + +#~ msgid "Internal error: n must be integer" +#~ msgstr "Erreur interne : n doit être un entier" + +#~ msgid "" +#~ "Internal error: invalid type for convertDate(), should have been caught " +#~ "before. please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : type invalide pour convertDate(). Cela aurait dû être " +#~ "détecté auparavant. Veuillez signaler ce problème au gestionnaire de " +#~ "tickets (issue tracker) de data.table" + +#~ msgid "" +#~ "Internal error: invalid type for convertDate, should have been caught " +#~ "before. please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : type invalide pour convertDate. Cela aurait dû être " +#~ "détecté auparavant. Veuillez signaler ce problème au gestionnaire de " +#~ "tickets (issue tracker) de data.table" + +#~ msgid "" +#~ "Internal error: invalid value for 'mult'; this should have been caught " +#~ "before. please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : valeur invalide pour 'mult' . Ce problème aurait dû être " +#~ "détecté auparavant. Veuillez signaler ce problème au gestionnaire de " +#~ "tickets (issue tracker) de data.table" + +#~ msgid "" +#~ "Internal error: invalid value for 'type'; this should have been caught " +#~ "before. please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : valeur invalide pour 'type' . Ce problème aurait dû être " +#~ "détecté auparavant. Veuillez signaler ce problème au gestionnaire de " +#~ "tickets (issue tracker) de data.table" + +#, c-format +#~ msgid "Internal error: unknown type in mult=%d in lookup: %d" +#~ msgstr "Erreur interne : type inconnu dans mult=%d dans lookup : %d" + +#, c-format +#~ msgid "Internal error: unknown mult in lookup: %d" +#~ msgstr "Erreur interne : mult inconnu dans la recherche : %d" + +#, c-format +#~ msgid "" +#~ "Internal error: unknown type lookup should have been caught earlier: %d" +#~ msgstr "" +#~ "Erreur interne : la recherche de type inconnu aurait dû être détectée " +#~ "plus tôt : %d" + +#, c-format +#~ msgid "" +#~ "Internal error: unknown type in mult=%d in lookup should have been caught " +#~ "earlier: %d" +#~ msgstr "" +#~ "Erreur interne : type inconnu dans mult=%d dans la recherche et aurait dû " +#~ "être détectée plus tôt : %d" + +#, c-format +#~ msgid "Internal error: unknown type in mult=ALL in overlaps: %d" +#~ msgstr "" +#~ "Erreur interne : type inconnu dans mult=ALL dans les chevauchements : %d" + +#, c-format +#~ msgid "Internal error: unknown type in mult=%d in overlaps: %d" +#~ msgstr "" +#~ "Erreur interne : type inconnu dans mult=%d dans les chevauchements : %d" + +#, c-format +#~ msgid "Internal error: unknown mult in overlaps: %d" +#~ msgstr "Erreur interne : mult inconnu dans les chevauchements : %d" + +#~ msgid "nan_is_na must be TRUE or FALSE" +#~ msgstr "nan_is_na doit être TRUE ou FALSE" + +#~ msgid "internal error: 'fill' should be recycled as list already" +#~ msgstr "erreur interne : 'fill' devrait déjà être recyclé en tant que liste" + +#~ msgid "Internal error: percent= must be TRUE or FALSE at C level" +#~ msgstr "Erreur interne : percent= doit être TRUE ou FALSE au niveau de C" + +#, c-format +#~ msgid "" +#~ "Internal error: threads==%d should be between 2 and 100 (percent=TRUE at " +#~ "C level)." +#~ msgstr "" +#~ "Erreur interne : threads==%d devrait être compris entre 2 et 100 " +#~ "(percent=TRUE au niveau de C)." + +#~ msgid "fill= should be TRUE or FALSE" +#~ msgstr "fill= doit être TRUE ou FALSE" + +#~ msgid "Internal error: rbindlist.c idcol is not a single string" +#~ msgstr "Erreur interne : rbindlist.c idcol is not a single string" + +#~ msgid "" +#~ "Internal error: usenames==NA but fill=TRUE. usenames should have been set " +#~ "to TRUE earlier with warning." +#~ msgstr "" +#~ "Erreur interne : usenames==NA but fill=TRUE. usenames aurait dû être mis " +#~ "à TRUE plus tôt avec un avis." + +#~ msgid "" +#~ "Internal error: could not find the first column name not present in " +#~ "earlier item" +#~ msgstr "" +#~ "Erreur interne : le nom de la première colonne n'est pas présent dans " +#~ "l'élément précédent" + +#, c-format +#~ msgid "" +#~ "Internal error: usenames==NA but an out-of-order name has been found in " +#~ "an item with no names or the first item. [%d]" +#~ msgstr "" +#~ "Erreur interne : usenames==NA mais un nom hors ordre a été trouvé dans un " +#~ "élément sans nom ou dans le premier élément. [%d]" + +#, c-format +#~ msgid "" +#~ "Internal error: column %d of result is determined to be integer64 but " +#~ "maxType=='%s' != REALSXP" +#~ msgstr "" +#~ "Erreur interne : la colonne %d du résultat est déterminée comme étant un " +#~ "integer64 mais maxType=='%s' != REALSXP" + +#~ msgid "" +#~ "Internal error in reorder.c: cannot reorder an ALTREP vector. Please see " +#~ "NEWS item 2 in v1.11.4 and report this as a bug." +#~ msgstr "" +#~ "Erreur interne dans reorder.c : impossible de réordonner un vecteur " +#~ "ALTREP. Veuillez consulter le point 2 des NEWS de la version 1.11.4 et " +#~ "signaler cela comme un bug." + +#, c-format +#~ msgid "Internal error: dt passed to setcolorder has %d columns but %d names" +#~ msgstr "" +#~ "Erreur interne : l'objet dt transmis à 'setcolorder' a %d colonnes mais " +#~ "%d noms" + +#~ msgid "" +#~ "Internal error: invalid type for shift(), should have been caught before. " +#~ "please report to data.table issue tracker" +#~ msgstr "" +#~ "Erreur interne : type invalide pour shift(). Ce problème aurait dû être " +#~ "détecté auparavant. Veuillez signaler ce problème au gestionnaire de " +#~ "tickets (issue tracker) de data.table" + +#~ msgid "Internal error: k must be integer" +#~ msgstr "Erreur interne : k doit être un entier" + +#, c-format +#~ msgid "Internal error: subsetVectorRaw length(ans)==%d n=%d" +#~ msgstr "Erreur interne : subsetVectorRaw length(ans)==%d n=%d" + +#, c-format +#~ msgid "" +#~ "Internal error: column type '%s' not supported by data.table subset. All " +#~ "known types are supported so please report as bug." +#~ msgstr "" +#~ "Erreur interne : le type de colonne '%s' n'est pas pris en charge par la " +#~ "fonction subset de data.table. Tous les types connus sont pris en charge, " +#~ "veuillez donc signaler ceci comme un bogue." + +#, c-format +#~ msgid "Internal error. 'idx' is type '%s' not 'integer'" +#~ msgstr "Erreur interne. 'idx' est de type '%s' et non 'integer'" + +#, c-format +#~ msgid "" +#~ "Internal error. 'maxArg' is type '%s' and length %d, should be an integer " +#~ "singleton" +#~ msgstr "" +#~ "Erreur interne. 'maxArg' est de type '%s', de longueur %d, et devrait " +#~ "être un singleton entier" + +#~ msgid "Internal error: allowOverMax must be TRUE/FALSE" +#~ msgstr "Erreur interne : allowOverMax doit être TRUE/FALSE" + +#, c-format +#~ msgid "Internal error. max is %d, must be >= 0." +#~ msgstr "Erreur interne. max est %d, doit être >= 0." + +#~ msgid "Internal error: allowNAArg must be TRUE/FALSE" +#~ msgstr "Erreur interne : allowNAArg doit être TRUE/FALSE" + +#~ msgid "" +#~ "Internal error: NULL can not be subset. It is invalid for a data.table to " +#~ "contain a NULL column." +#~ msgstr "" +#~ "Erreur interne : un sous-ensemble de NULL ne peut pas être créé. Un data." +#~ "table ne peut pas contenir de colonne NULL." + +#~ msgid "" +#~ "Internal error: CsubsetVector is internal-use-only but has received " +#~ "negatives, zeros or out-of-range" +#~ msgstr "" +#~ "Erreur interne : CsubsetVector est à usage interne uniquement mais a reçu " +#~ "des valeurs négatives, des zéros ou des valeurs hors limites" + +#~ msgid "internal error: status, nx, nk must be integer" +#~ msgstr "erreur interne : status, nx, nk must be integer" + +#~ msgid "Internal error: uniqlist has not been passed a list of columns" +#~ msgstr "Erreur interne : 'uniqlist' n'a pas reçu de liste de colonnes" + +#~ msgid "Internal error: uniqlist has been passed a non-integer order" +#~ msgstr "" +#~ "Erreur interne : 'uniqlist' a reçu pour la variable order un autre type " +#~ "qu'un entier" + +#~ msgid "Internal error: uniqlist has been passed a length-0 order" +#~ msgstr "" +#~ "Erreur interne : 'uniqlist' a reçu pour la variable order un élément de " +#~ "longueur 0" + +#, c-format +#~ msgid "" +#~ "Internal error: uniqlist has been passed length(order)==%d but nrow==%d" +#~ msgstr "Erreur interne : 'uniqlist' a reçu length(order)==%d but nrow==%d" + +#~ msgid "Internal error: nestedid was not passed a list length 1 or more" +#~ msgstr "" +#~ "Erreur interne : 'nestedid' n'a pas reçu une liste de longueur 1 ou plus" + +#, c-format +#~ msgid "Internal error: nrows[%d]>0 but ngrps==0" +#~ msgstr "Erreur interne : nrows[%d]>0 mais ngrps==0" + +#, c-format +#~ msgid "Internal error: type '%s' not supported in %s" +#~ msgstr "Erreur interne : le type '%s' n'est pas pris en charge dans %s" + +#, c-format +#~ msgid "Internal error: copyAsPlain returning ALTREP for type '%s'" +#~ msgstr "Erreur interne : copyAsPlain retourne ALTREP pour le type '%s'" diff --git a/src/assign.c b/src/assign.c index 340351d5c..b280c2259 100644 --- a/src/assign.c +++ b/src/assign.c @@ -393,8 +393,10 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values) UNPROTECT(protecti); return(dt); // all items of rows either 0 or NA. !length(newcolnames) for #759 } - if (verbose) Rprintf(_("Added %d new column%s initialized with all-NA\n"), - length(newcolnames), (length(newcolnames)>1)?"s":""); + if (verbose) Rprintf(Pl_(length(newcolnames), + "Added %d new column initialized with all-NA\n", + "Added %d new columns initialized with all-NA\n"), + length(newcolnames)); } } if (!length(cols)) { @@ -435,7 +437,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values) values = PROTECT(eval(PROTECT(lang2(sym_as_posixct, values)), R_GlobalEnv)); protecti+=2; } bool RHS_list_of_columns = TYPEOF(values)==VECSXP && length(cols)>1; // initial value; may be revised below - if (verbose) Rprintf(_("RHS_list_of_columns == %s\n"), RHS_list_of_columns ? "true" : "false"); + if (verbose) + Rprintf("RHS_list_of_columns == %s\n", RHS_list_of_columns ? "true" : "false"); // # notranslate if (TYPEOF(values)==VECSXP && length(cols)==1 && length(values)==1) { SEXP item = VECTOR_ELT(values,0); if (isNull(item) || length(item)==1 || length(item)==targetlen) { @@ -465,11 +468,17 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values) } coln--; SEXP thisvalue = RHS_list_of_columns ? VECTOR_ELT(values, i) : values; - vlen = length(thisvalue); - if (isNull(thisvalue) && !isNull(rows)) error(_("When deleting columns, i should not be provided")); // #1082, #3089 + if (isNull(thisvalue) && !isNull(rows)) { + if (coln >= oldncol) + error(_("Doubly-invalid attempt to delete a non-existent column while also providing i")); + if (TYPEOF(VECTOR_ELT(dt, coln)) == VECSXP) + error(_("Invalid attempt to delete a list column while also providing i; did you intend to add NULL to those rows instead? If so, use list_col := list(list(NULL)).")); // #5526 + error(_("When deleting columns, i should not be provided")); // #1082, #3089 + } if (coln+1 <= oldncol) colnam = STRING_ELT(names,coln); else colnam = STRING_ELT(newcolnames,coln-length(names)); if (coln+1 <= oldncol && isNull(thisvalue)) continue; // delete existing column(s) afterwards, near end of this function + vlen = length(thisvalue); //if (vlen<1 && nrow>0) { if (coln+1 <= oldncol && nrow>0 && vlen<1 && numToDo>0) { // numToDo > 0 fixes #2829, see test 1911 error(_("RHS of assignment to existing column '%s' is zero length but not NULL. If you intend to delete the column use NULL. Otherwise, the RHS must have length > 0; e.g., NA_integer_. If you are trying to change the column type to be an empty list column then, as with all column type changes, provide a full length RHS vector such as vector('list',nrow(DT)); i.e., 'plonk' in the new column."), CHAR(STRING_ELT(names,coln))); @@ -521,6 +530,8 @@ SEXP assign(SEXP dt, SEXP rows, SEXP cols, SEXP newcolnames, SEXP values) else if (TRUELENGTH(names) != oldtncol) // Use (long long) to cast R_xlen_t to a fixed type to robustly avoid -Wformat compiler warnings, see #5768, PRId64 didn't work internal_error(__func__, "selfrefnames is ok but tl names [%lld] != tl [%d]", (long long)TRUELENGTH(names), oldtncol); // # nocov + if (!selfrefok(dt, verbose)) // #6410 setDT(dt) and subsequent attr<- can lead to invalid selfref + error(_("It appears that at some earlier point, attributes of this data.table have been reassigned. Please use setattr(DT, name, value) rather than attr(DT, name) <- value. If that doesn't apply to you, please report your case to the data.table issue tracker.")); SETLENGTH(dt, oldncol+LENGTH(newcolnames)); SETLENGTH(names, oldncol+LENGTH(newcolnames)); for (int i=0; inlevel) { - error(_("Assigning factor numbers to %s. But %d is outside the level range [1,%d]"), targetDesc(colnum, colname), val, nlevel); + if (colnum == 0) + error(_("Assigning factor numbers to target vector. But %d is outside the level range [1,%d]"), val, nlevel); + else + error(_("Assigning factor numbers to column %d named '%s'. But %d is outside the level range [1,%d]"), colnum, colname, val, nlevel); } } } else { @@ -793,7 +807,10 @@ const char *memrecycle(const SEXP target, const SEXP where, const int start, con const double val = sd[i+soff]; // Since nlevel is an int, val < 1 || val > nlevel will deflect UB guarded against in PR #5832 if (!ISNAN(val) && (val < 1 || val > nlevel || val != (int)val)) { - error(_("Assigning factor numbers to %s. But %f is outside the level range [1,%d], or is not a whole number."), targetDesc(colnum, colname), val, nlevel); + if (colnum == 0) + error(_("Assigning factor numbers to target vector. But %f is outside the level range [1,%d], or is not a whole number."), val, nlevel); + else + error(_("Assigning factor numbers to column %d named '%s'. But %f is outside the level range [1,%d], or is not a whole number."), colnum, colname, val, nlevel); } } } @@ -885,42 +902,54 @@ const char *memrecycle(const SEXP target, const SEXP where, const int start, con } } } else if (isString(source) && !isString(target) && !isNewList(target)) { - warning(_("Coercing 'character' RHS to '%s' to match the type of %s."), targetIsI64?"integer64":type2char(TYPEOF(target)), targetDesc(colnum, colname)); + if (colnum == 0) + warning(_("Coercing 'character' RHS to '%s' to match the type of target vector."), targetIsI64?"integer64":type2char(TYPEOF(target))); + else + warning(_("Coercing 'character' RHS to '%s' to match the type of column %d named '%s'."), targetIsI64?"integer64":type2char(TYPEOF(target)), colnum, colname); // this "Coercing ..." warning first to give context in case coerceVector warns 'NAs introduced by coercion' // and also because 'character' to integer/double coercion is often a user mistake (e.g. wrong target column, or wrong // variable on RHS) which they are more likely to appreciate than find inconvenient source = PROTECT(coerceVector(source, TYPEOF(target))); protecti++; } else if (isNewList(source) && !isNewList(target)) { if (targetIsI64) { - error(_("Cannot coerce 'list' RHS to 'integer64' to match the type of %s."), targetDesc(colnum, colname)); + if (colnum == 0) + error(_("Cannot coerce 'list' RHS to 'integer64' to match the type of target vector.")); + else + error(_("Cannot coerce 'list' RHS to 'integer64' to match the type of column %d named '%s'."), colnum, colname); // because R's coerceVector doesn't know about integer64 } // as in base R; e.g. let as.double(list(1,2,3)) work but not as.double(list(1,c(2,4),3)) // relied on by NNS, simstudy and table.express; tests 1294.* - warning(_("Coercing 'list' RHS to '%s' to match the type of %s."), type2char(TYPEOF(target)), targetDesc(colnum, colname)); + if (colnum == 0) + warning(_("Coercing 'list' RHS to '%s' to match the type of target vector."), type2char(TYPEOF(target))); + else + warning(_("Coercing 'list' RHS to '%s' to match the type of column %d named '%s'."), type2char(TYPEOF(target)), colnum, colname); source = PROTECT(coerceVector(source, TYPEOF(target))); protecti++; } else if ((TYPEOF(target)!=TYPEOF(source) || targetIsI64!=sourceIsI64) && !isNewList(target)) { if (GetVerbose()>=3) { // only take the (small) cost of GetVerbose() (search of options() list) when types don't match - Rprintf(_("Zero-copy coerce when assigning '%s' to '%s' %s.\n"), - sourceIsI64 ? "integer64" : type2char(TYPEOF(source)), - targetIsI64 ? "integer64" : type2char(TYPEOF(target)), - targetDesc(colnum, colname)); + const char *sourceType = sourceIsI64 ? "integer64" : type2char(TYPEOF(source)); + const char *targetType = targetIsI64 ? "integer64" : type2char(TYPEOF(target)); + if (colnum == 0) + Rprintf(_("Zero-copy coerce when assigning '%s' to '%s' target vector.\n"), sourceType, targetType); + else + Rprintf(_("Zero-copy coerce when assigning '%s' to column %d named '%s' which is '%s'.\n"), sourceType, colnum, colname, targetType); } // The following checks are up front here, otherwise we'd need them twice in the two branches // inside BODY that cater for 'where' or not. Maybe there's a way to merge the two macros in future. // The idea is to do these range checks without calling coerceVector() (which allocates) - #define CHECK_RANGE(STYPE, RFUN, COND, FMT, TO, FMTVAL) {{ \ + #define CHECK_RANGE(STYPE, RFUN, COND, FMTVAL, FMT) {{ \ const STYPE *sd = (const STYPE *)RFUN(source); \ for (int i=0; i255, "d", "taken as 0", val) + case INTSXP: CHECK_RANGE(int, INTEGER, val<0 || val>255, val, _("%d (type '%s' at RHS position %d taken as 0 when assigning to type '%s' %s")) case REALSXP: if (sourceIsI64) - CHECK_RANGE(int64_t, REAL, val<0 || val>255, PRId64, "taken as 0", val) - else CHECK_RANGE(double, REAL, !R_FINITE(val) || val<0.0 || val>256.0 || (int)val!=val, "f", "either truncated (precision lost) or taken as 0", val) + CHECK_RANGE(int64_t, REAL, val<0 || val>255, val, _("%"PRId64" (type '%s') at RHS position %d taken as 0 when assigning to type '%s' %s")) + else CHECK_RANGE(double, REAL, !R_FINITE(val) || val<0.0 || val>256.0 || (int)val!=val, val, _("%f (type '%s') at RHS position %d either truncated (precision lost) or taken as 0 when assigning to type '%s' %s")) } break; case INTSXP: switch (TYPEOF(source)) { case REALSXP: if (sourceIsI64) - CHECK_RANGE(int64_t, REAL, val!=NA_INTEGER64 && (val<=NA_INTEGER || val>INT_MAX), PRId64, "out-of-range (NA)", val) - else CHECK_RANGE(double, REAL, !ISNAN(val) && (!within_int32_repres(val) || (int)val!=val), "f", "out-of-range(NA) or truncated (precision lost)", val) + CHECK_RANGE(int64_t, REAL, val!=NA_INTEGER64 && (val<=NA_INTEGER || val>INT_MAX), val, _("%"PRId64" (type '%s') at RHS position %d out-of-range (NA) when assigning to type '%s' %s")) + else CHECK_RANGE(double, REAL, !ISNAN(val) && (!within_int32_repres(val) || (int)val!=val), val, _("%f (type '%s') at RHS position %d out-of-range(NA) or truncated (precision lost) when assigning to type '%s' %s")) case CPLXSXP: CHECK_RANGE(Rcomplex, COMPLEX, !((ISNAN(val.i) || (R_FINITE(val.i) && val.i==0.0)) && - (ISNAN(val.r) || (within_int32_repres(val.r) && (int)val.r==val.r))), "f", "either imaginary part discarded or real part truncated (precision lost)", val.r) + (ISNAN(val.r) || (within_int32_repres(val.r) && (int)val.r==val.r))), val.r, _("%f (type '%s') at RHS position %d either imaginary part discarded or real part truncated (precision lost) when assigning to type '%s' %s")) } break; case REALSXP: switch (TYPEOF(source)) { case REALSXP: if (targetIsI64 && !sourceIsI64) - CHECK_RANGE(double, REAL, !ISNAN(val) && (!within_int64_repres(val) || (int64_t)val!=val), "f", "out-of-range(NA) or truncated (precision lost)", val) + CHECK_RANGE(double, REAL, !ISNAN(val) && (!within_int64_repres(val) || (int64_t)val!=val), val, _("%f (type '%s') at RHS position %d out-of-range(NA) or truncated (precision lost) when assigning to type '%s' %s")) break; case CPLXSXP: if (targetIsI64) CHECK_RANGE(Rcomplex, COMPLEX, !((ISNAN(val.i) || (R_FINITE(val.i) && val.i==0.0)) && - (ISNAN(val.r) || (R_FINITE(val.r) && (int64_t)val.r==val.r))), "f", "either imaginary part discarded or real part truncated (precision lost)", val.r) - else CHECK_RANGE(Rcomplex, COMPLEX, !(ISNAN(val.i) || (R_FINITE(val.i) && val.i==0.0)), "f", "imaginary part discarded", val.i) + (ISNAN(val.r) || (R_FINITE(val.r) && (int64_t)val.r==val.r))), val.r, _("%f (type '%s') at RHS position %d either imaginary part discarded or real part truncated (precision lost) when assigning to type '%s' %s")) + else CHECK_RANGE(Rcomplex, COMPLEX, !(ISNAN(val.i) || (R_FINITE(val.i) && val.i==0.0)), val.r, _("%f (type '%s') at RHS position %d imaginary part discarded when assigning to type '%s' %s")) } } } @@ -1161,7 +1190,7 @@ const char *memrecycle(const SEXP target, const SEXP where, const int start, con } } } break; - default : + default : // # nocov error(_("Unsupported column type in assign.c:memrecycle '%s'"), type2char(TYPEOF(target))); // # nocov } UNPROTECT(protecti); @@ -1215,7 +1244,7 @@ void writeNA(SEXP v, const int from, const int n, const bool listNA) case EXPRSXP : for (int i=from; i<=to; ++i) SET_VECTOR_ELT(v, i, R_NilValue); break; - default : + default : // # nocov internal_error(__func__, "Unsupported type '%s' for v", type2char(TYPEOF(v))); // # nocov } } @@ -1254,8 +1283,8 @@ void savetl_init(void) { saveds = (SEXP *)malloc(nalloc * sizeof(SEXP)); savedtl = (R_len_t *)malloc(nalloc * sizeof(R_len_t)); if (!saveds || !savedtl) { - free(saveds); free(savedtl); - savetl_end(); // # nocov + free(saveds); free(savedtl); // # nocov + savetl_end(); // # nocov error(_("Failed to allocate initial %d items in savetl_init"), nalloc); // # nocov } } diff --git a/src/between.c b/src/between.c index 25d85b57c..808bf2d35 100644 --- a/src/between.c +++ b/src/between.c @@ -192,7 +192,7 @@ SEXP between(SEXP x, SEXP lower, SEXP upper, SEXP incbounds, SEXP NAboundsArg, S } if (verbose) Rprintf(_("between non-parallel processing of character took %8.3fs\n"), omp_get_wtime()-tic); } break; - default: + default: // # nocov internal_error(__func__, "unsupported type '%s' should have been caught at R level", type2char(TYPEOF(x))); // # nocov } UNPROTECT(nprotect); diff --git a/src/bmerge.c b/src/bmerge.c index 84519aac9..f6f640e71 100644 --- a/src/bmerge.c +++ b/src/bmerge.c @@ -66,7 +66,8 @@ SEXP bmerge(SEXP idt, SEXP xdt, SEXP icolsArg, SEXP xcolsArg, SEXP xoArg, SEXP r if (xcols[col]>LENGTH(xdt) || xcols[col]<1) error(_("xcols[%d]=%d outside range [1,length(x)=%d]"), col, xcols[col], LENGTH(xdt)); int it = TYPEOF(VECTOR_ELT(idt, icols[col]-1)); int xt = TYPEOF(VECTOR_ELT(xdt, xcols[col]-1)); - if (iN && it!=xt) error(_("typeof x.%s (%s) != typeof i.%s (%s)"), CHAR(STRING_ELT(getAttrib(xdt,R_NamesSymbol),xcols[col]-1)), type2char(xt), CHAR(STRING_ELT(getAttrib(idt,R_NamesSymbol),icols[col]-1)), type2char(it)); + if (iN && it!=xt) + error("typeof x.%s (%s) != typeof i.%s (%s)", CHAR(STRING_ELT(getAttrib(xdt,R_NamesSymbol),xcols[col]-1)), type2char(xt), CHAR(STRING_ELT(getAttrib(idt,R_NamesSymbol),icols[col]-1)), type2char(it)); // # notranslate if (iN && it!=LGLSXP && it!=INTSXP && it!=REALSXP && it!=STRSXP) error(_("Type '%s' is not supported for joining/merging"), type2char(it)); } @@ -160,7 +161,8 @@ SEXP bmerge(SEXP idt, SEXP xdt, SEXP icolsArg, SEXP xcolsArg, SEXP xoArg, SEXP r protecti += 2; SEXP ascArg = PROTECT(ScalarInteger(1)); - SEXP oSxp = PROTECT(forderReuseSorting(idt, icolsArg, /* retGrpArg= */ScalarLogical(FALSE), /* retStatsArg= */ScalarLogical(FALSE), /* sortGroupsArg= */ScalarLogical(TRUE), ascArg, /* naArg= */ScalarLogical(FALSE), /* reuseSortingArg= */ScalarLogical(TRUE))); protecti++; + SEXP reuseSortingArg = INHERITS(idt, char_datatable) ? ScalarLogical(TRUE) : ScalarLogical(FALSE); + SEXP oSxp = PROTECT(forderReuseSorting(idt, icolsArg, /* retGrpArg= */ScalarLogical(FALSE), /* retStatsArg= */ScalarLogical(FALSE), /* sortGroupsArg= */ScalarLogical(TRUE), ascArg, /* naArg= */ScalarLogical(FALSE), reuseSortingArg)); protecti++; UNPROTECT(2); // down stack to 'ascArg' PROTECT(oSxp); @@ -379,8 +381,8 @@ void bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisg } break; // supported types were checked up front to avoid handling an error here in (future) parallel region - default: - error(_("Type '%s' is not supported for joining/merging"), type2char(TYPEOF(xc))); + default: // # nocov + internal_error("Invalid join/merge type '%s' should have been caught earlier", type2char(TYPEOF(xc))); // # nocov } if (xlow1 ? INT64_MAX : 0; + int64_t thenMask = n_this_arg>1 ? INT64_MAX : 0; switch(TYPEOF(ans)) { case LGLSXP: { const int *restrict pthens; if (!naout) pthens = LOGICAL(thens); // the content is not useful if out is NA_LOGICAL scalar int *restrict pans = LOGICAL(ans); const int pna = NA_LOGICAL; - for (int64_t j=0; j= 0")); + if (!isInteger(idx)) + error(_("concat: 'idx' must be an integer vector")); static char ans[1024]; // so only one call to concat() per calling warning/error int nidx=length(idx), nvec=length(vec); @@ -802,7 +803,8 @@ SEXP fmelt(SEXP DT, SEXP id, SEXP measure, SEXP varfactor, SEXP valfactor, SEXP } int protecti=0; dtnames = PROTECT(getAttrib(DT, R_NamesSymbol)); protecti++; - if (isNull(dtnames)) error(_("names(data) is NULL. Please report to data.table-help")); + if (isNull(dtnames)) + internal_error(__func__, "names(data) is NULL"); // # nocov if (LOGICAL(narmArg)[0] == TRUE) narm = TRUE; if (LOGICAL(verboseArg)[0] == TRUE) verbose = TRUE; struct processData data; diff --git a/src/forder.c b/src/forder.c index 4939ade28..398d471f9 100644 --- a/src/forder.c +++ b/src/forder.c @@ -283,8 +283,8 @@ static void cradix(SEXP *x, int n) cradix_counts = (int *)calloc(ustr_maxlen*256, sizeof(int)); // counts for the letters of left-aligned strings cradix_xtmp = (SEXP *)malloc(ustr_n*sizeof(SEXP)); if (!cradix_counts || !cradix_xtmp) { - free(cradix_counts); free(cradix_xtmp); - STOP(_("Failed to alloc cradix_counts and/or cradix_tmp")); + free(cradix_counts); free(cradix_xtmp); // # nocov + STOP(_("Failed to alloc cradix_counts and/or cradix_tmp")); // # nocov } cradix_r(x, n, 0); free(cradix_counts); cradix_counts=NULL; @@ -772,16 +772,15 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA }} free_ustr(); // ustr could be left allocated and reused, but free now in case large and we're tight on ram break; - default: - internal_error_with_cleanup(__func__, "column not supported, not caught earlier"); // # nocov + default: // # nocov + internal_error_with_cleanup(__func__, "column not supported, not caught earlier"); // # nocov } nradix += nbyte-1+(spare==0); TEND(4) - // Rprintf(_("Written key for column %d\n"), col); } if (key[nradix]!=NULL) nradix++; // nradix now number of bytes in key #ifdef TIMING_ON - Rprintf(_("nradix=%d\n"), nradix); + Rprintf("nradix=%d\n", nradix); // # notranslate #endif // global nth, TMP & UGRP @@ -789,8 +788,8 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA TMP = (int *)malloc(nth*UINT16_MAX*sizeof(int)); // used by counting sort (my_n<=65536) in radix_r() UGRP = (uint8_t *)malloc(nth*256); // TODO: align TMP and UGRP to cache lines (and do the same for stack allocations too) if (!TMP || !UGRP /*|| TMP%64 || UGRP%64*/) { - free(TMP); free(UGRP); - STOP(_("Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d"), nth); + free(TMP); free(UGRP); // # nocov + STOP(_("Failed to allocate TMP or UGRP or they weren't cache line aligned: nth=%d"), nth); // # nocov } if (retgrp) { @@ -798,8 +797,8 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA gs_thread_alloc = calloc(nth, sizeof(int)); gs_thread_n = calloc(nth, sizeof(int)); if (!gs_thread || !gs_thread_alloc || !gs_thread_n) { - free(gs_thread); free(gs_thread_alloc); free(gs_thread_n); - STOP(_("Could not allocate (very tiny) group size thread buffers")); + free(gs_thread); free(gs_thread_alloc); free(gs_thread_n); // # nocov + STOP(_("Could not allocate (very tiny) group size thread buffers")); // # nocov } } if (nradix) { @@ -869,9 +868,8 @@ SEXP forder(SEXP DT, SEXP by, SEXP retGrpArg, SEXP retStatsArg, SEXP sortGroupsA for (int i=0; i<=last; i++) { Rprintf(_("Timing block %2d%s = %8.3f %8d\n"), i, (i>=17&&i<=19)?"(*)":" ", tblock[i], nblock[i]); } - for (int i=0; i<=256; i++) { - if (stat[i]) Rprintf(_("stat[%03d]==%20"PRIu64"\n"), i, (uint64_t)stat[i]); - } + for (int i=0; i<=256; i++) if (stat[i]) + Rprintf("stat[%03d]==%20"PRIu64"\n", i, (uint64_t)stat[i]); // # notranslate } #endif return ans; @@ -918,7 +916,7 @@ void radix_r(const int from, const int to, const int radix) { uint8_t *restrict my_key = key[radix]+from; // safe to write as we don't use this radix again uint8_t *o = (uint8_t *)malloc(my_n * sizeof(uint8_t)); if (!o) - STOP(_("Failed to allocate %d bytes for '%s'."), (int)(my_n * sizeof(uint8_t)), "o"); + STOP(_("Failed to allocate %d bytes for '%s'."), (int)(my_n * sizeof(uint8_t)), "o"); // # nocov // if last key (i.e. radix+1==nradix) there are no more keys to reorder so we could reorder osub by reference directly and save allocating and populating o just // to use it once. However, o's type is uint8_t so many moves within this max-256 vector should be faster than many moves in osub (4 byte or 8 byte ints) [1 byte // type is always aligned] @@ -987,8 +985,8 @@ void radix_r(const int from, const int to, const int radix) { // reorder osub and each remaining ksub int *TMP = malloc(my_n * sizeof(int)); if (!TMP) { - free(o); - STOP(_("Failed to allocate %d bytes for '%s'."), (int)(my_n * sizeof(int)), "TMP"); + free(o); // # nocov + STOP(_("Failed to allocate %d bytes for '%s'."), (int)(my_n * sizeof(int)), "TMP"); // # nocov } const int *restrict osub = anso+from; for (int i=0; i= 0; } } break; - default : + default : // # nocov STOP(_("type '%s' is not yet supported"), type2char(TYPEOF(x))); // # nocov } if (!ok) return ScalarLogical(FALSE); // not sorted so return early diff --git a/src/fread.c b/src/fread.c index 932da5a76..7b89b3294 100644 --- a/src/fread.c +++ b/src/fread.c @@ -437,19 +437,16 @@ static const char* filesize_to_str(size_t fsize) snprintf(output, BUFFSIZE, "%"PRIu64" bytes", (uint64_t)lsize); return output; } - -void copyFile(size_t fileSize, const char *msg, bool verbose) // only called in very very rare cases +double copyFile(size_t fileSize) // only called in very very rare cases { double tt = wallclock(); - mmp_copy = (char *)malloc((size_t)fileSize + 1/* extra \0 */); + mmp_copy = (char *)malloc((size_t)fileSize + 1 /* extra \0 */); if (!mmp_copy) - STOP(_("Unable to allocate %s of contiguous virtual RAM. %s allocation."), filesize_to_str(fileSize), msg); + return -1.0; // # nocov memcpy(mmp_copy, mmp, fileSize); sof = mmp_copy; eof = (char *)mmp_copy + fileSize; - tt = wallclock()-tt; - if (tt>0.5) DTPRINT(_("Avoidable %.3f seconds. %s time to copy.\n"), tt, msg); // not warning as that could feasibly cause CRAN tests to fail, say, if test machine is heavily loaded - if (verbose) DTPRINT(_(" File copy in RAM took %.3f seconds.\n"), tt); + return wallclock()-tt; } @@ -566,7 +563,7 @@ static void Field(FieldParseContext *ctx) if (ch!=ch2) fieldStart--; // field ending is this sep|eol; neither (*1) or (*2) happened; opening quote wasn't really an opening quote } break; - default: + default: // # nocov return; // # nocov Internal error: undefined quote rule } target->len = (int32_t)(ch - fieldStart); @@ -1075,7 +1072,6 @@ static void parse_iso8601_timestamp(FieldParseContext *ctx) date_only: - //Rprintf("date=%d\thour=%d\tz_hour=%d\tminute=%d\ttz_minute=%d\tsecond=%.1f\n", date, hour, tz_hour, minute, tz_minute, second); // cast upfront needed to prevent silent overflow *target = 86400*(double)date + 3600*(hour - tz_hour) + 60*(minute - tz_minute) + second; @@ -1236,9 +1232,13 @@ static int detect_types( const char **pch, int8_t type[], int ncol, bool *bumped } } ch = fieldStart; - if (autoDec && IS_DEC_TYPE(tmpType[field]) && dec == '.') { // . didn't parse a double; try , - dec = ','; - continue; + if (autoDec && IS_DEC_TYPE(tmpType[field])) { + if (dec == '.') { // '.' didn't parse a double; try ',' + dec = ','; + continue; // i.e., restart since tmpType not incremented + } else if (dec == ',') { // ',' didn't parse a double either; reset + dec = '\0'; + } } while (++tmpType[field]>, " : "<<%s>>", s[-1]); - DTPRINT(_("]\n")); + DTPRINT("]\n"); // # notranslate if (any_number_like_NAstrings) DTPRINT(_(" One or more of the NAstrings looks like a number.\n")); else @@ -1534,10 +1534,22 @@ int freadMain(freadMainArgs _args) { // field) since we rely on that logic to avoid the copy below when fileSize$4096==0 but there is a final eol ok. // TODO: portable way to discover relevant page size. 4096 is lowest common denominator, though, and should suffice. } else { - const char *msg = _("This file is very unusual: it ends abruptly without a final newline, and also its size is a multiple of 4096 bytes. Please properly end the last row with a newline using for example 'echo >> file' to avoid this "); - if (verbose) DTPRINT(_(" File ends abruptly with '%c'. Copying file in RAM. %s copy.\n"), eof[-1], msg); + const char *msg = _("This file is very unusual: it ends abruptly without a final newline, and also its size is a multiple of 4096 bytes. Please properly end the last row with a newline using for example 'echo >> file'"); + if (verbose) + DTPRINT(_(" File ends abruptly with '%c'. Final end-of-line is missing. Copying file in RAM. %s.\n"), eof[-1], msg); // In future, we may discover a way to mmap fileSize+1 on all OS when fileSize%4096==0, reliably. If and when, this clause can be updated with no code impact elsewhere. - copyFile(fileSize, msg, verbose); + double time_taken = copyFile(fileSize); + if (time_taken == -1.0) { + // # nocov start + if (!verbose) + DTPRINT("%s. Attempt to copy file in RAM failed.", msg); + STOP(_("Unable to allocate %s of contiguous virtual RAM."), filesize_to_str(fileSize)); + // # nocov end + } + if (verbose) + DTPRINT(_(" File copy in RAM took %.3f seconds.\n"), time_taken); + else if (time_taken > 0.5) + DTPRINT(_("Avoidable file copy in RAM took %.3f seconds. %s.\n"), time_taken, msg); // # nocov. not warning as that could feasibly cause CRAN tests to fail, say, if test machine is heavily loaded } } *_const_cast(eof) = '\0'; // cow page @@ -1594,8 +1606,13 @@ int freadMain(freadMainArgs _args) { row1line++; } } - if (ch > sof && verbose) DTPRINT(_(" Skipped to line %"PRIu64" in the file"), (uint64_t)row1line); - if (ch>=eof) STOP(_("skip=%"PRIu64" but the input only has %"PRIu64" line%s"), (uint64_t)args.skipNrow, (uint64_t)row1line, row1line>1?"s":""); + if (ch > sof && verbose) + DTPRINT(_(" Skipped to line %"PRIu64" in the file"), (uint64_t)row1line); + if (ch>=eof) + STOP(Pl_(row1line, + "skip=%"PRIu64" but the input only has %"PRIu64" line", + "skip=%"PRIu64" but the input only has %"PRIu64" lines"), + (uint64_t)args.skipNrow, (uint64_t)row1line); pos = ch; } @@ -1801,10 +1818,22 @@ int freadMain(freadMainArgs _args) { if (ncol==1 && lastEOLreplaced && (eof[-1]=='\n' || eof[-1]=='\r')) { // Multiple newlines at the end are significant in the case of 1-column files only (multiple NA at the end) if (fileSize%4096==0) { - const char *msg = _("This file is very unusual: it's one single column, ends with 2 or more end-of-line (representing several NA at the end), and is a multiple of 4096, too."); - if (verbose) DTPRINT(_(" Copying file in RAM. %s\n"), msg); + const char *msg = _("This file is very unusual: it's one single column, ends with 2 or more end-of-line (representing several NA at the end), and the file size is a multiple of 4096, too"); + if (verbose) + DTPRINT(_(" Copying file in RAM. %s\n"), msg); ASSERT(mmp_copy==NULL, "mmp has already been copied due to abrupt non-eol ending, so it does not end with 2 or more eol.%s", ""/*dummy arg for macro*/); // #nocov - copyFile(fileSize, msg, verbose); + double time_taken = copyFile(fileSize); + if (time_taken == -1.0) { + // # nocov start + if (!verbose) + DTPRINT("%s. Attempt to copy file in RAM failed.", msg); + STOP(_("Unable to allocate %s of contiguous virtual RAM."), filesize_to_str(fileSize)); + // # nocov end + } + if (verbose) + DTPRINT(_(" File copy in RAM took %.3f seconds.\n"), time_taken); + else if (tt>0.5) // # nocov + DTPRINT(_("Avoidable file copy in RAM took %.3f seconds. %s.\n"), time_taken, msg); // # nocov. not warning as that could feasibly cause CRAN tests to fail, say, if test machine is heavily loaded pos = sof + (pos-(const char *)mmp); firstJumpEnd = sof + (firstJumpEnd-(const char *)mmp); } else { @@ -1833,8 +1862,8 @@ int freadMain(freadMainArgs _args) { type = (int8_t *)malloc((size_t)ncol * sizeof(int8_t)); tmpType = (int8_t *)malloc((size_t)ncol * sizeof(int8_t)); // used i) in sampling to not stop on errors when bad jump point and ii) when accepting user overrides if (!type || !tmpType) { - free(type); free(tmpType); - STOP(_("Failed to allocate 2 x %d bytes for type and tmpType: %s"), ncol, strerror(errno)); + free(type); free(tmpType); // # nocov + STOP(_("Failed to allocate 2 x %d bytes for type and tmpType: %s"), ncol, strerror(errno)); // # nocov } if (sep == ',' && dec == '\0') { // if sep=',' detected, don't attempt to detect dec [NB: . is not par of seps] @@ -1863,11 +1892,14 @@ int freadMain(freadMainArgs _args) { // *2 to get a good spacing. We don't want overlaps resulting in double counting. } if (verbose) { - DTPRINT(_(" Number of sampling jump points = %d because "), nJumps); - if (nrowLimit0) nJumps=1; // when nrows>0 supplied by user, no jumps (not even at the end) and single threaded @@ -1905,8 +1937,10 @@ int freadMain(freadMainArgs _args) { } if ( (thisNcol1 && !fill) || (!eol(&ch) && ch!=eof) ) { - if (verbose) DTPRINT(_(" A line with too-%s fields (%d/%d) was found on line %d of sample jump %d. %s\n"), - thisNcol0 ? _("Most likely this jump landed awkwardly so type bumps here will be skipped.") : ""); + if (verbose) + DTPRINT(thisNcol0 ? _("Most likely this jump landed awkwardly so type bumps here will be skipped.") : ""); bumped = false; if (jump==0) lastRowEnd=eof; // to prevent the end from being tested; e.g. a short file with blank line within first 100 like test 976 break; @@ -1977,9 +2011,13 @@ int freadMain(freadMainArgs _args) { if (ch!=pos) INTERNAL_STOP("ch!=pos after counting fields in the line before the first data row"); // # nocov if (verbose) DTPRINT(_("Types in 1st data row match types in 2nd data row but previous row has %d fields. Taking previous row as column names."), tt); if (ttncol) { if (fill) INTERNAL_STOP("fill=true but there is a previous row which should already have been filled"); // # nocov DTWARN(_("Detected %d column names but the data has %d columns. Filling rows automatically. Set fill=TRUE explicitly to avoid this warning.\n"), tt, ncol); @@ -2006,7 +2044,10 @@ int freadMain(freadMainArgs _args) { } if (verbose) { if (sampleLines==0) { - DTPRINT(_(" 'header' determined to be %s because there are%s number fields in the first and only row\n"), args.header?"TRUE":"FALSE", args.header?_(" no"):""); + if (args.header) + DTPRINT(_(" 'header' determined to be TRUE because there are no number fields in the first and only row\n")); + else + DTPRINT(_(" 'header' determined to be FALSE because there are number fields in the first and only row\n")); } else { if (args.header) DTPRINT(_(" 'header' determined to be true because all columns are type string and a better guess is not possible\n")); @@ -2048,14 +2089,14 @@ int freadMain(freadMainArgs _args) { // sd can be very close to 0.0 sometimes, so apply a +10% minimum // blank lines have length 1 so for fill=true apply a +100% maximum. It'll be grown if needed. if (verbose) { - DTPRINT(_(" =====\n")); + DTPRINT(" =====\n"); // # notranslate DTPRINT(_(" Sampled %"PRIu64" rows (handled \\n inside quoted fields) at %d jump points\n"), (uint64_t)sampleLines, nJumps); DTPRINT(_(" Bytes from first data row on line %d to the end of last row: %"PRIu64"\n"), row1line, (uint64_t)bytesRead); DTPRINT(_(" Line length: mean=%.2f sd=%.2f min=%d max=%d\n"), meanLineLen, sd, minLen, maxLen); DTPRINT(_(" Estimated number of rows: %"PRIu64" / %.2f = %"PRIu64"\n"), (uint64_t)bytesRead, meanLineLen, (uint64_t)estnrow); DTPRINT(_(" Initial alloc = %"PRIu64" rows (%"PRIu64" + %d%%) using bytes/max(mean-2*sd,min) clamped between [1.1*estn, 2.0*estn]\n"), (uint64_t)allocnrow, (uint64_t)estnrow, (int)(100.0*allocnrow/estnrow-100.0)); - DTPRINT(_(" =====\n")); + DTPRINT(" =====\n"); // # notranslate } else { if (sampleLines > allocnrow) INTERNAL_STOP("sampleLines(%"PRIu64") > allocnrow(%"PRIu64")", (uint64_t)sampleLines, (uint64_t)allocnrow); // # nocov } @@ -2082,7 +2123,7 @@ int freadMain(freadMainArgs _args) { } else { colNames = (lenOff*) calloc((size_t)ncol, sizeof(lenOff)); if (!colNames) - STOP(_("Unable to allocate %d*%d bytes for column name pointers: %s"), ncol, sizeof(lenOff), strerror(errno)); + STOP(_("Unable to allocate %d*%d bytes for column name pointers: %s"), ncol, sizeof(lenOff), strerror(errno)); // # nocov if (sep==' ') while (*ch==' ') ch++; void *targets[9] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, colNames + autoFirstColName}; FieldParseContext fctx = { @@ -2137,7 +2178,7 @@ int freadMain(freadMainArgs _args) { rowSize8 = 0; size = (int8_t *)malloc((size_t)ncol * sizeof(int8_t)); // TODO: remove size[] when we implement Pasha's idea to += size inside processor if (!size) - STOP(_("Failed to allocate %d bytes for '%s': %s"), (int)(ncol * sizeof(int8_t)), "size", strerror(errno)); + STOP(_("Failed to allocate %d bytes for '%s': %s"), (int)(ncol * sizeof(int8_t)), "size", strerror(errno)); // # nocov nStringCols = 0; nNonStringCols = 0; for (int j=0; jy); // largest first in a safe branchless way casting long to int } +static size_t shrinkMSB(size_t MSBsize, uint64_t *msbCounts, int *order, Rboolean verbose) { + size_t oldMSBsize = MSBsize; + while (MSBsize>0 && msbCounts[order[MSBsize-1]] < 2) + MSBsize--; + if (verbose && oldMSBsize != MSBsize) { + Rprintf(_("Reduced MSBsize from %zu to %zu by excluding 0 and 1 counts\n"), oldMSBsize, MSBsize); + } + return MSBsize; +} + /* OpenMP is used here to find the range and distribution of data for efficient grouping and sorting. @@ -119,7 +129,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) { int nth = getDTthreads(xlength(x), true); int nBatch=nth*2; // at least nth; more to reduce last-man-home; but not too large to keep counts small in cache - if (verbose) Rprintf(_("nth=%d, nBatch=%d\n"),nth,nBatch); + if (verbose) + Rprintf("nth=%d, nBatch=%d\n", nth, nBatch); // # notranslate size_t batchSize = (xlength(x)-1)/nBatch + 1; if (batchSize < 1024) batchSize = 1024; // simple attempt to work reasonably for short vector. 1024*8 = 2 4kb pages @@ -132,8 +143,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) { double *mins = (double *)malloc(nBatch * sizeof(double)); double *maxs = (double *)malloc(nBatch * sizeof(double)); if (!mins || !maxs) { - free(mins); free(maxs); - error(_("Failed to allocate %d bytes in fsort()."), (int)(2 * nBatch * sizeof(double))); + free(mins); free(maxs); // # nocov + error(_("Failed to allocate %d bytes in fsort()."), (int)(2 * nBatch * sizeof(double))); // # nocov } const double *restrict xp = REAL(x); #pragma omp parallel for schedule(dynamic) num_threads(getDTthreads(nBatch, false)) @@ -175,7 +186,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) { int MSBNbits = maxBit > 15 ? 16 : maxBit+1; // how many bits make up the MSB int shift = maxBit + 1 - MSBNbits; // the right shift to leave the MSB bits remaining size_t MSBsize = 1LL< 65,536) - if (verbose) Rprintf(_("maxBit=%d; MSBNbits=%d; shift=%d; MSBsize=%zu\n"), maxBit, MSBNbits, shift, MSBsize); + if (verbose) + Rprintf("maxBit=%d; MSBNbits=%d; shift=%d; MSBsize=%zu\n", maxBit, MSBNbits, shift, MSBsize); // # notranslate uint64_t *counts = (uint64_t *)R_alloc(nBatch*MSBsize, sizeof(uint64_t)); memset(counts, 0, nBatch*MSBsize*sizeof(uint64_t)); @@ -252,12 +264,8 @@ SEXP fsort(SEXP x, SEXP verboseArg) { if (verbose) { Rprintf(_("Top 20 MSB counts: ")); for(int i=0; i0 && msbCounts[order[MSBsize-1]] < 2) MSBsize--; - if (verbose) { - Rprintf(_("%zu by excluding 0 and 1 counts\n"), MSBsize); } + MSBsize = shrinkMSB(MSBsize, msbCounts, order, verbose); bool failed=false, alloc_fail=false, non_monotonic=false; // shared bools only ever assigned true; no need for atomic or critical assign t[6] = wallclock(); diff --git a/src/fwrite.c b/src/fwrite.c index 91ec977f2..e6d149750 100644 --- a/src/fwrite.c +++ b/src/fwrite.c @@ -465,6 +465,7 @@ void writePOSIXct(const void *col, int64_t row, char **pch) *pch = ch; } +// # nocov start. Covered in other.Rraw test 22, not the main suite. void writeNanotime(const void *col, int64_t row, char **pch) { int64_t x = ((const int64_t *)col)[row]; @@ -497,6 +498,7 @@ void writeNanotime(const void *col, int64_t row, char **pch) } *pch = ch; } +// # nocov end static inline void write_string(const char *x, char **pch) { @@ -628,15 +630,16 @@ void fwriteMain(fwriteMainArgs args) if (verbose) { DTPRINT(_("Column writers: ")); + // # notranslate start if (args.ncol<=50) { - for (int j=0; j= 2) { if (verbose && !hasPrinted) DTPRINT("\n"); - DTPRINT("\rWritten %.1f%% of %"PRId64" rows in %d secs using %d thread%s. " - "maxBuffUsed=%d%%. ETA %d secs. ", - (100.0*end)/args.nrow, args.nrow, (int)(now-startTime), nth, nth==1?"":"s", - maxBuffUsedPC, ETA); + DTPRINT(Pl_(nth, + "\rWritten %.1f%% of %"PRId64" rows in %d secs using %d thread. maxBuffUsed=%d%%. ETA %d secs. ", + "\rWritten %.1f%% of %"PRId64" rows in %d secs using %d threads. maxBuffUsed=%d%%. ETA %d secs. "), + (100.0*end)/args.nrow, args.nrow, (int)(now-startTime), nth, maxBuffUsedPC, ETA); // TODO: use progress() as in fread nextTime = now+1; hasPrinted = true; diff --git a/src/gsumm.c b/src/gsumm.c index 7b6c12b59..7f0eb75df 100644 --- a/src/gsumm.c +++ b/src/gsumm.c @@ -60,7 +60,8 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) { } else error(_("irowsArg is neither an integer vector nor NULL")); // # nocov ngrp = LENGTH(l); - if (LENGTH(f) != ngrp) error(_("length(f)=%d != length(l)=%d"), LENGTH(f), ngrp); + if (LENGTH(f) != ngrp) + error("length(f)=%d != length(l)=%d", LENGTH(f), ngrp); // # notranslate nrow=0; grpsize = INTEGER(l); maxgrpn = 0; @@ -119,8 +120,8 @@ SEXP gforce(SEXP env, SEXP jsub, SEXP o, SEXP f, SEXP l, SEXP irowsArg) { int *counts = calloc(nBatch*highSize, sizeof(int)); // TODO: cache-line align and make highSize a multiple of 64 int *TMP = malloc(nrow*2l*sizeof(int)); // must multiple the long int otherwise overflow may happen, #4295 if (!counts || !TMP ) { - free(counts); free(TMP); - error(_("Failed to allocate counts or TMP when assigning g in gforce")); + free(counts); free(TMP); // # nocov + error(_("Failed to allocate counts or TMP when assigning g in gforce")); // # nocov } #pragma omp parallel for num_threads(getDTthreads(nBatch, false)) // schedule(dynamic,1) for (int b=0; b #define _(String) dgettext("data.table", String) +// NB: flip argument order to match that of R's ngettext() +#define Pl_(n, String1, StringPlural) dngettext("data.table", String1, StringPlural, n) #else #define _(String) (String) +#define Pl_(n, String1, StringPlural) ((n) == 1 ? (String1) : (StringPlural)) #endif diff --git a/src/rbindlist.c b/src/rbindlist.c index 56a122e6d..9b65ec4c7 100644 --- a/src/rbindlist.c +++ b/src/rbindlist.c @@ -57,8 +57,10 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg, SEXP ignor if (numZero) { // #1871 SEXP names = getAttrib(VECTOR_ELT(l, firstZeroItem), R_NamesSymbol); const char *ch = names==R_NilValue ? "" : CHAR(STRING_ELT(names, firstZeroCol)); - warning(_("Column %d ['%s'] of item %d is length 0. This (and %d other%s like it) has been filled with NA (NULL for list columns) to make each item uniform."), - firstZeroCol+1, ch, firstZeroItem+1, numZero-1, numZero==2?"":"s"); + warning(Pl_(numZero-1, + "Column %d ['%s'] of item %d is length 0. This (and %d other like it) has been filled with NA (NULL for list columns) to make each item uniform.", + "Column %d ['%s'] of item %d is length 0. This (and %d others like it) has been filled with NA (NULL for list columns) to make each item uniform."), + firstZeroCol+1, ch, firstZeroItem+1, numZero-1); } if (nrow==0 && ncol==0) return(R_NilValue); if (nrow>INT32_MAX) error(_("Total rows in the list is %"PRId64" which is larger than the maximum number of rows, currently %d"), (int64_t)nrow, INT32_MAX); @@ -71,7 +73,7 @@ SEXP rbindlist(SEXP l, SEXP usenamesArg, SEXP fillArg, SEXP idcolArg, SEXP ignor // first find number of unique column names present; i.e. length(unique(unlist(lapply(l,names)))) SEXP *uniq = (SEXP *)malloc(upperBoundUniqueNames * sizeof(SEXP)); // upperBoundUniqueNames was initialized with 1 to ensure this is defined (otherwise 0 when no item has names) if (!uniq) - error(_("Failed to allocate upper bound of %"PRId64" unique column names [sum(lapply(l,ncol))]"), (int64_t)upperBoundUniqueNames); + error(_("Failed to allocate upper bound of %"PRId64" unique column names [sum(lapply(l,ncol))]"), (int64_t)upperBoundUniqueNames); // # nocov savetl_init(); int nuniq=0; for (int i=0; i= ((int64_t *)xd)[previ] : dtwiddle(xd[thisi]) >= dtwiddle(xd[previ]); } break; - default: + default: // # nocov error(_("Type '%s' is not supported"), type2char(TYPEOF(v))); // # nocov } } diff --git a/src/utils.c b/src/utils.c index 9d204eba1..b88a07985 100644 --- a/src/utils.c +++ b/src/utils.c @@ -286,7 +286,11 @@ void copySharedColumns(SEXP x) { if (shared[i]) SET_VECTOR_ELT(x, i, copyAsPlain(xp[i])); } - if (GetVerbose()) Rprintf(_("Found and copied %d column%s with a shared memory address\n"), nShared, nShared>1?"s":""); + if (GetVerbose()) + Rprintf(Pl_(nShared, + "Found and copied %d column with a shared memory address\n", + "Found and copied %d columns with a shared memory address\n"), + nShared); // GetVerbose() (slightly expensive call of all options) called here only when needed } } @@ -384,7 +388,7 @@ SEXP coerceAs(SEXP x, SEXP as, SEXP copyArg) { Rprintf(_("Coercing %s[%s] into %s[%s]\n"), type2char(TYPEOF(x)), class1(x), type2char(TYPEOF(as)), class1(as)); const char *ret = memrecycle(/*target=*/ans, /*where=*/R_NilValue, /*start=*/0, /*len=*/LENGTH(x), /*source=*/x, /*sourceStart=*/0, /*sourceLen=*/-1, /*colnum=*/0, /*colname=*/""); if (ret) - warning(_("%s"), ret); + warning("%s", ret); // # notranslate UNPROTECT(1); return ans; } diff --git a/vignettes/datatable-faq.Rmd b/vignettes/datatable-faq.Rmd index 8d949bfa9..eb03ce694 100644 --- a/vignettes/datatable-faq.Rmd +++ b/vignettes/datatable-faq.Rmd @@ -632,7 +632,7 @@ Yes, for both 32-bit and 64-bit on all platforms. Thanks to CRAN. There are no s ## I think it's great. What can I do? Please file suggestions, bug reports and enhancement requests on our [issues tracker](https://github.com/Rdatatable/data.table/issues). This helps make the package better. -Please do star the package on [GitHub](https://github.com/Rdatatable/data.table/wiki). This helps encourage the developers and helps other R users find the package. +Please do star the package on [GitHub](https://github.com/Rdatatable/data.table). This helps encourage the developers and helps other R users find the package. You can submit pull requests to change the code and/or documentation yourself; see our [Contribution Guidelines](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md). diff --git a/vignettes/datatable-importing.Rmd b/vignettes/datatable-importing.Rmd index 484047317..2d08ffcf9 100644 --- a/vignettes/datatable-importing.Rmd +++ b/vignettes/datatable-importing.Rmd @@ -15,7 +15,7 @@ h2 { } -This document is focused on using `data.table` as a dependency in other R packages. If you are interested in using `data.table` C code from a non-R application, or in calling its C functions directly, jump to the [last section](#non-r-API) of this vignette. +This document is focused on using `data.table` as a dependency in other R packages. If you are interested in using `data.table` C code from a non-R application, or in calling its C functions directly, jump to the [last section](#non-r-api) of this vignette. Importing `data.table` is no different from importing other R packages. This vignette is meant to answer the most common questions arising around that subject; the lessons presented here can be applied to other R packages. @@ -27,11 +27,11 @@ One of the biggest features of `data.table` is its concise syntax which makes ex It is very easy to use `data.table` as a dependency due to the fact that `data.table` does not have any of its own dependencies. This applies both to operating system and to R dependencies. It means that if you have R installed on your machine, it already has everything needed to install `data.table`. It also means that adding `data.table` as a dependency of your package will not result in a chain of other recursive dependencies to install, making it very convenient for offline installation. -## `DESCRIPTION` file {DESCRIPTION} +## `DESCRIPTION` file {#DESCRIPTION} The first place to define a dependency in a package is the `DESCRIPTION` file. Most commonly, you will need to add `data.table` under the `Imports:` field. Doing so will necessitate an installation of `data.table` before your package can compile/install. As mentioned above, no other packages will be installed because `data.table` does not have any dependencies of its own. You can also specify the minimal required version of a dependency; for example, if your package is using the `fwrite` function, which was introduced in `data.table` in version 1.9.8, you should incorporate this as `Imports: data.table (>= 1.9.8)`. This way you can ensure that the version of `data.table` installed is 1.9.8 or later before your users will be able to install your package. Besides the `Imports:` field, you can also use `Depends: data.table` but we strongly discourage this approach (and may disallow it in future) because this loads `data.table` into your user's workspace; i.e. it enables `data.table` functionality in your user's scripts without them requesting that. `Imports:` is the proper way to use `data.table` within your package without inflicting `data.table` on your user. In fact, we hope the `Depends:` field is eventually deprecated in R since this is true for all packages. -## `NAMESPACE` file {NAMESPACE} +## `NAMESPACE` file {#NAMESPACE} The next thing is to define what content of `data.table` your package is using. This needs to be done in the `NAMESPACE` file. Most commonly, package authors will want to use `import(data.table)` which will import all exported (i.e., listed in `data.table`'s own `NAMESPACE` file) functions from `data.table`. @@ -195,7 +195,7 @@ For more canonical documentation of defining packages dependency check the offic Some of internally used C routines are now exported on C level thus can be used in R packages directly from their C code. See [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) for details and [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) _Linking to native routines in other packages_ section for usage. -## Importing from non-r Applications {non-r-api} +## Importing from non-r Applications {#non-r-api} Some tiny parts of `data.table` C code were isolated from the R C API and can now be used from non-R applications by linking to .so / .dll files. More concrete details about this will be provided later; for now you can study the C code that was isolated from the R C API in [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) and [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c). @@ -275,7 +275,7 @@ result <- merge(dt, other_dt, by = "x") ``` ### Benefits of using `Imports` -- **User-Friendliness*: `Depends` alters your users' `search()` path, possibly without their wanting to do so. +- **User-Friendliness**: `Depends` alters your users' `search()` path, possibly without their wanting to do so. - **Namespace Management**: Only the functions your package explicitly imports are available, reducing the risk of function name clashes. - **Cleaner Package Loading**: Your package's dependencies are not attached to the search path, making the loading process cleaner and potentially faster. - **Easier Maintenance**: It simplifies maintenance tasks as upstream dependencies' APIs evolve. Depending too much on `Depends` can lead to conflicts and compatibility issues over time. diff --git a/vignettes/datatable-intro.Rmd b/vignettes/datatable-intro.Rmd index 5f2718ec1..e08280c5c 100644 --- a/vignettes/datatable-intro.Rmd +++ b/vignettes/datatable-intro.Rmd @@ -665,7 +665,7 @@ We can do much more in `i` by keying a `data.table`, which allows for blazing fa 3. Compute on columns: `DT[, .(sum(colA), mean(colB))]`. -4. Provide names if necessary: `DT[, .(sA =sum(colA), mB = mean(colB))]`. +4. Provide names if necessary: `DT[, .(sA = sum(colA), mB = mean(colB))]`. 5. Combine with `i`: `DT[colA > value, sum(colB)]`. diff --git a/vignettes/datatable-reference-semantics.Rmd b/vignettes/datatable-reference-semantics.Rmd index e46412b5e..170783165 100644 --- a/vignettes/datatable-reference-semantics.Rmd +++ b/vignettes/datatable-reference-semantics.Rmd @@ -68,7 +68,7 @@ DF$c <- 18:13 # (1) -- replace entire column DF$c[DF$ID == "b"] <- 15:13 # (2) -- subassign in column 'c' ``` -both (1) and (2) resulted in deep copy of the entire data.frame in versions of `R` versions `< 3.1`. [It copied more than once](https://stackoverflow.com/q/23898969/559784). To improve performance by avoiding these redundant copies, *data.table* utilised the [available but unused `:=` operator in R](https://stackoverflow.com/q/7033106/559784). +both (1) and (2) resulted in deep copy of the entire data.frame in versions of `R < 3.1`. [It copied more than once](https://stackoverflow.com/q/23898969/559784). To improve performance by avoiding these redundant copies, *data.table* utilised the [available but unused `:=` operator in R](https://stackoverflow.com/q/7033106/559784). Great performance improvements were made in `R v3.1` as a result of which only a *shallow* copy is made for (1) and not *deep* copy. However, for (2) still, the entire column is *deep* copied even in `R v3.1+`. This means the more columns one subassigns to in the *same query*, the more *deep* copies R does. @@ -247,7 +247,7 @@ head(flights) * We use the `LHS := RHS` form. We store the input column names and the new columns to add in separate variables and provide them to `.SDcols` and for `LHS` (for better readability). -* Note that since we allow assignment by reference without quoting column names when there is only one column as explained in [Section 2c](#delete-convenience), we can not do `out_cols := lapply(.SD, max)`. That would result in adding one new column named `out_col`. Instead we should do either `c(out_cols)` or simply `(out_cols)`. Wrapping the variable name with `(` is enough to differentiate between the two cases. +* Note that since we allow assignment by reference without quoting column names when there is only one column as explained in [Section 2c](#delete-convenience), we can not do `out_cols := lapply(.SD, max)`. That would result in adding one new column named `out_cols`. Instead we should do either `c(out_cols)` or simply `(out_cols)`. Wrapping the variable name with `(` is enough to differentiate between the two cases. * The `LHS := RHS` form allows us to operate on multiple columns. In the RHS, to compute the `max` on columns specified in `.SDcols`, we make use of the base function `lapply()` along with `.SD` in the same way as we have seen before in the *"Introduction to data.table"* vignette. It returns a list of two elements, containing the maximum value corresponding to `dep_delay` and `arr_delay` for each group. diff --git a/vignettes/datatable-reshape.Rmd b/vignettes/datatable-reshape.Rmd index 41b36c1a0..e5efb660f 100644 --- a/vignettes/datatable-reshape.Rmd +++ b/vignettes/datatable-reshape.Rmd @@ -80,7 +80,7 @@ str(DT.m1) * `measure.vars` specify the set of columns we would like to collapse (or combine) together. -* We can also specify column *indices* instead of *names*. +* We can also specify column *positions* instead of *names*. * By default, `variable` column is of type `factor`. Set `variable.factor` argument to `FALSE` if you'd like to return a *`character`* vector instead. @@ -157,7 +157,7 @@ DT.m1[, c("variable", "child") := tstrsplit(variable, "_", fixed = TRUE)] DT.c1 = dcast(DT.m1, family_id + age_mother + child ~ variable, value.var = "value") DT.c1 -str(DT.c1) ## gender column is character type now! +str(DT.c1) ## gender column is class IDate now! ``` #### Issues @@ -241,7 +241,7 @@ melt(two.iris, measure.vars = measure(value.name, dim, sep=".")) ``` Using the code above we get one value column per flower part. If we -instead want a value column for each measurement dimension, we can do +instead want a value column for each measurement dimension, we can do: ```{r} melt(two.iris, measure.vars = measure(part, value.name, sep="."))