Procedures implemented in the package
Completely Randomized Design (CRD)
For a two-arm trial and 1:1
target allocation, every subject is allocated to treatments with a fixed probability
\[\phi_j = 0.5, \: j = 1, \ldots, n.\]
In case of two-arm trial with unequal allocation or multi-arm trial with equal/unequal allocation, every subject is allocated to treatments with fixed probabilities that are equal to the target allocation proportions:
\[P_k(j) = \rho_k, \: k = 1, \ldots, K; \: j = 1, \ldots, n.\]
Incertus.CRD
— TypeA type of randomization, representing Completely Randomized Design (CRD).
CRD()
command initializes a complete randomization procedure, targeting 1:1
allocation.
CRD(w)
command initializes a complete randomization procedure, targeting allocation specified by w
.
An output of both commands is an instance of CRD
.
julia> using Incertus
julia> crd = CRD() # complete randomization, targeting 1:1 allocation
CRD: complete randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4]
4-element Vector{Int64}: 1 2 3 4
julia> crd = CRD(w) # complete randomization, targeting allocation specified by w
CRD: complete randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Permuted Block Design (PBD)
Treatment assignments are made in blocks of size $bs$ (for a two-arm trial and 1:1
target allocation, $bs= 2\lambda$; otherwise, $bs=\lambda W$, where $W=w_1 + \ldots + w_K$ is a sum of elements of vector $\mathbf{w}$, target allocation vector. Here, $\lambda$ is a parameter of the PBD, representing the number of minimal balanced sets in the block of size $bs$).
At the $j^\text{th}$ allocation step, let $k^{(j-1)} = \left \lfloor \frac{j-1}{bs}\right\rfloor$ ($\lfloor x \rfloor$ is a floor
function that returns the greatest integer less than or equal to $x$). In essence, $k^{(j-1)}$ is the number of complete blocks among the first $j-1$ assignments.
The probabilities of treatment assignments within each block are changed according the current imbalance in a block:
- for a two-arm trial and
1:1
target allocation,
\[\phi_j = \frac{0.5bs(1+k^{(j-1)})-N_1(j-1)}{bs(1+k^{(j-1)})-(j-1)}, \: j = 1, \ldots, n;\]
- for a two-arm trial with unequal allocation or multi-arm trial with equal/unequal allocation,
\[P_k(j) = \frac{w_k\lambda(1+k^{(j-1)})-N_k(j-1)}{bs(1+k^{(j-1)})-(j-1)}, k = 1, \ldots, K; \: j = 1, \ldots, n.\]
See [Zhao and Weng (2011), page 955, equation (5)]
Incertus.PBD
— TypeA type of rectricted randomization, representing Permuted Block Design (PBD).
PBD(λ)
command initializes a permuted block design with a block size equal to 2λ
, targeting 1:1
allocation.
PBD(w, λ)
command initializes a permuted block design with a parameter λ
, targeting allocation specified by w
; block size equals to λ*sum(w)
.
An output of both commands is an instance of PBD
.
julia> using Incertus
julia> pbd = PBD(1) # PBD, targeting 1:1 allocation, with a block size equal to 2*1 = 2
PBD(1): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> pbd = PBD(3) # PBD, targeting 1:1 allocation, with a block size equal to 2*3 = 6
PBD(3): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4]
4-element Vector{Int64}: 1 2 3 4
julia> pbd = PBD(w, 1) # PBD, targeting allocation specified by w, with a block size sum(w)
PBD(1): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
julia> pbd = PBD(w, 3) # PBD, targeting allocation specified by w, with a block size 3*sum(w)
PBD(3): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Random Allocation Rule (Rand)
A version of PBD, when the block size $bs$ equals to the total sample size $n$. At the $j^\text{th}$ allocation step, probabilities of treatment assignments are calculated as:
- for a two-arm trial and
1:1
target allocation,
\[\phi_j = \frac{0.5n-N_1(j-1)}{n-(j-1)}, \: j = 1, \ldots, n;\]
- for a two-arm trial with unequal allocation or multi-arm trial with equal/unequal allocation,
\[P_k(j) = \frac{nw_k/W-N_k(j-1)}{n-(j-1)}, k = 1, \ldots, K; \: j = 1, \ldots, n,\]
where $W=w_1 + \ldots + w_K$ is a sum of elements of vector $\mathbf{w}$, target allocation vector.
Incertus.RAND
— TypeA type of rectricted randomization, representing Random Allocation Rule (Rand).
RAND(n)
command initializes a random allocation rule , targeting 1:1
allocation in a trial with a sample size equal to n
.
RAND(w, n)
command initializes a random allocation rule , targeting allocation specified by w
in a trial with a sample size equal to n
.
An output of both commands is an instance of RAND
.
julia> using Incertus
julia> rnd = RAND(50) # RAND, targeting 1:1 allocation, in a trial with 50 subjects
RAND: restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4]
4-element Vector{Int64}: 1 2 3 4
julia> rnd = RAND(w, 50) # RAND, targeting allocation specified by w, in a trial with 50 subjects
RAND: restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Truncated Binomial Design (TBD)
Treatment assignments are made with probability 0.5 until one of the treatments receives its quota of $\frac{n}{2}$ subjects; thereafter all remaining assignments are made deterministically to the opposite treatment.
At the $j^\text{th}$allocation step, let $N_1$ and $N_2$ be the numbers of subjects allocated to treatments s.t. $N_1+N_2 = j-1.$ Then,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & \max(N_1, N_2) < \frac{n}{2} \\ 1, & N_1 < N2 \\ 0, & N_1 > N2 \end{array}\right. ,\: j = 1, \ldots, n.\]
Incertus.TBD
— TypeA type of rectricted randomization, representing Truncated Binomial Design (TBD).
TBD(n)
command initializes a truncated binomial design, targeting 1:1
allocation in a trial with a sample size equal to n
.
An output of the command is an isntance of TBD.
julia> using Incertus
julia> tbd = TBD(50) # TBD, targeting 1:1 allocation, in a trial with 50 subjects
TBD: restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Truncated Multinomial Design (TMD)
Treatment assignments are made according to CRD with probabilities $P_k(j) = \rho_k$, $j=1, 2, \ldots$; $k = 1, 2, \ldots, K$, until one of the treatments ($k_1$) receives its quota of $nw_{k_1}$ subjects. Next, the randomization process switches to the remaining $K-1$ treatments with adjusted multinomial probabilities until some other treatment ($k_2$) receives its target quota of $nw_{k_2}$ subjects, and so on, until only one incomplete treatment is left. The remaining subjects in the sequence are deterministically assigned to this treatment.
For $1:1$ target allocation, TMD
is simular to TBD
.
Incertus.TMD
— TypeA type of rectricted randomization, representing Truncated Multiinomial Design (TMD).
TMD(n)
command initializes a truncated multinomial design, targeting 1:1
allocation in a trial with a sample size equal to n
. (In this case, it is similar to TBD
).
TMD(w, n)
command initializes a truncated multinomial design, targeting allocation specified by w
in a trial with a sample size equal to n
.
An output of the command is an isntance of TMD.
julia> using Incertus
julia> tmd = TMD(50) # TMD, targeting 1:1 allocation, in a trial with 50 subjects
TMD: restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4]
4-element Vector{Int64}: 1 2 3 4
julia> rnd = TMD(w, 50) # TMD, targeting allocation specified by w, in a trial with 50 subjects
TMD: restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Efron's Biased Coin Design (EBCD)
At any allocation step, if treatment numbers $N_1$ and $N_2$ are balanced, the next assignment is made with probability 0.5; otherwise, the underrepresented treatment is assigned with probability $p$, where $0.5 \leq p \leq 1$ is a fixed and pre-specified parameter that determines the trade-off between balance and randomness.
At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$, and imbalance $d = N_1-N_2$,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & N_1 = N_2\\ p, & N_1 < N2 \\ 1-p, & N_1 > N2 \end{array}\right. ,\: j = 1, \ldots, n.\]
Note that $p=1$ corresponds to PBD with block size $b=2$.
Incertus.EBCD
— TypeA type of rectricted randomization, representing Efron's Biased Coin Design (EBCD).
EBCD(p)
command initializes Efron's biased coin design with a parameter equal to p
, targeting 1:1
allocation.
An output of the command is an isntance of EBCD.
julia> using Incertus
julia> ebcd = EBCD(2//3) # EBCD, targeting 1:1 allocation, with parameter p=2/3
EBCD(2/3): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Adjustable Biased Coin Design (ABCD)
An extension of Efron’s BCD. At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$, and imbalance $d = N_1-N_2$,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & |d| <= 1 \\ \frac{|d|^a}{1+|d|^a}, & d < -1 \\ \frac{1}{1+|d|^a}, & d > 1 \end{array}\right. ,\: j = 1, \ldots, n.\]
Incertus.ABCD
— TypeA type of rectricted randomization, representing Adjustable Biased Coin Design (ABCD).
ABCD(a)
command initializes adjustable biased coin design with a parameter equal to a
, targeting 1:1
allocation.
An output of the command is an isntance of ABCD.
julia> using Incertus
julia> abcd = ABCD(2) # ABCD, targeting 1:1 allocation, with parameter a=2
ABCD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Generalized Biased Coin Design (GBCD)
A generalization of Efron’s BCD. At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$, and imbalance $d = N_1-N_2$,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & j = 1 \\ \frac{N_2^\gamma}{N_1^\gamma+N_2^\gamma}, & j = 1, \ldots, n. \end{array}\right. \]
Incertus.GBCD
— TypeA type of rectricted randomization, representing Generalized Biased Coin Design (GBCD).
GBCD(γ)
command initializes generalized biased coin design with a parameter equal to γ
, targeting 1:1
allocation.
An output of the command is an isntance of GBCD.
julia> using Incertus
julia> gbcd = GBCD(2) # GBCD, targeting 1:1 allocation, with parameter γ=2
GBCD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Big Stick Design (BSD)
An example of maximum tolerated imbalance (MTI) procedures. It makes prediction of the future treatment allocations more difficult (even knowing the current sizes of the treatment groups) and controls treatment imbalance at a predefined threshold throughout the experiment. A general MTI procedure specifies a certain boundary for treatment imbalance, say $mti$, that cannot be exceeded.
At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$, and imbalance $d = N_1-N_2$,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & |d| < mti \\ 0, & d = mti \\ 1, & d = -mti \end{array}\right. ,\: j = 1, \ldots, n.\]
Incertus.BSD
— TypeA type of rectricted randomization, representing Big Stick Design (BSD).
BSD(mti)
command initializes big stick design with a parameter equal to mti
, targeting 1:1
allocation.
An output of the command is an isntance of BSD.
julia> using Incertus
julia> bsd = BSD(3) # BSD, targeting 1:1 allocation, with parameter mti=3
BSD(3): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Biased Coin Design With Imbalance Tolerance (BCDWIT)
A combination of Efron’s BCD and BSD. At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$, and imbalance $d = N_1-N_2$,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & |d| < mti\: \& \: d = 0 \\ p, & |d| < mti \: \& \: d < 0 \\ 1-p, & |d| < mti \: \& \: d > 0 \\ 0, & d = mti \\ 1, & d = -mti \end{array}\right. ,\: j = 1, \ldots, n.\]
Incertus.BCDWIT
— TypeA type of rectricted randomization, representing Biased Coin Design With Imbalance Tolerance (BCDWIT).
BCDWIT(p, mti)
command initializes biased coin design with imbalance tolerance with parameters equal to p
and mti
, targeting 1:1
allocation.
An output of the command is an isntance of BCDWIT.
julia> using Incertus
julia> bcdwit = BCDWIT(2//3, 3) # BCDWIT with p = 2/3 and mti=3, targeting 1:1 allocation
BCDWIT(2/3, 3): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Block Urn Design (BUD)
This design was proposed by Zhao and Weng (2011), to provide a more random design than the PBD. Let $N_k(j-1)$ denote the number of treatment $k$ assignments among first $j-1$ subjects, and $k^{(j-1)}=\min\limits_{1 \leq k \leq K} \left \lfloor \frac{N_k(j-1)}{w_k}\right \rfloor$ denote the number of minimal balanced sets among the first $j-1$ assignments. Then, at the $j^\text{th}$ allocation step, probabilities of treatment assignments are calculated as:
- for a two-arm trial and
1:1
target allocation,
\[\phi_j = \frac{\lambda+\min(N_1(j-1), N_2(j-1))-N_1(j-1)}{2(\lambda+\min(N_1(j-1), N_2(j-1)))-(j-1)}, \: j = 1, \ldots, n;\]
- for a two-arm trial with unequal allocation or multi-arm trial with equal/unequal allocation,
\[P_k(j) = \frac{w_k(\lambda+k^{(j-1)})-N_k(j-1)}{W(\lambda+k^{(j-1)})-(j-1)}, k = 1, \ldots, K; \: j = 1, \ldots, n,\]
where $W=w_1 + \ldots + w_K$ is a sum of elements of vector $\mathbf{w}$, target allocation vector.
See [Zhao and Weng (2011), page 955, equations (2) and (3)].
Incertus.BUD
— TypeA type of rectricted randomzation, representing Block Urn Design (BUD).
BUD(λ)
command initializes block urn desin with a parameter equal to $λ$, targeting 1:1
allocation.
BUD(w, λ)
command initializes block urn desin with a parameter equal to $λ$, targeting allocation specified by w
.
An output of both commands is an instance of BUD
.
julia> using Incertus
julia> bud = BUD(2) # BUD, targeting 1:1 allocation (λ=2)
BUD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4]
4-element Vector{Int64}: 1 2 3 4
julia> bud = BUD(w, 2) # BUD, targeting allocation specified by w (λ=2)
BUD(2): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Ehrenfest Urn Design (EUD)
Another example of the maximum tolerated imbalance (MTI) procedure. At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$, and imbalance $d = N_1-N_2$,
\[\phi_j = \frac{1}{2}\left(1-\frac{d}{mti}\right) ,\: j = 1, \ldots, n,\]
where $mti$ ($>0$) is a parameter of the procedure.
Incertus.EUD
— TypeA type of rectricted randomzation, representing Ehrenfest Urn Design (BUD).
EUD(mti)
command initializes Ehrenfest's urn design with a parameter equal to $mti$, targeting 1:1
allocation.
An output of the command is an isntance of EUD.
julia> using Incertus
julia> eud = EUD(2) # EUD, targeting 1:1 allocation (mti=2)
EUD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Bayesian Biased Coin Design (BBCD)
A special class of biased coind designs (BCDs). At the $j^\text{th}$ allocation step, given treatment numbers $N_1$ and $N_2$, s.t. $N_1+N_2 = j-1$,
\[\phi_j = \left\{\begin{array}{rl} 0.5, & j = 1 \\ 1, & j = 2 \: \& \: N_1 = 0 \\ 0, & j = 2 \: \& \: N_1 = 1 \\ \frac{\left(1 + \frac{N_2}{(j-1)N_1}\right)^\frac{1}{\gamma}}{\left(1 + \frac{N_2}{(j-1)N_1}\right)^\frac{1}{\gamma} + \left(1 + \frac{N_1}{(j-1)N_2}\right)^\frac{1}{\gamma}}, & j \geq 3 \end{array}\right. ,\: j = 1, \ldots, n.\]
where $\gamma$ ($>0$) is a parameter of the procedure.
Incertus.BBCD
— TypeA type of rectricted randomzation, representing Bayesian Biased Coin Design (BBCD).
BBCD(γ)
command initializes Bayesian biased coin design with a parameter equal to $γ$, targeting 1:1
allocation.
An output of the command is an isntance of BBCD.
julia> using Incertus
julia> bbcd = BBCD(0.1) # BBCD, targeting 1:1 allocation (γ=0.1)
BBCD(0.1): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
Mass Weighted Urn Design (MWUD)
A randomization procedure that can be used fo for two- and multi-arm trials, targeting both equal and unequal allocation. At the $j^\text{th}$ allocation step, given $K$ treatments and corresponding treatment numbers $N_1(j-1) \ldots N_K(j-1)$, s.t. $\sum_{k = 1}^K{N_k(j-1)} = j-1$,
\[P_k(j) = \frac{\max\left\{\alpha\rho_k-N_k(j-1) +(j-1)\rho_k , 0\right\}}{\sum_{k=1}^K\max\left\{\alpha\rho_k-N_k(j-1) +(j-1)\rho_k , 0\right\}} ,\: j = 1, \ldots, n.\]
where $\alpha$ ($>0$) is a parameter of the procedure that controls maximum tolerated imbalance.
Incertus.MWUD
— TypeA type of rectricted randomization, representing Mass Weighted Urn Design (MWUD).
MWUD(α)
command initializes mass weighted urn design with a parameter equal to α
, targeting 1:1
allocation.
MWUD(w, α)
command initializes mass weighted urn design with a parameter equal to α
, targeting allocation specified by w
.
An output of the command is an isntance of MWUD.
julia> using Incertus
julia> mwud = MWUD(2) # MWUD, targeting 1:1 allocation (α=2)
MWUD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4] # target allocation ratio
4-element Vector{Int64}: 1 2 3 4
julia> mwud = MWUD(w, 2) # MWUD, targeting 1:2:3:4 allocation (α=2)
MWUD(2): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Doubly-Adaptive Biased Coin Design (DBCD)
A randomization procedure that can be used fo for two- and multi-arm trials with $K$ treatments, targeting both equal and unequal allocation. Initial treatment assignments ($j=1, 2, \ldots, m_0$) are made completely at random ($P_k(j)=\rho_k$, $k=1, 2, \ldots, K$) until each group has at least one subject (i.e., $N_k(m_0)>0$). Subsequent treatment assignments are made as follows:
\[P_k(j) = \frac{\rho_k\left(\rho_k/\frac{N_k(j-1)}{j-1}\right)^\gamma}{\sum_{k=1}^K\rho_k\left(\rho_k/\frac{N_k(j-1)}{j-1}\right)^\gamma} ,\: j = m_0+1, \ldots, n.\]
where $\gamma$ ($>0$) is a parameter of the procedure.
Incertus.DBCD
— TypeA type of rectricted randomization, representing Doubly-Adaptive Biased Coin Design (DBCD).
DBCD(γ)
command initializes doubly-adaptive biased coin design with a parameter equal to γ
, targeting 1:1
allocation.
DBCD(w, γ)
command initializes doubly-adaptive biased coin design with a parameter equal to γ
, targeting allocation specified by w
.
An output of the command is an isntance of DBCD.
julia> using Incertus
julia> dbcd = DBCD(2) # DBCD, targeting 1:1 allocation (γ=2)
DBCD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4] # target allocation ratio
4-element Vector{Int64}: 1 2 3 4
julia> dbcd = DBCD(w, 2) # DBCD, targeting 1:2:3:4 allocation (γ=2)
DBCD(2): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Maximum Entropy Constraint Balance Randomization (MaxEnt)
A randomization procedure that can be used fo for two- and multi-arm trials with $K$ treatments, targeting both equal and unequal allocation.
Consider a point in the trial when $j-1$ subjects have been randomized among the $K$treatments, and let denote the corresponding treatment numbers as $N_k(j-1)$ ($k=1, \ldots, K$ and $\sum_{k_1}^KN_k(k-1) = j-1$). At the $j^\text{th}$ allocation step, the randomization rule is defined as follows:
a) For $k=1, 2, \ldots, K$, compute $B_k$, the hypothetical "lack of balnce", which results from assigning the $j^\text{th}$ subject to treatment $k$:
\[B_k = \max\limits_{1\leq i \leq K}\left|\frac{N^{(k)}_i(j)}{k}-\rho_k\right|, \text{ where }N^{(k)}_i(j) = \left\{ \begin{array}{rl} N_i(j-1) + 1, & i = k \\ N_i(j-1), & i \ne k \end{array} \right. .\]
b) The treatment randomization probabilities for the $j^\text{th}$ subject $\left(P_1(j), P_2(j), \ldots, P_K(j)\right)$ are determined as a solution to the constrained optimization problem:
\[\begin{aligned} &\text{minimize}\sum_{k=1}^KP_k(j)\log\left(\frac{P_k(j)}{\rho_k}\right) \\ &\text{subject to}\sum_{k=1}^KB_kP_k(j) \leq \eta B_{(1)} + (1-\eta)\sum_{k=1}^KB_k\rho_k \\ &\text{and}\sum_{k=1}^KP_k(j) = 1; \: 0\leq P_k(j) \leq 1, \: k = 1, 2, \ldots, K, \end{aligned}\]
where $B_{(1)}=\min\limits_{1\leq k \leq K}B_k$, and $\eta$ $\left(\in [0; 1]\right)$ is a parameter of the procedure that controls degree of randomness.
Incertus.MaxEnt
— TypeA type of rectricted randomization, representing Maximum Entopy Constraint Balance Randomization (MaxEnt).
MaxEnt(η)
command initializes MaxEnt design with a parameter equal to η
, targeting 1:1
allocation.
MaxEnt(w, η)
command initializes MaxEnt design with a parameter equal to η
, targeting allocation specified by w
.
An output of the command is an isntance of MaxEnt.
julia> using Incertus
julia> maxent = MaxEnt(0.5) # MaxEnt, targeting 1:1 allocation (η=2)
MaxEnt(0.5): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4] # target allocation ratio
4-element Vector{Int64}: 1 2 3 4
julia> maxent = MaxEnt(w, 0.5) # MaxEnt, targeting 1:2:3:4 allocation (η=2)
MaxEnt(0.5): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Drop-the-Loser Urn Design (DLUD)
Incertus.DLUD
— TypeA type of rectricted randomization, representing Drop-the-Loser Urn Design (DLUD).
DLUD(a)
command initializes drop-the-loser urn design with a parameter equal to a
, targeting 1:1
allocation.
DLUD(w, a)
command initializes drop-the-loser urn design with a parameter equal to a
, targeting allocation specified by w
.
An output of the command is an isntance of DLUD.
julia> using Incertus
julia> dlud = DLUD(2) # DLUD, targeting 1:1 allocation (a=2)
DLUD(2): restricted randomization procedure, targeting 1:1 allocation in 2-arm trial.
julia> w = [1, 2, 3, 4] # target allocation ratio
4-element Vector{Int64}: 1 2 3 4
julia> dlud = DLUD(w, 2) # DLUD, targeting 1:2:3:4 allocation (a=2)
DLUD(2): restricted randomization procedure, targeting 1:2:3:4 allocation in 4-arm trial.
Funcions implemented to calculate allocation probabilities
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for CRD.
Call
allocation_prb(rnd)
Arguments
rnd::CRD
: an object, representing Complete Randomization.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for PBD, given treatment numbers.
Call
- allocation_prb(rnd, N)
Arguments
rnd::PBD
: an object, representing Permuted Block Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for RAND, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::RAND
: an object, representing Random Allocation Rule.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for TBD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::TBD
: an object, representing Truncated Binomial Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for TMD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::TMD
: an object, representing Truncated Multinomial Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for EBCD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::EBCD
: an object, representing Efron's Biased Coin Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for ABCD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::ABCD
: an object, representing Adjustable Biased Coin Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for GBCD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::GBCD
: an object, representing Generalized Biased Coin Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for BSD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::BSD
: an object, representing Big Stick Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for BCDWIT, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::BCDWIT
: an object, representing Biased Coin Design With Imbalance Tolerance.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for BUD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::BUD
: an object, representing Block Urn Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for EUD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::EUD
: an object, representing Ehrenfest Urn Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for BBCD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::BBCD
: an object, representing Bayesian Biased Coin Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for MWUD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::MWUD
: an object, representing Mass Weighted Urn Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for DBCD, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::DBCD
: an object, representing Doubly-Adaptive Biased Coin Design.N::Vector{Int64}
: a vector of current treatment numbers.
Incertus.allocation_prb
— MethodFunction calculates allocation probabilities for MaxEnt, given treatment numbers.
Call
allocation_prb(rnd, N)
Arguments
rnd::MaxEnt
: an object, representing Maximum Entropy Constraint Balanced Randomiztion.N::Vector{Int64}
: a vector of current treatment numbers.