C++ emlrtAssign函数代码示例

static real_T m_fprintf(const emlrtStack *sp, const char_T varargin_1_data[77],
  const int32_T varargin_1_size[2])
{
  const mxArray *y;
  static const int32_T iv136[2] = { 1, 7 };

  const mxArray *m32;
  char_T cv168[7];
  int32_T i;
  static const char_T cv169[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv137[2] = { 1, 22 };

  char_T cv170[22];
  static const char_T cv171[22] = { 'M', 'A', 'C', '|', ' ', 'G', 'o', 't', ' ',
    'm', 'e', 's', 's', 'a', 'g', 'e', ':', ' ', '%', 's', '\\', 'n' };

  int32_T u_size[2];
  int32_T i29;
  char_T u_data[77];
  const mxArray *d_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m32 = mxCreateCharArray(2, iv136);
  for (i = 0; i < 7; i++) {
    cv168[i] = cv169[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m32, cv168);
  emlrtAssign(&y, m32);
  b_y = NULL;
  m32 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m32);
  c_y = NULL;
  m32 = mxCreateCharArray(2, iv137);
  for (i = 0; i < 22; i++) {
    cv170[i] = cv171[i];
  }

  emlrtInitCharArrayR2013a(sp, 22, m32, cv170);
  emlrtAssign(&c_y, m32);
  u_size[0] = 1;
  u_size[1] = varargin_1_size[1];
  i = varargin_1_size[0] * varargin_1_size[1];
  for (i29 = 0; i29 < i; i29++) {
    u_data[i29] = varargin_1_data[i29];
  }

  d_y = NULL;
  m32 = mxCreateCharArray(2, u_size);
  emlrtInitCharArrayR2013a(sp, u_size[1], m32, (char_T *)&u_data);
  emlrtAssign(&d_y, m32);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
    "feval");
}

static real_T k_fprintf(const emlrtStack *sp, const char_T varargin_1_data[76],
  const int32_T varargin_1_size[2])
{
  const mxArray *y;
  static const int32_T iv134[2] = { 1, 7 };

  const mxArray *m31;
  char_T cv164[7];
  int32_T i;
  static const char_T cv165[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv135[2] = { 1, 18 };

  char_T cv166[18];
  static const char_T cv167[18] = { 'D', 'L', '|', ' ', 'M', 'e', 's', 's', 'a',
    'g', 'e', '=', '|', '%', 's', '|', '\\', 'n' };

  int32_T u_size[2];
  int32_T i28;
  char_T u_data[76];
  const mxArray *d_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m31 = mxCreateCharArray(2, iv134);
  for (i = 0; i < 7; i++) {
    cv164[i] = cv165[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m31, cv164);
  emlrtAssign(&y, m31);
  b_y = NULL;
  m31 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m31);
  c_y = NULL;
  m31 = mxCreateCharArray(2, iv135);
  for (i = 0; i < 18; i++) {
    cv166[i] = cv167[i];
  }

  emlrtInitCharArrayR2013a(sp, 18, m31, cv166);
  emlrtAssign(&c_y, m31);
  u_size[0] = 1;
  u_size[1] = varargin_1_size[1];
  i = varargin_1_size[0] * varargin_1_size[1];
  for (i28 = 0; i28 < i; i28++) {
    u_data[i28] = varargin_1_data[i28];
  }

  d_y = NULL;
  m31 = mxCreateCharArray(2, u_size);
  emlrtInitCharArrayR2013a(sp, u_size[1], m31, (char_T *)&u_data);
  emlrtAssign(&d_y, m31);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
    "feval");
}

