Last updated on 2024-03-28 19:48:43 CET.
Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
---|---|---|---|---|---|---|
r-devel-linux-x86_64-debian-clang | 1.0.0.1 | 19.13 | 42.90 | 62.03 | OK | |
r-devel-linux-x86_64-debian-gcc | 1.0.0.1 | 16.70 | 31.35 | 48.05 | OK | |
r-devel-linux-x86_64-fedora-clang | 1.0.0.1 | 75.24 | OK | |||
r-devel-linux-x86_64-fedora-gcc | 1.0.0.1 | 79.63 | OK | |||
r-devel-windows-x86_64 | 1.0.0.1 | 20.00 | 1054.00 | 1074.00 | ERROR | |
r-patched-linux-x86_64 | 1.0.0.1 | 20.06 | 39.49 | 59.55 | OK | |
r-release-linux-x86_64 | 1.0.0.1 | 21.85 | 39.39 | 61.24 | OK | |
r-release-macos-arm64 | 1.0.0.1 | 29.00 | OK | |||
r-release-macos-x86_64 | 1.0.0.1 | 62.00 | OK | |||
r-release-windows-x86_64 | 1.0.0.1 | 21.00 | 63.00 | 84.00 | OK | |
r-oldrel-macos-arm64 | 1.0.0.1 | 30.00 | OK | |||
r-oldrel-windows-x86_64 | 1.0.0.1 | 23.00 | 62.00 | 85.00 | OK |
Version: 1.0.0.1
Check: tests
Result: ERROR
Running 'test_block_write.R' [171s]
Running 'test_bracket1.R' [168s]
Running 'test_bracket2.R' [159s]
Running 'test_extent_index.R' [168s]
Running 'test_fused_write_object1.R' [0s]
Comparing 'test_fused_write_object1.Rout' to 'test_fused_write_object1.Rout.save' ... OK
Running 'test_hash.R' [164s]
Running 'test_indexed_copy.R' [1s]
Comparing 'test_indexed_copy.Rout' to 'test_indexed_copy.Rout.save' ... OK
Running 'test_order1.R' [170s]
Running the tests in 'tests/test_block_write.R' failed.
Complete output:
> require("RMVL")
Loading required package: RMVL
>
> mvl_block_write<-function(MVLHANDLE, N, f, name=NULL, block=1000, type=NULL, ...) {
+ obj<-NULL
+ offset<-NULL
+ for(i in seq(1.0, N, by=block)) {
+ idx<-i-1+(1:block)
+ idx<-idx[idx<=N]
+
+ v<-f(idx, ...)
+
+ if(is.null(obj)) {
+ if(!is.null(type))attr(v, "MVL_TYPE")<-type
+ offset<-mvl_start_write_vector(MVLHANDLE, v, expected.length=N, name=name)
+ MVLHANDLE<-mvl_remap(MVLHANDLE)
+ obj<-MVLHANDLE[offset,ref=TRUE]
+ } else {
+ mvl_rewrite_vector(obj, i, v)
+ }
+ }
+ return(invisible(offset))
+ }
>
> test_write<-function(MVLHANDLE, vec, name, block=1000) {
+ f<-function(idx) { return(vec[idx]) }
+
+ mvl_block_write(M, length(vec), f, name=name, block=block)
+
+ MVLHANDLE<-mvl_remap(MVLHANDLE)
+
+ if(any(vec!=mvl2R(MVLHANDLE[name]))) {
+ cat("Block write test", name, "failed\n")
+ print(all.equal(vec, mvl2R(MVLHANDLE[name])))
+ }
+ }
>
> M<-mvl_open("test1.mvl", append=TRUE, create=TRUE)
>
> test_write(M, rnorm(1e6), "double1")
> test_write(M, as.integer(1:1e6), "int1")
> test_write(M, as.integer(1:1e6) %% 2==0, "logical1")
> test_write(M, as.Date("2001-01-01")+as.integer(1:1e6), "date1")
>
> mvl_close(M)
> unlink("test1.mvl")
>
>
>
>
> proc.time()
user system elapsed
0.57 0.29 0.85
Running the tests in 'tests/test_bracket1.R' failed.
Complete output:
> require("RMVL")
Loading required package: RMVL
>
> M3<-mvl_open("test2.mvl", append=TRUE, create=TRUE)
>
> L<-list()
>
> df<-data.frame(x=1:1e5, y=rnorm(1e5), s=rep(c("a", "b"), 5e4), b=rnorm(1e5)<0.5)
> L[["x"]]<-mvl_write_object(M3, df)
>
> aa<-array(rnorm(10000), c(10, 50, 20))
> L[["y"]]<-aa
>
> mm<-matrix(rnorm(10000), 10, 1000)
> L[["z"]]<-mm
>
> LL2<-as.list(rnorm(10000))
> names(LL2)<-paste("x", 1:10000, sep="")
> L[["LL2"]]<-LL2
>
> L[["description"]]<-"Example of large data frame"
> mvl_write_object(M3, L, "test_object")
>
> LM1<-lm(rnorm(100)~runif(100))
> mvl_write_serialized_object(M3, LM1, "LM1")
>
> mvl_close(M3)
>
> M3<-mvl_open("test2.mvl")
> print(names(M3))
[1] "test_object" "LM1"
> L2<-M3["test_object"]
>
> N<-dim(df)[1]
>
> compare_df<-function(x, y) {
+ if(length(dim(x))!=length(dim(y)))return(FALSE)
+ if(any(dim(x)!=dim(y)))return(FALSE)
+ if(any(names(x)!=names(y)))return(FALSE)
+ if(dim(x)[2]>0) {
+ for(i in 1:(dim(x)[2])) {
+ if(any(x[,i]!=y[,i]))return(FALSE)
+ }
+ }
+ return(TRUE)
+ }
>
> if(!compare_df(df, L2[["x"]][,])) {
+ cat("test1a failed\n")
+ print(attributes(df))
+ print(attributes(L2[["x"]][,]))
+ cat("-----------\n")
+ }
> if(!compare_df(df[1:20,], L2[["x"]][1:20,]))cat("test1b failed\n")
>
> if(!compare_df(df[(1:N) %% 5==0,], L2[["x"]][(1:N) %% 5==0,]))cat("test2 failed\n")
>
> if(!compare_df(df[(1:N) %% 5==0,], L2[["x"]][(1:N)[(1:N) %% 5==0],]))cat("test3 failed\n")
>
> if(!compare_df(df[(1:N) %% 5==0, c("y", "s")], L2[["x"]][(1:N)[(1:N) %% 5==0], c("y", "s")]))cat("test4 failed\n")
>
> if(!identical(df[(1:N) %% 5==0, c("s")], L2[["x"]][(1:N)[(1:N) %% 5==0], c("s")]))cat("test5 failed\n")
>
> if(!compare_df(df[(1:N) %% 5==0, 2:3], L2[["x"]][(1:N)[(1:N) %% 5==0], 2:3]))cat("test6 failed\n")
>
> if(!isTRUE(all.equal(aa, L2[["y"]][])))cat("test7 failed\n")
> if(!compare_df(mm, L2[["z"]][])) {
+ cat("test8 failed\n")
+ print(all.equal(mm, L2[["z"]][]))
+ print(attributes(mm))
+ print(attributes(L2[["z"]][]))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(aa[c(2,3,5),,], L2[["y"]][c(2,3,5),,])))cat("test9 failed\n")
> if(!isTRUE(all.equal(aa[,c(2,3,5),], L2[["y"]][,c(2,3,5),])))cat("test10 failed\n")
> if(!isTRUE(all.equal(aa[,,c(2,3,5)], L2[["y"]][,,c(2,3,5)])))cat("test11 failed\n")
> if(!isTRUE(all.equal(aa[c(2,3,5),c(6,10,20),c(7,3,5)], L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5)])))cat("test12 failed\n")
>
> if(!isTRUE(all.equal(mm[c(2,3,5),], L2[["z"]][c(2,3,5),])))cat("test13 failed\n")
> if(!isTRUE(all.equal(mm[,c(2,3,5)], L2[["z"]][,c(2,3,5)])))cat("test14 failed\n")
> if(!isTRUE(all.equal(mm[c(2,3,5),c(6,10,20)], L2[["z"]][c(2,3,5),c(6,10,20)])))cat("test15 failed\n")
>
> if(!isTRUE(all.equal(LL2, L2[["LL2"]][]))) {
+ cat("test16 failed\n")
+ print(all.equal(LL2, L2[["LL2"]][]))
+ cat("-----------\n")
+ }
>
> idx1<-20:2001
> if(!isTRUE(all.equal(LL2[idx1], L2[["LL2"]][idx1]))) {
+ cat("test17 failed\n")
+ print(all.equal(LL2[idx1], L2[["LL2"]][idx1]))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(LL2[5], L2[["LL2"]][5]))) {
+ cat("test18 failed\n")
+ print(all.equal(LL2[5], L2[["LL2"]][5]))
+ print(LL2[5])
+ print(L2[["LL2"]][5])
+ cat("-----------\n")
+ }
>
> if(!identical(LM1, mvl2R(M3["LM1"]))) {
+ cat("test19 failed\n")
+ print(all.equal(LM1, mvl2R(M3["LM1"])))
+ cat("-----------\n")
+ }
>
> # TODO:
> # Testing of [,raw=TRUE] is complicated because R's as.raw() function is only meant for conversion of characters,
> # while MVL raw mode only returns raw vectors when there is no equivalent R vector (such as the case of floats and INT64)
> #
> # if(!isTRUE(all.equal(as.raw(aa[c(2,3,5),c(6,10,20),c(7,3,5)]), L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5),raw=TRUE]))){
> # cat("test19 failed\n")
> # print(all.equal(as.raw(aa[c(2,3,5),c(6,10,20),c(7,3,5)]), L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5),raw=TRUE]))
> # print(as.raw(aa[c(2,3,5),c(6,10,20),c(7,3,5)]))
> # print(L2[["y"]][c(2,3,5),c(6,10,20),c(7,3,5),raw=TRUE])
> # cat("-----------\n")
> # }
>
> print(mvl_object_stats(L2[["x"]])[c("length", "type")])
$length
[1] 4
$type
[1] 100
> print(mvl_object_stats(L2[["y"]])[c("length", "type")])
$length
[1] 10000
$type
[1] 5
> print(mvl_object_stats(L2[["z"]])[c("length", "type")])
$length
[1] 10000
$type
[1] 5
> print(mvl_object_stats(L2[["LL2"]])[c("length", "type")])
$length
[1] 10000
$type
[1] 100
>
> mvl_close(M3)
>
> unlink("test2.mvl")
>
>
> proc.time()
user system elapsed
1.14 0.15 1.28
Running the tests in 'tests/test_bracket2.R' failed.
Complete output:
> require("RMVL")
Loading required package: RMVL
>
> M3<-mvl_open("test_bracket2a.mvl", append=TRUE, create=TRUE)
>
> L<-list()
>
> df<-data.frame(x=1:1e5, y=rnorm(1e5), s=rep(c("a", "b"), 5e4), b=rnorm(1e5)<0.5)
> L[["x"]]<-mvl_write_object(M3, df)
>
> aa<-array(rnorm(10000), c(10, 50, 20))
> L[["y"]]<-aa
>
> mm<-matrix(rnorm(10000), 10, 1000)
> L[["z"]]<-mm
>
> LL2<-as.list(rnorm(10000))
> names(LL2)<-paste("x", 1:10000, sep="")
> L[["LL2"]]<-LL2
>
> L[["description"]]<-"Example of large data frame"
> mvl_write_object(M3, L, "test_object")
>
> LM1<-lm(rnorm(100)~runif(100))
> mvl_write_serialized_object(M3, LM1, "LM1")
>
> mvl_close(M3)
>
>
> M3<-mvl_open("test_bracket2a.mvl")
> print(names(M3))
[1] "test_object" "LM1"
>
> L2<-M3["test_object", ref=TRUE]
>
> N<-dim(df)[1]
>
> compare_df<-function(x, y) {
+ if(length(dim(x))!=length(dim(y)))return(FALSE)
+ if(any(dim(x)!=dim(y)))return(FALSE)
+ if(any(names(x)!=names(y)))return(FALSE)
+ if(dim(x)[2]>0) {
+ for(i in 1:(dim(x)[2])) {
+ if(any(x[,i]!=y[,i]))return(FALSE)
+ }
+ }
+ return(TRUE)
+ }
>
> if(!compare_df(df, mvl2R(L2[["x"]]))) {
+ cat("test1a failed\n")
+ print(attributes(df))
+ print(attributes(mvl2R(L2[["x"]])))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(aa, mvl2R(L2[["y"]])))) {
+ cat("test1b failed\n")
+ print(all.equal(aa, mvl2R(L2[["y"]])))
+ print(attributes(aa))
+ print(attributes(mvl2R(L2[["y"]])))
+ cat("-----------\n")
+ }
>
> if(!compare_df(mm, mvl2R(L2[["z"]]))) {
+ cat("test1c failed\n")
+ print(all.equal(mm, mvl2R(L2[["z"]])))
+ print(attributes(mm))
+ print(attributes(mvl2R(L2[["z"]])))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(LL2, mvl2R(L2[["LL2"]])))) {
+ cat("test1d failed\n")
+ print(all.equal(LL2, mvl2R(L2[["LL2"]])))
+ print(attributes(LL2))
+ print(attributes(mvl2R(L2[["LL2"]])))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal("Example of large data frame", L2[["description"]]))) {
+ cat("test1e failed\n")
+ print(all.equal("Example of large data frame", L2[["description"]]))
+ print(attributes("Example of large data frame"))
+ print(attributes(L2[["description"]]))
+ cat("-----------\n")
+ }
>
> # # R behaviour is mixed in this situation
> # # For lists R returns empty list, but (1:5)[[NA]] throws an exception
> # # It would not be unreasonable to think that vec[[NA]] should be NA
> # # On the other hand, subscripting with NA is inefficient, and throwing an exception
> # # forces to filter out NAs first
> # # For now, we throw an exception and bypass the test
> # if(!isTRUE(all.equal(L[[NA]], mvl2R(L2[[NA]])))) {
> # cat("test1e failed\n")
> # print(all.equal(L[[NA]], mvl2R(L2[[NA]])))
> # print(attributes(L[[NA]]))
> # print(attributes(mvl2R(L2[[NA]])))
> # cat("-----------\n")
> # }
>
> if(!compare_df(df, mvl2R(L2[[1]]))) {
+ cat("test1f failed\n")
+ print(attributes(df))
+ print(attributes(mvl2R(L2[[1]])))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(aa, mvl2R(L2[[2]])))) {
+ cat("test1g failed\n")
+ print(all.equal(aa, mvl2R(L2[[2]])))
+ print(attributes(aa))
+ print(attributes(mvl2R(L2[[2]])))
+ cat("-----------\n")
+ }
>
> if(!compare_df(mm, mvl2R(L2[[3]]))) {
+ cat("test1h failed\n")
+ print(all.equal(mm, mvl2R(L2[[3]])))
+ print(attributes(mm))
+ print(attributes(mvl2R(L2[[3]])))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(LL2, mvl2R(L2[[4]])))) {
+ cat("test1i failed\n")
+ print(all.equal(LL2, mvl2R(L2[[4]])))
+ print(attributes(LL2))
+ print(attributes(mvl2R(L2[[4]])))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal("Example of large data frame", L2[[5]]))) {
+ cat("test1j failed\n")
+ print(all.equal("Example of large data frame", L2[[5]]))
+ print(attributes("Example of large data frame"))
+ print(attributes(L2[[5]]))
+ cat("-----------\n")
+ }
>
>
> if(!isTRUE(all.equal(L[c(2, 3)], L2[c(2,3), recurse=TRUE]))) {
+ cat("test2a failed\n")
+ print(all.equal(L[c(2, 3)], L2[c(2, 3), recurse=TRUE]))
+ print(attributes(L[c(2, 3)]))
+ print(attributes(L2[c(2, 3), recurse=TRUE]))
+ cat("-----------\n")
+ }
>
> # Some of the names are NA and all.equal() does not handle this properly
> if(!isTRUE(all.equal.list(L[c(2, NA, 3)], L2[c(2, NA, 3), recurse=TRUE], use.names=FALSE))) {
+ cat("test2b failed\n")
+ print(all.equal.list(L[c(2, NA, 3)], L2[c(2, NA, 3), recurse=TRUE], use.names=FALSE))
+ print(attributes(L[c(2, NA, 3)]))
+ print(attributes(L2[c(2, NA, 3), recurse=TRUE]))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(L[c("y", "z")], L2[c("y", "z"), recurse=TRUE]))) {
+ cat("test2c failed\n")
+ print(all.equal(L[c("y", "z")], L2[c("y", "z"), recurse=TRUE]))
+ print(attributes(L[c("y", "z")]))
+ print(attributes(L2[c("y", "z"), recurse=TRUE]))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(L[c("W", "y", "z")], L2[c("W", "y", "z"), recurse=TRUE]))) {
+ cat("test2d failed\n")
+ print(all.equal(L[c("W", "y", "z")], L2[c("W", "y", "z"), recurse=TRUE]))
+ print(attributes(L[c("W", "y", "z")]))
+ print(attributes(L2[c("W", "y", "z"), recurse=TRUE]))
+ cat("-----------\n")
+ }
>
> if(!isTRUE(all.equal(L[c("W", "y", NA, "z")], L2[c("W", "y", NA, "z"), recurse=TRUE]))) {
+ cat("test2e failed\n")
+ print(all.equal(L[c("W", "y", NA, "z")], L2[c("W", "y", NA, "z"), recurse=TRUE]))
+ print(attributes(L[c("W", "y", NA, "z")]))
+ print(attributes(L2[c("W", "y", NA, "z"), recurse=TRUE]))
+ cat("-----------\n")
+ }
>
>
> proc.time()
user system elapsed
1.75 0.17 1.89
Running the tests in 'tests/test_extent_index.R' failed.
Complete output:
> require("RMVL")
Loading required package: RMVL
>
> M3<-mvl_open("test2.mvl", append=TRUE, create=TRUE)
> L<-list()
> df<-data.frame(x=(1:1e5) %% 11, y=round(cos(1:1e5)*1000), s=rep(c("a", "b"), 5e4))
> mvl_write_object(M3, df, "test_object")
>
> M3<-mvl_remap(M3)
>
> mvl_write_extent_index(M3, list(M3$test_object[,"x", ref=TRUE]), "test_object_extent_index_x")
> mvl_write_extent_index(M3, list(M3$test_object[,"s", ref=TRUE]), "test_object_extent_index_s")
>
> mvl_close(M3)
>
> M3<-mvl_open("test2.mvl")
> L2<-M3["test_object", ref=TRUE]
>
> N<-dim(df)[1]
>
> idx0<-50:100
>
> S1<-sum(df[df[,"x"] %in% idx0, "y"])
> S2<-sum(unlist(mvl_extent_index_lapply(M3["test_object_extent_index_x", ref=TRUE], list(as.integer(idx0)), function(i, idx) {
+ return(sum(M3$test_object[idx, "y"]))
+ })))
> if(abs(S1-S2)>1e-5)cat("test1 failed: S1=", S1, "S2=", S2, "\n")
>
> S2<-sum(unlist(mvl_extent_index_lapply(M3["test_object_extent_index_x", ref=TRUE], list(as.numeric(idx0)), function(i, idx) {
+ return(sum(M3$test_object[idx, "y"]))
+ })))
> if(abs(S1-S2)>1e-5)cat("test2 failed: S1=", S1, "S2=", S2, "\n")
>
> S1<-sum(df[df[,"s"]=="a", "y"])
> S2<-sum(unlist(mvl_extent_index_lapply(M3["test_object_extent_index_s", ref=TRUE], list("a"), function(i, idx) {
+ return(sum(M3$test_object[idx, "y"]))
+ })))
> if(abs(S1-S2)>1e-5)cat("test2 failed: S1=", S1, "S2=", S2, "\n")
>
> mvl_close(M3)
>
> unlink("test2.mvl")
>
>
> proc.time()
user system elapsed
0.21 0.07 0.28
Running the tests in 'tests/test_hash.R' failed.
Complete output:
> require("RMVL")
Loading required package: RMVL
>
> N<-10000
>
> df<-data.frame(x=(1:N) %% 5, y=((1:N) %% 6)+0.5, ab=paste("ab", ((1:N) %% 10)))
>
> Mtmp<-mvl_open("tmp.mvl", append=TRUE, create=TRUE)
> mvl_write_object(Mtmp, df, "df")
> mvl_close(Mtmp)
>
> Mtmp<-mvl_open("tmp.mvl")
>
> h<-mvl_hash_vectors(list(Mtmp$df[,"x",ref=TRUE]))
> LL<-split(h, Mtmp$df[,"x"][])
> LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
> if(any(LL0!=0))cat("test1 failed\n")
>
> h<-mvl_hash_vectors(list(Mtmp$df[,"y",ref=TRUE]))
> LL<-split(h, Mtmp$df[,"y"][])
> LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
> if(any(LL0!=0))cat("test2 failed\n")
>
> h<-mvl_hash_vectors(list(Mtmp$df[,"ab",ref=TRUE]))
> LL<-split(h, Mtmp$df[,"ab"][])
> LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
> if(any(LL0!=0))cat("test3 failed\n")
>
> h<-mvl_hash_vectors(list(Mtmp$df[,"x",ref=TRUE], Mtmp$df[,"y",ref=TRUE], Mtmp$df[,"ab",ref=TRUE]))
> LL<-split(h, Mtmp$df[,])
> LL0<-unlist(lapply(LL, function(x){if(length(x)<1)return(x);return(max(abs(diff(x))))}))
> if(any(LL0!=0))cat("test4 failed\n")
>
> mvl_close(Mtmp)
> unlink("tmp.mvl")
>
> proc.time()
user system elapsed
0.31 0.04 0.34
Running the tests in 'tests/test_order1.R' failed.
Complete output:
> require("RMVL")
Loading required package: RMVL
>
> M3<-mvl_open("test2.mvl", append=TRUE, create=TRUE)
> L<-list()
> df<-data.frame(x=1:1e5, y=rnorm(1e5), s=rep(c("a", "b"), 5e4))
> L[["x"]]<-mvl_write_object(M3, df)
> L[["description"]]<-"Example of large data frame"
> mvl_write_object(M3, L, "test_object")
> mvl_close(M3)
>
> M3<-mvl_open("test2.mvl")
> L2<-M3["test_object"]
>
> N<-dim(df)[1]
>
> idx0<-50:100
>
> idx1a<-idx0[order(df[idx0, "x"])]
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"x"]), idx0)
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test1 failed\n")
>
> idx1a<-idx0[order(df[idx0, "y"])]
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"y"]), idx0)
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test2 failed\n")
>
> idx1a<-idx0[order(df[idx0, "s"])]
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"]), idx0)
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test3 failed\n")
>
> idx1a<-idx0[order(df[idx0, "s"], df[idx0, "y"])]
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]), idx0)
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test4 failed\n")
>
> idx1a<-order(df[, "y"])
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"y"]))
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test5 failed\n")
>
> idx1a<-order(df[, "s"], df[, "y"])
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]))
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test6 failed\n")
>
> idx1a<-order(df[, "s"], df[, "y"], decreasing=TRUE)
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]), decreasing=TRUE)
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test7 failed\n")
>
> idx1a<-idx0[order(df[idx0, "s"], df[idx0, "y"], decreasing=TRUE)]
> idx1b<-mvl_order_vectors(list(M3$test_object$x[,"s"], M3$test_object$x[,"y"]), idx0, decreasing=TRUE)
> if(!isTRUE(all.equal(idx1a, idx1b)))cat("test8 failed\n")
>
>
> mvl_close(M3)
>
> unlink("test2.mvl")
>
>
> proc.time()
user system elapsed
0.37 0.09 0.46
Flavor: r-devel-windows-x86_64