Auf insgesamt 14 Halbseiten sollen Fehler so verteilt werden, daß alle Fehlertypen und Fehlerorte gleichmäßig häufig auftreten. Fehlertype, hor. und vert. Komponente sind in jeweils 4 Kategorien aufgeteilt.

Type <- factor(c("Add","Mis","Rev","Sha"))   # Fehlertyp
Col <- factor(c("A","B","C","D"))            # hor. Ort
Zeile <- 1:4                                 # bleibt numerisch, da die Zeilenzahl 1:28 umfaßt

Zunächst werden alle Kombinationen von Fehler und Ort aufgelistet und zufällig gemischt:

de <- expand.grid(Type=Type,Col=Col,Zeile=Zeile)
de.s <- de[sample(1:64),]                    # Sample ohne Replikation -> Permutation

Danach wird eine Verteilung auf die Halbseiten vorgenommen. Es sind 64 Fehler auf 14 Halbseiten zu verteilen, es sind mindestens 4 und höchstens 6 gewünscht.

de.s$pg = c(rep(1:14,each=4), sample(2:13,4),sample(2:13,4))

Der grobe Wert in de.s$Zeile wird noch genau spezifiziert:

de.s$Zeile <- de.s$Zeile*7-sample(0:6,64,rep=T)  # Sample mit Replikation

Außerdem erzeugen wir noch eine Spalte mit Zufallsbuchstaben:

de.s$Let <- sample(letters,64,rep=T)

Die Liste der Fehler erhält man durch Sortieren nach Halbseite und Zeile:

de.s[order(de.s$pg,de.s$Zeile),]

T1.txt

   Type Col Zeile pg Let
6   Mis   B     5  1   t
47  Rev   D    15  1   w
33  Add   A    16  1   i
57  Add   C    24  1   m
3   Rev   A     1  2   f
32  Sha   D    13  2   q
48  Sha   D    21  2   g
45  Add   D    21  2   e
60  Sha   C    23  2   e
13  Add   D     4  3   e
29  Add   D     8  3   t
27  Rev   C    11  3   s
28  Sha   C    13  3   b
23  Rev   B    14  3   i
20  Sha   A    11  4   g
35  Rev   A    16  4   v
59  Rev   C    23  4   g
53  Add   B    23  4   n
1   Add   A     4  5   b
7   Rev   B     5  5   g
18  Mis   A     8  5   s
43  Rev   C    20  5   q
14  Mis   D     4  6   m
8   Sha   B     4  6   a
30  Mis   D     8  6   a
40  Sha   B    17  6   o
64  Sha   D    27  6   l
49  Add   A    28  6   h
5   Add   B     7  7   t
19  Rev   A    10  7   u
42  Mis   C    18  7   g
52  Sha   A    24  7   m
56  Sha   B    27  7   v
4   Sha   A     2  8   u
34  Mis   A    16  8   h
44  Sha   C    21  8   y
55  Rev   B    22  8   w
12  Sha   C     2  9   o
24  Sha   B    11  9   a
39  Rev   B    18  9   u
54  Mis   B    28  9   w
15  Rev   D     1 10   d
10  Mis   C     1 10   r
26  Mis   C    13 10   d
46  Mis   D    20 10   l
37  Add   B    21 10   w
2   Mis   A     1 11   f
16  Sha   D     1 11   t
17  Add   A    14 11   y
36  Sha   A    21 11   p
31  Rev   D    13 12   a
38  Mis   B    19 12   c
41  Add   C    20 12   f
50  Mis   A    27 12   h
62  Mis   D    27 12   d
11  Rev   C     2 13   z
9   Add   C     6 13   r
21  Add   B    10 13   b
25  Add   C    10 13   d
61  Add   D    25 13   c
22  Mis   B     8 14   y
63  Rev   D    22 14   e
58  Mis   C    23 14   x
51  Rev   A    23 14   i
> 

Im 7./8. Eintrag findet man einen möglichen Ortskonflikt (2 Fehler am selben Ort). Alle drei möglichen Konfliktlösungen sind auf ihre Art sinnvoll:

1. akzeptieren und beide Fehler einbauen
2. den 2. Fehler um 1 Zeile nach oben oder unten verschieben
3. ganzen Datensatz verwerfen und neu mischen

Wir verpacken die obigen Code-Fragmente in ein Skript, das die Ergebnisse von 6 Durchläufen in eine Datei T1.txt schreibt.

Die Hilfsfunktion dez() erzeugt Zufallszahlen zwischen 0 und 6, die sich in 4er-Blöcken nicht wiederholen (4mal wird Ziehen ohne Zurücklegen aus 0:6 durchgeführt).

dez <- function(){c(sample(0:6,4),sample(0:6,4),sample(0:6,4),sample(0:6,4))}
shuffle <- function() {
de$Zeile <- 7*rep(1:4,each=16)-dez()
de.s <- de[sample(1:64),]                      # Permutation
de.s$pg = c(rep(1:14,each=4), sample(2:13,4),sample(2:13,4))
# de.s$Let <- sample(letters,64,rep=T)
de.s <- de.s[order(de.s$pg,de.s$Zeile),] }

Damit erhalten Zeilen mit demselben Spaltencode auf jeden Fall verschiedene Zeilennummern.

Wenn mehr Varianz in der Fehlerzahl verlangt wird, ist das obige Verfahren noch nicht optimal. Außerdem soll eine breite Tabelle mit den 6 Werten erzeugt werden.

design.R

Type <- factor(c("Add","Mis","Rev","Sha"))
Col <- factor(c("A","B","C","D"))
Zeile <- 1:4
 
shuffle2 <- function() {
  Count <- sample(c(rep(2,2),rep(4:6,4)))        # Verteilung der Fehlerzahlen
  de.s <- de[sample(1:64),]                      # Permutation
  de.s$pg <- NA;
  dex= 0
  for (pg in 1:14) {
    jj <- dex+1:Count[pg];
    dex <- dex + Count[pg];
    de.s$pg[jj] <- pg;
    de.s$Zeile[jj] <- sort(7*de.s$Zeile[jj] - sample(0:6,length(jj))); }
  de.s }
 
T1 <- list()
for (i in 1:6) {
  de.s <- shuffle2()
  de.s$Zeile <- with(de.s,ifelse(pg%%2,Zeile,Zeile+28))
  de.s$pg <- (de.s$pg+1) %/%2
  T1[[i]] <- de.s[c(4,3,2,1)]
}
T1.wide <- cbind(T1[[1]],T1[[2]],T1[[3]],T1[[4]],T1[[5]],T1[[6]])
sink("T1.txt")
T1.wide
sink()