/*
 * File: targetSpec.c
 *
 * MATLAB Coder version            : 2.8
 * C/C++ source code generated on  : 03-Aug-2016 03:43:08
 */

/* Include Files */
#include "rt_nonfinite.h"
#include "targetSpec.h"

/* Type Definitions */
#ifndef struct_emxArray__common
#define struct_emxArray__common

struct emxArray__common
{
  void *data;
  int *size;
  int allocatedSize;
  int numDimensions;
  boolean_T canFreeData;
};

#endif                                 /*struct_emxArray__common*/

#ifndef typedef_emxArray__common
#define typedef_emxArray__common

typedef struct emxArray__common emxArray__common;

#endif                                 /*typedef_emxArray__common*/

#ifndef struct_emxArray_boolean_T
#define struct_emxArray_boolean_T

struct emxArray_boolean_T
{
  boolean_T *data;
  int *size;
  int allocatedSize;
  int numDimensions;
  boolean_T canFreeData;
};

#endif                                 /*struct_emxArray_boolean_T*/

#ifndef typedef_emxArray_boolean_T
#define typedef_emxArray_boolean_T

typedef struct emxArray_boolean_T emxArray_boolean_T;

#endif                                 /*typedef_emxArray_boolean_T*/

#ifndef struct_emxArray_int32_T
#define struct_emxArray_int32_T

struct emxArray_int32_T
{
  int *data;
  int *size;
  int allocatedSize;
  int numDimensions;
  boolean_T canFreeData;
};

#endif                                 /*struct_emxArray_int32_T*/

#ifndef typedef_emxArray_int32_T
#define typedef_emxArray_int32_T

typedef struct emxArray_int32_T emxArray_int32_T;

#endif                                 /*typedef_emxArray_int32_T*/

/* Function Declarations */
static void SP1996hor(double Period, double ecSoilCode, double
                      *koefAtonacijsko_b1, double *koefAtonacijsko_b2, double
                      *koefAtonacijsko_b3, double *koefAtonacijsko_b4, double
                      *koefAtonacijsko_h0, double *koefAtonacijsko_r0, double
                      *koefAtonacijsko_bSB, double *koefAtonacijsko_bSC, double *
                      koefAtonacijsko_bSD, double *koefAtonacijsko_sigma, double
                      *koefAtonacijsko_SB, double *koefAtonacijsko_SC, double
                      *koefAtonacijsko_SD);
static boolean_T any(const emxArray_boolean_T *x);
static void b_emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions);
static void b_log(emxArray_real_T *x);
static double eml_qrsolve(const emxArray_real_T *A, const emxArray_real_T *B);
static double eml_xnrm2(int n, const emxArray_real_T *x);
static void eml_xscal(int n, double a, emxArray_real_T *x);
static void emxEnsureCapacity(emxArray__common *emxArray, int oldNumel, int
  elementSize);
static void emxFree_boolean_T(emxArray_boolean_T **pEmxArray);
static void emxFree_int32_T(emxArray_int32_T **pEmxArray);
static void emxFree_real_T(emxArray_real_T **pEmxArray);
static void emxInit_boolean_T(emxArray_boolean_T **pEmxArray, int numDimensions);
static void emxInit_int32_T(emxArray_int32_T **pEmxArray, int numDimensions);
static void emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions);
static double interp1(const double varargin_1[15], const double varargin_2[15],
                      double varargin_3);
static void linspace(double n1, emxArray_real_T *y);
static double rt_hypotd_snf(double u0, double u1);

/* Function Definitions */

/*
 * %%%sabeta pugliese 1996 koeficienti
 * Arguments    : double Period
 *                double ecSoilCode
 *                double *koefAtonacijsko_b1
 *                double *koefAtonacijsko_b2
 *                double *koefAtonacijsko_b3
 *                double *koefAtonacijsko_b4
 *                double *koefAtonacijsko_h0
 *                double *koefAtonacijsko_r0
 *                double *koefAtonacijsko_bSB
 *                double *koefAtonacijsko_bSC
 *                double *koefAtonacijsko_bSD
 *                double *koefAtonacijsko_sigma
 *                double *koefAtonacijsko_SB
 *                double *koefAtonacijsko_SC
 *                double *koefAtonacijsko_SD
 * Return Type  : void
 */
