knitr::opts_chunk$set(echo = FALSE)
colorOrig <- "gray"
colorParity1 <- "orange"
colorParity2 <- "violet"

binVector <- function(n, min.length) {

  result <- integer()
  i <- 0
  while (n != 0) {
    result <- c(n %% 2, result)
    n = n %/% 2
    i <- i + 1
  }

  zeros <- rep(0, times = min.length)

  result <- c(zeros, result)

  return(paste(tail(result,min.length), collapse = ""))
}

decToBin <- function(x) { if (all(x<2)) x else paste(decToBin(x%/%2), x%%2, sep="") }

octalToDec <- function(x) {
  res <- numeric()
  for(j in 1:length(x)) {
  dec <- 0
  i <- 0
    while (x[j] > 0) {
      dec <- dec + (x[j] %% 10) * (8^i)
      i <- i + 1
      x[j] <- x[j] %/% 10
    }
  res[j] <- dec
  }

  return(res)
}

# returns an ordering of the state numbers for a nice state diagram
ordering <- function(num.states, next.state) {
  #next.state <- matrix(rep(0:(num.states-1), each = 2), ncol = 2)
  result <- integer(1)

  n <- 0
  for (i in 2:num.states) {
    n0 <- next.state[n+1,1]
    n1 <- next.state[n+1,2]

    if (n0 %in% result) {
      n <- n1
    }
    else if (n1 %in% result) {
      n <- n0
    }
    else {
      n <- if (n0 > n1) n0 else n1
    }

    result <- c(result, n)
  }

  return(result)
}

gcd <- function(n, m) {
  if (n == 0 && m == 0) return(0)

  n <- abs(n); m <- abs(m)
  if (m > n) {
    t <- n; n <- m; m <- t
  }
  while (m > 0) {
    t <- n
    n <- m
    m <- t %% m
  }
  return(n)
}
node.short <- 18
node.long <- 33
decimal.digits <- 1
dots <- function (v, node) if(length(v) > node) ", ..." else ""

if (params$encoder$rsc == TRUE) {
  art.coder <- "Rekursiver"
} else {
  art.coder <- "Nicht-Rekursiver"
}

if (params$encoder$rsc == FALSE) {
  generator.matrix <- 
    paste0(decToBin(octalToDec(params$encoder$generators)), " \\\\ ", collapse = "")
  generator.print <- paste0("(", paste(params$encoder$generators, collapse="_8,"), 
                           "_8) = \\begin{pmatrix}", generator.matrix, "\\end{pmatrix}")

} else {
  generator.print <- 
    paste0("\\left(1,", 
           paste0("\\frac{", 
              head(params$encoder$generators, length(params$encoder$generators) - 1), "_8}{",
                        tail(params$encoder$generators, 1), "_8}", collapse = ","), "\\right)")
}
#cut off the parameters
orig <- paste0(
  paste0(head(round(params$orig, decimal.digits), node.short), collapse = ", "), dots(params$orig, node.short))
parity1 <- paste0(
  paste0(head(round(params$parity1, decimal.digits), node.short), collapse = ", "), dots(params$parity1, node.short))
parity2 <- paste0(
  paste0(head(round(params$parity2, decimal.digits), node.short), collapse = ", "), dots(params$parity2, node.short))
origI <- paste0(
  paste0(head(round(params$origI, decimal.digits), node.short), collapse = ", "), dots(params$origI, node.short))
decode2 <- paste0(
  paste0(head(round(params$decode2, decimal.digits), node.short), collapse = ", "), dots(params$decode2, node.short))
decode2I <- paste0(
  paste0(head(round(params$decode2I, decimal.digits), node.short), collapse = ", "), dots(params$decode2I, node.short))
decode1 <- paste0(
  lapply(lapply(params$decode1,
           function(x) {head(round(x, decimal.digits), node.short)}),
    function(x) {paste0(x, collapse = ", ")}),
  lapply(params$decode1, function(x) {dots(x, node.short)}))
decode1I <- paste0(
  lapply(lapply(params$decode1I,
           function(x) {head(round(x, decimal.digits), node.short)}),
    function(x) {paste0(x, collapse = ", ")}),
  lapply(params$decode1I, function(x) {dots(x, node.short)}))
