/*
 * agc.c
 *
 * Code generation for function 'agc'
 *
 * C source code generated on: Wed Sep  9 10:33:12 2015
 *
 */

/* Include files */
#include "rt_nonfinite.h"
#include "agc.h"

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

struct emxArray__common
{
  void *data;
  int32_T *size;
  int32_T allocatedSize;
  int32_T 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;
  int32_T *size;
  int32_T allocatedSize;
  int32_T 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*/

/* Function Declarations */
static void b_abs(const emxArray_real_T *x, emxArray_real_T *y);
static void b_emxInit_real_T(emxArray_real_T **pEmxArray, int32_T numDimensions);
static void b_exp(emxArray_real_T *x);
static void b_log(emxArray_real_T *x);
static void c_log(emxArray_real_T *x);
static void diff(const emxArray_real_T *x, emxArray_real_T *y);
static void emxEnsureCapacity(emxArray__common *emxArray, int32_T oldNumel,
  int32_T elementSize);
static void emxFree_boolean_T(emxArray_boolean_T **pEmxArray);
static void emxFree_real_T(emxArray_real_T **pEmxArray);
static void emxInit_boolean_T(emxArray_boolean_T **pEmxArray, int32_T
  numDimensions);
static void emxInit_real_T(emxArray_real_T **pEmxArray, int32_T numDimensions);
static void interp1(const emxArray_real_T *varargin_1, const emxArray_real_T
                    *varargin_2, const emxArray_real_T *varargin_3,
                    emxArray_real_T *yi);
static real_T logncdf_(real_T x, real_T mu, real_T sigma);
static void rdivide(const emxArray_real_T *x, const emxArray_real_T *y,
                    emxArray_real_T *z);
static real_T rt_powd_snf(real_T u0, real_T u1);

/* Function Definitions */
static void b_abs(const emxArray_real_T *x, emxArray_real_T *y)
{
  uint32_T uv0[2];
  int32_T i2;
  int32_T k;
  for (i2 = 0; i2 < 2; i2++) {
    uv0[i2] = (uint32_T)x->size[i2];
  }

  i2 = y->size[0] * y->size[1];
  y->size[0] = (int32_T)uv0[0];
  y->size[1] = (int32_T)uv0[1];
  emxEnsureCapacity((emxArray__common *)y, i2, (int32_T)sizeof(real_T));
  i2 = x->size[0] * x->size[1];
  for (k = 0; k < i2; k++) {
    y->data[(int32_T)(1.0 + (real_T)k) - 1] = fabs(x->data[(int32_T)(1.0 +
      (real_T)k) - 1]);
  }
}

static void b_emxInit_real_T(emxArray_real_T **pEmxArray, int32_T numDimensions)
{
  emxArray_real_T *emxArray;
  int32_T i;
  *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
  emxArray = *pEmxArray;
  emxArray->data = (real_T *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int32_T *)malloc((uint32_T)(sizeof(int32_T) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = TRUE;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

static void b_exp(emxArray_real_T *x)
{
  int32_T i6;
  int32_T k;
  i6 = x->size[1];
  for (k = 0; k < i6; k++) {
    x->data[(int32_T)(1.0 + (real_T)k) - 1] = exp(x->data[(int32_T)(1.0 +
      (real_T)k) - 1]);
  }
}

static void b_log(emxArray_real_T *x)
{
  int32_T i4;
  int32_T k;
  i4 = x->size[0];
  for (k = 0; k < i4; k++) {
    x->data[(int32_T)(1.0 + (real_T)k) - 1] = log(x->data[(int32_T)(1.0 +
      (real_T)k) - 1]);
  }
}

static void c_log(emxArray_real_T *x)
{
  int32_T i5;
  int32_T k;
  i5 = x->size[1];
  for (k = 0; k < i5; k++) {
    x->data[(int32_T)(1.0 + (real_T)k) - 1] = log(x->data[(int32_T)(1.0 +
      (real_T)k) - 1]);
  }
}

static void diff(const emxArray_real_T *x, emxArray_real_T *y)
{
  int32_T ixLead;
  emxArray_real_T *b_y1;
  int32_T iyLead;
  real_T work_data_idx_0;
  int32_T m;
  real_T tmp1;
  real_T tmp2;
  if (x->size[1] == 0) {
    ixLead = y->size[0] * y->size[1];
    y->size[0] = 1;
    y->size[1] = 0;
    emxEnsureCapacity((emxArray__common *)y, ixLead, (int32_T)sizeof(real_T));
  } else {
    ixLead = x->size[1] - 1;
    if (ixLead <= 1) {
    } else {
      ixLead = 1;
    }

    if (ixLead < 1) {
      ixLead = y->size[0] * y->size[1];
      y->size[0] = 0;
      y->size[1] = 0;
      emxEnsureCapacity((emxArray__common *)y, ixLead, (int32_T)sizeof(real_T));
    } else {
      emxInit_real_T(&b_y1, 2);
      ixLead = b_y1->size[0] * b_y1->size[1];
      b_y1->size[0] = 1;
      b_y1->size[1] = x->size[1] - 1;
      emxEnsureCapacity((emxArray__common *)b_y1, ixLead, (int32_T)sizeof(real_T));
      ixLead = 1;
      iyLead = 0;
      work_data_idx_0 = x->data[0];
      for (m = 2; m <= x->size[1]; m++) {
        tmp1 = x->data[ixLead];
        tmp2 = work_data_idx_0;
        work_data_idx_0 = tmp1;
        tmp1 -= tmp2;
        ixLead++;
        b_y1->data[iyLead] = tmp1;
        iyLead++;
      }

      ixLead = y->size[0] * y->size[1];
      y->size[0] = 1;
      y->size[1] = b_y1->size[1];
      emxEnsureCapacity((emxArray__common *)y, ixLead, (int32_T)sizeof(real_T));
      iyLead = b_y1->size[0] * b_y1->size[1];
      for (ixLead = 0; ixLead < iyLead; ixLead++) {
        y->data[ixLead] = b_y1->data[ixLead];
      }

      emxFree_real_T(&b_y1);
    }
  }
}

static void emxEnsureCapacity(emxArray__common *emxArray, int32_T oldNumel,
  int32_T elementSize)
{
  int32_T newNumel;
  int32_T 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((uint32_T)i, (uint32_T)elementSize);
    if (emxArray->data != NULL) {
      memcpy(newData, emxArray->data, (uint32_T)(elementSize * oldNumel));
      if (emxArray->canFreeData) {
        free(emxArray->data);
      }
    }

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

static void emxFree_boolean_T(emxArray_boolean_T **pEmxArray)
{
  if (*pEmxArray != (emxArray_boolean_T *)NULL) {
    if ((*pEmxArray)->canFreeData) {
      free((void *)(*pEmxArray)->data);
    }

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

static void emxFree_real_T(emxArray_real_T **pEmxArray)
{
  if (*pEmxArray != (emxArray_real_T *)NULL) {
    if ((*pEmxArray)->canFreeData) {
      free((void *)(*pEmxArray)->data);
    }

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

static void emxInit_boolean_T(emxArray_boolean_T **pEmxArray, int32_T
  numDimensions)
{
  emxArray_boolean_T *emxArray;
  int32_T i;
  *pEmxArray = (emxArray_boolean_T *)malloc(sizeof(emxArray_boolean_T));
  emxArray = *pEmxArray;
  emxArray->data = (boolean_T *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int32_T *)malloc((uint32_T)(sizeof(int32_T) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = TRUE;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

static void emxInit_real_T(emxArray_real_T **pEmxArray, int32_T numDimensions)
{
  emxArray_real_T *emxArray;
  int32_T i;
  *pEmxArray = (emxArray_real_T *)malloc(sizeof(emxArray_real_T));
  emxArray = *pEmxArray;
  emxArray->data = (real_T *)NULL;
  emxArray->numDimensions = numDimensions;
  emxArray->size = (int32_T *)malloc((uint32_T)(sizeof(int32_T) * numDimensions));
  emxArray->allocatedSize = 0;
  emxArray->canFreeData = TRUE;
  for (i = 0; i < numDimensions; i++) {
    emxArray->size[i] = 0;
  }
}

static void interp1(const emxArray_real_T *varargin_1, const emxArray_real_T
                    *varargin_2, const emxArray_real_T *varargin_3,
                    emxArray_real_T *yi)
{
  emxArray_real_T *y;
  int32_T ixright;
  int32_T ixleft;
  emxArray_real_T *x;
  uint32_T outsize[2];
  int32_T exitg1;
  real_T r;
  real_T b;
  int32_T low_ip1;
  int32_T high_i;
  int32_T mid_i;
  b_emxInit_real_T(&y, 1);
  ixright = y->size[0];
  y->size[0] = varargin_2->size[0];
  emxEnsureCapacity((emxArray__common *)y, ixright, (int32_T)sizeof(real_T));
  ixleft = varargin_2->size[0];
  for (ixright = 0; ixright < ixleft; ixright++) {
    y->data[ixright] = varargin_2->data[ixright];
  }

  b_emxInit_real_T(&x, 1);
  ixright = x->size[0];
  x->size[0] = varargin_1->size[0];
  emxEnsureCapacity((emxArray__common *)x, ixright, (int32_T)sizeof(real_T));
  ixleft = varargin_1->size[0];
  for (ixright = 0; ixright < ixleft; ixright++) {
    x->data[ixright] = varargin_1->data[ixright];
  }

  for (ixright = 0; ixright < 2; ixright++) {
    outsize[ixright] = (uint32_T)varargin_3->size[ixright];
  }

  ixright = yi->size[0] * yi->size[1];
  yi->size[0] = 1;
  emxEnsureCapacity((emxArray__common *)yi, ixright, (int32_T)sizeof(real_T));
  ixright = yi->size[0] * yi->size[1];
  yi->size[1] = (int32_T)outsize[1];
  emxEnsureCapacity((emxArray__common *)yi, ixright, (int32_T)sizeof(real_T));
  ixleft = (int32_T)outsize[1];
  for (ixright = 0; ixright < ixleft; ixright++) {
    yi->data[ixright] = rtNaN;
  }

  if (varargin_3->size[1] == 0) {
  } else {
    ixleft = 1;
    do {
      exitg1 = 0;
      if (ixleft <= varargin_1->size[0]) {
        if (rtIsNaN(varargin_1->data[ixleft - 1])) {
          exitg1 = 1;
        } else {
          ixleft++;
        }
      } else {
        if (varargin_1->data[1] < varargin_1->data[0]) {
          ixright = varargin_1->size[0] >> 1;
          for (ixleft = 1; ixleft <= ixright; ixleft++) {
            r = x->data[ixleft - 1];
            x->data[ixleft - 1] = x->data[varargin_1->size[0] - ixleft];
            x->data[varargin_1->size[0] - ixleft] = r;
          }

          if ((!(varargin_2->size[0] == 0)) && (varargin_2->size[0] > 1)) {
            ixleft = 0;
            for (ixright = varargin_2->size[0]; ixleft + 1 < ixright; ixright--)
            {
              r = y->data[ixleft];
              y->data[ixleft] = y->data[ixright - 1];
              y->data[ixright - 1] = r;
              ixleft++;
            }
          }
        }

        for (ixleft = 0; ixleft + 1 <= varargin_3->size[1]; ixleft++) {
          if (varargin_3->data[ixleft] > x->data[x->size[0] - 1]) {
            r = (varargin_3->data[ixleft] - x->data[varargin_1->size[0] - 1]) /
              (x->data[varargin_1->size[0] - 1] - x->data[varargin_1->size[0] -
               2]);
            b = y->data[varargin_1->size[0] - 1] - y->data[varargin_1->size[0] -
              2];
            yi->data[ixleft] = y->data[varargin_1->size[0] - 1] + r * b;
          } else if (varargin_3->data[ixleft] < x->data[0]) {
            r = (varargin_3->data[ixleft] - x->data[0]) / (x->data[1] - x->data
              [0]);
            yi->data[ixleft] = y->data[0] + r * (y->data[1] - y->data[0]);
          } else {
            ixright = 1;
            low_ip1 = 2;
            high_i = x->size[0];
            while (high_i > low_ip1) {
              mid_i = (ixright >> 1) + (high_i >> 1);
              if (((ixright & 1) == 1) && ((high_i & 1) == 1)) {
                mid_i++;
              }

              if (varargin_3->data[ixleft] >= x->data[mid_i - 1]) {
                ixright = mid_i;
                low_ip1 = mid_i + 1;
              } else {
                high_i = mid_i;
              }
            }

            if (ixright == 0) {
            } else {
              r = (varargin_3->data[ixleft] - x->data[ixright - 1]) / (x->
                data[ixright] - x->data[ixright - 1]);
              if (y->data[ixright - 1] == y->data[ixright]) {
                yi->data[ixleft] = y->data[ixright - 1];
              } else {
                yi->data[ixleft] = (1.0 - r) * y->data[ixright - 1] + r *
                  y->data[ixright];
              }
            }
          }
        }

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

  emxFree_real_T(&x);
  emxFree_real_T(&y);
}

static real_T logncdf_(real_T x, real_T mu, real_T sigma)
{
  real_T p;
  real_T dv0[1];
  boolean_T b_x;
  int32_T k;
  int32_T i3;
  real_T dv1[1];
  real_T z;
  real_T absx;
  real_T s;
  real_T R;
  real_T S;
  int32_T eint;

  /* LOGNCDF Lognormal cumulative distribution function (cdf). */
  /*    P = LOGNCDF(X,MU,SIGMA) returns values at X of the lognormal cdf with  */
  /*    distribution parameters MU and SIGMA.  MU and SIGMA are the mean and  */
  /*    standard deviation, respectively, of the associated normal distribution.   */
  /*    The size of P is the common size of X, MU and SIGMA.  A scalar input  */
  /*    functions as a constant matrix of the same size as the other inputs. */
  /*  */
  /*    Default values for MU and SIGMA are 0 and 1, respectively. */
  /*  */
  /*    [P,PLO,PUP] = LOGNCDF(X,MU,SIGMA,PCOV,ALPHA) returns confidence bounds */
  /*    for P when the input parameters MU and SIGMA are estimates.  PCOV is a */
  /*    2-by-2 matrix containing the covariance matrix of the estimated parameters. */
  /*    ALPHA has a default value of 0.05, and specifies 100*(1-ALPHA)% confidence */
  /*    bounds.  PLO and PUP are arrays of the same size as P containing the lower */
  /*    and upper confidence bounds. */
  /*  */
  /*    See also ERF, ERFC, LOGNFIT, LOGNINV, LOGNLIKE, LOGNPDF, LOGNRND, LOGNSTAT. */
  /*    References: */
  /*       [1] Abramowitz, M. and Stegun, I.A. (1964) Handbook of Mathematical */
  /*           Functions, Dover, New York, 1046pp., sections 7.1, 26.2. */
  /*       [2] Evans, M., Hastings, N., and Peacock, B. (1993) Statistical */
  /*           Distributions, 2nd ed., Wiley, 170pp. */
  /*    Copyright 1993-2011 The MathWorks, Inc. */
  /*  More checking if we need to compute confidence bounds. */
  /*  Return NaN for out of range parameters. */
  dv0[0] = sigma;
  b_x = (sigma <= 0.0);
  k = 0;
  if (b_x) {
    k = 1;
  }

  i3 = 0;
  while (i3 <= k - 1) {
    dv0[0] = rtNaN;
    i3 = 1;
  }

  /*  Negative data would create complex values, which erfc cannot handle. */
  dv1[0] = x;
  b_x = (x < 0.0);
  k = 0;
  if (b_x) {
    k = 1;
  }

  i3 = 0;
  while (i3 <= k - 1) {
    dv1[0] = 0.0;
    i3 = 1;
  }

  /* try */
  /* catch ME */
  /*     error(message('stats:logncdf:InputSizeMismatch')); */
  /* end */
  /*  Use the complementary error function, rather than .5*(1+erf(z/sqrt(2))), */
  /*  to produce accurate near-zero results for large negative x. */
  z = -((log(dv1[0]) - mu) / dv0[0]) / 1.4142135623730951;

  /* <LEGAL> The algorithms for calculating ERF(X) and ERFC(X) are derived */
  /* <LEGAL> from FDLIBM, which has the following notice: */
  /* <LEGAL> */
  /* <LEGAL> Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. */
  /* <LEGAL> */
  /* <LEGAL> Developed at SunSoft, a Sun Microsystems, Inc. business. */
  /* <LEGAL> Permission to use, copy, modify, and distribute this */
  /* <LEGAL> software is freely granted, provided that this notice */
  /* <LEGAL> is preserved. */
  absx = fabs(z);
  if (rtIsNaN(z)) {
    s = z;
  } else if (rtIsInf(z)) {
    if (z < 0.0) {
      s = 2.0;
    } else {
      s = 0.0;
    }
  } else if (absx < 0.84375) {
    if (absx < 1.3877787807814457E-17) {
      s = 1.0 - z;
    } else {
      s = z * z;
      s = (0.12837916709551256 + s * (-0.3250421072470015 + s *
            (-0.02848174957559851 + s * (-0.0057702702964894416 + s *
              -2.3763016656650163E-5)))) / (1.0 + s * (0.39791722395915535 + s *
        (0.0650222499887673 + s * (0.0050813062818757656 + s *
        (0.00013249473800432164 + s * -3.9602282787753681E-6)))));
      if (z < 0.25) {
        s = 1.0 - (z + z * s);
      } else {
        s = 0.5 - (z * s + (z - 0.5));
      }
    }
  } else if (absx < 1.25) {
    if (z >= 0.0) {
      s = 0.15493708848953247 - (-0.0023621185607526594 + (absx - 1.0) *
        (0.41485611868374833 + (absx - 1.0) * (-0.37220787603570132 + (absx -
        1.0) * (0.31834661990116175 + (absx - 1.0) * (-0.11089469428239668 +
        (absx - 1.0) * (0.035478304325618236 + (absx - 1.0) *
                        -0.0021663755948687908)))))) / (1.0 + (absx - 1.0) *
        (0.10642088040084423 + (absx - 1.0) * (0.540397917702171 + (absx - 1.0) *
        (0.071828654414196266 + (absx - 1.0) * (0.12617121980876164 + (absx -
        1.0) * (0.013637083912029051 + (absx - 1.0) * 0.011984499846799107))))));
    } else {
      s = 1.0 + (0.84506291151046753 + (-0.0023621185607526594 + (absx - 1.0) *
                  (0.41485611868374833 + (absx - 1.0) * (-0.37220787603570132 +
                    (absx - 1.0) * (0.31834661990116175 + (absx - 1.0) *
        (-0.11089469428239668 + (absx - 1.0) * (0.035478304325618236 + (absx -
        1.0) * -0.0021663755948687908)))))) / (1.0 + (absx - 1.0) *
                  (0.10642088040084423 + (absx - 1.0) * (0.540397917702171 +
        (absx - 1.0) * (0.071828654414196266 + (absx - 1.0) *
                        (0.12617121980876164 + (absx - 1.0) *
                         (0.013637083912029051 + (absx - 1.0) *
                          0.011984499846799107)))))));
    }
  } else if (z < -6.0) {
    s = 2.0;
  } else if (z >= 28.0) {
    s = 0.0;
  } else {
    s = 1.0 / (absx * absx);
    if (absx < 2.8571414947509766) {
      R = -0.0098649440348471482 + s * (-0.69385857270718176 + s *
        (-10.558626225323291 + s * (-62.375332450326006 + s *
        (-162.39666946257347 + s * (-184.60509290671104 + s * (-81.2874355063066
        + s * -9.8143293441691455))))));
      S = 1.0 + s * (19.651271667439257 + s * (137.65775414351904 + s *
        (434.56587747522923 + s * (645.38727173326788 + s * (429.00814002756783
        + s * (108.63500554177944 + s * (6.5702497703192817 + s *
        -0.0604244152148581)))))));
    } else {
      R = -0.0098649429247001 + s * (-0.799283237680523 + s *
        (-17.757954917754752 + s * (-160.63638485582192 + s *
        (-637.56644336838963 + s * (-1025.0951316110772 + s * -483.5191916086514)))));
      S = 1.0 + s * (30.338060743482458 + s * (325.79251299657392 + s *
        (1536.729586084437 + s * (3199.8582195085955 + s * (2553.0504064331644 +
        s * (474.52854120695537 + s * -22.440952446585818))))));
    }

    if ((!rtIsInf(absx)) && (!rtIsNaN(absx))) {
      s = frexp(absx, &eint);
    } else {
      s = absx;
      eint = 0;
    }

    s = floor(s * 2.097152E+6) / 2.097152E+6 * rt_powd_snf(2.0, eint);
    s = exp(-s * s - 0.5625) * exp((s - absx) * (s + absx) + R / S) / absx;
    if (z < 0.0) {
      s = 2.0 - s;
    }
  }

  p = 0.5 * s;

  /*  Compute confidence bounds if requested. */
  /* if nargout>=2 */
  /*    zvar = (pcov(1,1) + 2*pcov(1,2)*z + pcov(2,2)*z.^2) ./ (sigma.^2); */
  /*    if all(all(zvar >= 0) == 1) */
  /*        normz = -norminv(alpha/2); */
  /*        halfwidth = normz * sqrt(zvar); */
  /*        zlo = z - halfwidth; */
  /*        zup = z + halfwidth; */
  /*  */
  /*        plo = 0.5 * erfc(-zlo./sqrt(2)); */
  /*        pup = 0.5 * erfc(-zup./sqrt(2)); */
  /*    else */
  /*       return; */
  /*       %error(message('stats:logncdf:BadCovarianceSymPos')); */
  /*    end */
  /*  */
  /* end */
  return p;
}

static void rdivide(const emxArray_real_T *x, const emxArray_real_T *y,
                    emxArray_real_T *z)
{
  int32_T i1;
  int32_T loop_ub;
  i1 = z->size[0] * z->size[1];
  z->size[0] = x->size[0];
  z->size[1] = x->size[1];
  emxEnsureCapacity((emxArray__common *)z, i1, (int32_T)sizeof(real_T));
  loop_ub = x->size[0] * x->size[1];
  for (i1 = 0; i1 < loop_ub; i1++) {
    z->data[i1] = x->data[i1] / y->data[i1];
  }
}

static real_T rt_powd_snf(real_T u0, real_T u1)
{
  real_T y;
  real_T d2;
  real_T d3;
  if (rtIsNaN(u0) || rtIsNaN(u1)) {
    y = rtNaN;
  } else {
    d2 = fabs(u0);
    d3 = fabs(u1);
    if (rtIsInf(u1)) {
      if (d2 == 1.0) {
        y = rtNaN;
      } else if (d2 > 1.0) {
        if (u1 > 0.0) {
          y = rtInf;
        } else {
          y = 0.0;
        }
      } else if (u1 > 0.0) {
        y = 0.0;
      } else {
        y = rtInf;
      }
    } else if (d3 == 0.0) {
      y = 1.0;
    } else if (d3 == 1.0) {
      if (u1 > 0.0) {
        y = u0;
      } else {
        y = 1.0 / u0;
      }
    } else if (u1 == 2.0) {
      y = u0 * u0;
    } else if ((u1 == 0.5) && (u0 >= 0.0)) {
      y = sqrt(u0);
    } else if ((u0 < 0.0) && (u1 > floor(u1))) {
      y = rtNaN;
    } else {
      y = pow(u0, u1);
    }
  }

  return y;
}

void agc(real_T lambdaCt, const emxArray_real_T *kpn_x, const emxArray_real_T
         *kpn_y, real_T betaC, real_T TRagR, real_T *b_agc, real_T *agr)
{
  int32_T ixstart;
  real_T mtmp;
  int32_T ixright;
  boolean_T exitg5;
  real_T anew;
  real_T ndbl;
  real_T y;
  real_T cdiff;
  emxArray_real_T *im1;
  int32_T i0;
  int32_T k;
  boolean_T exitg4;
  real_T absb;
  real_T d0;
  emxArray_real_T *im2;
  emxArray_real_T *Hint;
  emxArray_real_T *PC;
  emxArray_real_T *r0;
  emxArray_real_T *b_Hint;
  emxArray_real_T *m;
  emxArray_real_T *r1;
  emxArray_real_T *b_m;
  emxArray_real_T *c_m;
  emxArray_real_T *imCtM;
  emxArray_real_T *lambdaCa;
  emxArray_real_T *err;
  uint32_T j;
  emxArray_real_T *x;
  emxArray_real_T *d_m;
  emxArray_real_T *e_m;
  emxArray_real_T *b_imCtM;
  emxArray_real_T *c_imCtM;
  emxArray_real_T *d_imCtM;
  emxArray_real_T *e_imCtM;
  emxArray_real_T *f_imCtM;
  emxArray_real_T *g_imCtM;
  real_T imMax;
  boolean_T exitg3;
  real_T PC1;
  real_T d1;
  boolean_T guard1 = FALSE;
  emxArray_boolean_T *b_x;
  int32_T ii_data[1];
  boolean_T exitg2;
  int32_T b_ii_data[1];
  int32_T indagR__data[1];
  int32_T indagR_[2];
  real_T b_y[2];
  int32_T b_indagR_[2];
  real_T c_x[2];
  int32_T exitg1;
  int32_T c_indagR_[2];

  /*  Dolo�itev ciljne intenzitete in pripadajo�ega potresnega scenarija */
  /* intenzitete */
  /* frekvence */
  /*  Izra�un mediane ciljne intenzitete z numeri�no integracijo ena�be tveganja */
  ixstart = 1;
  mtmp = kpn_x->data[0];
  if (kpn_x->size[0] > 1) {
    if (rtIsNaN(kpn_x->data[0])) {
      ixright = 2;
      exitg5 = FALSE;
      while ((exitg5 == FALSE) && (ixright <= kpn_x->size[0])) {
        ixstart = ixright;
        if (!rtIsNaN(kpn_x->data[ixright - 1])) {
          mtmp = kpn_x->data[ixright - 1];
          exitg5 = TRUE;
        } else {
          ixright++;
        }
      }
    }

    if (ixstart < kpn_x->size[0]) {
      while (ixstart + 1 <= kpn_x->size[0]) {
        if (kpn_x->data[ixstart] > mtmp) {
          mtmp = kpn_x->data[ixstart];
        }

        ixstart++;
      }
    }
  }

  if (rtIsNaN(mtmp)) {
    ixright = 0;
    anew = rtNaN;
  } else if (mtmp < 0.001) {
    ixright = -1;
    anew = 0.001;
  } else if (rtIsInf(mtmp)) {
    ixright = 0;
    anew = rtNaN;
  } else {
    anew = 0.001;
    ndbl = floor((mtmp - 0.001) / 0.001 + 0.5);
    y = ndbl * 0.001;
    cdiff = (0.001 + y) - mtmp;
    if (fabs(cdiff) < 4.4408920985006262E-16 * mtmp) {
      ndbl++;
    } else if (cdiff > 0.0) {
      mtmp = 0.001 + (ndbl - 1.0) * 0.001;
    } else {
      ndbl++;
      mtmp = 0.001 + y;
    }

    if (ndbl >= 0.0) {
      ixright = (int32_T)ndbl - 1;
    } else {
      ixright = -1;
    }
  }

  emxInit_real_T(&im1, 2);
  i0 = im1->size[0] * im1->size[1];
  im1->size[0] = 1;
  im1->size[1] = ixright + 1;
  emxEnsureCapacity((emxArray__common *)im1, i0, (int32_T)sizeof(real_T));
  if (ixright + 1 > 0) {
    im1->data[0] = anew;
    if (ixright + 1 > 1) {
      im1->data[ixright] = mtmp;
      ixstart = ixright / 2;
      for (k = 1; k < ixstart; k++) {
        cdiff = (real_T)k * 0.001;
        im1->data[k] = anew + cdiff;
        im1->data[ixright - k] = mtmp - cdiff;
      }

      if (ixstart << 1 == ixright) {
        im1->data[ixstart] = (anew + mtmp) / 2.0;
      } else {
        cdiff = (real_T)ixstart * 0.001;
        im1->data[ixstart] = anew + cdiff;
        im1->data[ixstart + 1] = mtmp - cdiff;
      }
    }
  }

  ixstart = 1;
  mtmp = kpn_x->data[0];
  if (kpn_x->size[0] > 1) {
    if (rtIsNaN(kpn_x->data[0])) {
      ixright = 2;
      exitg4 = FALSE;
      while ((exitg4 == FALSE) && (ixright <= kpn_x->size[0])) {
        ixstart = ixright;
        if (!rtIsNaN(kpn_x->data[ixright - 1])) {
          mtmp = kpn_x->data[ixright - 1];
          exitg4 = TRUE;
        } else {
          ixright++;
        }
      }
    }

    if (ixstart < kpn_x->size[0]) {
      while (ixstart + 1 <= kpn_x->size[0]) {
        if (kpn_x->data[ixstart] > mtmp) {
          mtmp = kpn_x->data[ixstart];
        }

        ixstart++;
      }
    }
  }

  if (rtIsNaN(mtmp + 0.001)) {
    ixright = 0;
    anew = rtNaN;
    mtmp += 0.001;
  } else if (mtmp + 0.001 < 0.0005) {
    ixright = -1;
    anew = 0.0005;
    mtmp += 0.001;
  } else if (rtIsInf(mtmp + 0.001)) {
    ixright = 0;
    anew = rtNaN;
    mtmp += 0.001;
  } else {
    anew = 0.0005;
    ndbl = floor(((mtmp + 0.001) - 0.0005) / 0.001 + 0.5);
    y = ndbl * 0.001;
    cdiff = (0.0005 + y) - (mtmp + 0.001);
    absb = fabs(mtmp + 0.001);
    if (0.0005 > absb) {
      d0 = 0.0005;
    } else {
      d0 = absb;
    }

    if (fabs(cdiff) < 4.4408920985006262E-16 * d0) {
      ndbl++;
      mtmp += 0.001;
    } else if (cdiff > 0.0) {
      mtmp = 0.0005 + (ndbl - 1.0) * 0.001;
    } else {
      ndbl++;
      mtmp = 0.0005 + y;
    }

    if (ndbl >= 0.0) {
      ixright = (int32_T)ndbl - 1;
    } else {
      ixright = -1;
    }
  }

  emxInit_real_T(&im2, 2);
  i0 = im2->size[0] * im2->size[1];
  im2->size[0] = 1;
  im2->size[1] = ixright + 1;
  emxEnsureCapacity((emxArray__common *)im2, i0, (int32_T)sizeof(real_T));
  if (ixright + 1 > 0) {
    im2->data[0] = anew;
    if (ixright + 1 > 1) {
      im2->data[ixright] = mtmp;
      ixstart = ixright / 2;
      for (k = 1; k < ixstart; k++) {
        cdiff = (real_T)k * 0.001;
        im2->data[k] = anew + cdiff;
        im2->data[ixright - k] = mtmp - cdiff;
      }

      if (ixstart << 1 == ixright) {
        im2->data[ixstart] = (anew + mtmp) / 2.0;
      } else {
        cdiff = (real_T)ixstart * 0.001;
        im2->data[ixstart] = anew + cdiff;
        im2->data[ixstart + 1] = mtmp - cdiff;
      }
    }
  }

  emxInit_real_T(&Hint, 2);

  /* Hint = exp(pchip_(log(x),log(y),log(im2))); */
  /* Hint = exp(pchip_(log(x),log(y),log(im2'))); */
  i0 = Hint->size[0] * Hint->size[1];
  Hint->size[0] = 1;
  Hint->size[1] = im2->size[1];
  emxEnsureCapacity((emxArray__common *)Hint, i0, (int32_T)sizeof(real_T));
  ixstart = im2->size[0] * im2->size[1];
  for (i0 = 0; i0 < ixstart; i0++) {
    Hint->data[i0] = im2->data[i0];
  }

  b_emxInit_real_T(&PC, 1);
  c_log(Hint);
  i0 = PC->size[0];
  PC->size[0] = kpn_y->size[0];
  emxEnsureCapacity((emxArray__common *)PC, i0, (int32_T)sizeof(real_T));
  ixstart = kpn_y->size[0];
  for (i0 = 0; i0 < ixstart; i0++) {
    PC->data[i0] = kpn_y->data[i0];
  }

  b_emxInit_real_T(&r0, 1);
  b_log(PC);
  i0 = r0->size[0];
  r0->size[0] = kpn_x->size[0];
  emxEnsureCapacity((emxArray__common *)r0, i0, (int32_T)sizeof(real_T));
  ixstart = kpn_x->size[0];
  for (i0 = 0; i0 < ixstart; i0++) {
    r0->data[i0] = kpn_x->data[i0];
  }

  emxInit_real_T(&b_Hint, 2);
  b_log(r0);
  i0 = b_Hint->size[0] * b_Hint->size[1];
  b_Hint->size[0] = 1;
  b_Hint->size[1] = Hint->size[1];
  emxEnsureCapacity((emxArray__common *)b_Hint, i0, (int32_T)sizeof(real_T));
  ixstart = Hint->size[0] * Hint->size[1];
  for (i0 = 0; i0 < ixstart; i0++) {
    b_Hint->data[i0] = Hint->data[i0];
  }

  emxInit_real_T(&m, 2);
  emxInit_real_T(&r1, 2);
  emxInit_real_T(&b_m, 2);
  interp1(r0, PC, b_Hint, Hint);
  b_exp(Hint);
  diff(im2, m);
  diff(Hint, r1);
  i0 = b_m->size[0] * b_m->size[1];
  b_m->size[0] = m->size[0];
  b_m->size[1] = m->size[1];
  emxEnsureCapacity((emxArray__common *)b_m, i0, (int32_T)sizeof(real_T));
  ixstart = m->size[0] * m->size[1];
  emxFree_real_T(&b_Hint);
  for (i0 = 0; i0 < ixstart; i0++) {
    b_m->data[i0] = m->data[i0];
  }

  emxInit_real_T(&c_m, 2);
  rdivide(r1, b_m, m);
  i0 = c_m->size[0] * c_m->size[1];
  c_m->size[0] = m->size[0];
  c_m->size[1] = m->size[1];
  emxEnsureCapacity((emxArray__common *)c_m, i0, (int32_T)sizeof(real_T));
  ixstart = m->size[0] * m->size[1];
  emxFree_real_T(&b_m);
  for (i0 = 0; i0 < ixstart; i0++) {
    c_m->data[i0] = m->data[i0];
  }

  emxInit_real_T(&imCtM, 2);
  emxInit_real_T(&lambdaCa, 2);
  emxInit_real_T(&err, 2);
  b_abs(c_m, m);
  j = 1U;
  i0 = imCtM->size[0] * imCtM->size[1];
  imCtM->size[0] = 1;
  imCtM->size[1] = 1;
  emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
  imCtM->data[0] = 1.0;
  cdiff = 1.0;
  i0 = lambdaCa->size[0] * lambdaCa->size[1];
  lambdaCa->size[0] = 1;
  lambdaCa->size[1] = 0;
  emxEnsureCapacity((emxArray__common *)lambdaCa, i0, (int32_T)sizeof(real_T));
  i0 = err->size[0] * err->size[1];
  err->size[0] = 1;
  err->size[1] = 0;
  emxEnsureCapacity((emxArray__common *)err, i0, (int32_T)sizeof(real_T));

  /* % */
  emxFree_real_T(&c_m);
  emxInit_real_T(&x, 2);
  emxInit_real_T(&d_m, 2);
  emxInit_real_T(&e_m, 2);
  emxInit_real_T(&b_imCtM, 2);
  emxInit_real_T(&c_imCtM, 2);
  emxInit_real_T(&d_imCtM, 2);
  emxInit_real_T(&e_imCtM, 2);
  emxInit_real_T(&f_imCtM, 2);
  emxInit_real_T(&g_imCtM, 2);
  while (cdiff > 0.001) {
    ixstart = 1;
    imMax = kpn_x->data[0];
    if (kpn_x->size[0] > 1) {
      if (rtIsNaN(kpn_x->data[0])) {
        ixright = 2;
        exitg3 = FALSE;
        while ((exitg3 == FALSE) && (ixright <= kpn_x->size[0])) {
          ixstart = ixright;
          if (!rtIsNaN(kpn_x->data[ixright - 1])) {
            imMax = kpn_x->data[ixright - 1];
            exitg3 = TRUE;
          } else {
            ixright++;
          }
        }
      }

      if (ixstart < kpn_x->size[0]) {
        while (ixstart + 1 <= kpn_x->size[0]) {
          if (kpn_x->data[ixstart] > imMax) {
            imMax = kpn_x->data[ixstart];
          }

          ixstart++;
        }
      }
    }

    PC1 = logncdf_(imMax, log(imCtM->data[(int32_T)j - 1]), betaC);
    while (PC1 < 0.99) {
      imMax++;
      PC1 = logncdf_(imMax, log(imCtM->data[(int32_T)j - 1]), betaC);
      if (rtIsNaN(imMax)) {
        ixright = 0;
        anew = rtNaN;
        mtmp = imMax;
      } else if (imMax < 0.001) {
        ixright = -1;
        anew = 0.001;
        mtmp = imMax;
      } else if (rtIsInf(imMax)) {
        ixright = 0;
        anew = rtNaN;
        mtmp = imMax;
      } else {
        anew = 0.001;
        ndbl = floor((imMax - 0.001) / 0.001 + 0.5);
        y = ndbl * 0.001;
        cdiff = (0.001 + y) - imMax;
        if (fabs(cdiff) < 4.4408920985006262E-16 * imMax) {
          ndbl++;
          mtmp = imMax;
        } else if (cdiff > 0.0) {
          mtmp = 0.001 + (ndbl - 1.0) * 0.001;
        } else {
          ndbl++;
          mtmp = 0.001 + y;
        }

        if (ndbl >= 0.0) {
          ixright = (int32_T)ndbl - 1;
        } else {
          ixright = -1;
        }
      }

      i0 = im1->size[0] * im1->size[1];
      im1->size[0] = 1;
      im1->size[1] = ixright + 1;
      emxEnsureCapacity((emxArray__common *)im1, i0, (int32_T)sizeof(real_T));
      if (ixright + 1 > 0) {
        im1->data[0] = anew;
        if (ixright + 1 > 1) {
          im1->data[ixright] = mtmp;
          ixstart = ixright / 2;
          for (k = 1; k < ixstart; k++) {
            cdiff = (real_T)k * 0.001;
            im1->data[k] = anew + cdiff;
            im1->data[ixright - k] = mtmp - cdiff;
          }

          if (ixstart << 1 == ixright) {
            im1->data[ixstart] = (anew + mtmp) / 2.0;
          } else {
            cdiff = (real_T)ixstart * 0.001;
            im1->data[ixstart] = anew + cdiff;
            im1->data[ixstart + 1] = mtmp - cdiff;
          }
        }
      }

      if (rtIsNaN(imMax + 0.001)) {
        ixright = 0;
        anew = rtNaN;
        mtmp = imMax + 0.001;
      } else if (imMax + 0.001 < 0.0005) {
        ixright = -1;
        anew = 0.0005;
        mtmp = imMax + 0.001;
      } else if (rtIsInf(imMax + 0.001)) {
        ixright = 0;
        anew = rtNaN;
        mtmp = imMax + 0.001;
      } else {
        anew = 0.0005;
        ndbl = floor(((imMax + 0.001) - 0.0005) / 0.001 + 0.5);
        y = ndbl * 0.001;
        cdiff = (0.0005 + y) - (imMax + 0.001);
        absb = fabs(imMax + 0.001);
        if (0.0005 > absb) {
          d1 = 0.0005;
        } else {
          d1 = absb;
        }

        if (fabs(cdiff) < 4.4408920985006262E-16 * d1) {
          ndbl++;
          mtmp = imMax + 0.001;
        } else if (cdiff > 0.0) {
          mtmp = 0.0005 + (ndbl - 1.0) * 0.001;
        } else {
          ndbl++;
          mtmp = 0.0005 + y;
        }

        if (ndbl >= 0.0) {
          ixright = (int32_T)ndbl - 1;
        } else {
          ixright = -1;
        }
      }

      i0 = im2->size[0] * im2->size[1];
      im2->size[0] = 1;
      im2->size[1] = ixright + 1;
      emxEnsureCapacity((emxArray__common *)im2, i0, (int32_T)sizeof(real_T));
      if (ixright + 1 > 0) {
        im2->data[0] = anew;
        if (ixright + 1 > 1) {
          im2->data[ixright] = mtmp;
          ixstart = ixright / 2;
          for (k = 1; k < ixstart; k++) {
            cdiff = (real_T)k * 0.001;
            im2->data[k] = anew + cdiff;
            im2->data[ixright - k] = mtmp - cdiff;
          }

          if (ixstart << 1 == ixright) {
            im2->data[ixstart] = (anew + mtmp) / 2.0;
          } else {
            cdiff = (real_T)ixstart * 0.001;
            im2->data[ixstart] = anew + cdiff;
            im2->data[ixstart + 1] = mtmp - cdiff;
          }
        }
      }

      /* Hint   = exp(pchip_(log(x),log(y),log(im2))); */
      /* m      = abs(diff(Hint)./diff(im2)); */
      /*          im2a=max(x)+dim/2:dim:imMax+dim; */
      i0 = Hint->size[0] * Hint->size[1];
      Hint->size[0] = 1;
      Hint->size[1] = im2->size[1];
      emxEnsureCapacity((emxArray__common *)Hint, i0, (int32_T)sizeof(real_T));
      ixstart = im2->size[0] * im2->size[1];
      for (i0 = 0; i0 < ixstart; i0++) {
        Hint->data[i0] = im2->data[i0];
      }

      c_log(Hint);
      i0 = PC->size[0];
      PC->size[0] = kpn_y->size[0];
      emxEnsureCapacity((emxArray__common *)PC, i0, (int32_T)sizeof(real_T));
      ixstart = kpn_y->size[0];
      for (i0 = 0; i0 < ixstart; i0++) {
        PC->data[i0] = kpn_y->data[i0];
      }

      b_log(PC);
      i0 = r0->size[0];
      r0->size[0] = kpn_x->size[0];
      emxEnsureCapacity((emxArray__common *)r0, i0, (int32_T)sizeof(real_T));
      ixstart = kpn_x->size[0];
      for (i0 = 0; i0 < ixstart; i0++) {
        r0->data[i0] = kpn_x->data[i0];
      }

      b_log(r0);
      interp1(r0, PC, Hint, x);
      i0 = Hint->size[0] * Hint->size[1];
      Hint->size[0] = 1;
      Hint->size[1] = x->size[1];
      emxEnsureCapacity((emxArray__common *)Hint, i0, (int32_T)sizeof(real_T));
      ixstart = x->size[0] * x->size[1];
      for (i0 = 0; i0 < ixstart; i0++) {
        Hint->data[i0] = x->data[i0];
      }

      for (k = 0; k < x->size[1]; k++) {
        Hint->data[(int32_T)(1.0 + (real_T)k) - 1] = exp(Hint->data[(int32_T)
          (1.0 + (real_T)k) - 1]);
      }

      diff(im2, m);
      diff(Hint, r1);
      i0 = e_m->size[0] * e_m->size[1];
      e_m->size[0] = m->size[0];
      e_m->size[1] = m->size[1];
      emxEnsureCapacity((emxArray__common *)e_m, i0, (int32_T)sizeof(real_T));
      ixstart = m->size[0] * m->size[1];
      for (i0 = 0; i0 < ixstart; i0++) {
        e_m->data[i0] = m->data[i0];
      }

      rdivide(r1, e_m, m);
      i0 = d_m->size[0] * d_m->size[1];
      d_m->size[0] = m->size[0];
      d_m->size[1] = m->size[1];
      emxEnsureCapacity((emxArray__common *)d_m, i0, (int32_T)sizeof(real_T));
      ixstart = m->size[0] * m->size[1];
      for (i0 = 0; i0 < ixstart; i0++) {
        d_m->data[i0] = m->data[i0];
      }

      b_abs(d_m, m);

      /*          m2=[m ma]; */
    }

    /*      if extrap== */
    /*          m2=m; */
    /*      end */
    i0 = Hint->size[0] * Hint->size[1];
    Hint->size[0] = 1;
    Hint->size[1] = 0;
    emxEnsureCapacity((emxArray__common *)Hint, i0, (int32_T)sizeof(real_T));
    i0 = PC->size[0];
    PC->size[0] = im1->size[1];
    emxEnsureCapacity((emxArray__common *)PC, i0, (int32_T)sizeof(real_T));
    ixstart = im1->size[1];
    for (i0 = 0; i0 < ixstart; i0++) {
      PC->data[i0] = 0.0;
    }

    for (ixstart = 0; ixstart < im1->size[1]; ixstart++) {
      PC->data[ixstart] = logncdf_(im1->data[ixstart], log(imCtM->data[(int32_T)
        j - 1]), betaC);
      ixright = Hint->size[1];
      i0 = Hint->size[0] * Hint->size[1];
      Hint->size[1] = ixright + 1;
      emxEnsureCapacity((emxArray__common *)Hint, i0, (int32_T)sizeof(real_T));
      Hint->data[ixright] = PC->data[ixstart] * m->data[ixstart] * 0.001;

      /* lambdaCa1(i)=PC(i)*m2(i)*dim; */
    }

    if (Hint->size[1] == 0) {
      y = 0.0;
    } else {
      y = Hint->data[0];
      for (k = 2; k <= Hint->size[1]; k++) {
        y += Hint->data[k - 1];
      }
    }

    ixright = lambdaCa->size[1];
    i0 = lambdaCa->size[0] * lambdaCa->size[1];
    lambdaCa->size[1] = ixright + 1;
    emxEnsureCapacity((emxArray__common *)lambdaCa, i0, (int32_T)sizeof(real_T));
    lambdaCa->data[ixright] = y;

    /* lambdaCa(j)=sum(lambdaCa1); */
    /*  lambdaCa=PC*m'*dim; */
    ixright = err->size[1];
    i0 = err->size[0] * err->size[1];
    err->size[1] = ixright + 1;
    emxEnsureCapacity((emxArray__common *)err, i0, (int32_T)sizeof(real_T));
    err->data[ixright] = lambdaCa->data[(int32_T)j - 1] - lambdaCt;
    guard1 = FALSE;
    if ((int32_T)j == 1) {
      guard1 = TRUE;
    } else {
      i0 = x->size[0] * x->size[1];
      x->size[0] = 1;
      x->size[1] = err->size[1];
      emxEnsureCapacity((emxArray__common *)x, i0, (int32_T)sizeof(real_T));
      ixstart = err->size[0] * err->size[1];
      for (i0 = 0; i0 < ixstart; i0++) {
        x->data[i0] = err->data[i0];
      }

      for (k = 0; k < err->size[1]; k++) {
        cdiff = x->data[k];
        if (cdiff < 0.0) {
          y = -1.0;
        } else if (cdiff > 0.0) {
          y = 1.0;
        } else if (cdiff == 0.0) {
          y = 0.0;
        } else {
          y = cdiff;
        }

        x->data[k] = y;
      }

      if (x->size[1] == 0) {
        y = 0.0;
      } else {
        y = x->data[0];
        for (k = 2; k <= x->size[1]; k++) {
          y += x->data[k - 1];
        }
      }

      if (fabs(y) == j) {
        guard1 = TRUE;
      } else if (err->data[(int32_T)j - 1] > 0.0) {
        mtmp = imCtM->data[(int32_T)j - 1] - imCtM->data[(int32_T)j - 2];
        cdiff = imCtM->data[(int32_T)j - 1];
        i0 = d_imCtM->size[0] * d_imCtM->size[1];
        d_imCtM->size[0] = 1;
        d_imCtM->size[1] = imCtM->size[1] + 1;
        emxEnsureCapacity((emxArray__common *)d_imCtM, i0, (int32_T)sizeof
                          (real_T));
        ixstart = imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          d_imCtM->data[d_imCtM->size[0] * i0] = imCtM->data[imCtM->size[0] * i0];
        }

        d_imCtM->data[d_imCtM->size[0] * imCtM->size[1]] = cdiff + fabs(mtmp) /
          2.0;
        i0 = imCtM->size[0] * imCtM->size[1];
        imCtM->size[0] = 1;
        imCtM->size[1] = d_imCtM->size[1];
        emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
        ixstart = d_imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          imCtM->data[imCtM->size[0] * i0] = d_imCtM->data[d_imCtM->size[0] * i0];
        }
      } else if (err->data[(int32_T)j - 1] < 0.0) {
        mtmp = imCtM->data[(int32_T)j - 1] - imCtM->data[(int32_T)j - 2];
        cdiff = imCtM->data[(int32_T)j - 1];
        i0 = c_imCtM->size[0] * c_imCtM->size[1];
        c_imCtM->size[0] = 1;
        c_imCtM->size[1] = imCtM->size[1] + 1;
        emxEnsureCapacity((emxArray__common *)c_imCtM, i0, (int32_T)sizeof
                          (real_T));
        ixstart = imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          c_imCtM->data[c_imCtM->size[0] * i0] = imCtM->data[imCtM->size[0] * i0];
        }

        c_imCtM->data[c_imCtM->size[0] * imCtM->size[1]] = cdiff - fabs(mtmp) /
          2.0;
        i0 = imCtM->size[0] * imCtM->size[1];
        imCtM->size[0] = 1;
        imCtM->size[1] = c_imCtM->size[1];
        emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
        ixstart = c_imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          imCtM->data[imCtM->size[0] * i0] = c_imCtM->data[c_imCtM->size[0] * i0];
        }
      } else {
        cdiff = imCtM->data[(int32_T)j - 1];
        i0 = b_imCtM->size[0] * b_imCtM->size[1];
        b_imCtM->size[0] = 1;
        b_imCtM->size[1] = imCtM->size[1] + 1;
        emxEnsureCapacity((emxArray__common *)b_imCtM, i0, (int32_T)sizeof
                          (real_T));
        ixstart = imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          b_imCtM->data[b_imCtM->size[0] * i0] = imCtM->data[imCtM->size[0] * i0];
        }

        b_imCtM->data[b_imCtM->size[0] * imCtM->size[1]] = cdiff;
        i0 = imCtM->size[0] * imCtM->size[1];
        imCtM->size[0] = 1;
        imCtM->size[1] = b_imCtM->size[1];
        emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
        ixstart = b_imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          imCtM->data[imCtM->size[0] * i0] = b_imCtM->data[b_imCtM->size[0] * i0];
        }
      }
    }

    if (guard1 == TRUE) {
      if (err->data[(int32_T)j - 1] > 0.0) {
        cdiff = imCtM->data[(int32_T)j - 1];
        i0 = g_imCtM->size[0] * g_imCtM->size[1];
        g_imCtM->size[0] = 1;
        g_imCtM->size[1] = imCtM->size[1] + 1;
        emxEnsureCapacity((emxArray__common *)g_imCtM, i0, (int32_T)sizeof
                          (real_T));
        ixstart = imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          g_imCtM->data[g_imCtM->size[0] * i0] = imCtM->data[imCtM->size[0] * i0];
        }

        g_imCtM->data[g_imCtM->size[0] * imCtM->size[1]] = cdiff * 2.0;
        i0 = imCtM->size[0] * imCtM->size[1];
        imCtM->size[0] = 1;
        imCtM->size[1] = g_imCtM->size[1];
        emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
        ixstart = g_imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          imCtM->data[imCtM->size[0] * i0] = g_imCtM->data[g_imCtM->size[0] * i0];
        }
      } else if (err->data[(int32_T)j - 1] < 0.0) {
        cdiff = imCtM->data[(int32_T)j - 1];
        i0 = f_imCtM->size[0] * f_imCtM->size[1];
        f_imCtM->size[0] = 1;
        f_imCtM->size[1] = imCtM->size[1] + 1;
        emxEnsureCapacity((emxArray__common *)f_imCtM, i0, (int32_T)sizeof
                          (real_T));
        ixstart = imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          f_imCtM->data[f_imCtM->size[0] * i0] = imCtM->data[imCtM->size[0] * i0];
        }

        f_imCtM->data[f_imCtM->size[0] * imCtM->size[1]] = cdiff / 2.0;
        i0 = imCtM->size[0] * imCtM->size[1];
        imCtM->size[0] = 1;
        imCtM->size[1] = f_imCtM->size[1];
        emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
        ixstart = f_imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          imCtM->data[imCtM->size[0] * i0] = f_imCtM->data[f_imCtM->size[0] * i0];
        }
      } else {
        cdiff = imCtM->data[(int32_T)j - 1];
        i0 = e_imCtM->size[0] * e_imCtM->size[1];
        e_imCtM->size[0] = 1;
        e_imCtM->size[1] = imCtM->size[1] + 1;
        emxEnsureCapacity((emxArray__common *)e_imCtM, i0, (int32_T)sizeof
                          (real_T));
        ixstart = imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          e_imCtM->data[e_imCtM->size[0] * i0] = imCtM->data[imCtM->size[0] * i0];
        }

        e_imCtM->data[e_imCtM->size[0] * imCtM->size[1]] = cdiff;
        i0 = imCtM->size[0] * imCtM->size[1];
        imCtM->size[0] = 1;
        imCtM->size[1] = e_imCtM->size[1];
        emxEnsureCapacity((emxArray__common *)imCtM, i0, (int32_T)sizeof(real_T));
        ixstart = e_imCtM->size[1];
        for (i0 = 0; i0 < ixstart; i0++) {
          imCtM->data[imCtM->size[0] * i0] = e_imCtM->data[e_imCtM->size[0] * i0];
        }
      }
    }

    mtmp = imCtM->data[(int32_T)j] - imCtM->data[(int32_T)j - 1];
    cdiff = fabs(mtmp);
    j++;
  }

  emxFree_real_T(&g_imCtM);
  emxFree_real_T(&f_imCtM);
  emxFree_real_T(&e_imCtM);
  emxFree_real_T(&d_imCtM);
  emxFree_real_T(&c_imCtM);
  emxFree_real_T(&b_imCtM);
  emxFree_real_T(&e_m);
  emxFree_real_T(&d_m);
  emxFree_real_T(&r0);
  emxFree_real_T(&r1);
  emxFree_real_T(&x);
  emxFree_real_T(&PC);
  emxFree_real_T(&err);
  emxFree_real_T(&lambdaCa);
  emxFree_real_T(&m);
  emxFree_real_T(&Hint);
  emxFree_real_T(&im2);
  emxFree_real_T(&im1);
  emxInit_boolean_T(&b_x, 1);
  *b_agc = imCtM->data[imCtM->size[1] - 1];
  y = 1.0 / TRagR;
  i0 = b_x->size[0];
  b_x->size[0] = kpn_y->size[0];
  emxEnsureCapacity((emxArray__common *)b_x, i0, (int32_T)sizeof(boolean_T));
  ixstart = kpn_y->size[0];
  emxFree_real_T(&imCtM);
  for (i0 = 0; i0 < ixstart; i0++) {
    b_x->data[i0] = (kpn_y->data[i0] < y);
  }

  ixstart = b_x->size[0];
  if (1 <= ixstart) {
    k = 1;
  } else {
    k = ixstart;
  }

  ixstart = 0;
  ixright = 1;
  exitg2 = FALSE;
  while ((exitg2 == FALSE) && (ixright <= b_x->size[0])) {
    if (b_x->data[ixright - 1]) {
      ixstart = 1;
      ii_data[0] = ixright;
      exitg2 = TRUE;
    } else {
      ixright++;
    }
  }

  emxFree_boolean_T(&b_x);
  if (k == 1) {
    if (ixstart == 0) {
      k = 0;
    }
  } else {
    if (1 > ixstart) {
      ixstart = -1;
    } else {
      ixstart = 0;
    }

    i0 = 0;
    while (i0 <= ixstart) {
      b_ii_data[0] = ii_data[0];
      i0 = 1;
    }

    k = ixstart + 1;
    ixstart++;
    i0 = 0;
    while (i0 <= ixstart - 1) {
      ii_data[0] = b_ii_data[0];
      i0 = 1;
    }
  }

  for (i0 = 0; i0 < k; i0++) {
    indagR__data[i0] = ii_data[i0];
  }

  if (indagR__data[0] > 1) {
    y = 1.0 / TRagR;
    indagR_[0] = indagR__data[0] - 1;
    indagR_[1] = indagR__data[0];
    for (i0 = 0; i0 < 2; i0++) {
      b_y[i0] = kpn_x->data[indagR_[i0] - 1];
    }

    b_indagR_[0] = indagR__data[0] - 1;
    b_indagR_[1] = indagR__data[0];
    for (i0 = 0; i0 < 2; i0++) {
      c_x[i0] = kpn_y->data[b_indagR_[i0] - 1];
    }

    *agr = rtNaN;
    k = 1;
    do {
      exitg1 = 0;
      if (k < 3) {
        c_indagR_[0] = indagR__data[0] - 1;
        c_indagR_[1] = indagR__data[0];
        if (rtIsNaN(kpn_y->data[c_indagR_[k - 1] - 1])) {
          exitg1 = 1;
        } else {
          k++;
        }
      } else {
        if (kpn_y->data[indagR__data[0] - 1] < kpn_y->data[indagR__data[0] - 2])
        {
          c_x[0] = kpn_y->data[indagR__data[0] - 1];
          c_x[1] = kpn_y->data[indagR__data[0] - 2];
          ixstart = 1;
          ixright = 2;
          while (ixstart < ixright) {
            cdiff = b_y[0];
            b_y[0] = b_y[1];
            b_y[1] = cdiff;
            ixstart = 2;
            ixright = 1;
          }
        }

        if ((y > c_x[1]) || (y < c_x[0])) {
        } else {
          cdiff = (y - c_x[0]) / (c_x[1] - c_x[0]);
          if (b_y[0] == b_y[1]) {
            *agr = b_y[0];
          } else {
            *agr = (1.0 - cdiff) * b_y[0] + cdiff * b_y[1];
          }
        }

        exitg1 = 1;
      }
    } while (exitg1 == 0);
  } else {
    *agr = kpn_x->data[0];
  }

  /*  */
  /*  % */
  /*  kvanAll = zeros(nAcc,1); */
  /*  for i=1:nAcc */
  /*     kvanAll(i) = (i-0.5)/nAcc; */
  /*  end */
  /*  [~,index] = min(abs(kvanAll-0.1587)); */
  /*   */
  /*  % Izracun ciljne intenzitete za izbran kvantil (0.1625 za skupino s 40 akcelerogrami) */
  /*  ss = size(imCtM,2); */
  /*  if ss ~= 1 */
  /*      imCt = imCtM(ss)*exp(norminv_(kvanAll(index),0,1)*betaC); */
  /*  end */
  /*   */
  /*  % Dolo�itev epsilona za pogojni spekter */
  /*  %[median_sa,sigma]=SP_1996(T1,M,R,1,0,4); */
  /*  %epsilon=(log(imCt16)-log(median_sa))/sigma; */
  /*   */
  /*  % Dolo�itev povratne dobe, ki pripada ciljni intenziteti */
  /*  %RP=1/exp(pchip_(log(x),log(y),log(imCt16))); */
  /*   */
  /*  %Himct */
  /*  Himct  = exp(pchip_(log(x),log(y),log(imCt))); */
  /*  PCimct = logncdf_(imCt,log(imCtM(ss)),betaC); */
  /*   */
  /*  saUser         = kpn_x'; */
  /*  hUser          = kpn_y'; */
  /*   */
  /*  isExtrap = extrap; */
  /*  if(isExtrap == 1) */
  /*  	% Shorten interpolated HF to max 200 points (or greater than user defined function) */
  /*  	while(size(Hint,2) > 200 && size(Hint,2) > size(hUser,2)) */
  /*  		Hint_tmp = Hint(2:2:end-1); */
  /*  		im2_tmp  = im2(2:2:end-1); */
  /*  		Hint     = [Hint(1,1) Hint_tmp Hint(1,end)]; */
  /*  		im2      = [im2(1,1) im2_tmp im2(1,end)]; */
  /*      end */
  /*   */
  /*  	% Modify interpolated Hazard function to include(Sact) */
  /*  	if ~any(Hint == Himct) */
  /*  	    hInterpolated  = [Hint(Hint > Himct) Himct Hint(Hint < Himct)]; */
  /*  	    saInterpolated = [im2(im2 < imCt) imCt im2(im2 > imCt)]; */
  /*  	else */
  /*  	    hInterpolated  = Hint; */
  /*  	    saInterpolated = im2; */
  /*      end */
  /*  	% Calc PC */
  /*  	PC_ = zeros(1,size(saInterpolated,2)); */
  /*  	for i = 1:size(saInterpolated,2) */
  /*  		PC_(1,i) = logncdf_(saInterpolated(1,i),log(imCtM(ss)),betaC); */
  /*  	end */
  /*  else */
  /*  	saInterpolated = []; */
  /*  	hInterpolated  = []; */
  /*  	if ~any(hUser == Himct) */
  /*  	    hUser  = [hUser(hUser > Himct) Himct hUser(hUser < Himct)]; */
  /*  	    saUser = [saUser(saUser < imCt) imCt saUser(saUser > imCt)]; */
  /*  	end */
  /*   */
  /*  	% Calc PC */
  /*  	PC_ = zeros(1,size(saUser,2)); */
  /*  	for i = 1:size(saUser,2) */
  /*  		PC_(1,i) = logncdf_(saUser(1,i),log(imCtM(ss)),betaC); */
  /*  	end */
  /*  end */
}

void agc_initialize(void)
{
  rt_InitInfAndNaN(8U);
}

void agc_terminate(void)
{
  /* (no terminate code required) */
}

emxArray_real_T *emxCreateND_real_T(int32_T numDimensions, int32_T *size)
{
  emxArray_real_T *emx;
  int32_T numEl;
  int32_T i;
  b_emxInit_real_T(&emx, numDimensions);
  numEl = 1;
  for (i = 0; i < numDimensions; i++) {
    numEl *= size[i];
    emx->size[i] = size[i];
  }

  emx->data = (real_T *)calloc((uint32_T)numEl, sizeof(real_T));
  emx->numDimensions = numDimensions;
  emx->allocatedSize = numEl;
  return emx;
}

emxArray_real_T *emxCreateWrapperND_real_T(real_T *data, int32_T numDimensions,
  int32_T *size)
{
  emxArray_real_T *emx;
  int32_T numEl;
  int32_T i;
  b_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;
}

emxArray_real_T *emxCreateWrapper_real_T(real_T *data, int32_T rows, int32_T
  cols)
{
  emxArray_real_T *emx;
  int32_T size[2];
  int32_T numEl;
  int32_T i;
  size[0] = rows;
  size[1] = cols;
  b_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;
}

emxArray_real_T *emxCreate_real_T(int32_T rows, int32_T cols)
{
  emxArray_real_T *emx;
  int32_T size[2];
  int32_T numEl;
  int32_T i;
  size[0] = rows;
  size[1] = cols;
  b_emxInit_real_T(&emx, 2);
  numEl = 1;
  for (i = 0; i < 2; i++) {
    numEl *= size[i];
    emx->size[i] = size[i];
  }

  emx->data = (real_T *)calloc((uint32_T)numEl, sizeof(real_T));
  emx->numDimensions = 2;
  emx->allocatedSize = numEl;
  return emx;
}

void emxDestroyArray_real_T(emxArray_real_T *emxArray)
{
  emxFree_real_T(&emxArray);
}

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