'Constructs the computational graph of this layer.
:type state_below: theano variable
:param state_below: the input to the layer
:type mask: None or theano variable
:param mask: mask describing the length of each sequence in a
minibatch
:type state_before: theano variable
:param state_before: the previous value of the hidden state of the
layer
:type gater_below: theano variable
:param gater_below: the input to the update gate
:type reseter_below: theano variable
:param reseter_below: the input to the reset gate
:type use_noise: bool
:param use_noise: flag saying if weight noise should be used in
computing the output of this layer
:type no_noise_bias: bool
:param no_noise_bias: flag saying if weight noise should be added to
the bias as well'

def step_fprop(self, state_below, mask=None, state_before=None, gater_below=None, reseter_below=None, use_noise=True, no_noise_bias=False):

    rval = []
    if (self.weight_noise and use_noise and self.noise_params):
        W_hh = (self.W_hh + self.nW_hh)
        if self.gating:
            G_hh = (self.G_hh + self.nG_hh)
        if self.reseting:
            R_hh = (self.R_hh + self.nR_hh)
    else:
        W_hh = self.W_hh
        if self.gating:
            G_hh = self.G_hh
        if self.reseting:
            R_hh = self.R_hh
    if (self.reseting and reseter_below):
        reseter = self.reseter_activation((TT.dot(state_before, R_hh) + reseter_below))
        state_before_ = (reseter * state_before)
    else:
        state_before_ = state_before
    preactiv = (TT.dot(state_before_, W_hh) + state_below)
    preactiv = TT.cast(preactiv, theano.config.floatX)
    h = self.activation(preactiv)
    if (self.gating and gater_below):
        gater = self.gater_activation((TT.dot(state_before, G_hh) + gater_below))
        h = ((gater * h) + ((1 - gater) * state_before))
    if (self.activ_noise and use_noise):
        h = (h + self.trng.normal(h.shape, avg=0, std=self.activ_noise, dtype=h.dtype))
    if (mask is not None):
        if ((h.ndim == 2) and (mask.ndim == 1)):
            mask = mask.dimshuffle(0, 'x')
        h = ((mask * h) + ((1 - mask) * state_before))
    return h