decode2Back <- paste0(
  lapply(lapply(params$decode2Back,
           function(x) {head(round(x, decimal.digits), node.short)}),
    function(x) {paste0(x, collapse = ", ")}),
  lapply(params$decode2Back, function(x) {dots(x, node.short)}))
decode2IBack <- paste0(
  lapply(lapply(params$decode2IBack,
           function(x) {head(round(x, decimal.digits), node.short)}),
    function(x) {paste0(x, collapse = ", ")}),
  lapply(params$decode2IBack, function(x) {dots(x, node.short)}))
resultHard <- paste0(
  lapply(lapply(params$tempResultHard, 
          function(x) {head(x, node.short)}),
    function(x) {paste0(x, collapse = ", ")}),
  lapply(params$tempResultHard, function(x) {dots(x, node.short)}))
resultSoft <- paste0(
  lapply(lapply(params$tempResultSoft, 
          function(x) {head(round(x, decimal.digits), node.short)}),
    function(x) {paste0(x, collapse = ", ")}),
  lapply(params$tempResultSoft, function(x) {dots(x, node.short)}))

Faltungskodierer Informationen

Faltungskodierer Matrix : Nächster Zustand

\begin{center}

next.table <- params$encoder$next.state
colnames(next.table) <- c("Bit 0", "Bit 1")
row.counter <- rep(0:(dim(next.table)[1]-1))
rownames(next.table) <- paste("Zustand ", row.counter)
knitr::kable(next.table, format="latex", align="c")

\end{center}

Faltungskodierer Matrix : Ausgangsbits

\begin{center}

output.table <- params$encoder$output
output.table <- matrix(decToBin(as.vector(output.table)), ncol = ncol(output.table))
colnames(output.table) <- c("Bit 0", "Bit 1")
row.counter <- rep(0:(dim(next.table)[1]-1))
rownames(output.table) <- paste("Zustand ", row.counter)
knitr::kable(output.table, format="latex", align="c")

\end{center}

Faltungskodierer Matrix : Zustandsdiagramm

num.states <- 2^params$encoder$M

state.order <- ordering(num.states, params$encoder$next.state)

## STATE DIAGRAM
tikz.diagram <- ""
# state diagram nodes
for (s in 0:(num.states-1)) {
  xpos <- 2.5*sin(s*2*pi/num.states)
  ypos <- 2.5*cos(s*2*pi/num.states)
  position <- paste0(xpos,",",ypos)
  name <- paste(binVector(state.order[s+1], params$encoder$M),collapse = "")
  state <- paste0("\\node[state] (state",state.order[s+1],") at (",position,") {",name,"};")

  tikz.diagram <- paste(tikz.diagram, state)
}