static real_T s_fprintf(const emlrtStack *sp, int16_T varargin_1, real_T
  varargin_2)
{
  const mxArray *y;
  static const int32_T iv142[2] = { 1, 7 };

  const mxArray *m35;
  char_T cv180[7];
  int32_T i;
  static const char_T cv181[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv143[2] = { 1, 43 };

  char_T cv182[43];
  static const char_T cv183[43] = { 'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't',
    'i', 'n', 'g', ' ', 't', 'o', ' ', 'n', 'o', 'd', 'e', ':', ' ', '%', 'd',
    ',', ' ', 'w', 'i', 't', 'h', ' ', 'o', 'f', 'f', 's', 'e', 't', ':', ' ',
    '%', 'f', '\\', 'n' };

  const mxArray *d_y;
  const mxArray *e_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m35 = mxCreateCharArray(2, iv142);
  for (i = 0; i < 7; i++) {
    cv180[i] = cv181[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m35, cv180);
  emlrtAssign(&y, m35);
  b_y = NULL;
  m35 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m35);
  c_y = NULL;
  m35 = mxCreateCharArray(2, iv143);
  for (i = 0; i < 43; i++) {
    cv182[i] = cv183[i];
  }

  emlrtInitCharArrayR2013a(sp, 43, m35, cv182);
  emlrtAssign(&c_y, m35);
  d_y = NULL;
  m35 = mxCreateNumericMatrix(1, 1, mxINT16_CLASS, mxREAL);
  *(int16_T *)mxGetData(m35) = varargin_1;
  emlrtAssign(&d_y, m35);
  e_y = NULL;
  m35 = mxCreateDoubleScalar(varargin_2);
  emlrtAssign(&e_y, m35);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, c_feval(&st, y, b_y, c_y, d_y, e_y, &n_emlrtMCI),
    "feval");
}

void warning(const emlrtStack *sp)
{
  int32_T i1;
  static const char_T cv1[7] = { 'w', 'a', 'r', 'n', 'i', 'n', 'g' };

  char_T u[7];
  const mxArray *y;
  static const int32_T iv0[2] = { 1, 7 };

  const mxArray *m0;
  static const char_T cv2[7] = { 'm', 'e', 's', 's', 'a', 'g', 'e' };

  char_T b_u[7];
  const mxArray *b_y;
  static const int32_T iv1[2] = { 1, 7 };

  static const char_T msgID[43] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
    'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't', 'e', 'r', ':', 'O', 'u', 't',
    'O', 'f', 'R', 'a', 'n', 'g', 'e', 'I', 'n', 't', 'e', 'r', 'p', 'F', 'a',
    'c', 't', 'o', 'r' };

  char_T c_u[43];
  const mxArray *c_y;
  static const int32_T iv2[2] = { 1, 43 };

  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  for (i1 = 0; i1 < 7; i1++) {
    u[i1] = cv1[i1];
  }

  y = NULL;
  m0 = emlrtCreateCharArray(2, iv0);
  emlrtInitCharArrayR2013a(sp, 7, m0, &u[0]);
  emlrtAssign(&y, m0);
  for (i1 = 0; i1 < 7; i1++) {
    b_u[i1] = cv2[i1];
  }

  b_y = NULL;
  m0 = emlrtCreateCharArray(2, iv1);
  emlrtInitCharArrayR2013a(sp, 7, m0, &b_u[0]);
  emlrtAssign(&b_y, m0);
  for (i1 = 0; i1 < 43; i1++) {
    c_u[i1] = msgID[i1];
  }

  c_y = NULL;
  m0 = emlrtCreateCharArray(2, iv2);
  emlrtInitCharArrayR2013a(sp, 43, m0, &c_u[0]);
  emlrtAssign(&c_y, m0);
  st.site = &fb_emlrtRSI;
  b_feval(&st, y, feval(&st, b_y, c_y, &emlrtMCI), &b_emlrtMCI);
}

void b_warning(const emlrtStack *sp)
{
  int32_T i11;
  static const char_T cv7[7] = { 'w', 'a', 'r', 'n', 'i', 'n', 'g' };

  char_T u[7];
  const mxArray *y;
  static const int32_T iv5[2] = { 1, 7 };

  const mxArray *m1;
  static const char_T cv8[7] = { 'm', 'e', 's', 's', 'a', 'g', 'e' };

  char_T b_u[7];
  const mxArray *b_y;
  static const int32_T iv6[2] = { 1, 7 };

  static const char_T msgID[39] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
    'R', 'e', 'c', 'e', 'i', 'v', 'e', 'r', ':', 'O', 'u', 't', 'O', 'f', 'R',
    'a', 'n', 'g', 'e', 'D', 'e', 'c', 'i', 'm', 'F', 'a', 'c', 't', 'o', 'r' };

  char_T c_u[39];
  const mxArray *c_y;
  static const int32_T iv7[2] = { 1, 39 };

  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  for (i11 = 0; i11 < 7; i11++) {
    u[i11] = cv7[i11];
  }

  y = NULL;
  m1 = emlrtCreateCharArray(2, iv5);
  emlrtInitCharArrayR2013a(sp, 7, m1, &u[0]);
  emlrtAssign(&y, m1);
  for (i11 = 0; i11 < 7; i11++) {
    b_u[i11] = cv8[i11];
  }

  b_y = NULL;
  m1 = emlrtCreateCharArray(2, iv6);
  emlrtInitCharArrayR2013a(sp, 7, m1, &b_u[0]);
  emlrtAssign(&b_y, m1);
  for (i11 = 0; i11 < 39; i11++) {
    c_u[i11] = msgID[i11];
  }

  c_y = NULL;
  m1 = emlrtCreateCharArray(2, iv7);
  emlrtInitCharArrayR2013a(sp, 39, m1, &c_u[0]);
  emlrtAssign(&c_y, m1);
  st.site = &fb_emlrtRSI;
  b_feval(&st, y, feval(&st, b_y, c_y, &emlrtMCI), &b_emlrtMCI);
}