static void SP1996hor(double Period, double ecSoilCode, double
                      *koefAtonacijsko_b1, double *koefAtonacijsko_b2, double
                      *koefAtonacijsko_b3, double *koefAtonacijsko_b4, double
                      *koefAtonacijsko_h0, double *koefAtonacijsko_r0, double
                      *koefAtonacijsko_bSB, double *koefAtonacijsko_bSC, double *
                      koefAtonacijsko_bSD, double *koefAtonacijsko_sigma, double
                      *koefAtonacijsko_SB, double *koefAtonacijsko_SC, double
                      *koefAtonacijsko_SD)
{
  int SB;
  int SC;
  int SD;
  double b1;
  int low_i;
  int low_ip1;
  int high_i;
  int mid_i;
  static const double dv0[15] = { 0.0, 0.04, 0.067, 0.1, 0.15, 0.2, 0.3, 0.4,
    0.5, 0.752, 1.0, 1.493, 2.0, 3.03, 4.0 };

  double r;
  static const double dv1[15] = { -3.597, -2.994, -2.422, -2.079, -2.001, -2.174,
    -2.926, -4.311, -5.278, -6.722, -7.629, -8.927, -9.887, -11.155, -11.962 };

  double dv2[15];
  double dv3[15];
  double dv4[15];
  double dv5[15];
  static const double dv6[15] = { 0.705, 0.629, 0.587, 0.564, 0.587, 0.629,
    0.725, 0.921, 1.048, 1.22, 1.312, 1.428, 1.497, 1.554, 1.577 };

  static const double x[15] = { 0.0, 0.04, 0.067, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5,
    0.752, 1.0, 1.493, 2.0, 3.03, 4.0 };

  static const double dv7[15] = { 5.8, 5.8, 7.2, 7.3, 6.7, 6.3, 5.7, 5.3, 5.0,
    4.4, 4.0, 3.5, 3.1, 2.5, 2.1 };

  static const double dv8[15] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.15, 0.265,
    0.359, 0.534, 0.557, 0.484, 0.424, 0.348, 0.299 };

  static const double dv9[15] = { 0.389, 0.299, 0.299, 0.299, 0.299, 0.299, 0.38,
    0.484, 0.507, 0.276, 0.115, 0.023, 0.0, 0.0, 0.0 };

  static const double dv10[15] = { 0.398, 0.419, 0.419, 0.437, 0.461, 0.495,
    0.564, 0.608, 0.624, 0.652, 0.668, 0.679, 0.684, 0.684, 0.684 };

  /* %%%%% Soil type%%%%%%% */
  /* %%%%% Soil type%%%%%%% */
  if (ecSoilCode == 1.0) {
    /* Rock */
    SB = 0;
    SC = 0;
    SD = 0;
  } else if (ecSoilCode == 2.0) {
    /* Stiff soil  */
    SB = 1;
    SC = 0;
    SD = 0;
  } else if (ecSoilCode == 3.0) {
    /* Soft soil */
    SB = 0;
    SC = 1;
    SD = 0;
  } else {
    SB = 0;
    SC = 0;
    SD = 1;
  }

  /* fault distance */
  b1 = rtNaN;
  if (rtIsNaN(Period) || (Period > 4.0) || (Period < 0.0)) {
  } else {
    low_i = 1;
    low_ip1 = 2;
    high_i = 15;
    while (high_i > low_ip1) {
      mid_i = (low_i + high_i) >> 1;
      if (Period >= dv0[mid_i - 1]) {
        low_i = mid_i;
        low_ip1 = mid_i + 1;
      } else {
        high_i = mid_i;
      }
    }

    r = (Period - dv0[low_i - 1]) / (dv0[low_i] - dv0[low_i - 1]);
    if (r == 0.0) {
      b1 = dv1[low_i - 1];
    } else if (r == 1.0) {
      b1 = dv1[low_i];
    } else if (dv1[low_i - 1] == dv1[low_i]) {
      b1 = dv1[low_i - 1];
    } else {
      b1 = (1.0 - r) * dv1[low_i - 1] + r * dv1[low_i];
    }
  }

  for (low_i = 0; low_i < 15; low_i++) {
    dv2[low_i] = -1.0;
  }

  memset(&dv3[0], 0, 15U * sizeof(double));
  memset(&dv4[0], 0, 15U * sizeof(double));
  memset(&dv5[0], 0, 15U * sizeof(double));
  *koefAtonacijsko_b1 = b1;
  *koefAtonacijsko_b2 = interp1(x, dv6, Period);
  *koefAtonacijsko_b3 = interp1(x, dv2, Period);
  *koefAtonacijsko_b4 = interp1(x, dv3, Period);
  *koefAtonacijsko_h0 = interp1(x, dv7, Period);
  *koefAtonacijsko_r0 = interp1(x, dv4, Period);
  *koefAtonacijsko_bSB = interp1(x, dv8, Period);
  *koefAtonacijsko_bSC = interp1(x, dv9, Period);
  *koefAtonacijsko_bSD = interp1(x, dv5, Period);
  *koefAtonacijsko_sigma = interp1(x, dv10, Period);
  *koefAtonacijsko_SB = SB;
  *koefAtonacijsko_SC = SC;
  *koefAtonacijsko_SD = SD;
}

/*
 * Arguments    : const emxArray_boolean_T *x
 * Return Type  : boolean_T
 */
static boolean_T any(const emxArray_boolean_T *x)
{
  boolean_T y;
  int ix;
  boolean_T exitg1;
  boolean_T b0;
  y = false;
  ix = 1;
  exitg1 = false;
  while ((!exitg1) && (ix <= x->size[1])) {
    b0 = !x->data[ix - 1];
    if (!b0) {
      y = true;
      exitg1 = true;
    } else {
      ix++;
    }
  }

  return y;
}

/*
 * Arguments    : emxArray_real_T **pEmxArray
 *                int numDimensions
 * Return Type  : void
 */