# state diagram connections
for (s in 0:(num.states-1)) {
  this.state <- paste0("(state",s,")")
  n_next.state.0 <- params$encoder$next.state[s+1,1]
  n_next.state.1 <- params$encoder$next.state[s+1,2]
  str_next.state.0 <- paste0("(state",n_next.state.0,")")
  str_next.state.1 <- paste0("(state",n_next.state.1,")")

  label.value.0 <- paste(binVector(params$encoder$output[s+1,1],params$encoder$N),collapse = "")
  label.value.1 <- paste(binVector(params$encoder$output[s+1,2],params$encoder$N),collapse = "")

  # indices of the states in the ordering vector (1 based)
  this.ordering.index <- which(state.order == s)
  next.0.ordering.index <- which(state.order == n_next.state.0)
  next.1.ordering.index <- which(state.order == n_next.state.1)

  # if edges do not go to neighbour, set label near start
  # to avoid label crossings
  near.0 <- ""
  near.1 <- ""
  distance.to.0 <- abs(this.ordering.index - next.0.ordering.index)
  distance.to.1 <- abs(this.ordering.index - next.1.ordering.index)
  if (distance.to.0 > 1 && distance.to.0 < num.states-1) {
    near.0 <- ",near start"
  }

  if (distance.to.1 > 1 && distance.to.1 < num.states-1) {
    near.1 <- ",near start"
  }
  # 2nd check in previous if clause necessary because if state numbers
  # are in first and last position of the ordering, they have distance
  # num.states-1 but are neighbours in the state diagram

  label.0 <- paste0("node [sloped, above",near.0,"] {",label.value.0,"}")
  label.1 <- paste0("node [sloped, above",near.1,"] {",label.value.1,"}")

  # in case of a loop
  angle <- (90-(this.ordering.index-1)*360/num.states) %% 360
  angle.out <- (angle + 15) %% 360
  angle.in <- (angle - 15) %% 360

  if (n_next.state.0 == s) {
    # loop with input bit 0
    loop <- paste0("[looseness=8,out=",angle.out,",in=",angle.in,"]")

    if (sin(angle*pi/180) < 0) {
      label.0 <- paste0("node [sloped, below",near.0,"] {",label.value.0,"}")
    }

    edge.0 <- paste("\\draw[->]",this.state,"to",loop,label.0,this.state,";")
  }
  else {
    # 'normal' edge to other node
    bend <- ""
    if (params$encoder$next.state[n_next.state.0+1,1] == s || params$encoder$next.state[n_next.state.0+1,2] == s) {
      # there is a connection back -> bend the edge
      bend <- "[bend left=15]"
    }
    edge.0 <- paste("\\draw[->]",this.state,"to",bend,label.0,str_next.state.0,";")
  }

  if (n_next.state.1 == s) {
    # loop with input bit 1
    loop <- paste0("[looseness=8,out=",angle.out,",in=",angle.in,"]")

    if (sin(angle*pi/180) < 0) {
      label.1 <- paste0("node [sloped, below",near.1,"] {",label.value.1,"}")
    }

    edge.1 <- paste("\\draw[->, dashed]",this.state,"to",loop,label.1,this.state,";")
  }
  else {
    # 'normal' edge to other node
    bend <- ""
    if (params$encoder$next.state[n_next.state.1+1,1] == s || params$encoder$next.state[n_next.state.1+1,2] == s) {
      # there is a connection back -> bend the edge
      bend <- "[bend left=15]"
    }
    edge.1 <- paste("\\draw[->, dashed]",this.state,"to",bend,label.1,str_next.state.1,";")
  }

  tikz.diagram <- paste(tikz.diagram, edge.0, edge.1)
}

\begin{center} \begin{tikzpicture}[>=stealth, font=\scriptsize] \tikzstyle{state} = [draw, circle, inner sep=1mm, minimum size=8mm, font=\footnotesize]

r tikz.diagram

\end{tikzpicture} \end{center}

Turbo-Dekodierer Informationen

Turbodekodierung ohne Punktierung

\begin{center} \begin{tikzpicture}[node distance=8mm, inner sep=2mm, outer sep=0,

=stealth, font=\tiny, align=center]

\tikzstyle{decoderStyle} = [rectangle, draw] \tikzstyle{deinterleaverStyle} = [rectangle, draw, node distance=4mm] \tikzstyle{startEndStyle} = [rectangle, draw] \tikzstyle{demultiplexerStyle} = [deinterleaverStyle] \tikzstyle{showStyle} = [decoderStyle, thick, draw=red, text=red, inner sep=1mm, overlay, fill=white] \tikzstyle{showDrawStyle} = [->, red, thick]

\node [node distance=4mm] (demultiplexerTemp) {}; \node [demultiplexerStyle, rotate=90] (demultiplexer) at (demultiplexerTemp.west) {Demultiplexer}; \node [decoderStyle] (decoder1) [above right=of demultiplexerTemp] {SISO\ Dekodierer 1}; \node [deinterleaverStyle] (interleaver1) [right=of decoder1] {$I$}; \node [deinterleaverStyle] (interleaver2) [above=4mm of interleaver1] {$I^{-1}$}; \node [deinterleaverStyle] (interleaver3) [below=4mm of interleaver1] {$I$}; \node [decoderStyle, node distance=4mm] (decoder2) [right=of interleaver3] {SISO\ Dekodierer 2}; \node [deinterleaverStyle] (interleaver4) [right=of decoder2] {$I^{-1}$}; \node [deinterleaverStyle] (finalCalculation) [right=of interleaver4] {$=$}; \node [startEndStyle] (start) [left=of demultiplexerTemp] {Input}; \node [startEndStyle, node distance=5mm] (end) [right=of finalCalculation] {Output};

