.packageName <- "mefa"
`add.attrib` <-
function(mf, which=c("samples", "species"), attrib, index=1){
if(class(mf) != "mefa") stop("Object '",mf,"' is not of 'mefa' class.")
xord <- xorder(as.xcount(mf$xcount), which, attrib, index)
xord$data[[index]] <- NULL
if(which == "species") {
xsamp.out <- mf$sample.attr
xspec.out <- data.frame(mf$species.attr, xord$data)
nsample.attr <- mf$nsample.attr
nspecies.attr <- dim(xspec.out)[2]}
if(which == "samples") {
xsamp.out <- data.frame(mf$sample.attr, xord$data)
xspec.out <- mf$species.attr
nsample.attr <- dim(xsamp.out)[2]
nspecies.attr <- mf$nspecies.attr}
out <- list(segment = mf$segment,
xcount = as.matrix(mf$xcount),
sample.attr = as.data.frame(xsamp.out),
species.attr = as.data.frame(xspec.out),
nsamples = mf$nsamples,
nspecies = mf$nspecies,
totalcount = mf$totalcount,
nsample.attr = nsample.attr,
nspecies.attr = nspecies.attr)
class(out) <- "mefa"
return(out)}

`as.xcount` <-
function (table, species.columns=TRUE, segment="unspecified"){
#if(!is.integer(as.integer(as.matrix(table)))) stop("Count must be integer!")
if(species.columns == FALSE) table <- t(table)
table <- table[order(rownames(table)), order(colnames(table))]
out <- list(segment = segment,
data = as.matrix(table),
nsamples = dim(table)[1],
nspecies = dim(table)[2])
class(out) <- "xcount"
return(out)}

`check.attrib` <-
function(xc, which=c("samples", "species"), attrib, index=1){
if(class(xc) != "xcount") stop("Object '",xc,"' is not of 'xcount' class.")
if(which == "species") {list.in.xc <- colnames(xc$data)} else {
if(which == "samples") {list.in.xc <- rownames(xc$data)} else {stop("Undefined 'which' tag.")}}
list.in.attr <- as.character(attrib[,index])
if(length(union(list.in.xc, list.in.attr)) - nlevels(as.factor(list.in.xc)) - nlevels(as.factor(list.in.attr))
== 0) {duplicate <- "NULL"
set.relation <- "separate"
missing <- list.in.xc} else {
match <- subset(list.in.attr, is.element(list.in.attr, list.in.xc))
if(sum(apply(table(match, match) > 1, 1, sum)) == 0) duplicate <- "NULL" else {
duplicate <- subset(levels(as.factor(match)), apply(table(match, match) > 1, 1, sum) != 0)
}
if(length(intersect(list.in.xc, list.in.attr)) == length(list.in.xc)) {missing <- "NULL"
if(setequal(list.in.xc, list.in.attr) == TRUE) {set.relation <- "equal"} else {set.relation <- "inclusion"}
} else { set.relation <- "intersect"
missing <- setdiff(list.in.xc, list.in.attr)}}
out <- list(set.relation = set.relation, duplicate = duplicate, missing = missing)
return(out)}

`drtsscount` <-
function(table, sample, segment="unspecified"){
#if(!is.integer(as.integer(as.matrix(table)))) stop("Count must be integer!")
if(length(sample) != dim(table)[1]) stop("Dimensions are not the same.\n")
table <- as.matrix(table)
sample <- as.factor(sample)
zc <- "NULL"
excl <- subset(table, apply(table, 1, sum) ==0)
sample.excl <- subset(sample, apply(table, 1, sum) == 0)
rexcl <- dim(excl)[1]
sample <- subset(sample, apply(table, 1, sum) > 0)
table <- subset(table, apply(table, 1, sum) > 0)
rows.out <- sum(table > 0)
data.out <- as.data.frame(array(data = NA, dim = c(rows.out + rexcl, 4), dimnames = NULL))
r <- 1
for(i in 1:dim(table)[2]) {# species
table.sub <- subset(table[,i], table[,i] > 0)
sample.sub <- subset(sample, table[,i] > 0)
for(j in 1:length(sample.sub)){ #samples within species
data.out[r,1] <- as.character(sample.sub[j])
data.out[r,2] <- colnames(table)[i]
data.out[r,3] <- as.character(segment)
data.out[r,4] <- as.numeric(table.sub[j])
r <- r + 1}}
if(rexcl != 0){
for(z in 1:rexcl){
data.out[rows.out+z,1] <- as.character(sample.excl[z])
data.out[rows.out+z,2] <- "zero.count"
data.out[rows.out+z,3] <- segment
data.out[rows.out+z,4] <- 1}
zc <- "zero.count"
cat(dim(excl)[1], "Rows with 0 total count were found and flagged as 'zero.count'.\n")}
data.fin <- data.frame(
as.factor(data.out[,1]),
as.factor(data.out[,2]),
as.factor(data.out[,3]),
as.numeric(data.out[,4]))
colnames(data.fin) <- c("sample", "species", "segment", "count")
data.fin[] <- lapply(data.fin, function(x) x[drop=TRUE])
ifelse (zc == "NULL", nspecies <- nlevels(data.fin[,2]), nspecies <- nlevels(data.fin[,2]) - 1)
out <- list(data = data.fin,
zc = zc,
nsamples = as.numeric(nlevels(data.fin[,1])),
nspecies = as.numeric(nspecies),
segment.levels = levels(as.factor(data.fin[,3])))
class(out) <- "sscount"
return(out)}

