/*
 * diag.c
 *
 * Code generation for function 'diag'
 *
 * C source code generated on: Wed Aug 26 14:59:33 2015
 *
 */

/* Include files */
#include "rt_nonfinite.h"
#include "Select_Ground_Motions.h"
#include "diag.h"
#include "Select_Ground_Motions_emxutil.h"
#include "Select_Ground_Motions_mexutil.h"

/* Variable Definitions */
static emlrtRSInfo dg_emlrtRSI = { 51, "diag",
  "/usr/local/MATLAB/R2013a/toolbox/eml/lib/matlab/elmat/diag.m" };

static emlrtMCInfo ib_emlrtMCI = { 52, 9, "diag",
  "/usr/local/MATLAB/R2013a/toolbox/eml/lib/matlab/elmat/diag.m" };

static emlrtMCInfo jb_emlrtMCI = { 51, 19, "diag",
  "/usr/local/MATLAB/R2013a/toolbox/eml/lib/matlab/elmat/diag.m" };

static emlrtRTEInfo sb_emlrtRTEI = { 1, 14, "diag",
  "/usr/local/MATLAB/R2013a/toolbox/eml/lib/matlab/elmat/diag.m" };

/* Function Declarations */
static int32_T div_s32_floor(int32_T numerator, int32_T denominator);

/* Function Definitions */
static int32_T div_s32_floor(int32_T numerator, int32_T denominator)
{
  int32_T quotient;
  uint32_T absNumerator;
  uint32_T absDenominator;
  int32_T quotientNeedsNegation;
  uint32_T tempAbsQuotient;
  if (denominator == 0) {
    if (numerator >= 0) {
      quotient = MAX_int32_T;
    } else {
      quotient = MIN_int32_T;
    }

    emlrtDivisionByZeroErrorR2012b(0, emlrtRootTLSGlobal);
  } else {
    if (numerator >= 0) {
      absNumerator = (uint32_T)numerator;
    } else {
      absNumerator = (uint32_T)-numerator;
    }

    if (denominator >= 0) {
      absDenominator = (uint32_T)denominator;
    } else {
      absDenominator = (uint32_T)-denominator;
    }

    quotientNeedsNegation = ((numerator < 0) != (denominator < 0));
    tempAbsQuotient = absNumerator / absDenominator;
    if ((uint32_T)quotientNeedsNegation) {
      absNumerator %= absDenominator;
      if (absNumerator > (uint32_T)0) {
        tempAbsQuotient++;
      }
    }

    if ((uint32_T)quotientNeedsNegation) {
      quotient = -(int32_T)tempAbsQuotient;
    } else {
      quotient = (int32_T)tempAbsQuotient;
    }
  }

  return quotient;
}

void b_diag(const emxArray_creal_T *v, emxArray_creal_T *d)
{
  const mxArray *y;
  static const int32_T iv56[2] = { 1, 39 };

  const mxArray *m16;
  char_T cv71[39];
  int32_T i;
  static const char_T cv72[39] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
    'l', 'b', 'o', 'x', ':', 'd', 'i', 'a', 'g', '_', 'v', 'a', 'r', 's', 'i',
    'z', 'e', 'd', 'M', 'a', 't', 'r', 'i', 'x', 'V', 'e', 'c', 't', 'o', 'r' };

  emxArray_int32_T *r32;
  emxArray_int32_T *r33;
  int32_T i10;
  int32_T i11;
  emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
  if (!((v->size[0] == 1) || (v->size[1] == 1))) {
  } else {
    emlrtPushRtStackR2012b(&dg_emlrtRSI, emlrtRootTLSGlobal);
    y = NULL;
    m16 = mxCreateCharArray(2, iv56);
    for (i = 0; i < 39; i++) {
      cv71[i] = cv72[i];
    }

    emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 39, m16, cv71);
    emlrtAssign(&y, m16);
    error(message(y, &ib_emlrtMCI), &jb_emlrtMCI);
    emlrtPopRtStackR2012b(&dg_emlrtRSI, emlrtRootTLSGlobal);
  }

  b_emxInit_int32_T(&r32, 2, &sb_emlrtRTEI, TRUE);
  emxInit_int32_T(&r33, 1, &sb_emlrtRTEI, TRUE);
  if ((v->size[0] == 0) || (v->size[1] == 0)) {
    i10 = d->size[0] * d->size[1];
    d->size[0] = 0;
    d->size[1] = 0;
    emxEnsureCapacity((emxArray__common *)d, i10, (int32_T)sizeof(creal_T),
                      &sb_emlrtRTEI);
  } else {
    i10 = v->size[0] + 1;
    i11 = (v->size[0] + 1) * (muIntScalarMin_sint32(v->size[0], v->size[1]) - 1);
    i = r33->size[0];
    r33->size[0] = div_s32_floor(i11, i10) + 1;
    emxEnsureCapacity((emxArray__common *)r33, i, (int32_T)sizeof(int32_T),
                      &sb_emlrtRTEI);
    i = div_s32_floor(i11, i10);
    for (i11 = 0; i11 <= i; i11++) {
      r33->data[i11] = 1 + i10 * i11;
    }

    i10 = r32->size[0] * r32->size[1];
    r32->size[0] = 1;
    emxEnsureCapacity((emxArray__common *)r32, i10, (int32_T)sizeof(int32_T),
                      &sb_emlrtRTEI);
    i = r33->size[0];
    i10 = r32->size[0] * r32->size[1];
    r32->size[1] = i;
    emxEnsureCapacity((emxArray__common *)r32, i10, (int32_T)sizeof(int32_T),
                      &sb_emlrtRTEI);
    i = r33->size[0];
    for (i10 = 0; i10 < i; i10++) {
      r32->data[i10] = r33->data[i10];
    }

    i = r32->size[1];
    i10 = d->size[0] * d->size[1];
    d->size[0] = i;
    emxEnsureCapacity((emxArray__common *)d, i10, (int32_T)sizeof(creal_T),
                      &sb_emlrtRTEI);
    i10 = d->size[0] * d->size[1];
    d->size[1] = 1;
    emxEnsureCapacity((emxArray__common *)d, i10, (int32_T)sizeof(creal_T),
                      &sb_emlrtRTEI);
    i = r32->size[1];
    for (i10 = 0; i10 < i; i10++) {
      d->data[i10] = v->data[r32->data[i10] - 1];
    }
  }

  emxFree_int32_T(&r33);
  emxFree_int32_T(&r32);
  emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}

