Nothing
###############################################################################
############################# Real Data ###################################
###############################################################################
## Hu and Hu's general covariate-adaptive randomization(CAR) ########
################################################################################
#HuHuCAR = function(data, omega = NULL, p = 0.85) UseMethod("HuHuCAR")
#HuHuCAR.carandom = function(data, omega = NULL, p = 0.85) UseMethod("carandom")
HuHuCAR = function(data, omega = NULL, p = 0.85){
R = NULL;
pdoub = as.double(p);
if(is.na(pdoub)){
stop("p must be a positive number!");
}else if(p <= 0.5){
stop("set p larger than 0.5 to achieve balance!");
}else if(p > 1){
stop("p must be a positive number between 0 and 1!");
}
if(length(data[is.na(data)]) == 0){
datap = data;
}else{
data[is.na(data)] = "HFFMWYXQTFY<= 1.0";
datap = data;
}
rdata = Preprocess(datap);
data_proc = rdata$data;
cov_num = rdata$cov_num; level_num = rdata$level_num;
R$datanumeric = FALSE;
if(length(omega) != (2 + cov_num) && !is.null(omega)){
stop("Length of omega must equal to ncols(data) + 2 !")
}else if(is.null(omega)){
omega = rep(1.0 / (cov_num + 2), times = cov_num + 2);
}else{
omega = abs(omega) / sum(abs(omega));
}
RES = C_RHPS(data_proc, cov_num, level_num, omega, p);
covn = colnames(data);
R$covariates = covn;
strt_num = ncol(RES[2, 1][[1]]);
R$strt_num = strt_num;
R$cov_num = cov_num;
R$level_num = level_num;
CA = RES[3, 1][[1]];
n = ncol(CA);
R$n = n;
colnames(CA) = BBCDname(n, "pat");
#rownames(CA) = c(paste("covariate", 1 : cov_num,"(", covn, ")", sep = ""), "assignment");
rownames(CA) = c(paste("covariate", 1 : cov_num, sep = ""), "assignment");
R$Cov_Assig = CA;
assig_temp = CA[dim(CA)[1], ];
R$assignments = LETTERS[assig_temp];
AS0 = RES[2, 1][[1]];
AS0ordinPS = MVReturnM(PStrGen(cov_num, level_num), AS0)[, 1];
AS = AS0[, order(AS0ordinPS)]
colnames(AS) = BBCDname(strt_num, "stratum");
rownames(AS) = paste("covariate", 1 : cov_num,"(", covn, ")", sep = "");
R$'All strata' = AS;
Df0 = RES[4, 1][[1]];
Df = Df0[c(1, 1 + order(AS0ordinPS), (1 + strt_num + 1) : (1 + strt_num + sum(level_num))), ,drop = FALSE]
rownames(Df) = nameString(cov_num, level_num, strt_num, "All", AS);
R$Diff = Df;
R$method = "Hu and Hu's General CAR";
R$'Data Type' = "Real";
R$weight = omega[3 : (2 + cov_num)];
R$framework = "Stratified randomization";
R$data = data;
class(R) = "carandom";
return(R);
}
###############################################################################
## Pocock and Simon's procedure ########
################################################################################
#PocSimMIN = function(data, weight = NULL, p = 0.85) UseMethod("PocSimMIN")
#PocSimMIN.carandom = function(data, weight = NULL, p = 0.85) UseMethod("carandom")
PocSimMIN = function(data, weight = NULL, p = 0.85){
R = NULL;
pdoub = as.double(p);
if(is.na(pdoub)){
stop("p must be a positive number!");
}else if(p <= 0.5){
stop("set p larger than 0.5 to achieve balance!");
}else if(p > 1){
stop("p must be a positive number between 0 and 1!");
}
if(length(data[is.na(data)]) == 0){
datap = data;
}else{
data[is.na(data)] = "NA";
datap = data;
}
rdata = Preprocess(datap);
data_proc = rdata$data;
cov_num = rdata$cov_num; level_num = rdata$level_num;
R$datanumeric = FALSE;
if(length(weight) != cov_num && !is.null(weight)){
stop("Length of weight must equal to ncols(data)!")
}else if(is.null(weight)){
omega = c(0, 0, rep(1.0 / cov_num, times = cov_num));
}else{
omega = c(0, 0, abs(weight) / sum(abs(weight)));
}
RES = C_RHPS(data_proc, cov_num, level_num, omega, p);
covn = colnames(data);
R$covariates = covn;
strt_num = ncol(RES[2, 1][[1]]);
R$strt_num = strt_num;
R$cov_num = cov_num;
R$level_num = level_num;
CA = RES[3, 1][[1]];
n = ncol(CA);
R$n = n;
colnames(CA) = BBCDname(n, "pat");
#rownames(CA) = c(paste("covariate", 1 : cov_num,"(", covn, ")", sep = ""), "assignment");
rownames(CA) = c(paste("covariate", 1 : cov_num, sep = ""), "assignment");
R$Cov_Assig = CA;
assig_temp = CA[dim(CA)[1], ];
R$assignments = LETTERS[assig_temp];
AS0 = RES[2, 1][[1]];
AS0ordinPS = MVReturnM(PStrGen(cov_num, level_num), AS0)[, 1];
AS = AS0[, order(AS0ordinPS)]
colnames(AS) = BBCDname(strt_num, "stratum");
rownames(AS) = paste("covariate", 1 : cov_num,"(", covn, ")", sep = "");
R$'All strata' = AS;
Df0 = RES[4, 1][[1]];
Df = Df0[c(1, 1 + order(AS0ordinPS), (1 + strt_num + 1) : (1 + strt_num + sum(level_num))), ,drop = FALSE]
rownames(Df) = nameString(cov_num, level_num, strt_num, "All", AS);
R$Diff = Df;
R$method = "Pocock and Simon's Procedure with Two Arms";
R$'Data Type' = "Real";
R$weight = omega[3 : (2 + cov_num)];
R$framework = "Stratified randomization";
R$data = data;
class(R) = "carandom";
return(R);
}
###############################################################################
## Shao's randomization ########
################################################################################
#StrBCD = function(data, p = 0.85) UseMethod("StrBCD")
#StrBCD.carandom = function(data, p = 0.85) UseMethod("carandom")
StrBCD = function(data, p = 0.85){
R = NULL;
pdoub = as.double(p);
if(is.na(pdoub)){
stop("p must be a positive number!");
}else if(p <= 0.5){
stop("set p larger than 0.5 to achieve balance!");
}else if(p > 1){
stop("p must be a positive number between 0 and 1!");
}
if(length(data[is.na(data)]) == 0){
datap = data;
}else{
data[is.na(data)] = "NA";
datap = data;
}
rdata = Preprocess(datap);
data_proc = rdata$data;
cov_num = rdata$cov_num; level_num = rdata$level_num;
R$datanumeric = FALSE;
omega = c(0, 1, rep(0, times = cov_num));
RES = C_RHPS(data_proc, cov_num, level_num, omega, p);
covn = colnames(data);
R$covariates = covn;
strt_num = ncol(RES[2, 1][[1]]);
R$strt_num = strt_num;
R$cov_num = cov_num;
R$level_num = level_num;
CA = RES[3, 1][[1]];
n = ncol(CA);
R$n = n;
colnames(CA) = BBCDname(n, "pat");
#rownames(CA) = c(paste("covariate", 1 : cov_num,"(", covn, ")", sep = ""), "assignment");
rownames(CA) = c(paste("covariate", 1 : cov_num, sep = ""), "assignment");
R$Cov_Assig = CA;
assig_temp = CA[dim(CA)[1], ];
R$assignments = LETTERS[assig_temp];
AS0 = RES[2, 1][[1]];
AS0ordinPS = MVReturnM(PStrGen(cov_num, level_num), AS0)[, 1];
AS = AS0[, order(AS0ordinPS)]
colnames(AS) = BBCDname(strt_num, "stratum");
rownames(AS) = paste("covariate", 1 : cov_num,"(", covn, ")", sep = "");
R$'All strata' = AS;
Df0 = RES[4, 1][[1]];
Df = Df0[c(1, 1 + order(AS0ordinPS), (1 + strt_num + 1) : (1 + strt_num + sum(level_num))), ,drop = FALSE]
rownames(Df) = nameString(cov_num, level_num, strt_num, "All", AS);
R$Diff = Df;
R$method = "Shao's Procedure";
R$'Data Type' = "Real";
R$framework = "Stratified randomization";
R$data = data;
class(R) = "carandom";
return(R);
}
###############################################################################
## Stratified permuted block randomization ########
################################################################################
#StrPBR = function(data, bsize = 4) UseMethod("StrPBR")
#StrPBR.carandom = function(data, bsize = 4) UseMethod("carandom")
StrPBR = function(data, bsize = 4){
R = NULL;
bsint = as.integer(bsize);
if(is.na(bsint)){
stop("bsize must be a positive integer!")
}else if(bsint %% 2 != 0){
stop("bsize must be a multiple of 2!")
}else if(bsize %% 2 != 0){
warning("bsize is mandated to be an integer!", call. = FALSE);
}
if(length(data[is.na(data)]) == 0){
datap = data;
}else{
data[is.na(data)] = "NA";
datap = data;
}
rdata = Preprocess(datap);
data_proc = rdata$data;
cov_num = rdata$cov_num; level_num = rdata$level_num;
R$datanumeric = FALSE;
RES = C_RStrR(data_proc, cov_num, level_num, bsize, tr_num = 2);
covn = colnames(data);
R$covariates = covn;
strt_num = ncol(RES[2, 1][[1]]);
R$strt_num = strt_num;
R$cov_num = cov_num;
R$level_num = level_num;
CA = RES[3, 1][[1]];
n = ncol(CA);
R$n = n;
colnames(CA) = BBCDname(n, "pat");
#rownames(CA) = c(paste("covariate", 1 : cov_num,"(", covn, ")", sep = ""), "assignment");
rownames(CA) = c(paste("covariate", 1 : cov_num, sep = ""), "assignment");
R$Cov_Assig = CA;
assig_temp = CA[dim(CA)[1], ];
R$assignments = LETTERS[assig_temp];
AS0 = RES[2, 1][[1]];
AS0ordinPS = MVReturnM(PStrGen(cov_num, level_num), AS0)[, 1];
AS = AS0[, order(AS0ordinPS)]
colnames(AS) = BBCDname(strt_num, "stratum");
rownames(AS) = paste("covariate", 1 : cov_num,"(", covn, ")", sep = "");
R$'All strata' = AS;
Df0 = RES[4, 1][[1]];
Df = Df0[c(1, 1 + order(AS0ordinPS), (1 + strt_num + 1) : (1 + strt_num + sum(level_num))), ,drop = FALSE]
rownames(Df) = nameString(cov_num, level_num, strt_num, "All", AS);
R$Diff = Df;
R$method = "Stratified Permuted Block Randomization";
R$'Data Type' = "Real";
R$framework = "Stratified randomization";
R$data = data;
R$bsize = bsint;
st_num = RES[1, 1][[1]];
colnames(st_num) = BBCDname(ncol(AS), "level-");
R$`numbers of pats for each stratum` = st_num;
class(R) = "carandom";
return(R);
}
###############################################################################
## Atkinson's Optimum Biased Coin Design ########
################################################################################
#DoptBCD = function(data) UseMethod("DoptBCD")
#DoptBCD.carandom = function(data) UseMethod("carandom")
DoptBCD = function(data){
R = NULL;
if(length(data[is.na(data)]) == 0){
datap = data;
}else{
data[is.na(data)] = "NA";
datap = data;
}
rdata = Preprocess(datap);
data_proc = rdata$data;
cov_num = rdata$cov_num; level_num = rdata$level_num;
R$datanumeric = FALSE;
RES = C_RAtkinBCD(data_proc, cov_num, level_num);
covn = colnames(data);
R$covariates = covn;
strt_num = ncol(RES[2, 1][[1]]);
R$strt_num = strt_num;
R$cov_num = cov_num;
R$level_num = level_num;
CA = RES[3, 1][[1]];
n = ncol(CA);
R$n = n;
colnames(CA) = BBCDname(n, "pat");
#rownames(CA) = c(paste("covariate", 1 : cov_num,"(", covn, ")", sep = ""), "assignment");
rownames(CA) = c(paste("covariate", 1 : cov_num, sep = ""), "assignment");
R$Cov_Assig = CA;
assig_temp = CA[dim(CA)[1], ];
R$assignments = LETTERS[assig_temp];
AS0 = RES[2, 1][[1]];
AS0ordinPS = MVReturnM(PStrGen(cov_num, level_num), AS0)[, 1];
AS = AS0[, order(AS0ordinPS)]
colnames(AS) = BBCDname(strt_num, "stratum");
rownames(AS) = paste("covariate", 1 : cov_num,"(", covn, ")", sep = "");
R$'All strata' = AS;
Df0 = RES[4, 1][[1]];
Df = Df0[c(1, 1 + order(AS0ordinPS), (1 + strt_num + 1) : (1 + strt_num + sum(level_num))), ,drop = FALSE]
rownames(Df) = nameString(cov_num, level_num, strt_num, "All", AS);
R$Diff = Df;
R$method = "Atkinson's Optimum Biased Coin Design";
R$'Data Type' = "Real";
R$framework = "Model-based approach";
R$data = data;
class(R) = "carandom";
return(R);
}
###############################################################################
## Covariate-adaptive Biased Coin Design ########
###############################################################################
#AdjBCD = function(data, a = 2.0) UseMethod("AdjBCD")
#AdjBCD.carandom = function(data, a = 2.0) UseMethod("carandom")
AdjBCD = function(data, a = 3.0){
R = NULL;
adoub = as.double(a);
if(is.na(adoub)){
stop("a must be a positive number!");
}else if(a == 0){
stop("a must be a positive number!");
}else if(a < 0){
warning("a is mandated to be positive", call. = FALSE);
}
if(length(data[is.na(data)]) == 0){
datap = data;
}else{
data[is.na(data)] = "NA";
datap = data;
}
rdata = Preprocess(datap);
data_proc = rdata$data;
cov_num = rdata$cov_num; level_num = rdata$level_num;
R$datanumeric = FALSE;
RES = C_RAdjustBCD(data_proc, cov_num, level_num, adoub);
covn = colnames(data);
R$covariates = covn;
strt_num = ncol(RES[2, 1][[1]]);
R$strt_num = strt_num;
R$cov_num = cov_num;
R$level_num = level_num;
CA = RES[3, 1][[1]];
n = ncol(CA);
R$n = n;
colnames(CA) = BBCDname(n, "pat");
#rownames(CA) = c(paste("covariate", 1 : cov_num,"(", covn, ")", sep = ""), "assignment");
rownames(CA) = c(paste("covariate", 1 : cov_num, sep = ""), "assignment");
R$Cov_Assig = CA;
assig_temp = CA[dim(CA)[1], ];
R$assignments = LETTERS[assig_temp];
AS0 = RES[2, 1][[1]];
AS0ordinPS = MVReturnM(PStrGen(cov_num, level_num), AS0)[, 1];
AS = AS0[, order(AS0ordinPS)]
colnames(AS) = BBCDname(strt_num, "stratum");
rownames(AS) = paste("covariate", 1 : cov_num,"(", covn, ")", sep = "");
R$'All strata' = AS;
Df0 = RES[4, 1][[1]];
Df = Df0[c(1, 1 + order(AS0ordinPS), (1 + strt_num + 1) : (1 + strt_num + sum(level_num))), ,drop = FALSE]
rownames(Df) = nameString(cov_num, level_num, strt_num, "All", AS);
R$Diff = Df;
R$method = "Covariate-adaptive Biased Coin Design";
R$'Data Type' = "Real";
R$framework = "Stratified randomization";
R$data = data;
class(R) = "carandom";
return(R);
}
# ###############################################################################
# ## Biased Coin Design with a Bayesian Bias ########
# ###############################################################################
# #BayesBCD = function(data, J = 2) UseMethod("BayesBCD")
#
# BayesBCD.carandom = function(data, J = 2) UseMethod("carandom")
#
# BayesBCD = function(data, J = 2){
# Jint = as.integer(J);
# if(is.na(Jint)){
# stop("J must be a positive integer!")
# }else if(J %% Jint != 0){
# warning("J is mandated to be an integer", call. = FALSE)
# }
#
# if(length(data[is.na(data)]) == 0){
# datap = data;
# }else{
# data[is.na(data)] = "NA";
# datap = data;
# }
#
# rdata = Preprocess(datap);
# data_proc = rdata$data;
# cov_num = rdata$cov_num; level_num = rdata$level_num;
#
# RES = C_RBayesBCD(data_proc, cov_num, level_num, Jint);
#
# R = NULL;
#
# covn = colnames(data);
# R$covariates = covn;
#
# strt_num = ncol(RES[4, 1][[1]]);
# R$strt_num = strt_num;
#
# R$cov_num = cov_num;
# R$level_num = level_num;
#
# CA = RES[6, 1][[1]];
# n = ncol(CA);
# R$N = n;
# colnames(CA) = BBCDname(n, "pat");
# rownames(CA) = c(BBCDname(cov_num, "covariate"), "assignment");
# R$Cov_Assig = CA;
#
# AS = RES[4, 1][[1]];
# colnames(AS) = BBCDname(strt_num, "strt.");
# rownames(AS) = BBCDname(cov_num, "covariate");
# R$'All strata' = AS;
#
# Df = RES[7, 1][[1]];
# rownames(Df) = nameString(cov_num, level_num, strt_num, "All", "Real");
# R$Diff = t(Df);
#
# R$method = "Covariate-adaptive Biased Coin Design";
# R$'Data Type' = "Real";
# R$framework = "Stratified randomization";
# R$data = data;
#
# numJ = RES[5, 1][[1]];
# rownames(numJ) = BBCDname(2, "Treat.");
# colnames(numJ) = BBCDname(J, "Category-");
# R$numJ = numJ;
#
# RR = t(RES[2, 1][[1]]);
# colnames(RR) = c("no._of_t1", "no._of_t2", "diff");
# R$num_diff = RR;
#
# class(R) = "carandom";
#
# return(R);
# }
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.