`fill.count` <-
function(table){
out <- table
for(col in 1:ncol(table)){
for(row in 1:nrow(table)){
if(is.na(table[row,col]) == TRUE) out[row,col] <- out[row-1,col]
}}
return(out)}

`inflate` <-
function(factors, count){
if(nrow(factors) != length(count)) stop("Number of dimensions must be equal!")
factors <- data.frame(factors)
n.total <- sum(count)
row.orig <- nrow(factors)
col.orig <- ncol(factors)
infl.data <- array(data=NA, dim=c(n.total, col.orig))
colnames(infl.data) <- colnames(factors)
j <- 1
for (i in 1:row.orig){
for(individuals in 1:count[i]){
if (count[i] < 0)  stop("Negative count value.") else {
if (count[i] == 0) stop("Zero count value.") else {
infl.data[j, 1:col.orig] <- as.matrix(factors[i, 1:col.orig])
j<-j+1}}}}
return(data.frame(infl.data))}

`mefa` <-
function(xc, xorder.samples, xorder.species){
if(class(xc) != "xcount") stop("Object '",xc,"' is not of 'xcount' class.")
if(class(xorder.species) != "xorder") stop("Object '",xorder.species,"' is not of 'xorder' class.")
if(xorder.species$which != "species") stop("Species/sample mismatch.")
rspec <- rownames(xorder.species$data)
if(class(xorder.samples) != "xorder") stop("Object '",xorder.samples,"' is not of 'xorder' class.")
if(xorder.samples$which != "samples") stop("Species/sample mismatch.")
rsamp <- rownames(xorder.samples$data)
cxc <- colnames(xc$data)
rxc <- rownames(xc$data)
if(length(rspec) != length(cxc)) stop("Species list lengths differ.")
if(length(rsamp) != length(rxc)) stop("Sample list lengths differ.")
if(sum(rspec != cxc) != 0) stop("Species list mismatch.")
if(sum(rsamp != rxc) != 0) stop("Sample list mismatch.")
out <- list(segment = xc$segment,
xcount = as.matrix(xc$data),
sample.attr = as.data.frame(xorder.samples$data),
species.attr = as.data.frame(xorder.species$data),
nsamples = xc$nsamples,
nspecies = xc$nspecies,
totalcount = sum(xc$data),
nsample.attr = length(colnames(xorder.samples$data)),
nspecies.attr = length(colnames(xorder.species$data)))
class(out) <- "mefa"
return(out)}