\draw [->] (start.east) -- node (afterInput) {} (demultiplexer.north); \draw [->] (decoder1.east) -- node (afterDecoder1) {}(interleaver1.west); \draw [->] (interleaver3.east) -- node (afterInterleaver3) {} (decoder2.west); \draw [->] (decoder2.east) -- node (afterDecoder2) {} (interleaver4.west); \draw [->] (interleaver4.east) -- node (afterInterleaver4) {} (finalCalculation.west); \draw [->] (finalCalculation.east) -- node (afterFinalCalculation) {} (end.west);

\draw [->] ($(decoder2.east)+(0,+.2)$) -| ++(.2,.7) node (afterDecoder2Back) {} |- (interleaver2.east); \visible<1-5>{ \draw [<-, lightgray] ($(decoder1.west)+(0,+.2)$) -| ++(-.2,.7) |- node [near end] (afterInterleaver2) {} (interleaver2.west); } \alt<1-5>{ \draw [<-] ($(decoder1.west)+(0,+.2)$) -- ++(-1.1,0) node [near end, above=-0.1] {$\left(0,0,\cdots \right)$}; } { \draw [<-, lightgray] ($(decoder1.west)+(0,+.2)$) -- ++(-1.1,0) node [near end, above=-0.1] {$\left(0,0,\cdots \right)$}; } \visible<6->{ \draw [<-] ($(decoder1.west)+(0,+.2)$) -| ++(-.2,.7) |- node [near end] (afterInterleaver2) {} (interleaver2.west); } \draw [->] (interleaver1.east) -| ++(+.2,-.7) node [midway] (afterInterleaver1) {} |- ($(decoder2.west)+(0,+.2)$); \draw [->] ($(demultiplexer.south)+(0,+.4)$) -| ++(+.15,+.2) node (afterDemOrig) {} |- (decoder1.west); \draw [->] (demultiplexer.south) -| ++(+.3,+.4) node (afterDemParity1) {} |- ($(decoder1.west)+(0,-.2)$); \draw [->] (afterDemOrig) |- node [near end] (afterDemOrigInterl) {} (interleaver3.west); \draw [<-] ($(decoder2.west)+(0,-.2)$) -| ++(-.2,-.3)|- node [near end] (afterDemParity2) {} ($(demultiplexer.south)+(0,-.4)$);

\begin{scope}[on background layer] \node [draw, fit=(decoder1) (decoder2) (demultiplexer) (interleaver1) (interleaver2) (interleaver3) (interleaver4) (finalCalculation)] (background) {}; \end{scope}

\visible<1-4>{ \node [below =4mm of decoder2] {Iteration 1}; }

multipl.color <- character()
vec <- head(round(params$code, decimal.digits), node.short)
for (i in c(0:((length(vec) / 3) - 1))) {
  temp <- paste0(
    "\\textcolor{", colorOrig, "}{", vec[i * 3 + 1], "}, ",
    "\\textcolor{", colorParity1, "}{", vec[i * 3 + 2], "}, ",
    "\\textcolor{", colorParity2, "}{", vec[i * 3 + 3], "}",
    collapse = ""
  )

  if (i == ((length(vec) / 3) - 1)) {
    multipl.color <- paste0(multipl.color, temp, collapse = "")
  } else {
    multipl.color <- paste0(multipl.color, temp, ", ", collapse = "")
  }
}

% AfterDemultiplexer \visible<2>{ \node [showStyle] (showAboveCenterTop) [above=9mm of background] {r multipl.color``r dots(params$code, node.short)}; \draw [showDrawStyle] (showAboveCenterTop) -- (afterInput.center);

\node [showStyle] (showAboveCenter) [above=3mm of background, text=`r colorOrig`] {`r orig`};
\draw [showDrawStyle] (showAboveCenter) -- (afterDemOrig.center);

\node [showStyle] (showBelowCenterBottom) [below=9mm of background, text=`r colorParity1`] {`r parity1`};
\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDemParity1.center);

\node [showStyle] (showBelowCenter) [below=3mm of background, text=`r colorParity2`] {`r parity2`};
\draw [showDrawStyle] (showBelowCenter) -- (afterDemParity2.center);

}