/* Function Definitions */
void dynamic_size_checks(const emxArray_creal_T *a, const emxArray_creal_T *b)
{
  const mxArray *y;
  static const int32_T iv32[2] = { 1, 45 };

  const mxArray *m5;
  char_T cv18[45];
  int32_T i;
  static const char_T cv19[45] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
    'l', 'b', 'o', 'x', ':', 'm', 't', 'i', 'm', 'e', 's', '_', 'n', 'o', 'D',
    'y', 'n', 'a', 'm', 'i', 'c', 'S', 'c', 'a', 'l', 'a', 'r', 'E', 'x', 'p',
    'a', 'n', 's', 'i', 'o', 'n' };

  const mxArray *b_y;
  static const int32_T iv33[2] = { 1, 21 };

  char_T cv20[21];
  static const char_T cv21[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
    'L', 'A', 'B', ':', 'i', 'n', 'n', 'e', 'r', 'd', 'i', 'm' };

  if (!(a->size[1] == b->size[0])) {
    if (((a->size[0] == 1) && (a->size[1] == 1)) || ((b->size[0] == 1) &&
         (b->size[1] == 1))) {
      emlrtPushRtStackR2012b(&ih_emlrtRSI, emlrtRootTLSGlobal);
      emlrt_synchGlobalsToML();
      y = NULL;
      m5 = mxCreateCharArray(2, iv32);
      for (i = 0; i < 45; i++) {
        cv18[i] = cv19[i];
      }

      emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 45, m5, cv18);
      emlrtAssign(&y, m5);
      error(message(y, &l_emlrtMCI), &m_emlrtMCI);
      emlrt_synchGlobalsFromML();
      emlrtPopRtStackR2012b(&ih_emlrtRSI, emlrtRootTLSGlobal);
    } else {
      emlrtPushRtStackR2012b(&hh_emlrtRSI, emlrtRootTLSGlobal);
      emlrt_synchGlobalsToML();
      b_y = NULL;
      m5 = mxCreateCharArray(2, iv33);
      for (i = 0; i < 21; i++) {
        cv20[i] = cv21[i];
      }

      emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m5, cv20);
      emlrtAssign(&b_y, m5);
      error(message(b_y, &n_emlrtMCI), &o_emlrtMCI);
      emlrt_synchGlobalsFromML();
      emlrtPopRtStackR2012b(&hh_emlrtRSI, emlrtRootTLSGlobal);
    }
  }
}

static const mxArray *emlrt_marshallOut(const emlrtStack *sp, const int64_T u)
{
  const mxArray *y;
  const mxArray *b_y;
  const mxArray *m0;
  y = NULL;
  b_y = NULL;
  m0 = emlrtCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL);
  *(int64_T *)mxGetData(m0) = u;
  emlrtAssign(&b_y, m0);
  emlrtAssign(&y, emlrtCreateFIR2013b(sp, eml_mx, c_eml_mx, "simulinkarray", b_y,
    true, false));
  return y;
}