`msscount` <-
function(ssc1, ssc2){
if(class(ssc1) != "sscount" | class(ssc2) != "sscount") stop("Objects must be of 'sscount' class.")
zzc <- "NULL"
if(ssc1$zc != "NULL" & ssc2$zc != "NULL")
{if(ssc1$zc != ssc2$zc) cat("Different 'zero.count' indicators were united.\n")
if(sum(is.element(subset(ssc1$data$species, ssc1$data$species != ssc1$zc), ssc2$zc)) != 0)
stop("Zero count identifier was detected for not zero count sample!")
if(sum(is.element(subset(ssc2$data$species, ssc2$data$species != ssc2$zc), ssc1$zc)) != 0)
stop("Zero count identifier was detected for not zero count sample!")}
if(ssc1$zc == "NULL") {ssc1.sub <- ssc1$data} else {
ssc1.sub <- subset(ssc1$data, ssc1$data$species != ssc1$zc)}
if(ssc2$zc == "NULL") {ssc2.sub <- ssc2$data} else {
ssc2.sub <- subset(ssc2$data, ssc2$data$species != ssc2$zc)}
ssc1.zc <- subset(ssc1$data[,1], ssc1$data$species == ssc1$zc)
ssc2.zc <- subset(ssc2$data[,1], ssc2$data$species == ssc2$zc)
rows.sub <- dim(ssc1.sub)[1] + dim(ssc2.sub)[1]
rows.zc <- length(ssc1.zc) + length(ssc2.zc)
rows.out <- rows.sub + rows.zc
start2 <- dim(ssc1.sub)[1] + 1
start.zc1 <- rows.sub + 1
stop.zc1 <- rows.sub + length(ssc1.zc)
start.zc2 <- start.zc1 + length(ssc1.zc)
data.out <- as.data.frame(array(data = NA, dim = c(rows.out, 4), dimnames = NULL))
data.out[1:dim(ssc1.sub)[1],1] <- as.character(ssc1.sub[,1])
data.out[1:dim(ssc1.sub)[1],2] <- as.character(ssc1.sub[,2])
data.out[1:dim(ssc1.sub)[1],3] <- as.character(ssc1.sub[,3])
data.out[1:dim(ssc1.sub)[1],4] <- as.numeric(ssc1.sub[,4])
data.out[start2:rows.sub,1] <- as.character(ssc2.sub[,1])
data.out[start2:rows.sub,2] <- as.character(ssc2.sub[,2])
data.out[start2:rows.sub,3] <- as.character(ssc2.sub[,3])
data.out[start2:rows.sub,4] <- as.numeric(ssc2.sub[,4])
if(ssc1$zc != "NULL"){
data.out[start.zc1:stop.zc1,1] <- as.character(ssc1.zc)
data.out[start.zc1:stop.zc1,2] <- as.character("zero.count")
data.out[start.zc1:stop.zc1,3] <- as.character("unspecified")
data.out[start.zc1:stop.zc1,4] <- as.numeric(1)
zzc <- "zero.count"}
if(ssc2$zc != "NULL"){
data.out[start.zc2:rows.out,1] <- as.character(ssc2.zc)
data.out[start.zc2:rows.out,2] <- as.character("zero.count")
data.out[start.zc2:rows.out,3] <- as.character("unspecified")
data.out[start.zc2:rows.out,4] <- as.numeric(1)
zzc <- "zero.count"}
data.fin <- data.frame(
as.factor(data.out[,1]),
as.factor(data.out[,2]),
as.factor(data.out[,3]),
as.numeric(data.out[,4]))
colnames(data.fin) <- c("sample", "species", "segment", "count")
data.fin[] <- lapply(data.fin, function(x) x[drop=TRUE])
ifelse (ssc1$zc == "NULL" , nspecies <- nlevels(data.fin[,2]), nspecies <- nlevels(data.fin[,2]) - 1)
out <- list(data = as.data.frame(data.fin), 
zc = zzc,
nsamples = as.numeric(nlevels(data.fin[,1])),
nspecies = as.numeric(nspecies),
segment.levels = levels(data.fin[,3]))
class(out) <- "sscount"
return(out)}

`mxcount` <-
function(xc1,xc2,segment="unspecified"){
out <- xcount(msscount(ttsscount(as.data.frame(xc1$data)), ttsscount(as.data.frame(xc2$data))))
out$segment <- segment
return(out)}