% AfterDemulitplexer, AfterInterleaver2 - AfterDecoder1 \visible<3>{ \node [showStyle] (showAboveCenterTop) [above=9mm of background] {r decode1[[1]]}; \draw [showDrawStyle] (showAboveCenterTop) -- (afterDecoder1.center);

\node [showStyle] (showAboveCenter) [above=3mm of background] {`r orig`};
\draw [showDrawStyle] ($(showAboveCenter.south)+(-.5,0)$) -- (afterDemOrig.center);

\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {`r parity1`};
\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDemParity1.center);

}

% AfterDecoder1, AfterDemultiplexer - AfterInterleaver1, 2 \visible<4>{ \node [showStyle] (showAboveCenterTop) [above=9mm of background] {r decode1[[1]]}; \draw [showDrawStyle] (showAboveCenterTop) -- (afterDecoder1.center);

\node [showStyle] (showAboveCenter) [above=3mm of background] {`r decode1I[[1]]`};
\draw [showDrawStyle] (showAboveCenter) -- (afterInterleaver1.center);

\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {`r orig`};
\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDemOrigInterl.center);

\node [showStyle] (showBelowCenter) [below=3mm of background] {`r origI`};
\draw [showDrawStyle] (showBelowCenter) -- (afterInterleaver3.center);

}

tikz.string <- character()
if (params$iterations > 1) {
  for (i in c(1:(params$iterations - 1))) {
  #AfterInterleaver1, 2, AfterDemultiplexer - AfterDecoder2Back
  slide1 <- paste0(
    "\\visible<", 5 + 4 * (i - 1),
    ">{ \\node [showStyle] (showAboveCenterTop) [above=9mm of background] {",
    parity2,
    "}; \\draw [showDrawStyle] (showAboveCenterTop) -- (afterDemParity2.center); \\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {",
    decode2Back[[i]],
    "}; \\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDecoder2Back.center); \\node [showStyle] (showAboveCenter) [above=3mm of background] {",
    decode1I[[i]],
    "}; \\draw [showDrawStyle] (showAboveCenter) -- (afterInterleaver1.center); \\node [showStyle] (showBelowCenter) [below=3mm of background] {",
    origI,
    "}; \\draw [showDrawStyle] (showBelowCenter) -- (afterInterleaver3.center);}",
    collapse = ""
  )

  # AfterDecoder2Back - AfterInterleaver2
  slide2 <- paste0(
    "\\visible<", 6 + 4 * (i - 1),
    ">{ \\node [showStyle] (showAboveCenterTop) [above=9mm of background] {",
    decode2IBack[[i]],
    "}; \\draw [showDrawStyle] (showAboveCenterTop) -- (afterInterleaver2.center);  \\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {",
    decode2Back[[i]],
    "}; \\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDecoder2Back.center);}",
    collapse = ""
  )

  # AfterDemulitplexer, AfterInterleaver2 - AfterDecoder1
  slide3 <- paste0(
    "\\visible<", 7 + 4 * (i - 1),
    ">{ \\node [showStyle] (showAboveCenterTop) [above=9mm of background] {",
    decode2IBack[[i]],
    "}; \\draw [showDrawStyle] (showAboveCenterTop) -- (afterInterleaver2.center); \\node [showStyle] (showAboveCenter) [above=3mm of background] {",
    orig,
    "}; \\draw [showDrawStyle] (showAboveCenter) -- (afterDemOrig.center);  \\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {",
    parity1,
    "}; \\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDemParity1.center); \\node [showStyle] (showBelowCenter) [below=3mm of background] {",
    decode1[[i + 1]],
    "}; \\draw [showDrawStyle] (showBelowCenter) -- (afterDecoder1.center);}",
    collapse = ""
  )

  # AfterDecoder1, AfterDemultiplexer - AfterInterleaver1, 2
  slide4 <- paste0(
    "\\visible<", 8 + 4 * (i - 1),
    ">{ \\node [showStyle] (showAboveCenterTop) [above=9mm of background] {",
    decode1[[i + 1]],
    "}; \\draw [showDrawStyle] (showAboveCenterTop) -- (afterDecoder1.center); \\node [showStyle] (showAboveCenter) [above=3mm of background] {",
    decode1I[[i + 1]],
    "}; \\draw [showDrawStyle] (showAboveCenter) -- (afterInterleaver1.center); \\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {",
    orig,
    "}; \\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDemOrigInterl.center);  \\node [showStyle] (showBelowCenter) [below=3mm of background] {",
    origI,
    "}; \\draw [showDrawStyle] (showBelowCenter) -- (afterInterleaver3.center);}",
    collapse = ""
  )

  counter <- paste0(
    "\\visible<", 5 + 4 * (i - 1), "-",  8 + 4 * (i - 1),
    ">{\\node [below =4mm of decoder2] {Iteration ", i + 1 ,"};}"
  )

  output <- paste0(
    "\\visible<", 5 + 4 * (i - 1), "-",  8 + 4 * (i - 1),
    ">{\\node [below =15mm of background, font=\\small, overlay] {Output : (", resultHard[[i]],")};}"
    )

  tikz.string <- paste0(tikz.string, slide1, slide2, slide3, slide4, counter, output, collapse = "")
} 
}