static real_T o_fprintf(const emlrtStack *sp, int16_T varargin_1)
{
  const mxArray *y;
  static const int32_T iv138[2] = { 1, 7 };

  const mxArray *m33;
  char_T cv172[7];
  int32_T i;
  static const char_T cv173[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv139[2] = { 1, 20 };

  char_T cv174[20];
  static const char_T cv175[20] = { 'M', 'A', 'C', '|', ' ', 'F', 'r', 'o', 'm',
    ' ', 'N', 'o', 'd', 'e', ':', ' ', '%', 'd', '\\', 'n' };

  const mxArray *d_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m33 = mxCreateCharArray(2, iv138);
  for (i = 0; i < 7; i++) {
    cv172[i] = cv173[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m33, cv172);
  emlrtAssign(&y, m33);
  b_y = NULL;
  m33 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m33);
  c_y = NULL;
  m33 = mxCreateCharArray(2, iv139);
  for (i = 0; i < 20; i++) {
    cv174[i] = cv175[i];
  }

  emlrtInitCharArrayR2013a(sp, 20, m33, cv174);
  emlrtAssign(&c_y, m33);
  d_y = NULL;
  m33 = mxCreateNumericMatrix(1, 1, mxINT16_CLASS, mxREAL);
  *(int16_T *)mxGetData(m33) = varargin_1;
  emlrtAssign(&d_y, m33);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
    "feval");
}

static void eml_li_find(const emlrtStack *sp, const boolean_T x_data[1224],
  const int32_T x_size[1], int32_T y_data[1224], int32_T y_size[1])
{
  int32_T k;
  const mxArray *y;
  const mxArray *m25;
  int32_T i;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  st.site = &dr_emlrtRSI;
  k = compute_nones(&st, x_data, x_size[0]);
  if (k <= x_size[0]) {
  } else {
    y = NULL;
    m25 = mxCreateString("Assertion failed.");
    emlrtAssign(&y, m25);
    st.site = &ov_emlrtRSI;
    c_error(&st, y, &db_emlrtMCI);
  }

  emlrtNonNegativeCheckFastR2012b(k, &c_emlrtDCI, sp);
  y_size[0] = k;
  k = 0;
  st.site = &er_emlrtRSI;
  for (i = 1; i <= x_size[0]; i++) {
    if (x_data[i - 1]) {
      y_data[k] = i;
      st.site = &fr_emlrtRSI;
      k++;
    }
  }
}

static void eml_warning(void)
{
  const mxArray *y;
  static const int32_T iv3[2] = { 1, 27 };

  const mxArray *m2;
  char_T cv4[27];
  int32_T i;
  static const char_T cv5[27] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
    'L', 'A', 'B', ':', 's', 'i', 'n', 'g', 'u', 'l', 'a', 'r', 'M', 'a', 't',
    'r', 'i', 'x' };

  emlrtPushRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
  emlrt_synchGlobalsToML();
  y = NULL;
  m2 = mxCreateCharArray(2, iv3);
  for (i = 0; i < 27; i++) {
    cv4[i] = cv5[i];
  }

  emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 27, m2, cv4);
  emlrtAssign(&y, m2);
  warning(b_message(y, &d_emlrtMCI), &e_emlrtMCI);
  emlrt_synchGlobalsFromML();
  emlrtPopRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
}

void check_forloop_overflow_error(const emlrtStack *sp)
{
  const mxArray *y;
  static const int32_T iv10[2] = { 1, 34 };

  const mxArray *m2;
  char_T cv15[34];
  int32_T i;
  static const char_T cv16[34] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
    'l', 'b', 'o', 'x', ':', 'i', 'n', 't', '_', 'f', 'o', 'r', 'l', 'o', 'o',
    'p', '_', 'o', 'v', 'e', 'r', 'f', 'l', 'o', 'w' };

  const mxArray *b_y;
  static const int32_T iv11[2] = { 1, 23 };

  char_T cv17[23];
  static const char_T cv18[23] = { 'c', 'o', 'd', 'e', 'r', '.', 'i', 'n', 't',
    'e', 'r', 'n', 'a', 'l', '.', 'i', 'n', 'd', 'e', 'x', 'I', 'n', 't' };

  emlrtStack st;
  emlrtStack b_st;
  st.prev = sp;
  st.tls = sp->tls;
  b_st.prev = sp;
  b_st.tls = sp->tls;
  y = NULL;
  m2 = emlrtCreateCharArray(2, iv10);
  for (i = 0; i < 34; i++) {
    cv15[i] = cv16[i];
  }

  emlrtInitCharArrayR2013a(sp, 34, m2, cv15);
  emlrtAssign(&y, m2);
  b_y = NULL;
  m2 = emlrtCreateCharArray(2, iv11);
  for (i = 0; i < 23; i++) {
    cv17[i] = cv18[i];
  }

  emlrtInitCharArrayR2013a(sp, 23, m2, cv17);
  emlrtAssign(&b_y, m2);
  st.site = &fe_emlrtRSI;
  b_st.site = &me_emlrtRSI;
  error(&st, message(&b_st, y, b_y, &emlrtMCI), &b_emlrtMCI);
}