`report.mefa` <-
function(filename, mf, order="species", biotic.data=1, species.name=1, species.order=1,
author=0, tex=FALSE, binary=FALSE, sep=c(", "," (",")","; ")){
if(class(mf) != "mefa") stop("not 'mefa' class")
if(sum(is.element(c("species", "samples"), order)) == 0) stop("Specify 'sort' parameter.")
if(length(biotic.data) > 6) stop("More than 6 columns selected.")
if(length(sep) != 4) stop("Specify exactly 4 separators.")
loc <- as.matrix(mf$sample.attr[,biotic.data])
if(length(biotic.data) == 1) sort <- order(loc[,1])
if(length(biotic.data) == 2) sort <- order(loc[,1], loc[,2])
if(length(biotic.data) == 3) sort <- order(loc[,1], loc[,2], loc[,3])
if(length(biotic.data) == 4) sort <- order(loc[,1], loc[,2], loc[,3], loc[,4])
if(length(biotic.data) == 5) sort <- order(loc[,1], loc[,2], loc[,3], loc[,4], loc[,5])
if(length(biotic.data) == 6) sort <- order(loc[,1], loc[,2], loc[,3], loc[,4], loc[,5], loc[,6])
loc <- as.matrix(loc[order(sort),])
xcr <- mf$xcount[order(sort),order(mf$species.attr[,species.order])]
nam <- as.vector(mf$species.attr)[,species.name][order(mf$species.attr[,species.order])]
if(author != 0) autv <- as.vector(mf$species.attr)[,author][order(mf$species.attr[,species.order])]
ti <- "\textit{"
if(order == "species") {
zz <- file(filename, "w")
cat("%Start writing data from 'mefa' object sorted by species into file '",
filename, "' on ",date(), ".", file = zz, sep = "")
for(spec in 1:length(nam)){
ifelse(author == 0, aut <- "", aut <- as.vector(autv[spec]))
loc.sub <- as.matrix(subset(loc, xcr[,spec] > 0))
xcr.sub <- as.vector(subset(xcr[,spec], xcr[,spec] > 0))
cat("\n\n\n", file = zz, sep = "")
if(tex == TRUE) {
cat(gsub("par", "\\\\par", "paragraph{"), file = zz, sep = "")
cat(encodeString(ti), file = zz, sep = "")}
cat(as.character(nam[spec]), file = zz, sep = "")
if(tex == TRUE) cat("}", file = zz, sep = "")
if(author != 0) cat(" ", as.character(aut), file = zz, sep = "")
if(tex == TRUE) cat("}", file = zz, sep = "")
cat("\n\n", file = zz, sep = "")
for (samp in 1:dim(loc.sub)[1]){
locv <- loc.sub[samp,]
xcrd <- xcr.sub[samp]
if(samp < dim(loc.sub)[1]){
cat(t(locv), file = zz, sep = sep[1])
if(binary == TRUE) {cat(sep[4], file = zz, sep = "")} else {
cat(sep[2], xcrd, sep[3], sep[4], file = zz, sep = "")}
if(tex == TRUE) cat("\n", file = zz, sep = "")
} else {
cat(t(locv), file = zz, sep = sep[1])
if(binary == TRUE) {cat(".", file = zz, sep = "")} else {
cat(sep[2], xcrd, sep[3], ".", file = zz, sep = "")}}}}
cat("\n\n%End of output.", file = zz, sep = "\n")
close(zz)}
if(order == "samples") {
zz <- file(filename, "w")
cat("%Start writing data from 'mefa' object sorted by samples into file '",
filename, "' on ",date(), ".", file = zz, sep = "")
xcr <- t(xcr)
for(samp in 1:dim(loc)[1]){
xcr.sub <- as.vector(subset(xcr[,samp], xcr[,samp] > 0))
nam.sub <- as.vector(subset(nam, xcr[,samp] > 0))
ifelse(author == 0, aut <- "", aut <- as.vector(subset(autv, xcr[,samp] > 0)))
locv <- as.vector(loc[samp,])
cat("\n\n\n", file = zz, sep = "")
if(tex == TRUE) cat(gsub("par", "\\\\par", "paragraph{"),  file = zz, sep = "")
cat(as.character(locv), file = zz, sep = sep[1])
if(tex == TRUE) cat("}\n", file = zz, sep = "")
cat("\n\n", file = zz, sep = "")
if(sum(xcr.sub) == 0) {cat("No species were found.", file = zz, sep = "")} else {
for (spec in 1:length(nam.sub)){
xcrd <- xcr.sub[spec]
if(spec < length(nam.sub)){
if(tex == TRUE) cat(encodeString(ti), file = zz, sep = "")
cat(as.character(nam.sub[spec]), file = zz, sep = "")
if(tex == TRUE) cat("}", file = zz, sep = "")
if(author != 0) cat(" ", as.character(aut[spec]), file = zz, sep = "")
if(binary == TRUE) {cat(sep[4], file = zz, sep = "")} else {
cat(sep[2], xcrd, sep[3], sep[4], file = zz, sep = "")}
if(tex == TRUE) cat("\n", file = zz, sep = "")
} else {
if(tex == TRUE) cat(encodeString(ti), file = zz, sep = "")
cat(as.character(nam.sub[spec]), file = zz, sep = "")
if(tex == TRUE) cat("}", file = zz, sep = "")
if(author != 0) cat(" ", as.character(aut[spec]), file = zz, sep = "")
if(binary == TRUE) {cat(".", file = zz, sep = "")} else {
cat(sep[2], xcrd, sep[3], ".", file = zz, sep = "")}
}}}}
cat("\n\n%End of output.", file = zz, sep = "\n")
close(zz)}}