r tikz.string

%END

\visible<r params$iterations * 4 + 1-r params$iterations * 4 + 3>{ \node [below =4mm of decoder2] {Iteration r params$iterations}; } \visible<r params$iterations * 4 + 1-r params$iterations * 4 + 3>{ \node [below =15mm of background, font=\small, overlay] {Output : (r resultHard[[params$iterations]])}; }

% AfterInterleaver1, 2, AfterDemultiplexer - AfterDecoder2 \visible<r params$iterations * 4 + 1>{ \node [showStyle] (showAboveCenterTop) [above=9mm of background] {r parity2}; \draw [showDrawStyle] (showAboveCenterTop) -- (afterDemParity2.center);

\node [showStyle] (showAboveCenter) [above=3mm of background] {`r decode1I[[params$iterations]]`};
\draw [showDrawStyle] (showAboveCenter) -- (afterInterleaver1.center);

\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {`r decode2`};
\draw [showDrawStyle] (showBelowCenterBottom) -- (afterDecoder2.center);

\node [showStyle] (showBelowCenter) [below=3mm of background] {`r origI`};
\draw [showDrawStyle] (showBelowCenter) -- (afterInterleaver3.center);

}

% AfterDecoder2 - AfterInterleaver4 \visible<r params$iterations * 4 + 2>{ \node [showStyle] (showBelowCenterBottom) [below=9mm of background] {r decode2}; \draw [showDrawStyle] (showBelowCenterBottom) -- (afterDecoder2.center);

\node [showStyle] (showAboveCenter) [above=3mm of background] {`r decode2I`};
\draw [showDrawStyle] (showAboveCenter) -- (afterInterleaver4.center);

}

% AfterInterleaver4 - AfterFinalCalculation \visible<r params$iterations * 4 + 3>{ \node [showStyle] (showAboveCenter) [above=3mm of background] {r decode2I}; \draw [showDrawStyle] (showAboveCenter) -- (afterInterleaver4.center);

\node [showStyle] (showBelowCenterBottom) [below=9mm of background] {`r resultSoft[[params$iterations]]`};
\draw [showDrawStyle] (showBelowCenterBottom) -- (afterFinalCalculation.center);

}

\end{tikzpicture} \end{center}

Terminierung

  term.string <- paste0(
    "- Output mit Terminierung : (",
    paste0(head(params$tempResultHard[[params$iterations]], length(params$tempResultHard[[params$iterations]]) - params$encoder$M), collapse = ", "),
    "\\textcolor{orange}{, ",
    paste0(tail(params$tempResultHard[[params$iterations]], params$encoder$M), collapse = ", "),
    "})",
    "\\vspace*{6mm}",
    "\n- Output ohne Terminierung : (",
    paste0(params$result$output.hard, collapse = ", "),
    ")"
  )

  if (length(params$result$output.hard) > node.long) {
    term.string <- "Da der Output zu lang ist, kann die Terminierung leider nicht angezeigt werden!"
  }

r term.string



DaniWi/Channelcoding documentation built on May 6, 2019, 1:23 p.m.