/* Function Definitions */
static real_T c_fprintf(const emlrtStack *sp)
{
  const mxArray *y;
  static const int32_T iv8[2] = { 1, 7 };

  const mxArray *m1;
  char_T cv14[7];
  int32_T i;
  static const char_T cv15[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv9[2] = { 1, 50 };

  char_T cv16[50];
  static const char_T cv17[50] = { 'R', 'e', 'm', 'e', 'm', 'b', 'e', 'r', ' ',
    't', 'o', ' ', 'c', 'o', 'm', 'p', 'a', 'r', 'e', ' ', 'o', 'u', 't', 'p',
    'u', 't', ' ', 'f', 'i', 'l', 'e', 's', ' ', 'w', 'i', 't', 'h', ' ', 'm',
    'd', '5', ' ', 'o', 'r', ' ', 'S', 'H', 'A', '\\', 'n' };

  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m1 = mxCreateCharArray(2, iv8);
  for (i = 0; i < 7; i++) {
    cv14[i] = cv15[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m1, cv14);
  emlrtAssign(&y, m1);
  b_y = NULL;
  m1 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m1);
  c_y = NULL;
  m1 = mxCreateCharArray(2, iv9);
  for (i = 0; i < 50; i++) {
    cv16[i] = cv17[i];
  }

  emlrtInitCharArrayR2013a(sp, 50, m1, cv16);
  emlrtAssign(&c_y, m1);
  st.site = &cb_emlrtRSI;
  return e_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &r_emlrtMCI), "feval");
}

/* Function Definitions */
void check_forloop_overflow_error(const emlrtStack *sp)
{
  const mxArray *y;
  static const int32_T iv21[2] = { 1, 34 };

  const mxArray *m4;
  char_T cv27[34];
  int32_T i;
  static const char_T cv28[34] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
    'l', 'b', 'o', 'x', ':', 'i', 'n', 't', '_', 'f', 'o', 'r', 'l', 'o', 'o',
    'p', '_', 'o', 'v', 'e', 'r', 'f', 'l', 'o', 'w' };

  const mxArray *b_y;
  static const int32_T iv22[2] = { 1, 23 };

  char_T cv29[23];
  static const char_T cv30[23] = { 'c', 'o', 'd', 'e', 'r', '.', 'i', 'n', 't',
    'e', 'r', 'n', 'a', 'l', '.', 'i', 'n', 'd', 'e', 'x', 'I', 'n', 't' };

  emlrtStack st;
  emlrtStack b_st;
  st.prev = sp;
  st.tls = sp->tls;
  b_st.prev = sp;
  b_st.tls = sp->tls;
  y = NULL;
  m4 = mxCreateCharArray(2, iv21);
  for (i = 0; i < 34; i++) {
    cv27[i] = cv28[i];
  }

  emlrtInitCharArrayR2013a(sp, 34, m4, cv27);
  emlrtAssign(&y, m4);
  b_y = NULL;
  m4 = mxCreateCharArray(2, iv22);
  for (i = 0; i < 23; i++) {
    cv29[i] = cv30[i];
  }

  emlrtInitCharArrayR2013a(sp, 23, m4, cv29);
  emlrtAssign(&b_y, m4);
  st.site = &vm_emlrtRSI;
  b_st.site = &ym_emlrtRSI;
  c_error(&st, message(&b_st, y, b_y, &e_emlrtMCI), &f_emlrtMCI);
}

  static const mxArray *emlrt_marshallOut(const real_T u)
{
  const mxArray *y;
  const mxArray *m1;
  y = NULL;
  m1 = emlrtCreateDoubleScalar(u);
  emlrtAssign(&y, m1);
  return y;
}

/*
 * Arguments    : const double u
 * Return Type  : const mxArray *
 */
static const mxArray *emlrt_marshallOut(const double u)
{
  const mxArray *y;
  const mxArray *m0;
  y = NULL;
  m0 = emlrtCreateDoubleScalar(u);
  emlrtAssign(&y, m0);
  return y;
}