static void b_emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions)
{
  emxArray_real_T *emxArray;
  int i;
  *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
  emxArray = *pEmxArray;
  emxArray->data = (double *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = true;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

/*
 * Arguments    : emxArray_real_T *x
 * Return Type  : void
 */
static void b_log(emxArray_real_T *x)
{
  int i1;
  int k;
  i1 = x->size[1];
  for (k = 0; k < i1; k++) {
    x->data[k] = log(x->data[k]);
  }
}

/*
 * Arguments    : const emxArray_real_T *A
 *                const emxArray_real_T *B
 * Return Type  : double
 */
static double eml_qrsolve(const emxArray_real_T *A, const emxArray_real_T *B)
{
  double Y;
  emxArray_real_T *b_A;
  int knt;
  int maxmn;
  int m;
  int mn;
  double atmp;
  double tau_data_idx_0;
  double xnorm;
  int rankR;
  emxArray_real_T *b_B;
  b_emxInit_real_T(&b_A, 1);
  knt = b_A->size[0];
  b_A->size[0] = A->size[0];
  emxEnsureCapacity((emxArray__common *)b_A, knt, (int)sizeof(double));
  maxmn = A->size[0];
  for (knt = 0; knt < maxmn; knt++) {
    b_A->data[knt] = A->data[knt];
  }

  m = A->size[0] - 1;
  if (A->size[0] <= 1) {
    mn = A->size[0];
  } else {
    mn = 1;
  }

  if (A->size[0] == 0) {
  } else {
    knt = 1;
    while (knt <= mn) {
      if (1 < m + 1) {
        atmp = b_A->data[0];
        tau_data_idx_0 = 0.0;
        xnorm = eml_xnrm2(m, b_A);
        if (xnorm != 0.0) {
          xnorm = rt_hypotd_snf(b_A->data[0], xnorm);
          if (b_A->data[0] >= 0.0) {
            xnorm = -xnorm;
          }

          if (fabs(xnorm) < 1.0020841800044864E-292) {
            knt = 0;
            do {
              knt++;
              eml_xscal(m, 9.9792015476736E+291, b_A);
              xnorm *= 9.9792015476736E+291;
              atmp *= 9.9792015476736E+291;
            } while (!(fabs(xnorm) >= 1.0020841800044864E-292));

            xnorm = eml_xnrm2(m, b_A);
            xnorm = rt_hypotd_snf(atmp, xnorm);
            if (atmp >= 0.0) {
              xnorm = -xnorm;
            }

            tau_data_idx_0 = (xnorm - atmp) / xnorm;
            eml_xscal(m, 1.0 / (atmp - xnorm), b_A);
            for (maxmn = 1; maxmn <= knt; maxmn++) {
              xnorm *= 1.0020841800044864E-292;
            }

            atmp = xnorm;
          } else {
            tau_data_idx_0 = (xnorm - b_A->data[0]) / xnorm;
            eml_xscal(m, 1.0 / (b_A->data[0] - xnorm), b_A);
            atmp = xnorm;
          }
        }
      } else {
        atmp = b_A->data[0];
        tau_data_idx_0 = 0.0;
      }

      b_A->data[0] = atmp;
      knt = 2;
    }
  }

  rankR = 0;
  if (b_A->size[0] < 1) {
    knt = 0;
    maxmn = 1;
  } else {
    knt = 1;
    maxmn = b_A->size[0];
  }

  if (knt > 0) {
    xnorm = (double)maxmn * fabs(b_A->data[0]) * 2.2204460492503131E-16;
    while ((rankR < 1) && (fabs(b_A->data[0]) >= xnorm)) {
      rankR = 1;
    }
  }

  b_emxInit_real_T(&b_B, 1);
  knt = b_B->size[0];
  b_B->size[0] = B->size[0];
  emxEnsureCapacity((emxArray__common *)b_B, knt, (int)sizeof(double));
  maxmn = B->size[0];
  for (knt = 0; knt < maxmn; knt++) {
    b_B->data[knt] = B->data[knt];
  }

  m = b_A->size[0];
  mn = !(b_A->size[0] < 1);
  Y = 0.0;
  maxmn = 1;
  while (maxmn <= mn) {
    if (tau_data_idx_0 != 0.0) {
      xnorm = b_B->data[0];
      for (knt = 1; knt + 1 <= m; knt++) {
        xnorm += b_A->data[knt] * b_B->data[knt];
      }

      xnorm *= tau_data_idx_0;
      if (xnorm != 0.0) {
        b_B->data[0] -= xnorm;
        for (knt = 1; knt + 1 <= m; knt++) {
          b_B->data[knt] -= b_A->data[knt] * xnorm;
        }
      }
    }

    maxmn = 2;
  }

  knt = 1;
  while (knt <= rankR) {
    Y = b_B->data[0];
    knt = 2;
  }

  emxFree_real_T(&b_B);
  while (rankR > 0) {
    Y /= b_A->data[0];
    rankR = 0;
  }

  emxFree_real_T(&b_A);
  return Y;
}

/*
 * Arguments    : int n
 *                const emxArray_real_T *x
 * Return Type  : double
 */
static double eml_xnrm2(int n, const emxArray_real_T *x)
{
  double y;
  double scale;
  int k;
  double absxk;
  double t;
  y = 0.0;
  if (n < 1) {
  } else if (n == 1) {
    y = fabs(x->data[1]);
  } else {
    scale = 2.2250738585072014E-308;
    for (k = 2; k <= n + 1; k++) {
      absxk = fabs(x->data[k - 1]);
      if (absxk > scale) {
        t = scale / absxk;
        y = 1.0 + y * t * t;
        scale = absxk;
      } else {
        t = absxk / scale;
        y += t * t;
      }
    }

    y = scale * sqrt(y);
  }

  return y;
}

/*
 * Arguments    : int n
 *                double a
 *                emxArray_real_T *x
 * Return Type  : void
 */
static void eml_xscal(int n, double a, emxArray_real_T *x)
{
  int k;
  for (k = 1; k + 1 <= n + 1; k++) {
    x->data[k] *= a;
  }
}

/*
 * Arguments    : emxArray__common *emxArray
 *                int oldNumel
 *                int elementSize
 * Return Type  : void
 */
static void emxEnsureCapacity(emxArray__common *emxArray, int oldNumel, int
  elementSize)
{
  int newNumel;
  int i;
  void *newData;
  newNumel = 1;
  for (i = 0; i < emxArray->numDimensions; i++) {
    newNumel *= emxArray->size[i];
  }

  if (newNumel > emxArray->allocatedSize) {
    i = emxArray->allocatedSize;
    if (i < 16) {
      i = 16;
    }

    while (i < newNumel) {
      i <<= 1;
    }

    newData = calloc((unsigned int)i, (unsigned int)elementSize);
    if (emxArray->data != NULL) {
      memcpy(newData, emxArray->data, (unsigned int)(elementSize * oldNumel));
      if (emxArray->canFreeData) {
        free(emxArray->data);
      }
    }

    emxArray->data = newData;
    emxArray->allocatedSize = i;
    emxArray->canFreeData = true;
  }
}

/*
 * Arguments    : emxArray_boolean_T **pEmxArray
 * Return Type  : void
 */
static void emxFree_boolean_T(emxArray_boolean_T **pEmxArray)
{
  if (*pEmxArray != (emxArray_boolean_T *)NULL) {
    if (((*pEmxArray)->data != (boolean_T *)NULL) && (*pEmxArray)->canFreeData)
    {
      free((void *)(*pEmxArray)->data);
    }

    free((void *)(*pEmxArray)->size);
    free((void *)*pEmxArray);
    *pEmxArray = (emxArray_boolean_T *)NULL;
  }
}

/*
 * Arguments    : emxArray_int32_T **pEmxArray
 * Return Type  : void
 */
static void emxFree_int32_T(emxArray_int32_T **pEmxArray)
{
  if (*pEmxArray != (emxArray_int32_T *)NULL) {
    if (((*pEmxArray)->data != (int *)NULL) && (*pEmxArray)->canFreeData) {
      free((void *)(*pEmxArray)->data);
    }

    free((void *)(*pEmxArray)->size);
    free((void *)*pEmxArray);
    *pEmxArray = (emxArray_int32_T *)NULL;
  }
}

/*
 * Arguments    : emxArray_real_T **pEmxArray
 * Return Type  : void
 */
static void emxFree_real_T(emxArray_real_T **pEmxArray)
{
  if (*pEmxArray != (emxArray_real_T *)NULL) {
    if (((*pEmxArray)->data != (double *)NULL) && (*pEmxArray)->canFreeData) {
      free((void *)(*pEmxArray)->data);
    }

    free((void *)(*pEmxArray)->size);
    free((void *)*pEmxArray);
    *pEmxArray = (emxArray_real_T *)NULL;
  }
}

/*
 * Arguments    : emxArray_boolean_T **pEmxArray
 *                int numDimensions
 * Return Type  : void
 */
static void emxInit_boolean_T(emxArray_boolean_T **pEmxArray, int numDimensions)
{
  emxArray_boolean_T *emxArray;
  int i;
  *pEmxArray = (emxArray_boolean_T *)malloc(sizeof(emxArray_boolean_T));
  emxArray = *pEmxArray;
  emxArray->data = (boolean_T *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = true;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

/*
 * Arguments    : emxArray_int32_T **pEmxArray
 *                int numDimensions
 * Return Type  : void
 */
static void emxInit_int32_T(emxArray_int32_T **pEmxArray, int numDimensions)
{
  emxArray_int32_T *emxArray;
  int i;
  *pEmxArray = (emxArray_int32_T *)malloc(sizeof(emxArray_int32_T));
  emxArray = *pEmxArray;
  emxArray->data = (int *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = true;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

/*
 * Arguments    : emxArray_real_T **pEmxArray
 *                int numDimensions
 * Return Type  : void
 */
static void emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions)
{
  emxArray_real_T *emxArray;
  int i;
  *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
  emxArray = *pEmxArray;
  emxArray->data = (double *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int *)malloc((unsigned int)(sizeof(int) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = true;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

/*
 * Arguments    : const double varargin_1[15]
 *                const double varargin_2[15]
 *                double varargin_3
 * Return Type  : double
 */
static double interp1(const double varargin_1[15], const double varargin_2[15],
                      double varargin_3)
{
  double Vq;
  double y[15];
  double x[15];
  int low_i;
  int32_T exitg1;
  double r;
  int low_ip1;
  int high_i;
  int mid_i;
  for (low_i = 0; low_i < 15; low_i++) {
    y[low_i] = varargin_2[low_i];
    x[low_i] = varargin_1[low_i];
  }

  Vq = rtNaN;
  low_i = 1;
  do {
    exitg1 = 0;
    if (low_i < 16) {
      if (rtIsNaN(varargin_1[low_i - 1])) {
        exitg1 = 1;
      } else {
        low_i++;
      }
    } else {
      if (varargin_1[1] < varargin_1[0]) {
        for (low_i = 0; low_i < 7; low_i++) {
          r = x[low_i];
          x[low_i] = x[14 - low_i];
          x[14 - low_i] = r;
        }

        for (low_i = 0; low_i < 7; low_i++) {
          r = y[low_i];
          y[low_i] = y[14 - low_i];
          y[14 - low_i] = r;
        }
      }

      if (rtIsNaN(varargin_3) || (varargin_3 > x[14]) || (varargin_3 < x[0])) {
      } else {
        low_i = 1;
        low_ip1 = 2;
        high_i = 15;
        while (high_i > low_ip1) {
          mid_i = (low_i + high_i) >> 1;
          if (varargin_3 >= x[mid_i - 1]) {
            low_i = mid_i;
            low_ip1 = mid_i + 1;
          } else {
            high_i = mid_i;
          }
        }

        r = (varargin_3 - x[low_i - 1]) / (x[low_i] - x[low_i - 1]);
        if (r == 0.0) {
          Vq = y[low_i - 1];
        } else if (r == 1.0) {
          Vq = y[low_i];
        } else if (y[low_i - 1] == y[low_i]) {
          Vq = y[low_i - 1];
        } else {
          Vq = (1.0 - r) * y[low_i - 1] + r * y[low_i];
        }
      }

      exitg1 = 1;
    }
  } while (exitg1 == 0);

  return Vq;
}

/*
 * Arguments    : double n1
 *                emxArray_real_T *y
 * Return Type  : void
 */
static void linspace(double n1, emxArray_real_T *y)
{
  double delta1;
  int i0;
  int k;
  if (n1 < 0.0) {
    n1 = 0.0;
  }

  delta1 = floor(n1);
  i0 = y->size[0] * y->size[1];
  y->size[0] = 1;
  y->size[1] = (int)delta1;
  emxEnsureCapacity((emxArray__common *)y, i0, (int)sizeof(double));
  if ((int)delta1 >= 1) {
    y->data[(int)delta1 - 1] = 4.0;
    if (y->size[1] >= 2) {
      y->data[0] = 0.0;
      if (y->size[1] >= 3) {
        delta1 = 4.0 / ((double)y->size[1] - 1.0);
        i0 = y->size[1];
        for (k = 0; k <= i0 - 3; k++) {
          y->data[1 + k] = (1.0 + (double)k) * delta1;
        }
      }
    }
  }
}

/*
 * Arguments    : double u0
 *                double u1
 * Return Type  : double
 */
static double rt_hypotd_snf(double u0, double u1)
{
  double y;
  double a;
  double b;
  a = fabs(u0);
  b = fabs(u1);
  if (a < b) {
    a /= b;
    y = b * sqrt(a * a + 1.0);
  } else if (a > b) {
    b /= a;
    y = a * sqrt(b * b + 1.0);
  } else if (rtIsNaN(b)) {
    y = b;
  } else {
    y = a * 1.4142135623730951;
  }

  return y;
}

/*
 * Arguments    : int numDimensions
 *                int *size
 * Return Type  : emxArray_real_T *
 */
emxArray_real_T *emxCreateND_real_T(int numDimensions, int *size)
{
  emxArray_real_T *emx;
  int numEl;
  int i;
  emxInit_real_T(&emx, numDimensions);
  numEl = 1;
  for (i = 0; i < numDimensions; i++) {
    numEl *= size[i];
    emx->size[i] = size[i];
  }

  emx->data = (double *)calloc((unsigned int)numEl, sizeof(double));
  emx->numDimensions = numDimensions;
  emx->allocatedSize = numEl;
  return emx;
}

/*
 * Arguments    : double *data
 *                int numDimensions
 *                int *size
 * Return Type  : emxArray_real_T *
 */
emxArray_real_T *emxCreateWrapperND_real_T(double *data, int numDimensions, int *
  size)
{
  emxArray_real_T *emx;
  int numEl;
  int i;
  emxInit_real_T(&emx, numDimensions);
  numEl = 1;
  for (i = 0; i < numDimensions; i++) {
    numEl *= size[i];
    emx->size[i] = size[i];
  }

  emx->data = data;
  emx->numDimensions = numDimensions;
  emx->allocatedSize = numEl;
  emx->canFreeData = false;
  return emx;
}

/*
 * Arguments    : double *data
 *                int rows
 *                int cols
 * Return Type  : emxArray_real_T *
 */
emxArray_real_T *emxCreateWrapper_real_T(double *data, int rows, int cols)
{
  emxArray_real_T *emx;
  int size[2];
  int numEl;
  int i;
  size[0] = rows;
  size[1] = cols;
  emxInit_real_T(&emx, 2);
  numEl = 1;
  for (i = 0; i < 2; i++) {
    numEl *= size[i];
    emx->size[i] = size[i];
  }

  emx->data = data;
  emx->numDimensions = 2;
  emx->allocatedSize = numEl;
  emx->canFreeData = false;
  return emx;
}

/*
 * Arguments    : int rows
 *                int cols
 * Return Type  : emxArray_real_T *
 */
emxArray_real_T *emxCreate_real_T(int rows, int cols)
{
  emxArray_real_T *emx;
  int size[2];
  int numEl;
  int i;
  size[0] = rows;
  size[1] = cols;
  emxInit_real_T(&emx, 2);
  numEl = 1;
  for (i = 0; i < 2; i++) {
    numEl *= size[i];
    emx->size[i] = size[i];
  }

  emx->data = (double *)calloc((unsigned int)numEl, sizeof(double));
  emx->numDimensions = 2;
  emx->allocatedSize = numEl;
  return emx;
}

/*
 * Arguments    : emxArray_real_T *emxArray
 * Return Type  : void
 */
void emxDestroyArray_real_T(emxArray_real_T *emxArray)
{
  emxFree_real_T(&emxArray);
}

/*
 * Arguments    : emxArray_real_T **pEmxArray
 *                int numDimensions
 * Return Type  : void
 */
void emxInitArray_real_T(emxArray_real_T **pEmxArray, int numDimensions)
{
  emxInit_real_T(pEmxArray, numDimensions);
}

/*
 * EPS_BAR Summary of this function goes here
 *    Detailed explanation goes here
 * Arguments    : double agC
 *                double Rls
 *                double T1
 *                double T1dej
 *                double nX
 *                double M_mean
 *                double R_mean
 *                double ecSoilCode
 *                double *eps_bar
 *                emxArray_real_T *tSpec
 *                emxArray_real_T *PerTgt
 * Return Type  : void
 */
void targetSpec(double agC, double Rls, double T1, double T1dej, double nX,
                double M_mean, double R_mean, double ecSoilCode, double *eps_bar,
                emxArray_real_T *tSpec, emxArray_real_T *PerTgt)
{
  emxArray_real_T *PerTgt_tmp;
  emxArray_boolean_T *b_PerTgt_tmp;
  int i;
  int ii;
  emxArray_real_T *PerTgt_tmp2;
  emxArray_int32_T *r0;
  emxArray_int32_T *b_ii;
  int idx;
  int nx;
  emxArray_boolean_T *b_PerTgt_tmp2;
  unsigned int x[2];
  unsigned int y[2];
  int mtmp;
  double koefAtonacijsko_SD;
  double koefAtonacijsko_SC;
  double koefAtonacijsko_SB;
  double koefAtonacijsko_sigma;
  double koefAtonacijsko_bSD;
  double koefAtonacijsko_bSC;
  double koefAtonacijsko_bSB;
  double koefAtonacijsko_r0;
  double koefAtonacijsko_h0;
  double koefAtonacijsko_b4;
  double koefAtonacijsko_b3;
  double koefAtonacijsko_b2;
  double koefAtonacijsko_b1;
  emxArray_boolean_T *b_x;
  boolean_T exitg1;
  boolean_T guard1 = false;
  emxArray_real_T *indT1;
  emxArray_real_T *eps_bar_;
  double c_x;
  emxArray_real_T *B;
  emxArray_real_T *b_B;
  emxArray_real_T *b_eps_bar_;
  emxArray_real_T *b_indT1;
  emxArray_real_T *c_indT1;
  boolean_T b_guard1 = false;
  double C2;
  double T_min;
  double T_max;
  double b_T_min;
  double C3;
  double C4;
  emxInit_real_T(&PerTgt_tmp, 2);
  emxInit_boolean_T(&b_PerTgt_tmp, 2);

  /*  if ecSoilCode==1 */
  /*      S1=0; % is there shallow alluvium */
  /*      S2=0; % is there deep alluvium */
  /*      coef=4; % 1-fault dist,raw coef; 2-fault dist,smooth coef 3-epicentral dist,raw coef; 4-epicentral dist,smooth coef */
  /*  elseif ecSoilCode==2 */
  /*      S1=0; % is there shallow alluvium */
  /*      S2=1; % is there deep alluvium */
  /*      coef=4; % 1-fault dist,raw coef; 2-fault dist,smooth coef 3-epicentral dist,raw coef; 4-epicentral dist,smooth coef   */
  /*  elseif ecSoilCode==3 */
  /*      S1=1; % is there shallow alluvium */
  /*      S2=0; % is there deep alluvium */
  /*      coef=4; % 1-fault dist,raw coef; 2-fault dist,smooth coef 3-epicentral dist,raw coef; 4-epicentral dist,smooth coef   */
  /*  else */
  /*      S1=0;% is there shallow alluvium */
  /*      S2=1; % is there deep alluvium */
  /*      coef=4; % 1-fault dist,raw coef; 2-fault dist,smooth coef 3-epicentral dist,raw coef; 4-epicentral dist,smooth coef   */
  /*  end */
  linspace(nX, PerTgt_tmp);

  /*  Modify perTgt to include T1 */
  i = b_PerTgt_tmp->size[0] * b_PerTgt_tmp->size[1];
  b_PerTgt_tmp->size[0] = 1;
  b_PerTgt_tmp->size[1] = PerTgt_tmp->size[1];
  emxEnsureCapacity((emxArray__common *)b_PerTgt_tmp, i, (int)sizeof(boolean_T));
  ii = PerTgt_tmp->size[0] * PerTgt_tmp->size[1];
  for (i = 0; i < ii; i++) {
    b_PerTgt_tmp->data[i] = (PerTgt_tmp->data[i] == T1);
  }

  emxInit_real_T(&PerTgt_tmp2, 2);
  emxInit_int32_T(&r0, 2);
  emxInit_int32_T(&b_ii, 2);
  if (!any(b_PerTgt_tmp)) {
    idx = PerTgt_tmp->size[1] - 1;
    ii = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp->data[i] < T1) {
        ii++;
      }
    }

    i = b_ii->size[0] * b_ii->size[1];
    b_ii->size[0] = 1;
    b_ii->size[1] = ii;
    emxEnsureCapacity((emxArray__common *)b_ii, i, (int)sizeof(int));
    nx = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp->data[i] < T1) {
        b_ii->data[nx] = i + 1;
        nx++;
      }
    }

    idx = PerTgt_tmp->size[1] - 1;
    ii = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp->data[i] > T1) {
        ii++;
      }
    }

    i = r0->size[0] * r0->size[1];
    r0->size[0] = 1;
    r0->size[1] = ii;
    emxEnsureCapacity((emxArray__common *)r0, i, (int)sizeof(int));
    nx = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp->data[i] > T1) {
        r0->data[nx] = i + 1;
        nx++;
      }
    }

    i = PerTgt_tmp2->size[0] * PerTgt_tmp2->size[1];
    PerTgt_tmp2->size[0] = 1;
    PerTgt_tmp2->size[1] = (b_ii->size[1] + r0->size[1]) + 1;
    emxEnsureCapacity((emxArray__common *)PerTgt_tmp2, i, (int)sizeof(double));
    ii = b_ii->size[1];
    for (i = 0; i < ii; i++) {
      PerTgt_tmp2->data[PerTgt_tmp2->size[0] * i] = PerTgt_tmp->data[b_ii->
        data[b_ii->size[0] * i] - 1];
    }

    PerTgt_tmp2->data[PerTgt_tmp2->size[0] * b_ii->size[1]] = T1;
    ii = r0->size[1];
    for (i = 0; i < ii; i++) {
      PerTgt_tmp2->data[PerTgt_tmp2->size[0] * ((i + b_ii->size[1]) + 1)] =
        PerTgt_tmp->data[r0->data[r0->size[0] * i] - 1];
    }
  } else {
    i = PerTgt_tmp2->size[0] * PerTgt_tmp2->size[1];
    PerTgt_tmp2->size[0] = 1;
    PerTgt_tmp2->size[1] = PerTgt_tmp->size[1];
    emxEnsureCapacity((emxArray__common *)PerTgt_tmp2, i, (int)sizeof(double));
    ii = PerTgt_tmp->size[0] * PerTgt_tmp->size[1];
    for (i = 0; i < ii; i++) {
      PerTgt_tmp2->data[i] = PerTgt_tmp->data[i];
    }
  }

  emxFree_boolean_T(&b_PerTgt_tmp);
  emxInit_boolean_T(&b_PerTgt_tmp2, 2);

  /*  Modify perTgt to include T1dej */
  i = b_PerTgt_tmp2->size[0] * b_PerTgt_tmp2->size[1];
  b_PerTgt_tmp2->size[0] = 1;
  b_PerTgt_tmp2->size[1] = PerTgt_tmp2->size[1];
  emxEnsureCapacity((emxArray__common *)b_PerTgt_tmp2, i, (int)sizeof(boolean_T));
  ii = PerTgt_tmp2->size[0] * PerTgt_tmp2->size[1];
  for (i = 0; i < ii; i++) {
    b_PerTgt_tmp2->data[i] = (PerTgt_tmp2->data[i] == T1dej);
  }

  if (!any(b_PerTgt_tmp2)) {
    idx = PerTgt_tmp2->size[1] - 1;
    ii = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp2->data[i] < T1dej) {
        ii++;
      }
    }

    i = b_ii->size[0] * b_ii->size[1];
    b_ii->size[0] = 1;
    b_ii->size[1] = ii;
    emxEnsureCapacity((emxArray__common *)b_ii, i, (int)sizeof(int));
    nx = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp2->data[i] < T1dej) {
        b_ii->data[nx] = i + 1;
        nx++;
      }
    }

    idx = PerTgt_tmp2->size[1] - 1;
    ii = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp2->data[i] > T1dej) {
        ii++;
      }
    }

    i = r0->size[0] * r0->size[1];
    r0->size[0] = 1;
    r0->size[1] = ii;
    emxEnsureCapacity((emxArray__common *)r0, i, (int)sizeof(int));
    nx = 0;
    for (i = 0; i <= idx; i++) {
      if (PerTgt_tmp2->data[i] > T1dej) {
        r0->data[nx] = i + 1;
        nx++;
      }
    }

    i = PerTgt->size[0] * PerTgt->size[1];
    PerTgt->size[0] = 1;
    PerTgt->size[1] = (b_ii->size[1] + r0->size[1]) + 1;
    emxEnsureCapacity((emxArray__common *)PerTgt, i, (int)sizeof(double));
    ii = b_ii->size[1];
    for (i = 0; i < ii; i++) {
      PerTgt->data[PerTgt->size[0] * i] = PerTgt_tmp2->data[b_ii->data
        [b_ii->size[0] * i] - 1];
    }

    PerTgt->data[PerTgt->size[0] * b_ii->size[1]] = T1dej;
    ii = r0->size[1];
    for (i = 0; i < ii; i++) {
      PerTgt->data[PerTgt->size[0] * ((i + b_ii->size[1]) + 1)] =
        PerTgt_tmp2->data[r0->data[r0->size[0] * i] - 1];
    }
  } else {
    i = PerTgt->size[0] * PerTgt->size[1];
    PerTgt->size[0] = 1;
    PerTgt->size[1] = PerTgt_tmp2->size[1];
    emxEnsureCapacity((emxArray__common *)PerTgt, i, (int)sizeof(double));
    ii = PerTgt_tmp2->size[0] * PerTgt_tmp2->size[1];
    for (i = 0; i < ii; i++) {
      PerTgt->data[i] = PerTgt_tmp2->data[i];
    }
  }

  emxFree_boolean_T(&b_PerTgt_tmp2);
  emxFree_int32_T(&r0);
  for (i = 0; i < 2; i++) {
    x[i] = (unsigned int)PerTgt->size[i];
  }

  for (ii = 0; ii < 2; ii++) {
    y[ii] = x[ii];
  }

  mtmp = (int)y[0];
  if ((int)y[1] > (int)y[0]) {
    mtmp = (int)y[1];
  }

  i = tSpec->size[0] * tSpec->size[1];
  tSpec->size[0] = 1;
  tSpec->size[1] = mtmp;
  emxEnsureCapacity((emxArray__common *)tSpec, i, (int)sizeof(double));
  for (i = 0; i < mtmp; i++) {
    tSpec->data[i] = 0.0;
  }

  i = PerTgt_tmp->size[0] * PerTgt_tmp->size[1];
  PerTgt_tmp->size[0] = 1;
  PerTgt_tmp->size[1] = mtmp;
  emxEnsureCapacity((emxArray__common *)PerTgt_tmp, i, (int)sizeof(double));
  for (i = 0; i < mtmp; i++) {
    PerTgt_tmp->data[i] = 0.0;
  }

  i = PerTgt_tmp2->size[0] * PerTgt_tmp2->size[1];
  PerTgt_tmp2->size[0] = 1;
  PerTgt_tmp2->size[1] = mtmp;
  emxEnsureCapacity((emxArray__common *)PerTgt_tmp2, i, (int)sizeof(double));
  for (i = 0; i < mtmp; i++) {
    PerTgt_tmp2->data[i] = 0.0;
  }

  for (i = 0; i < mtmp; i++) {
    /* [sa_, sigma_] = SP_1996(PerTgt(i), M_mean, R_mean, S1, S2, coef); */
    SP1996hor(PerTgt->data[i], ecSoilCode, &koefAtonacijsko_b1,
              &koefAtonacijsko_b2, &koefAtonacijsko_b3, &koefAtonacijsko_b4,
              &koefAtonacijsko_h0, &koefAtonacijsko_r0, &koefAtonacijsko_bSB,
              &koefAtonacijsko_bSC, &koefAtonacijsko_bSD, &koefAtonacijsko_sigma,
              &koefAtonacijsko_SB, &koefAtonacijsko_SC, &koefAtonacijsko_SD);

    /* fF=bFn*Fn+bFs*Fs+bFr*Fr+bFt*Ft+bFu*Fu; */
    tSpec->data[tSpec->size[0] * i] = (((koefAtonacijsko_b1 + koefAtonacijsko_b2
      * M_mean) + koefAtonacijsko_b3 * log(sqrt(R_mean * R_mean +
      koefAtonacijsko_h0 * koefAtonacijsko_h0) + koefAtonacijsko_r0)) +
      koefAtonacijsko_b4 * (sqrt(R_mean * R_mean + koefAtonacijsko_h0 *
      koefAtonacijsko_h0) + koefAtonacijsko_r0)) + ((koefAtonacijsko_bSB *
      koefAtonacijsko_SB + koefAtonacijsko_bSC * koefAtonacijsko_SC) +
      koefAtonacijsko_bSD * koefAtonacijsko_SD);
    PerTgt_tmp->data[PerTgt_tmp->size[0] * i] = koefAtonacijsko_sigma;
  }

  i = tSpec->size[1];
  for (ii = 0; ii < i; ii++) {
    tSpec->data[ii] = exp(tSpec->data[ii]);
  }

  emxInit_boolean_T(&b_x, 2);
  i = b_x->size[0] * b_x->size[1];
  b_x->size[0] = 1;
  b_x->size[1] = PerTgt->size[1];
  emxEnsureCapacity((emxArray__common *)b_x, i, (int)sizeof(boolean_T));
  ii = PerTgt->size[0] * PerTgt->size[1];
  for (i = 0; i < ii; i++) {
    b_x->data[i] = (PerTgt->data[i] == T1);
  }

  nx = b_x->size[1];
  idx = 0;
  i = b_ii->size[0] * b_ii->size[1];
  b_ii->size[0] = 1;
  b_ii->size[1] = b_x->size[1];
  emxEnsureCapacity((emxArray__common *)b_ii, i, (int)sizeof(int));
  ii = 1;
  exitg1 = false;
  while ((!exitg1) && (ii <= nx)) {
    guard1 = false;
    if (b_x->data[ii - 1]) {
      idx++;
      b_ii->data[idx - 1] = ii;
      if (idx >= nx) {
        exitg1 = true;
      } else {
        guard1 = true;
      }
    } else {
      guard1 = true;
    }

    if (guard1) {
      ii++;
    }
  }

  if (b_x->size[1] == 1) {
    if (idx == 0) {
      i = b_ii->size[0] * b_ii->size[1];
      b_ii->size[0] = 1;
      b_ii->size[1] = 0;
      emxEnsureCapacity((emxArray__common *)b_ii, i, (int)sizeof(int));
    }
  } else {
    i = b_ii->size[0] * b_ii->size[1];
    if (1 > idx) {
      b_ii->size[1] = 0;
    } else {
      b_ii->size[1] = idx;
    }

    emxEnsureCapacity((emxArray__common *)b_ii, i, (int)sizeof(int));
  }

  emxFree_boolean_T(&b_x);
  emxInit_real_T(&indT1, 2);
  i = indT1->size[0] * indT1->size[1];
  indT1->size[0] = 1;
  indT1->size[1] = b_ii->size[1];
  emxEnsureCapacity((emxArray__common *)indT1, i, (int)sizeof(double));
  ii = b_ii->size[0] * b_ii->size[1];
  for (i = 0; i < ii; i++) {
    indT1->data[i] = b_ii->data[i];
  }

  emxFree_int32_T(&b_ii);
  emxInit_real_T(&eps_bar_, 2);
  c_x = log(agC / Rls);
  i = eps_bar_->size[0] * eps_bar_->size[1];
  eps_bar_->size[0] = 1;
  eps_bar_->size[1] = indT1->size[1];
  emxEnsureCapacity((emxArray__common *)eps_bar_, i, (int)sizeof(double));
  ii = indT1->size[1];
  for (i = 0; i < ii; i++) {
    eps_bar_->data[eps_bar_->size[0] * i] = tSpec->data[tSpec->size[0] * ((int)
      indT1->data[indT1->size[0] * i] - 1)];
  }

  b_log(eps_bar_);
  i = eps_bar_->size[0] * eps_bar_->size[1];
  eps_bar_->size[0] = 1;
  emxEnsureCapacity((emxArray__common *)eps_bar_, i, (int)sizeof(double));
  ii = eps_bar_->size[0];
  nx = eps_bar_->size[1];
  ii *= nx;
  for (i = 0; i < ii; i++) {
    eps_bar_->data[i] = c_x - eps_bar_->data[i];
  }

  emxInit_real_T(&B, 2);
  i = B->size[0] * B->size[1];
  B->size[0] = 1;
  B->size[1] = indT1->size[1];
  emxEnsureCapacity((emxArray__common *)B, i, (int)sizeof(double));
  ii = indT1->size[1];
  for (i = 0; i < ii; i++) {
    B->data[B->size[0] * i] = PerTgt_tmp->data[PerTgt_tmp->size[0] * ((int)
      indT1->data[indT1->size[0] * i] - 1)];
  }

  b_emxInit_real_T(&b_B, 1);
  b_emxInit_real_T(&b_eps_bar_, 1);
  b_emxInit_real_T(&b_indT1, 1);
  b_emxInit_real_T(&c_indT1, 1);
  b_guard1 = false;
  if (eps_bar_->size[1] == 0) {
    b_guard1 = true;
  } else {
    i = b_indT1->size[0];
    b_indT1->size[0] = indT1->size[1];
    emxEnsureCapacity((emxArray__common *)b_indT1, i, (int)sizeof(double));
    ii = indT1->size[1];
    for (i = 0; i < ii; i++) {
      b_indT1->data[i] = indT1->data[indT1->size[0] * i];
    }

    if (b_indT1->size[0] == 0) {
      b_guard1 = true;
    } else {
      i = c_indT1->size[0];
      c_indT1->size[0] = indT1->size[1];
      emxEnsureCapacity((emxArray__common *)c_indT1, i, (int)sizeof(double));
      ii = indT1->size[1];
      for (i = 0; i < ii; i++) {
        c_indT1->data[i] = indT1->data[indT1->size[0] * i];
      }

      if (1 == c_indT1->size[0]) {
        eps_bar_->data[0] *= 1.0 / B->data[0];
      } else {
        i = b_B->size[0];
        b_B->size[0] = B->size[1];
        emxEnsureCapacity((emxArray__common *)b_B, i, (int)sizeof(double));
        ii = B->size[1];
        for (i = 0; i < ii; i++) {
          b_B->data[i] = B->data[B->size[0] * i];
        }

        i = b_eps_bar_->size[0];
        b_eps_bar_->size[0] = eps_bar_->size[1];
        emxEnsureCapacity((emxArray__common *)b_eps_bar_, i, (int)sizeof(double));
        ii = eps_bar_->size[1];
        for (i = 0; i < ii; i++) {
          b_eps_bar_->data[i] = eps_bar_->data[eps_bar_->size[0] * i];
        }

        i = eps_bar_->size[0] * eps_bar_->size[1];
        eps_bar_->size[0] = 1;
        eps_bar_->size[1] = 1;
        emxEnsureCapacity((emxArray__common *)eps_bar_, i, (int)sizeof(double));
        c_x = eml_qrsolve(b_B, b_eps_bar_);
        eps_bar_->data[0] = c_x;
      }
    }
  }

  if (b_guard1) {
    i = eps_bar_->size[0] * eps_bar_->size[1];
    eps_bar_->size[0] = 1;
    eps_bar_->size[1] = 1;
    emxEnsureCapacity((emxArray__common *)eps_bar_, i, (int)sizeof(double));
    eps_bar_->data[0] = 0.0;
  }

  emxFree_real_T(&c_indT1);
  emxFree_real_T(&b_indT1);
  emxFree_real_T(&b_eps_bar_);
  emxFree_real_T(&b_B);
  emxFree_real_T(&B);
  emxFree_real_T(&indT1);
  *eps_bar = eps_bar_->data[0];

  /*  (Log) Response Spectrum Mean: meanReq */
  for (i = 0; i < mtmp; i++) {
    /*  Created by Jack Baker, 2/28/07 (updated 6/25/2007) */
    /*  Compute the correlation of epsilons for the NGA ground motion models */
    /*  */
    /*  The function is strictly emperical, fitted over the range the range 0.01s <= T1, T2 <= 10s */
    /*  */
    /*  Documentation is provided in the following document: */
    /*  Baker, J.W. and Jayaram, N., "Correlation of spectral acceleration values from NGA ground  */
    /*  motion models," Earthquake Spectra, (in review). */
    /*  INPUT */
    /*  */
    /*    T1, T2      = The two periods of interest. The periods may be equal, */
    /*                  and there is no restriction on which one is larger. */
    /*  */
    /*  INPUT */
    /*  */
    /*    rho         = The predicted correlation coefficient */
    C2 = 0.0;
    if ((PerTgt->data[i] <= T1) || rtIsNaN(T1)) {
      T_min = PerTgt->data[i];
    } else {
      T_min = T1;
    }

    if ((PerTgt->data[i] >= T1) || rtIsNaN(T1)) {
      T_max = PerTgt->data[i];
    } else {
      T_max = T1;
    }

    if (T_min >= 0.109) {
      b_T_min = T_min;
    } else {
      b_T_min = 0.109;
    }

    c_x = cos(1.5707963267948966 - log(T_max / b_T_min) * 0.366);
    if (T_max < 0.2) {
      C2 = 1.0 - 0.105 * (1.0 - 1.0 / (1.0 + exp(100.0 * T_max - 5.0))) * (T_max
        - T_min) / (T_max - 0.0099);
    }

    if (T_max < 0.109) {
      C3 = C2;
    } else {
      C3 = 1.0 - c_x;
    }

    C4 = (1.0 - c_x) + 0.5 * (sqrt(C3) - C3) * (1.0 + cos(3.1415926535897931 *
      T_min / 0.109));
    if (T_max <= 0.109) {
      PerTgt_tmp2->data[i] = C2;
    } else if (T_min > 0.109) {
      PerTgt_tmp2->data[i] = 1.0 - c_x;
    } else if (T_max < 0.2) {
      if ((C2 <= C4) || rtIsNaN(C4)) {
        PerTgt_tmp2->data[i] = C2;
      } else {
        PerTgt_tmp2->data[i] = C4;
      }
    } else {
      PerTgt_tmp2->data[i] = C4;
    }
  }

  b_log(tSpec);
  i = tSpec->size[0] * tSpec->size[1];
  tSpec->size[0] = 1;
  emxEnsureCapacity((emxArray__common *)tSpec, i, (int)sizeof(double));
  ii = tSpec->size[0];
  nx = tSpec->size[1];
  c_x = eps_bar_->data[0];
  ii *= nx;
  emxFree_real_T(&eps_bar_);
  for (i = 0; i < ii; i++) {
    tSpec->data[i] += PerTgt_tmp->data[i] * c_x * PerTgt_tmp2->data[i];
  }

  emxFree_real_T(&PerTgt_tmp2);
  emxFree_real_T(&PerTgt_tmp);
}

/*
 * Arguments    : void
 * Return Type  : void
 */
void targetSpec_initialize(void)
{
  rt_InitInfAndNaN(8U);
}

/*
 * Arguments    : void
 * Return Type  : void
 */
void targetSpec_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for targetSpec.c
 *
 * [EOF]
 */