code: def c_code(self, node, name, inp, out, sub):
      # If we try to use the C code here with something else than a
      # TensorType, something is wrong (likely one of the GPU ops
      # not defining C code correctly).
      assert isinstance(node.inputs[0].type, TensorType)
      if self.output_type.dtype == "float16":
          # C code is not tested, fall back to Python
          super(mrg_uniform, self).c_code(node, name, inp, out, sub)
      return """
          //////// <code generated by mrg_uniform>
          npy_int64 odims_i;
          npy_int64 n_elements = 1;
          int n_streams = 0;
          int must_alloc_sample = ((NULL == %(o_sample)s)
                                   || (PyArray_NDIM(%(o_sample)s) != %(params)s->ndim)
                                   || !(PyArray_ISCONTIGUOUS(%(o_sample)s)));
          int o_rstate_requirement = %(params)s->inplace ?
                                      (NPY_ARRAY_C_CONTIGUOUS|NPY_ARRAY_ALIGNED) :
                                      (NPY_ARRAY_ENSURECOPY|NPY_ARRAY_C_CONTIGUOUS|NPY_ARRAY_ALIGNED);
  
          const npy_int32 i0 = 0;
          const npy_int32 i7 = 7;
          const npy_int32 i9 = 9;
          const npy_int32 i15 = 15;
          const npy_int32 i16 = 16;
          const npy_int32 i22 = 22;
          const npy_int32 i24 = 24;
  
          const npy_int32 M1 = 2147483647;      //2^31 - 1
          const npy_int32 M2 = 2147462579;      //2^31 - 21069
          const npy_int32 MASK12 = 511;       //2^9 - 1
          const npy_int32 MASK13 = 16777215;  //2^24 - 1
          const npy_int32 MASK2 = 65535;      //2^16 - 1
          const npy_int32 MULT2 = 21069;
  
          // We have to read size[i] as an int64, but odims has to be intp*
          // for NumPy on 32-bit platforms.
          npy_intp* odims = (npy_intp*)malloc(%(params)s->ndim * sizeof(npy_intp));
          if (odims == NULL) {
              PyErr_NoMemory();
              %(just_fail)s
          }
  
          if (PyArray_NDIM(%(size)s) != 1)
          {
              PyErr_SetString(PyExc_ValueError, "size must be vector");
              %(fail)s
          }
          if (PyArray_DIMS(%(size)s)[0] != %(params)s->ndim)
          {
              PyErr_Format(PyExc_ValueError, "size must have length %%i (not %%i)",
                  %(params)s->ndim, int(PyArray_DIMS(%(size)s)[0]));
              %(fail)s
          }
  
          for (int i = 0; i < %(params)s->ndim; ++i)
          {
              odims_i = *(dtype_%(size)s *)PyArray_GETPTR1(%(size)s, i);
              odims[i] = odims_i;
              n_elements *= odims_i;
              must_alloc_sample = must_alloc_sample || (PyArray_DIMS(%(o_sample)s)[i] != odims[i]);
              //fprintf(stderr, "size %%i %%i\\n", i, (int)odims[i]);
              //printf("%%li", n_elements);
          }
          //fprintf(stderr, "n_elements %%lld\\n", (long long)n_elements);
          if (n_elements > M1)
          {
              PyErr_SetString(
                  PyExc_ValueError,
                  "rng_mrg cpu-implementation does not support more than (2**31 -1) samples");
              %(fail)s
          }
  
          if (must_alloc_sample)
          {
              Py_XDECREF(%(o_sample)s);
              %(o_sample)s = (PyArrayObject*)PyArray_SimpleNew(%(params)s->ndim, odims, %(params)s->otypenum);
              if(!%(o_sample)s) {
                  PyErr_SetString(PyExc_MemoryError, "failed to alloc mrg_uniform output");
                  %(fail)s
              }
          }
          Py_XDECREF(%(o_rstate)s);
          %(o_rstate)s = (PyArrayObject*)PyArray_FromAny(
              (PyObject*)%(rstate)s,
              NULL, 0, 0, o_rstate_requirement,NULL);
  
          if (PyArray_NDIM(%(o_rstate)s) != 2)
          {
              PyErr_SetString(PyExc_ValueError, "rstate must be matrix");
              %(fail)s
          }
          if (PyArray_DIMS(%(o_rstate)s)[1] != 6)
          {
              PyErr_Format(PyExc_ValueError, "rstate must have 6 columns");
              %(fail)s
          }
          if (PyArray_DESCR(%(o_rstate)s)->type_num != NPY_INT32)
          {
              PyErr_SetString(PyExc_ValueError, "rstate must be int32");
              %(fail)s
          }
          n_streams = PyArray_DIMS(%(o_rstate)s)[0];
  
          if (%(params)s->otype_is_float32) {
              cpu_rng_mrg_uniform_npy_float32(%(o_sample)s, %(o_rstate)s, n_elements, n_streams);
          } else {
              cpu_rng_mrg_uniform_npy_float64(%(o_sample)s, %(o_rstate)s, n_elements, n_streams);
          }
  
          free(odims);
          //////// </ code generated by mrg_uniform>
          """ % dict(
          rstate=inp[0],
          size=inp[1],
          o_rstate=out[0],
          o_sample=out[1],
          params=sub["params"],
          just_fail=sub["fail"],
          fail="""
                     {
                         free(odims);
                         %(fail)s
                     }
                     """
          % dict(fail=sub["fail"]),
      )
  
imports: from __future__ import absolute_import, print_function, division
  import warnings
  import numpy
  from six import integer_types, string_types
  from six.moves import xrange
  import theano
  from theano import Op, Apply, shared, config, Variable
  from theano import gradient, function
  from theano.gradient import undefined_grad
  from theano import tensor
  from theano.tensor import TensorType, as_tensor_variable, get_vector_length, cast, opt, scal
  from theano.compile import optdb
  from theano.gof import local_optimizer, ParamsType
  from theano.scalar import bool, int32
  from .None import multinomial
label_desc: Use image node_id 5 for calling the mrg_uniform obj's underlying member method code with example usage: obj.c_code(node, name, inp, out, sub) and returns: unknown