\textbf{A model with all kinds of functional dependencies}

New value codes are too trivial to be represented here. Only calculating new values for functional parameters, acceptation formulae and acceptation codes for parameters a1 - a26 are included.

Calculating new values for functional parameters depending on a1:

\begin{verbatim}
! calculating new value(s) for b1

b1 % one_dim(1) % new_value = a1 % one_dim(1) % new_value+1
\end{verbatim}

Acceptation formula for a1:

\begin{verbatim}
!  P(a1') / P(a1)

p_acc = 1
CALL user_dist_1_freq(1.0_dp, a1 % one_dim(1) % new_value, new_frequency)
CALL user_dist_1_freq(1.0_dp, a1 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! q(a1', a1) / q(a1, a1')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a1 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a1 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a1 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a1 % one_dim(1) % value = a1 % one_dim(1) % new_value
    a1 % one_dim(1) % successful_changes = a1 % one_dim(1) % &
        successful_changes + 1
    
    b1 % one_dim(1) % value = b1 % one_dim(1) % new_value

END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a2:

\begin{verbatim}
! calculating new value(s) for b2

b2 % one_dim(1) % new_value = a2 % one_dim(1) % new_value-2
\end{verbatim}

Acceptation formula for a2:

\begin{verbatim}
!  P(a2') / P(a2)

p_acc = 1
CALL user_dist_2_freq(2.0_dp, a2 % one_dim(1) % new_value, new_frequency)
CALL user_dist_2_freq(2.0_dp, a2 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c2 | a2') / P( c2 | a2)

CALL user_dist_2-_freq(b2% one_dim(1) % new_value, c2 % one_dim(1), &
    new_frequency)
CALL user_dist_2-_freq(b2% one_dim(1) % value, c2 % one_dim(1), frequency)
p_acc = p_acc * new_frequency / frequency

! q(a2', a2) / q(a2, a2')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a2 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a2 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a2 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a2 % one_dim(1) % value = a2 % one_dim(1) % new_value
    a2 % one_dim(1) % successful_changes = a2 % one_dim(1) % &
        successful_changes + 1
    
    b2 % one_dim(1) % value = b2 % one_dim(1) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a4:

\begin{verbatim}
! calculating new value(s) for b4

i2 = i
b4 % one_dim(i2) % new_value = a4 % one_dim(i2) % new_value/4
\end{verbatim}

Acceptation formula for a4:

\begin{verbatim}

!  P(a4') / P(a4)

p_acc = 1
CALL user_dist_4_freq(4.0_dp, a4 % one_dim(i) % new_value, new_frequency)
CALL user_dist_4_freq(4.0_dp, a4 % one_dim(i) % value, frequency)
p_acc = p_acc * new_frequency / frequency


! q(a4', a4) / q(a4, a4')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a4 % one_dim(i) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a4 % one_dim(i) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a4 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a4 % one_dim(i) % value = a4 % one_dim(i) % new_value
    a4 % one_dim(i) % successful_changes = a4 % one_dim(i) % &
        successful_changes + 1
    
    i2 = i
    b4 % one_dim(i2) % value = b4 % one_dim(i2) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a5:

\begin{verbatim}
! calculating new value(s) for b5

i2 = i
b5 % one_dim(i2) % new_value = EXP(a5 % one_dim(i2) % new_value)
\end{verbatim}

Acceptation formula for a5:
\begin{verbatim}

!  P(a5') / P(a5)

p_acc = 1
CALL user_dist_2_freq(5.0_dp, a5 % one_dim(i) % new_value, new_frequency)
CALL user_dist_2_freq(5.0_dp, a5 % one_dim(i) % value, frequency)
p_acc = p_acc * new_frequency / frequency


! P( c5 | a5') / P( c5 | a5)

CALL user_dist_5-_freq(b5 % one_dim(i) % new_value, c5 % one_dim(i) % value, &
    new_frequency)
CALL user_dist_5-_freq(b5 % one_dim(i) % value, c5 % one_dim(i) % value, &
    frequency)
p_acc = p_acc * new_frequency / frequency

! q(a5', a5) / q(a5, a5')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a5 % one_dim(i) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a5 % one_dim(i) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a5 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a5 % one_dim(i) % value = a5 % one_dim(i) % new_value
    a5 % one_dim(i) % successful_changes = a5 % one_dim(i) % &
        successful_changes + 1
    
    i2 = i
    b5 % one_dim(i2) % value = b5 % one_dim(i2) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a7:

\begin{verbatim}
! calculating new value(s) for b7

i2 = i
j2 = j
b7 % two_dim(i2, j2) % new_value = a7 % two_dim(i2, j2) % new_value**2
\end{verbatim}

Acceptation formula for a7:

\begin{verbatim}
!  P(a7') / P(a7)

p_acc = 1
CALL user_dist_7_freq(7.0_dp, a7 % two_dim(i, j) % new_value, new_frequency)
CALL user_dist_7_freq(7.0_dp, a7 % two_dim(i, j) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! q(a7', a7) / q(a7, a7')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a7 % two_dim(i, j) % value, &
    frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a7 % two_dim(i, j) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a7 (if the update strategy is sequential):
\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a7 % two_dim(i, j) % value = a7 % two_dim(i, j) % new_value
    a7 % two_dim(i, j) % successful_changes = a7 % two_dim(i, j) % &
        successful_changes + 1
    
    i2 = i
    j2 = j
    b7 % two_dim(i2, j2) % value = b7 % two_dim(i2, j2) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a8:

\begin{verbatim}
! calculating new value(s) for b8

i2 = i
j2 = j
b8 % two_dim(i2, j2) % new_value = EXP(a8 % two_dim(i2, j2) % new_value)
\end{verbatim}

Acceptation formula for a8:

\begin{verbatim}

!  P(a8') / P(a8)

p_acc = 1
CALL user_dist_2_freq(8.0_dp, a8 % two_dim(i, j) % new_value, new_frequency)
CALL user_dist_2_freq(8.0_dp, a8 % two_dim(i, j) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c8 | a8') / P( c8 | a8)

CALL user_dist_8-_freq(b8 % two_dim(i, j) % new_value, c8 % two_dim(i, j) % &
    value, new_frequency)
CALL user_dist_8-_freq(b8 % two_dim(i, j) % value, c8 % two_dim(i, j) % &
    value, frequency)
p_acc = p_acc * new_frequency / frequency

! q(a8', a8) / q(a8, a8')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a8 % two_dim(i, j) % value, &
    frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a8 % two_dim(i, j) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a8 (if the update strategy is sequential):
\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a8 % two_dim(i, j) % value = a8 % two_dim(i, j) % new_value
    a8 % two_dim(i, j) % successful_changes = a8 % two_dim(i, j) % &
        successful_changes + 1
    
    i2 = i
    j2 = j
    b8 % two_dim(i2, j2) % value = b8 % two_dim(i2, j2) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a10:

\begin{verbatim}
! calculating new value(s) for b10

DO i2 = 1, 16
    b10 % one_dim(i2) % new_value = SIN(a10 % one_dim(1) % new_value)
END DO
\end{verbatim}

Acceptation formula for a10:

\begin{verbatim}

!  P(a10') / P(a10)

p_acc = 1
CALL user_dist_10_freq(10.0_dp, a10 % one_dim(1) % new_value, new_frequency)
CALL user_dist_10_freq(10.0_dp, a10 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c10 | a10') / P( c10 | a10)

DO i=1, 16
    CALL user_dist_10-_freq(b10 % one_dim(i) % new_value, c10 % one_dim(i) % &
        value, new_frequency)
    CALL user_dist_10-_freq(b10 % one_dim(i) % value, c10 % one_dim(i) % &
        value, frequency)
    p_acc = p_acc * new_frequency / frequency
END DO

! q(a10', a10) / q(a10, a10')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a10 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a10 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a10 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a10 % one_dim(1) % value = a10 % one_dim(1) % new_value
    a10 % one_dim(1) % successful_changes = a10 % one_dim(1) % &
        successful_changes + 1
    
    DO i2 = 1, 16
        b10 % one_dim(i2) % value = b10 % one_dim(i2) % new_value
    END DO
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a12:

\begin{verbatim}
! calculating new value(s) for b12

b12 % one_dim(1) % new_value = 3-a12 % one_dim(1) % new_value
\end{verbatim}

Acceptation formula for a12:

\begin{verbatim}
!  P(a12') / P(a12)

p_acc = 1
CALL user_dist_12_freq(12.0_dp, a12 % one_dim(1) % new_value, new_frequency)
CALL user_dist_12_freq(12.0_dp, a12 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c12 | a12') / P( c12 | a12)

DO i=1, 17
    CALL user_dist_12-_freq(b12 % one_dim(1) % new_value, c12 % one_dim(i) % &
        value, new_frequency)
    CALL user_dist_12-_freq(b12 % one_dim(1) % value, c12 % one_dim(i) % &
        value, frequency)
    p_acc = p_acc * new_frequency / frequency
END DO

! q(a12', a12) / q(a12, a12')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a12 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a12 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a12 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a12 % one_dim(1) % value = a12 % one_dim(1) % new_value
    a12 % one_dim(1) % successful_changes = a12 % one_dim(1) % &
        successful_changes + 1
    
    b12 % one_dim(1) % value = b12 % one_dim(1) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a14:

\begin{verbatim}
! calculating new value(s) for b14

i2 = i
b14 % one_dim(i2) % new_value = 18/a14 % one_dim(i2) % new_value
\end{verbatim}

Acceptation formula for a14:

\begin{verbatim}

!  P(a14') / P(a14)

p_acc = 1
CALL user_dist_14_freq(14.0_dp, a14 % one_dim(i) % new_value, new_frequency)
CALL user_dist_14_freq(14.0_dp, a14 % one_dim(i) % value, frequency)
p_acc = p_acc * new_frequency / frequency


! P( c14 | a14') / P( c14 | a14)

DO j=1, 19
    CALL user_dist_14-_freq(b14 % one_dim(i) % new_value, c14 % two_dim(i, j) &
        % value, new_frequency)
    CALL user_dist_14-_freq(b14 % one_dim(i) % value, c14 % two_dim(i, j) % &
        value, frequency)
    p_acc = p_acc * new_frequency / frequency
END DO

! q(a14', a14) / q(a14, a14')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a14 % one_dim(i) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a14 % one_dim(i) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a14 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a14 % one_dim(i) % value = a14 % one_dim(i) % new_value
    a14 % one_dim(i) % successful_changes = a14 % one_dim(i) % &
        successful_changes + 1
    
    i2 = i
    b14 % one_dim(i2) % value = b14 % one_dim(i2) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a16:

\begin{verbatim}
! calculating new value(s) for b16

i2 = i
b16 % one_dim(i2) % new_value = 18/a16 % one_dim(i2) % new_value
\end{verbatim}

Acceptation formula for a16:
\begin{verbatim}

!  P(a16') / P(a16)

p_acc = 1
CALL user_dist_16_freq(16.0_dp, a16 % one_dim(i) % new_value, new_frequency)
CALL user_dist_16_freq(16.0_dp, a16 % one_dim(i) % value, frequency)
p_acc = p_acc * new_frequency / frequency


! P( c16 | a16') / P( c16 | a16)

DO j=1, 20
    CALL user_dist_16-_freq(b16 % one_dim(i) % new_value, c16 % two_dim(j, i) &
        % value, new_frequency)
    CALL user_dist_16-_freq(b16 % one_dim(i) % value, c16 % two_dim(j, i) % &
        value, frequency)
    p_acc = p_acc * new_frequency / frequency
END DO

! q(a16', a16) / q(a16, a16')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a16 % one_dim(i) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a16 % one_dim(i) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a16 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a16 % one_dim(i) % value = a16 % one_dim(i) % new_value
    a16 % one_dim(i) % successful_changes = a16 % one_dim(i) % &
        successful_changes + 1
    
    i2 = i
    b16 % one_dim(i2) % value = b16 % one_dim(i2) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a18:

\begin{verbatim}
! calculating new value(s) for b18

i2 = i
DO j2 = 1, 23
    b18 % two_dim(i2, j2) % new_value = a18 % one_dim(i2) % new_value
END DO
\end{verbatim}

Acceptation formula for a18:

\begin{verbatim}
!  P(a18') / P(a18)

p_acc = 1
CALL user_dist_18_freq(18.0_dp, a18 % one_dim(i) % new_value, new_frequency)
CALL user_dist_18_freq(18.0_dp, a18 % one_dim(i) % value, frequency)
p_acc = p_acc * new_frequency / frequency


! P( c18 | a18') / P( c18 | a18)

DO j=1, 23
    CALL user_dist_18-_freq(b18 % two_dim(i, j) % new_value, c18 % two_dim(i, &
        j) % value, new_frequency)
    CALL user_dist_18-_freq(b18 % two_dim(i, j) % value, c18 % two_dim(i, j) &
        % value, frequency)
    p_acc = p_acc * new_frequency / frequency
END DO

! q(a18', a18) / q(a18, a18')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a18 % one_dim(i) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a18 % one_dim(i) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a18 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a18 % one_dim(i) % value = a18 % one_dim(i) % new_value
    a18 % one_dim(i) % successful_changes = a18 % one_dim(i) % &
        successful_changes + 1
    
    i2 = i
    DO j2 = 1, 23
        b18 % two_dim(i2, j2) % value = b18 % two_dim(i2, j2) % new_value
    END DO
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a20:

\begin{verbatim}
! calculating new value(s) for b20

j2 = i
DO i2 = 1, 24
    b20 % two_dim(i2, j2) % new_value = a20 % one_dim(j2) % new_value
END DO
\end{verbatim}

Acceptation formula for a20:

\begin{verbatim}
!  P(a20') / P(a20)

p_acc = 1
CALL user_dist_20_freq(20.0_dp, a20 % one_dim(i) % new_value, new_frequency)
CALL user_dist_20_freq(20.0_dp, a20 % one_dim(i) % value, frequency)
p_acc = p_acc * new_frequency / frequency


! P( c20 | a20') / P( c20 | a20)

DO j=1, 24
    CALL user_dist_20-_freq(b20 % two_dim(j, i) % new_value, c20 % two_dim(j, &
        i) % value, new_frequency)
    CALL user_dist_20-_freq(b20 % two_dim(j, i) % value, c20 % two_dim(j, i) &
        % value, frequency)
    p_acc = p_acc * new_frequency / frequency
END DO

! q(a20', a20) / q(a20, a20')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a20 % one_dim(i) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a20 % one_dim(i) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a20 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a20 % one_dim(i) % value = a20 % one_dim(i) % new_value
    a20 % one_dim(i) % successful_changes = a20 % one_dim(i) % &
        successful_changes + 1
    
    j2 = i
    DO i2 = 1, 24
        b20 % two_dim(i2, j2) % value = b20 % two_dim(i2, j2) % new_value
    END DO
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a22:

\begin{verbatim}
! calculating new value(s) for b22

b22 % one_dim(1) % new_value = 5*a22 % one_dim(1) % new_value
\end{verbatim}

Acceptation formula for a22:

\begin{verbatim}

!  P(a22') / P(a22)

p_acc = 1
CALL user_dist_22_freq(22.0_dp, a22 % one_dim(1) % new_value, new_frequency)
CALL user_dist_22_freq(22.0_dp, a22 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c22 | a22') / P( c22 | a22)

DO i=1, 26
    DO j=1, 27
        CALL user_dist_22-_freq(b22 % one_dim(1) % new_value, c22 % &
            two_dim(i, j) % value, new_frequency)
        CALL user_dist_22-_freq(b22 % one_dim(1) % value, c22 % two_dim(i, j) &
            % value, frequency)
        p_acc = p_acc * new_frequency / frequency
    END DO
END DO

! q(a22', a22) / q(a22, a22')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a22 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a22 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a22 (if the update strategy is sequential):

\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a22 % one_dim(1) % value = a22 % one_dim(1) % new_value
    a22 % one_dim(1) % successful_changes = a22 % one_dim(1) % &
        successful_changes + 1
    
    b22 % one_dim(1) % value = b22 % one_dim(1) % new_value
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a24:

\begin{verbatim}
! calculating new value(s) for b24

DO i2 = 1, 28
    b24 % one_dim(i2) % new_value = a24 % one_dim(1) % new_value+1**2
END DO
\end{verbatim}

Acceptation formula for a24:

\begin{verbatim}
!  P(a24') / P(a24)

p_acc = 1
CALL user_dist_24_freq(24.0_dp, a24 % one_dim(1) % new_value, new_frequency)
CALL user_dist_24_freq(24.0_dp, a24 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c24 | a24') / P( c24 | a24)

DO i=1, 28
    DO j=1, 29
        CALL user_dist_24-_freq(b24 % one_dim(i) % new_value, c24 % &
            two_dim(i, j) % value, new_frequency)
        CALL user_dist_24-_freq(b24 % one_dim(i) % value, c24 % two_dim(i, j) &
            % value, frequency)
        p_acc = p_acc * new_frequency / frequency
    END DO
END DO

! q(a24', a24) / q(a24, a24')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a24 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a24 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a24 (if the update strategy is sequential):
\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a24 % one_dim(1) % value = a24 % one_dim(1) % new_value
    a24 % one_dim(1) % successful_changes = a24 % one_dim(1) % &
        successful_changes + 1
    
    DO i2 = 1, 28
        b24 % one_dim(i2) % value = b24 % one_dim(i2) % new_value
    END DO
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}

Calculating new values for functional parameters depending on a26:

\begin{verbatim}
! calculating new value(s) for b26

DO i2 = 1, 31
    b26 % one_dim(i2) % new_value = a26 % one_dim(1) % new_value+1**2
END DO
\end{verbatim}

Acceptation formula for a26:

\begin{verbatim}
!  P(a26') / P(a26)

p_acc = 1
CALL user_dist_26_freq(26.0_dp, a26 % one_dim(1) % new_value, new_frequency)
CALL user_dist_26_freq(26.0_dp, a26 % one_dim(1) % value, frequency)
p_acc = p_acc * new_frequency / frequency

! P( c26 | a26') / P( c26 | a26)

DO i=1, 30
    DO j=1, 31
        CALL user_dist_26-_freq(b26 % one_dim(j) % new_value, c26 % &
            two_dim(i, j) % value, new_frequency)
        CALL user_dist_26-_freq(b26 % one_dim(j) % value, c26 % two_dim(i, j) &
            % value, frequency)
        p_acc = p_acc * new_frequency / frequency
    END DO
END DO

! q(a26', a26) / q(a26, a26')

CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a26 % one_dim(1) % value, frequency)
CALL user_dist_prop_freq(3.14_dp, 4.13_dp, a26 % one_dim(1) % new_value, &
    new_frequency)
p_acc = p_acc * frequency / new_frequency
\end{verbatim}

Acceptation code for a26 (if the update strategy is sequential):
\begin{verbatim}
IF (p_acc > prob(prob_index)) THEN
    a26 % one_dim(1) % value = a26 % one_dim(1) % new_value
    a26 % one_dim(1) % successful_changes = a26 % one_dim(1) % &
        successful_changes + 1
    
    DO i2 = 1, 31
        b26 % one_dim(i2) % value = b26 % one_dim(i2) % new_value
    END DO
END IF
prob_index = prob_index + 1
IF (prob_index > SIZE(prob) .OR. prob_index < 1) THEN
    CALL G05FAF(0.0_dp, 1.0_dp, SIZE(prob), prob)
    prob_index = 1
END IF
\end{verbatim}