`sscount` <-
function(sstable, zc="NULL"){
if(ncol(as.data.frame(sstable)) < 3 | ncol(as.data.frame(sstable)) > 4) 
stop("Three or four columns are required.")
if(zc != "NULL") if(sum(is.element(sstable[,2], zc)) == 0) {
cat("Samples with '", zc, "' were not detected, 'zc' is set to 'NULL'.\n")
zc <- "NULL"}
sample <- as.factor(sstable[,1])
species <- as.factor(sstable[,2])
if(ncol(sstable) == 3) {
if(!is.numeric(sstable[,3])) stop("Count must be numeric!")
segment <- as.factor(rep("undefined", nrow(sstable)))
count <- as.numeric(sstable[,3])}

if(ncol(sstable) == 4) {
if(!is.numeric(sstable[,4])) stop("Count must be numeric!")
segment <- as.factor(sstable[,3])
count <- as.numeric(sstable[,4])}

frame <- data.frame(sample, species, segment, count)
frame[] <- lapply(frame, function(x) x[drop=TRUE])
colnames(frame) <- c("sample", "species", "segment", "count")
ifelse (zc == "NULL", nspecies <- nlevels(frame[,2]), nspecies <- nlevels(frame[,2]) - 1)
out <- list(data = frame, 
zc = zc,
nsamples = as.numeric(nlevels(frame[,1])),
nspecies = as.numeric(nspecies),
segment.levels = levels(frame[,3]))
class(out) <- "sscount"
return(out)}

`strify` <-
function(xc, strata, which=c("samples", "species")){
if(is.element(class(xc), c("xcount", "mefa")) == FALSE) 
stop("Object '",xc,"' is not of 'xcount' or 'mefa' class.")
if(is.element(which, c("samples", "species")) == FALSE) stop("Undefined 'which' tag.")
if(class(xc) == "xcount") {
ifelse(which == "samples", table <- xc$data, table <- t(xc$data))
str <- as.factor(strata)}
if(class(xc) == "mefa") {
ifelse(which == "samples", table <- xc$xcount, table <- t(xc$xcount))
ifelse(which == "samples", str <- as.factor(xc$sample.attr[,strata]), 
str <- as.factor(xc$species.attr[,strata]))}
table.out <- array(data=NA, dim=c(nlevels(str), dim(table)[2]))
for(i in 1:dim(table.out)[2]){table.out[,i] <- aggregate(table[,i], list(str), sum)[[2]]}
colnames(table.out) <- colnames(table)
rownames(table.out) <- levels(str)
ifelse(which == "samples", data <- as.matrix(table.out), data <- as.matrix(t(table.out)))
out <- list(segment = xc$segment,
data = data,
nsamples = dim(data)[1],
nspecies = dim(data)[2])
class(out) <- "xcount"
return(out)}