void diag(const emxArray_real_T *v, emxArray_real_T *d)
{
  const mxArray *y;
  static const int32_T iv48[2] = { 1, 39 };

  const mxArray *m10;
  char_T cv55[39];
  int32_T i;
  static const char_T cv56[39] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
    'l', 'b', 'o', 'x', ':', 'd', 'i', 'a', 'g', '_', 'v', 'a', 'r', 's', 'i',
    'z', 'e', 'd', 'M', 'a', 't', 'r', 'i', 'x', 'V', 'e', 'c', 't', 'o', 'r' };

  emxArray_int32_T *r30;
  emxArray_int32_T *r31;
  int32_T i7;
  int32_T i8;
  emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
  if (!((v->size[0] == 1) || (v->size[1] == 1))) {
  } else {
    emlrtPushRtStackR2012b(&dg_emlrtRSI, emlrtRootTLSGlobal);
    y = NULL;
    m10 = mxCreateCharArray(2, iv48);
    for (i = 0; i < 39; i++) {
      cv55[i] = cv56[i];
    }

    emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 39, m10, cv55);
    emlrtAssign(&y, m10);
    error(message(y, &ib_emlrtMCI), &jb_emlrtMCI);
    emlrtPopRtStackR2012b(&dg_emlrtRSI, emlrtRootTLSGlobal);
  }

  b_emxInit_int32_T(&r30, 2, &sb_emlrtRTEI, TRUE);
  emxInit_int32_T(&r31, 1, &sb_emlrtRTEI, TRUE);
  if ((v->size[0] == 0) || (v->size[1] == 0)) {
    i7 = d->size[0] * d->size[1];
    d->size[0] = 0;
    d->size[1] = 0;
    emxEnsureCapacity((emxArray__common *)d, i7, (int32_T)sizeof(real_T),
                      &sb_emlrtRTEI);
  } else {
    i7 = v->size[0] + 1;
    i8 = (v->size[0] + 1) * (muIntScalarMin_sint32(v->size[0], v->size[1]) - 1);
    i = r31->size[0];
    r31->size[0] = div_s32_floor(i8, i7) + 1;
    emxEnsureCapacity((emxArray__common *)r31, i, (int32_T)sizeof(int32_T),
                      &sb_emlrtRTEI);
    i = div_s32_floor(i8, i7);
    for (i8 = 0; i8 <= i; i8++) {
      r31->data[i8] = 1 + i7 * i8;
    }

    i7 = r30->size[0] * r30->size[1];
    r30->size[0] = 1;
    emxEnsureCapacity((emxArray__common *)r30, i7, (int32_T)sizeof(int32_T),
                      &sb_emlrtRTEI);
    i = r31->size[0];
    i7 = r30->size[0] * r30->size[1];
    r30->size[1] = i;
    emxEnsureCapacity((emxArray__common *)r30, i7, (int32_T)sizeof(int32_T),
                      &sb_emlrtRTEI);
    i = r31->size[0];
    for (i7 = 0; i7 < i; i7++) {
      r30->data[i7] = r31->data[i7];
    }

    i = r30->size[1];
    i7 = d->size[0] * d->size[1];
    d->size[0] = i;
    emxEnsureCapacity((emxArray__common *)d, i7, (int32_T)sizeof(real_T),
                      &sb_emlrtRTEI);
    i7 = d->size[0] * d->size[1];
    d->size[1] = 1;
    emxEnsureCapacity((emxArray__common *)d, i7, (int32_T)sizeof(real_T),
                      &sb_emlrtRTEI);
    i = r30->size[1];
    for (i7 = 0; i7 < i; i7++) {
      d->data[i7] = v->data[r30->data[i7] - 1];
    }
  }

  emxFree_int32_T(&r31);
  emxFree_int32_T(&r30);
  emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}

/* End of code generation (diag.c) */