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.CRDType

A 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.

source
julia> using Incertus
julia> crd = CRD() # complete randomization, targeting 1:1 allocationCRD: 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 wCRD: 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.PBDType

A type of rectricted randomization, representing Permuted Block Design (PBD).

PBD(λ) command initializes a permuted block design with a block size equal to , 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.

source
julia> using Incertus
julia> pbd = PBD(1) # PBD, targeting 1:1 allocation, with a block size equal to 2*1 = 2PBD(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 = 6PBD(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.RANDType

A 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.

source
julia> using Incertus
julia> rnd = RAND(50) # RAND, targeting 1:1 allocation, in a trial with 50 subjectsRAND: 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 subjectsRAND: 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.TBDType

A 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.

source
julia> using Incertus
julia> tbd = TBD(50) # TBD, targeting 1:1 allocation, in a trial with 50 subjectsTBD: 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.TMDType

A 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.

source
julia> using Incertus
julia> tmd = TMD(50) # TMD, targeting 1:1 allocation, in a trial with 50 subjectsTMD: 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 subjectsTMD: 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.EBCDType

A 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.

source
julia> using Incertus
julia> ebcd = EBCD(2//3) # EBCD, targeting 1:1 allocation, with parameter p=2/3EBCD(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.ABCDType

A 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.

source
julia> using Incertus
julia> abcd = ABCD(2) # ABCD, targeting 1:1 allocation, with parameter a=2ABCD(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.GBCDType

A 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.

source
julia> using Incertus
julia> gbcd = GBCD(2) # GBCD, targeting 1:1 allocation, with parameter γ=2GBCD(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.BSDType

A 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.

source
julia> using Incertus
julia> bsd = BSD(3) # BSD, targeting 1:1 allocation, with parameter mti=3BSD(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.BCDWITType

A 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.

source
julia> using Incertus
julia> bcdwit = BCDWIT(2//3, 3) # BCDWIT with p = 2/3 and mti=3, targeting 1:1 allocationBCDWIT(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.BUDType

A 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.

source
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.EUDType

A 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.

source
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.BBCDType

A 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.

source
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.MWUDType

A 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.

source
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 ratio4-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.DBCDType

A 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.

source
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 ratio4-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.MaxEntType

A 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.

source
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 ratio4-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.DLUDType

A 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.

source
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 ratio4-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_prbMethod

Function calculates allocation probabilities for CRD.

Call

  • allocation_prb(rnd)

Arguments

  • rnd::CRD: an object, representing Complete Randomization.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source
Incertus.allocation_prbMethod

Function 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.
source