====== Erzeugen eines balancierten Versuchsplans ======

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),]
  
<file none 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
> 
</file>

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:
  - akzeptieren und beide Fehler einbauen
  - den 2. Fehler um 1 Zeile nach oben oder unten verschieben
  - ganzen Datensatz verwerfen und neu mischen

===== Beseitigung der Konflikte =====
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.

===== mehr Varianz bei Fehlerzahl pro Seite =====

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.

<file R 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()
</file>