`ttsscount` <-
function(table, species.columns=TRUE, segment="unspecified"){
#if(!is.integer(as.integer(as.matrix(table)))) stop("Count must be integer!")
if(species.columns == FALSE) table <- t(table)
zc <- "NULL"
excl <- subset(table, apply(table, 1, sum) ==0)
incl <- subset(table, apply(table, 1, sum) > 0)
incl <- t(incl)
incl <- incl[,order(colnames(incl))]
row.exp <- sum(incl > 0) + dim(excl)[1]
expanded <- array(data = NA, dim = c(row.exp, 4), dimnames = NULL)
r <- 1
for(i in 1:dim(incl)[2]){
incl.c <- incl[,i]
incl.c <- incl.c[order(as.vector(rownames(incl)))]
incl.sub <- subset(incl.c, incl.c > 0)
rownam.sub <- names(incl.sub)
for(j in 1:length(incl.sub)){
expanded[r,1] <- colnames(incl)[i]
expanded[r,2] <- rownam.sub[j]
expanded[r,3] <- segment
expanded[r,4] <- as.numeric(incl.sub[j])
r <- r + 1}}
if(dim(excl)[1] > 0) {excl <- excl[order(rownames(excl)),]
excl.out <- array(data = NA, dim = c(dim(excl)[1], 4), dimnames = NULL)
zc <- "zero.count"
for(z in 1:dim(excl)[1]){
excl.out[z,1] <- rownames(excl)[z]
excl.out[z,2] <- "zero.count"
excl.out[z,3] <- segment
excl.out[z,4] <- 1}
cat(dim(excl)[1], "rows with 0 total count were found and flagged as 'zero.count'.\n")
start <- dim(expanded)[1] - dim(excl.out)[1] + 1
stop <- dim(expanded)[1]
expanded[start:stop,] <- excl.out}
data.out <- data.frame(
as.factor(expanded[,1]),
as.factor(expanded[,2]),
as.factor(expanded[,3]),
as.numeric(expanded[,4]))
colnames(data.out) <- c("sample", "species", "segment", "count")
data.out[] <- lapply(data.out, function(x) x[drop=TRUE])
ifelse (zc == "NULL", nspecies <- nlevels(data.out[,2]), nspecies <- nlevels(data.out[,2]) - 1)
out <- list(data = data.out,
zc = zc,
nsamples = as.numeric(nlevels(data.out[,1])),
nspecies = as.numeric(nspecies),
segment.levels = levels(as.factor(data.out[,3])))
class(out) <- "sscount"
return(out)}

`xcount` <-
function(ssc, segment=0){
if(class(ssc) != "sscount") stop("Object '",ssc,"' is not of 'sscount' class.")
infl <- inflate(ssc$data[,1:3], ssc$data[,4])
if (segment ==0){crosstable <- as.array(table(infl[,2], infl[,1]))
segment.index <- "all"}
else{crosstable <- as.array(table(infl[,2], infl[,1], infl[,3]))[,,segment]
segment.index <- ssc$segment.levels[segment]}
rct <- rownames(crosstable)
cct <- colnames(crosstable)
crosstable.sub <- subset(crosstable, row.names(crosstable) != ssc$zc)
out.data <- matrix(data = crosstable.sub, nrow=ssc$nspecies, ncol=ssc$nsamples)
if (ssc$zc == "NULL"){rownames(out.data) <- rct}
else{rownames(out.data) <- rct[1:length(rct) - 1]
cat("Samples with '", ssc$zc, "' were detected.\n")}
colnames(out.data) <- cct
out <- list(segment = segment.index,
data = as.matrix(t(out.data)),
nsamples = dim(out.data)[2],
nspecies = dim(out.data)[1])
class(out) <- "xcount"
return(out)}

`xorder` <-
function(xc, which=c("samples", "species"), attrib, index=1){
if(class(xc) != "xcount") stop("Object '",xc,"' is not of 'xcount' class.")
check1 <- check.attrib(xc, which, attrib, index)$set.relation
check2 <- check.attrib(xc, which, attrib, index)$duplicate
if(sum(is.element(c("equal", "inclusion"), check1)) == 0) stop("Set relation in 'check.attrib' result: ", 
check1, ".\nMissing elements: ", check.attrib(xc, which, attrib, index)$missing)
if(check2 != "NULL") stop("Duplicates were found by 'check.attrib': ", check2, ".")
if(check1 == "equal"){
attrib.out <- attrib[order(as.character(attrib[,index])),]
if(which == "species") index.out <- as.character(colnames(xc$data))
if(which == "samples") index.out <- as.character(rownames(xc$data))}
if(check1 == "inclusion"){
if(which == "species") {
exclude <- is.element(attrib[,index],colnames(xc$data))
index.out <- as.character(colnames(xc$data))}
if(which == "samples") {
exclude <- is.element(attrib[,index],rownames(xc$data))
index.out <- as.character(rownames(xc$data))}
attrib.sub <- subset(attrib, exclude == TRUE)
attrib.sub[] <- lapply(attrib.sub, function(x) x[drop=TRUE])
attrib.out <- attrib.sub[order(as.character(attrib.sub[,index])),]}
rownames(attrib.out) <- index.out
as.data.frame(attrib.out)
out <- list(which = which, check.setrel = check1, check.dupl = check2, data = attrib.out)
class(out) <- "xorder"
return(out)}

