text: //
  // File: cwt_emxutil.cpp
  //
  // MATLAB Coder version            : 4.3
  // C/C++ source code generated on  : 30-Mar-2020 11:59:32
  //
  
  // Include Files
  #include "cwt_emxutil.h"
  #include "cwt.h"
  #include "rt_nonfinite.h"
  #include <cstdlib>
  #include <cstring>
  #include <string.h>
  
  // Function Definitions
  
  //
  // Arguments    : emxArray_char_T *emxArray
  //                int oldNumel
  // Return Type  : void
  //
  void emxEnsureCapacity_char_T(emxArray_char_T *emxArray, int oldNumel)
  {
    int newNumel;
    int i;
    void *newData;
    if (oldNumel < 0) {
      oldNumel = 0;
    }
  
    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) {
        if (i > 1073741823) {
          i = MAX_int32_T;
        } else {
          i *= 2;
        }
      }
  
      newData = std::calloc(static_cast<unsigned int>(i), sizeof(char));
      if (emxArray->data != NULL) {
        std::memcpy(newData, emxArray->data, sizeof(char) * oldNumel);
        if (emxArray->canFreeData) {
          std::free(emxArray->data);
        }
      }
  
      emxArray->data = (char *)newData;
      emxArray->allocatedSize = i;
      emxArray->canFreeData = true;
    }
  }
  
  //
  // Arguments    : emxArray_creal_T *emxArray
  //                int oldNumel
  // Return Type  : void
  //
  void emxEnsureCapacity_creal_T(emxArray_creal_T *emxArray, int oldNumel)
  {
    int newNumel;
    int i;
    void *newData;
    if (oldNumel < 0) {
      oldNumel = 0;
    }
  
    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) {
        if (i > 1073741823) {
          i = MAX_int32_T;
        } else {
          i *= 2;
        }
      }
  
      newData = std::calloc(static_cast<unsigned int>(i), sizeof(creal_T));
      if (emxArray->data != NULL) {
        std::memcpy(newData, emxArray->data, sizeof(creal_T) * oldNumel);
        if (emxArray->canFreeData) {
          std::free(emxArray->data);
        }
      }
  
      emxArray->data = (creal_T *)newData;
      emxArray->allocatedSize = i;
      emxArray->canFreeData = true;
    }
  }
  
  //
  // Arguments    : emxArray_real_T *emxArray
  //                int oldNumel
  // Return Type  : void
  //
  void emxEnsureCapacity_real_T(emxArray_real_T *emxArray, int oldNumel)
  {
    int newNumel;
    int i;
    void *newData;
    if (oldNumel < 0) {
      oldNumel = 0;
    }
  
    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) {
        if (i > 1073741823) {
          i = MAX_int32_T;
        } else {
          i *= 2;
        }
      }
  
      newData = std::calloc(static_cast<unsigned int>(i), sizeof(double));
      if (emxArray->data != NULL) {
        std::memcpy(newData, emxArray->data, sizeof(double) * oldNumel);
        if (emxArray->canFreeData) {
          std::free(emxArray->data);
        }
      }
  
      emxArray->data = (double *)newData;
      emxArray->allocatedSize = i;
      emxArray->canFreeData = true;
    }
  }
  
  //
  // Arguments    : cwtfilterbank *pStruct
  // Return Type  : void
  //
  void emxFreeStruct_cwtfilterbank(cwtfilterbank *pStruct)
  {
    emxFree_real_T(&pStruct->Scales);
    emxFree_real_T(&pStruct->PsiDFT);
    emxFree_real_T(&pStruct->WaveletCenterFrequencies);
    emxFree_real_T(&pStruct->Omega);
  }
  
  //
  // Arguments    : emxArray_char_T **pEmxArray
  // Return Type  : void
  //
  void emxFree_char_T(emxArray_char_T **pEmxArray)
  {
    if (*pEmxArray != (emxArray_char_T *)NULL) {
      if (((*pEmxArray)->data != (char *)NULL) && (*pEmxArray)->canFreeData) {
        std::free((*pEmxArray)->data);
      }
  
      std::free((*pEmxArray)->size);
      std::free(*pEmxArray);
      *pEmxArray = (emxArray_char_T *)NULL;
    }
  }
  
  //
  // Arguments    : emxArray_creal_T **pEmxArray
  // Return Type  : void
  //
  void emxFree_creal_T(emxArray_creal_T **pEmxArray)
  {
    if (*pEmxArray != (emxArray_creal_T *)NULL) {
      if (((*pEmxArray)->data != (creal_T *)NULL) && (*pEmxArray)->canFreeData) {
        std::free((*pEmxArray)->data);
      }
  
      std::free((*pEmxArray)->size);
      std::free(*pEmxArray);
      *pEmxArray = (emxArray_creal_T *)NULL;
    }
  }
  
  //
  // Arguments    : emxArray_real_T **pEmxArray
  // Return Type  : void
  //
  void emxFree_real_T(emxArray_real_T **pEmxArray)
  {
    if (*pEmxArray != (emxArray_real_T *)NULL) {
      if (((*pEmxArray)->data != (double *)NULL) && (*pEmxArray)->canFreeData) {
        std::free((*pEmxArray)->data);
      }
  
      std::free((*pEmxArray)->size);
      std::free(*pEmxArray);
      *pEmxArray = (emxArray_real_T *)NULL;
    }
  }
  
  //
  // Arguments    : cwtfilterbank *pStruct
  // Return Type  : void
  //
  void emxInitStruct_cwtfilterbank(cwtfilterbank *pStruct)
  {
    emxInit_real_T(&pStruct->Scales, 2);
    emxInit_real_T(&pStruct->PsiDFT, 2);
    emxInit_real_T(&pStruct->WaveletCenterFrequencies, 1);
    emxInit_real_T(&pStruct->Omega, 2);
  }
  
  //
  // Arguments    : emxArray_char_T **pEmxArray
  //                int numDimensions
  // Return Type  : void
  //
  void emxInit_char_T(emxArray_char_T **pEmxArray, int numDimensions)
  {
    emxArray_char_T *emxArray;
    int i;
    *pEmxArray = (emxArray_char_T *)std::malloc(sizeof(emxArray_char_T));
    emxArray = *pEmxArray;
    emxArray->data = (char *)NULL;
    emxArray->numDimensions = numDimensions;
    emxArray->size = (int *)std::malloc(sizeof(int) * numDimensions);
    emxArray->allocatedSize = 0;
    emxArray->canFreeData = true;
    for (i = 0; i < numDimensions; i++) {
      emxArray->size[i] = 0;
    }
  }
  
  //
  // Arguments    : emxArray_creal_T **pEmxArray
  //                int numDimensions
  // Return Type  : void
  //
  void emxInit_creal_T(emxArray_creal_T **pEmxArray, int numDimensions)
  {
    emxArray_creal_T *emxArray;
    int i;
    *pEmxArray = (emxArray_creal_T *)std::malloc(sizeof(emxArray_creal_T));
    emxArray = *pEmxArray;
    emxArray->data = (creal_T *)NULL;
    emxArray->numDimensions = numDimensions;
    emxArray->size = (int *)std::malloc(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
  //
  void emxInit_real_T(emxArray_real_T **pEmxArray, int numDimensions)
  {
    emxArray_real_T *emxArray;
    int i;
    *pEmxArray = (emxArray_real_T *)std::malloc(sizeof(emxArray_real_T));
    emxArray = *pEmxArray;
    emxArray->data = (double *)NULL;
    emxArray->numDimensions = numDimensions;
    emxArray->size = (int *)std::malloc(sizeof(int) * numDimensions);
    emxArray->allocatedSize = 0;
    emxArray->canFreeData = true;
    for (i = 0; i < numDimensions; i++) {
      emxArray->size[i] = 0;
    }
  }
  
  //
  // File trailer for cwt_emxutil.cpp
  //
  // [EOF]
  //
  