/*
* PUBLISHED header for emlrt, the runtime library for MATLAB Coder
*
* Copyright 1984-2021 The MathWorks, Inc.
*
*/
#ifndef emlrt_h
#define emlrt_h
#if defined(_MSC_VER) || defined(__GNUC__)
#pragma once
#endif
/*
* Only define EXTERN_C if it hasn't been defined already. This allows
* individual modules to have more control over managing their exports.
*/
#ifndef EXTERN_C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
#endif
#endif
#ifndef LIBEMLRT_API
#define LIBEMLRT_API
#endif
#if defined(BUILDING_LIBEMLRT)
#include "emlrt_extern_include_begin.hpp"
#endif
#include "matrix.h"
#if defined(BUILDING_LIBEMLRT)
#include "emlrt_extern_include_end.hpp"
#endif
#include <setjmp.h>
#include <stdio.h>
#include <stdarg.h>
/* Incomplete typedef for mxGPUArray */
#ifndef MX_GPUARRAY_DEFINED
#ifdef __cplusplus
class mxGPUArray;
#else
typedef struct mxGPUArray_tag mxGPUArray;
#endif
/*lint -esym(1923,MX_GPUARRAY_DEFINED) // MACRO input cannot be converted to const variable in C*/
#define MX_GPUARRAY_DEFINED 1.0
#endif
/*
* MATLAB INTERNAL USE ONLY :: MEX Version
*/
#define EMLRT_VERSION_R2021B 0x2021B
#define EMLRT_VERSION_INFO EMLRT_VERSION_R2021B
/*
* MATLAB INTERNAL USE ONLY :: Thread local context type
*/
typedef void* emlrtCTX;
typedef const void* emlrtConstCTX;
/*
* MATLAB INTERNAL USE ONLY :: MEX error function
*/
typedef void (*EmlrtErrorFunction)(const char* aIdentifier,
const CHAR16_T* aMessage,
emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Prototypes of OpenMP lock functions.
*/
typedef void (*EmlrtLockeeFunction)(emlrtConstCTX aTLS, void* aData);
typedef void (*EmlrtLockerFunction)(EmlrtLockeeFunction aLockee, emlrtConstCTX aTLS, void* aData);
#define emlrtCallLockeeFunction(emlrtLockeeFcnPtr, emlrtLockeeArg0, emlrtLockeeArg1) \
emlrtLockeeFcnPtr(emlrtLockeeArg0, emlrtLockeeArg1)
/*
* MATLAB INTERNAL USE ONLY :: Runtime message identifier
*/
typedef struct emlrtMsgIdentifier {
const char* fIdentifier;
const struct emlrtMsgIdentifier* fParent;
boolean_T bParentIsCell;
} emlrtMsgIdentifier;
/*
* MATLAB INTERNAL USE ONLY :: Runtime stack info
*/
typedef struct emlrtRSInfo {
int32_T lineNo;
const char* fcnName;
const char* pathName;
} emlrtRSInfo;
/*
* MATLAB INTERNAL USE ONLY :: Runtime call stack
*/
typedef struct emlrtStack {
emlrtRSInfo* site;
emlrtCTX tls;
const struct emlrtStack* prev;
} emlrtStack;
/*
* MATLAB INTERNAL USE ONLY :: Runtime call stack
*/
typedef struct emlrtCallStack {
uint32_T fRTStackPointer;
uint32_T* fRTStackSize;
} emlrtCallStack;
/*
* MATLAB INTERNAL USE ONLY :: MEX Context
*/
typedef struct emlrtContext {
boolean_T bFirstTime;
boolean_T bInitialized;
uint32_T fVersionInfo;
EmlrtErrorFunction fErrorFunction;
const char* fFunctionName;
struct emlrtCallStack* fRTCallStack;
boolean_T bDebugMode;
uint32_T fSigWrd[4];
void* fSigMem;
} emlrtContext;
/*
* MATLAB INTERNAL USE ONLY :: External Mode Simulation
*/
typedef struct emlrtExternalSim {
void* fESim;
uint8_T* fIOBuffer;
uint8_T* fIOBufHead;
size_t fIOBufSize;
} emlrtExternalSim;
/*
* MATLAB INTERNAL USE ONLY :: Array bounds check parameters
*/
typedef struct emlrtBCInfo {
int32_T iFirst;
int32_T iLast;
int32_T lineNo;
int32_T colNo;
const char* aName;
const char* fName;
const char* pName;
int32_T checkKind;
} emlrtBCInfo;
/*
* MATLAB INTERNAL USE ONLY :: Design range check parameters
*/
typedef struct emlrtDRCInfo {
int32_T lineNo;
int32_T colNo;
const char* fName;
const char* pName;
} emlrtDRCInfo;
/*
* MATLAB INTERNAL USE ONLY :: Equality check parameters
*/
typedef struct emlrtECInfo {
int32_T nDims;
int32_T lineNo;
int32_T colNo;
const char* fName;
const char* pName;
} emlrtECInfo;
/*
* MATLAB INTERNAL USE ONLY :: Array bounds check parameters
*/
typedef struct {
int32_T lineNo;
int32_T colNo;
const char* fName;
const char* pName;
} emlrtRTEInfo;
typedef emlrtRTEInfo emlrtMCInfo;
/* MATLAB INTERNAL USE ONLY :: Reference to global runtime context */
extern emlrtContext emlrtContextGlobal;
/*
* MATLAB INTERNAL USE ONLY :: Dispatch to mexPrintf
*/
EXTERN_C LIBEMLRT_API int32_T emlrtMexVprintf(const char* aFmt, va_list aVargs);
/*
* MATLAB INTERNAL USE ONLY :: Dispatch to mexPrintf
*/
EXTERN_C LIBEMLRT_API int32_T emlrtMexPrintf(emlrtConstCTX aTLS, const char* aFmt, ...);
/*
* MATLAB INTERNAL USE ONLY :: Dispatch to snprintf
*/
EXTERN_C LIBEMLRT_API int32_T emlrtMexSnprintf(char* retString, size_t n, const char* aFmt, ...);
/*
* MATLAB INTERNAL USE ONLY :: Query first-time sentinel
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtFirstTimeR2012b(emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Create an mxArray alias
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtAlias(const mxArray* in);
/*
* MATLAB INTERNAL USE ONLY :: Create a persistent mxArray alias
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtAliasP(const mxArray* in);
/*
* MATLAB INTERNAL USE ONLY :: Return a vector of mxArray to MATLAB
*/
EXTERN_C LIBEMLRT_API void emlrtReturnArrays(const int32_T aNlhs,
mxArray* aLHS[],
const mxArray* const aRHS[]);
/*
* MATLAB INTERNAL USE ONLY :: Protect mxArray from being overwritten if necessary
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtProtectR2012b(const mxArray* pa,
int32_T,
boolean_T,
int32_T reservedNumEl);
/*
* MATLAB INTERNAL USE ONLY :: License check
*/
EXTERN_C LIBEMLRT_API void emlrtLicenseCheckR2012b(emlrtCTX aTLS,
const char* aFeatureKey,
const int32_T b);
/*
* MATLAB INTERNAL USE ONLY :: Verify default fimath
*/
EXTERN_C LIBEMLRT_API void emlrtCheckDefaultFimathR2008b(const mxArray** ctFimath);
/*
* MATLAB INTERNAL USE ONLY :: Clear mxArray allocation count
*/
EXTERN_C LIBEMLRT_API void emlrtClearAllocCountR2012b(emlrtCTX aTLS,
boolean_T bM,
uint32_T iL,
const char* ctDTO);
/*
* MATLAB INTERNAL USE ONLY :: Load a specified library
*/
EXTERN_C LIBEMLRT_API int32_T emlrtLoadLibrary(const char* aFullname);
/*
* MATLAB INTERNAL USE ONLY :: Load a specified MATLAB library
*/
EXTERN_C LIBEMLRT_API int32_T emlrtLoadMATLABLibrary(const char* aFullName);
/*
* MATLAB INTERNAL USE ONLY :: Assign to an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtAssign(const mxArray** lhs, const mxArray* rhs);
/*
* MATLAB INTERNAL USE ONLY :: Assign to a persistent mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtAssignP(const mxArray** lhs, const mxArray* rhs);
/*
* MATLAB INTERNAL USE ONLY :: Array bounds check
*/
EXTERN_C LIBEMLRT_API int32_T emlrtBoundsCheckR2012b(int32_T indexValue,
emlrtBCInfo* aInfo,
emlrtCTX aTLS);
#ifdef INT_TYPE_64_IS_SUPPORTED
/*
* MATLAB INTERNAL USE ONLY :: Array bounds check for int64
*/
EXTERN_C LIBEMLRT_API int64_T emlrtBoundsCheckInt64(const int64_T indexValue,
const emlrtBCInfo* const aInfo,
const emlrtCTX aTLS);
#endif
/*
* MATLAB INTERNAL USE ONLY :: Dynamic array bounds check
*/
EXTERN_C LIBEMLRT_API int32_T emlrtDynamicBoundsCheckR2012b(int32_T indexValue,
int32_T loBound,
int32_T hiBound,
emlrtBCInfo* aInfo,
emlrtConstCTX aTLS);
#ifdef INT_TYPE_64_IS_SUPPORTED
/*
* MATLAB INTERNAL USE ONLY :: Dynamic array bounds check for int64
*/
EXTERN_C LIBEMLRT_API int64_T emlrtDynamicBoundsCheckInt64(const int64_T indexValue,
const int32_T loBound,
const int32_T hiBound,
const emlrtBCInfo* const aInfo,
const emlrtConstCTX aTLS);
#endif
/*
* MATLAB INTERNAL USE ONLY :: Check that the target value is within the design range.
*/
EXTERN_C LIBEMLRT_API real_T emlrtDesignRangeCheck(real_T targetValue,
real_T rangeMin,
real_T rangeMax,
emlrtDRCInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Perform integer multiplication, raise runtime error
* if the operation overflows.
*/
EXTERN_C LIBEMLRT_API size_t emlrtSizeMulR2012b(size_t s1,
size_t s2,
const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Create an mxArray string from a C string
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateString(const char* in);
/*
* MATLAB INTERNAL USE ONLY :: Create an mxArray string from a single char
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateString1(char c);
/*
* MATLAB INTERNAL USE ONLY :: Create a struct matrix mxArray
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtCreateStructMatrix(int32_T m,
int32_T n,
int32_T nfields,
const char** field_names);
/*
* MATLAB INTERNAL USE ONLY :: Create a class instance mxArray
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtCreateClassInstance(const char* className);
/*
* MATLAB INTERNAL USE ONLY :: Create a struct matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateStructArray(int32_T ndim,
const int32_T* pdim,
int32_T nfields,
const char** field_names);
/*
* MATLAB INTERNAL USE ONLY :: Create an enum
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateEnumR2012b(emlrtConstCTX aTLS,
const char* name,
const mxArray* data);
/*
* MATLAB INTERNAL USE ONLY :: Add a field to a struct matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateField(const mxArray* mxStruct, const char* fldName);
/*
* MATLAB INTERNAL USE ONLY :: Check an input sparse matrix
*/
EXTERN_C LIBEMLRT_API void emlrtCheckSparse(emlrtConstCTX aTLS,
const emlrtMsgIdentifier* aMsgId,
const mxArray* s,
const void* pDims,
const boolean_T* aDynamic,
int32_T aClassId,
int32_T aComplexity);
/*
* MATLAB INTERNAL USE ONLY :: Polymorphic mex utility functions
*/
EXTERN_C LIBEMLRT_API const char* emlrtGetClassName(const mxArray* pa);
EXTERN_C LIBEMLRT_API boolean_T emlrtCompareString(const char* actual, const char* expected);
EXTERN_C LIBEMLRT_API boolean_T emlrtIsComplex(const mxArray* pa);
EXTERN_C LIBEMLRT_API boolean_T emlrtIsHeterogeneous(const mxArray* pa);
EXTERN_C LIBEMLRT_API int emlrtNumCellElements(const mxArray* pa);
EXTERN_C LIBEMLRT_API mxArray* emlrtGetCellElement(const mxArray* pa, int index);
EXTERN_C LIBEMLRT_API int emlrtGetNumStructFields(const mxArray* pa);
EXTERN_C LIBEMLRT_API const char* emlrtGetStructFieldName(const mxArray* pa, int index);
EXTERN_C LIBEMLRT_API mxArray* emlrtGetStructField(const mxArray* pa, const char* fieldName);
EXTERN_C LIBEMLRT_API boolean_T emlrtIsCompatibleSize(const mxArray* pa,
const uint32_T* aSizeVec,
const boolean_T* aVardimVec,
const uint32_T sizeLength);
EXTERN_C LIBEMLRT_API boolean_T emlrtIsSparse(const mxArray* pa);
EXTERN_C LIBEMLRT_API uint32_T emlrtGetSizeLength(const mxArray* pa);
EXTERN_C LIBEMLRT_API mxArray* emlrtGetClassProperty(const mxArray* pa, const char* propertyName);
EXTERN_C LIBEMLRT_API boolean_T emlrtCompareFiType(const mxArray* aFi,
const mxArray* fiMathMx,
const mxArray* ntMx);
EXTERN_C LIBEMLRT_API boolean_T emlrtIsComplexFi(const mxArray* aFi);
EXTERN_C LIBEMLRT_API boolean_T emlrtCompareConstant(const mxArray* aConst,
const uint32_T* aCheckSum);
/*
* MATLAB INTERNAL USE ONLY :: Check an input sparse matrix
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtCreateSparse(const void* d,
const int32_T* colidx,
const int32_T* rowidx,
int32_T m,
int32_T n,
int32_T maxnz,
int32_T aClassId,
int32_T aComplexity);
/*
* MATLAB INTERNAL USE ONLY :: Add a field to a struct matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtAddField(const mxArray* mxStruct,
const mxArray* mxField,
const char* fldName,
int32_T index);
/*
* MATLAB INTERNAL USE ONLY :: Set the value from propValues of all properties in propNames of a
* class instance mxArray.
*/
EXTERN_C LIBEMLRT_API void emlrtSetAllProperties(emlrtConstCTX,
const mxArray**,
int32_T index,
int32_T numberOfProperties,
const char** propertyNames,
const char** classNames,
const mxArray** propertyValues);
/*
* MATLAB INTERNAL USE ONLY :: Get the value mxArray of all properties of a class instance mxArray.
*/
EXTERN_C LIBEMLRT_API void emlrtGetAllProperties(emlrtConstCTX,
const mxArray*,
int32_T index,
int32_T numberOfProperties,
const char** propertyNames,
const char** classNames,
const mxArray** propertyValues);
/*
* MATLAB INTERNAL USE ONLY :: Get the redirect target MCOS instance mxArray of a redirect source
* MCOS instance mxArray.
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtConvertInstanceToRedirectTarget(emlrtConstCTX aTLS,
const mxArray* mxCls,
int aIndex,
const char* className);
/*
* MATLAB INTERNAL USE ONLY :: Get the redirect source MCOS instance mxArray of a redirect target
* MCOS instance mxArray.
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtConvertInstanceToRedirectSource(emlrtConstCTX aTLS,
const mxArray* mxCls,
int aIndex,
const char* className);
/*
* MATLAB INTERNAL USE ONLY :: Get a field from a struct matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtGetFieldR2017b(emlrtConstCTX aTLS,
const mxArray* mxStruct,
int32_T aIndex,
int32_T fldNumber,
const char* fldName);
/*
* MATLAB INTERNAL USE ONLY :: Set field value in structure array, given index and field name
*/
EXTERN_C LIBEMLRT_API void emlrtSetField(mxArray* mxStruct,
int32_T aIndex,
const char* fldName,
mxArray* mxValue);
/*
* MATLAB INTERNAL USE ONLY :: Set field value in structure array, given index and field index
*/
EXTERN_C LIBEMLRT_API void emlrtSetFieldR2017b(const mxArray* mxStruct,
int32_T aIndex,
const char* fldName,
const mxArray* mxValue,
int32_T fldIdx);
/*
* MATLAB INTERNAL USE ONLY :: Create a cell array
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateCellArrayR2014a(int32_T ndim, const int32_T* pdim);
/*
* MATLAB INTERNAL USE ONLY :: Create a cell matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateCellMatrix(int32_T m, int32_T n);
/*
* MATLAB INTERNAL USE ONLY :: Set a cell element
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtSetCell(const mxArray* mxCellArray,
int32_T aIndex,
const mxArray* mxCell);
/*
* MATLAB INTERNAL USE ONLY :: Get a cell element
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtGetCell(emlrtConstCTX aTLS,
const emlrtMsgIdentifier* aMsgId,
const mxArray* mxCell,
int32_T aIndex);
/*
* MATLAB INTERNAL USE ONLY :: Check if empty
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtIsEmpty(const mxArray* mxCell);
/*
* MATLAB INTERNAL USE ONLY :: Create a numeric matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateNumericMatrix(int32_T m,
int32_T n,
int32_T classID,
int32_T nComplexFlag);
/*
* MATLAB INTERNAL USE ONLY :: Create a numeric matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateNumericArray(int32_T ndim,
const void* pdim,
int32_T classID,
int32_T nComplexFlag);
/*
* MATLAB INTERNAL USE ONLY :: Create a scaled numeric matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateScaledNumericArrayR2008b(int32_T ndim,
const void* pdim,
int32_T classID,
int32_T nComplexFlag,
int32_T aScale);
/*
* MATLAB INTERNAL USE ONLY :: Create a double scalar mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateDoubleScalar(real_T in);
/*
* MATLAB INTERNAL USE ONLY :: Create a logical matrix mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateLogicalArray(int32_T ndim, const int32_T* dims);
/*
* MATLAB INTERNAL USE ONLY :: Create a 2-D logical matrix mxArray
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtCreateLogicalMatrix(int32_T aN, int32_T aM);
/*
* MATLAB INTERNAL USE ONLY :: Create a logical scalar mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateLogicalScalar(boolean_T in);
/*
* MATLAB INTERNAL USE ONLY :: Create a character array mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateCharArray(int32_T ndim, const int32_T* dims);
/*
* MATLAB INTERNAL USE ONLY :: Create a FI mxArray from a value mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateFIR2013b(emlrtConstCTX aTLS,
const mxArray* fimath,
const mxArray* ntype,
const char* fitype,
const mxArray* fival,
const boolean_T fmIsLocal,
const boolean_T aForceComplex);
/*
* MATLAB INTERNAL USE ONLY :: Set the dimensions of an mxArray.
*/
EXTERN_C LIBEMLRT_API int32_T emlrtSetDimensions(mxArray* aMx, const int32_T* dims, int32_T ndims);
/*
* MATLAB INTERNAL USE ONLY :: Get the intarray from a FI mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtImportFiIntArrayR2008b(const mxArray* aFiMx);
/*
* MATLAB INTERNAL USE ONLY :: Get the enum int32_T from an MCOS enumeration mxArray.
*/
EXTERN_C LIBEMLRT_API int32_T emlrtGetEnumElementR2009a(const mxArray* aEnum, int32_T aIndex);
/*
* MATLAB INTERNAL USE ONLY :: Get the enum int32_T from an MCOS enumeration mxArray.
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtGetEnumUnderlyingArrayR2009a(const mxArray* aEnum);
/*
* MATLAB INTERNAL USE ONLY :: Convert MATLAB mxArray data format to C data format
*/
EXTERN_C LIBEMLRT_API void emlrtMatlabDataToCFormat(const mxArray* inputMx,
const mxArray* cformatMx);
/*
* MATLAB INTERNAL USE ONLY :: Convert C data format to MATLAB data format
*/
EXTERN_C LIBEMLRT_API void emlrtMatlabDataFromCFormat(const mxArray* outputMx,
const mxArray* cformatMx);
/*
* MATLAB INTERNAL USE ONLY :: Try to coerce mxArray to provided class; return same mxArray if not
* possible.
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCoerceToClassR2014b(const mxArray* inputMx,
const char* className);
/*
* MATLAB INTERNAL USE ONLY :: Destroy an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtDestroyArray(const mxArray** pa);
/*
* MATLAB INTERNAL USE ONLY :: Destroy an mxArray R2017a
*/
EXTERN_C LIBEMLRT_API void emlrtDestroyArrayR2017a(mxArray* pa);
/*
* MATLAB INTERNAL USE ONLY :: Destroy a vector of mxArrays
*/
EXTERN_C LIBEMLRT_API void emlrtDestroyArrays(int32_T narrays, const mxArray** parrays);
/*
* MATLAB INTERNAL USE ONLY :: Free the imaginary part of a matrix if all the imaginary elements are
* zero
*/
EXTERN_C LIBEMLRT_API void emlrtFreeImagIfZero(const mxArray* pa);
/*
* MATLAB INTERNAL USE ONLY :: Display an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtDisplayR2012b(const mxArray* pa,
const char* name,
emlrtMCInfo* aLoc,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Double check parameters
*/
typedef struct {
int32_T lineNo;
int32_T colNo;
const char* fName;
const char* pName;
int32_T checkKind; /* see src/cg_ir/base/Node.hpp::CG_Node_CheckEnum */
} emlrtDCInfo;
/*
* MATLAB INTERNAL USE ONLY :: Check that d can be safely cast to int.
*/
EXTERN_C LIBEMLRT_API real_T emlrtIntegerCheckR2012b(real_T d,
emlrtDCInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Check that d is not NaN.
*/
EXTERN_C LIBEMLRT_API real_T emlrtNotNanCheckR2012b(real_T d,
emlrtDCInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Check that d >= 0.
*/
EXTERN_C LIBEMLRT_API real_T emlrtNonNegativeCheckR2012b(real_T d,
emlrtDCInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Check that the loop has an integer number of iterations.
*/
EXTERN_C LIBEMLRT_API void emlrtForLoopVectorCheckR2012b(real_T start,
real_T step,
real_T end,
mxClassID classID,
int32_T n,
emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Check that the loop range is valid for code generation.
*/
EXTERN_C LIBEMLRT_API void emlrtForLoopVectorCheckR2021a(real_T start,
real_T step,
real_T end,
mxClassID classID,
int32_T n,
emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: fetch a global variable
*/
EXTERN_C LIBEMLRT_API void emlrtPutGlobalVariable(const char* name, const mxArray* parray);
/*
* MATLAB INTERNAL USE ONLY :: fetch a global variable
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtGetGlobalVariable(const char* name);
/*
* MATLAB INTERNAL USE ONLY :: Call out to MATLAB to report error from MLFB/Stateflow
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtSFCallMATLABReportError(emlrtConstCTX aTLS,
emlrtMCInfo* aLoc,
int32_T nrhs,
const mxArray** prhs);
/*
* MATLAB INTERNAL USE ONLY :: Extract the C stack from emlrtConstCtx
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtExtractStack(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Call out to MATLAB
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCallMATLABR2012b(emlrtConstCTX aTLS,
int32_T nlhs,
const mxArray** plhs,
int32_T nrhs,
const mxArray** prhs,
const char* cmd,
boolean_T tmp,
emlrtMCInfo* aLoc);
/*
* MATLAB INTERNAL USE ONLY :: malloc for MEX
*/
EXTERN_C LIBEMLRT_API void* emlrtMallocMex(size_t aSize);
/*
* MATLAB INTERNAL USE ONLY :: calloc for MEX
*/
EXTERN_C LIBEMLRT_API void* emlrtCallocMex(size_t aNum, size_t aSize);
/*
* MATLAB INTERNAL USE ONLY :: free for MEX
*/
EXTERN_C LIBEMLRT_API void emlrtFreeMex(void* aPtr);
/*
* MATLAB INTERNAL USE ONLY :: malloc for EmxArrays
*/
EXTERN_C LIBEMLRT_API void* emlrtMallocEmxArray(size_t aSize);
/*
* MATLAB INTERNAL USE ONLY :: free for EmxArrays
*/
EXTERN_C LIBEMLRT_API void emlrtFreeEmxArray(void* aPtr);
/*
* MATLAB INTERNAL USE ONLY :: Enter a new function within a MEX call.
*/
EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackEnterFcnR2012b(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Enter a new function within a MEX call.
*/
EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackEnterFcn(void);
/*
* MATLAB INTERNAL USE ONLY :: Leave a scope within a MEX call.
*/
EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackLeaveScope(emlrtConstCTX aTLS,
int32_T aAllocCount);
/*
* MATLAB INTERNAL USE ONLY :: Leave a function within a MEX call.
*/
EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackLeaveFcnR2012b(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Leave a function within a MEX call.
*/
EXTERN_C LIBEMLRT_API void emlrtHeapReferenceStackLeaveFcn(void);
EXTERN_C LIBEMLRT_API void emlrtPushHeapReferenceStackR2021a(emlrtConstCTX aTLS,
bool aNeedStack,
void* aHeapReference,
void* aFreeFcn,
void* aSimStruct,
void* aJITInstance,
void* aStackData);
/*
* MATLAB INTERNAL USE ONLY :: Push emxArray onto heap reference stack.
*/
EXTERN_C LIBEMLRT_API void emlrtPushHeapReferenceStackEmxArray(emlrtConstCTX aTLS,
bool aNeedStack,
void* aHeapReference,
void* aFreeFcn,
void* aSimStruct,
void* aJITInstance,
void* aStackData);
EXTERN_C LIBEMLRT_API void emlrtRemoveHeapReference(emlrtConstCTX aTLS, void* aHeapReference);
/*
* MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack.
*/
EXTERN_C LIBEMLRT_API void emlrtSetGlobalSyncFcn(emlrtConstCTX aTLS, void* aSyncFcn);
/*
* MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack.
*/
EXTERN_C LIBEMLRT_API void emlrtSetGlobalSyncFcnWithSD(emlrtConstCTX aTLS,
void* aStackData,
void* aSyncFcn);
/*
* MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack.
*/
EXTERN_C LIBEMLRT_API void emlrtSetJITGlobalSyncFcn(emlrtConstCTX aTLS,
void* aJITInstance,
void* aSyncFcn);
/*
* MATLAB INTERNAL USE ONLY :: Push a new entry to the heap reference stack.
*/
EXTERN_C LIBEMLRT_API void emlrtSetJITGlobalSyncFcnWithSD(emlrtConstCTX aTLS,
void* aJITInstance,
void* aStackData,
void* aSyncFcn);
/*
* MATLAB INTERNAL USE ONLY :: Initialize a character mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtInitCharArrayR2013a(emlrtConstCTX aTLS,
int32_T n,
const mxArray* a,
const char* s);
/*
* MATLAB INTERNAL USE ONLY :: Initialize a logical mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtInitLogicalArray(int32_T n, const mxArray* a, const boolean_T* b);
/*
* MATLAB INTERNAL USE ONLY :: Initialize an integral array from a multiword type
*/
EXTERN_C LIBEMLRT_API void emlrtInitIntegerArrayFromMultiword(const mxArray* aOut,
const void* aInData);
/*
* MATLAB INTERNAL USE ONLY :: Export a numeric mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtExportNumericArrayR2013b(emlrtConstCTX aTLS,
const mxArray* aOut,
const void* aInData,
int32_T aElementSize);
/*
* MATLAB INTERNAL USE ONLY :: Auto-generated mexFunction
*/
typedef void (*emlrtMexFunction)(int, mxArray*[], int, const mxArray*[]);
/*
* MATLAB INTERNAL USE ONLY :: Auto-generated entry-point
*/
typedef struct emlrtEntryPoint {
const char* fName;
emlrtMexFunction fMethod;
} emlrtEntryPoint;
/*
* MATLAB INTERNAL USE ONLY :: Lookup an entry point
*/
EXTERN_C LIBEMLRT_API int32_T emlrtGetEntryPointIndexR2016a(emlrtConstCTX aTLS,
int32_T nrhs,
const mxArray* prhs[],
const char* aEntryPointNames[],
int32_T aNumEntryPoints);
/*
* MATLAB INTERNAL USE ONLY :: Decode wide character strings in mxArray struct array.
* The struct array consists of name resolution entries which may contain file paths.
* If the file path is using UTF-8, then the string is plain 7-bit ASCII but encoded.
* We need to decode those if necessary. The resulting mxArray strings (for file paths)
* will be proper UTF-16 strings.
*/
EXTERN_C LIBEMLRT_API void emlrtNameCapturePostProcessR2013b(const mxArray** mxInfo);
/*
* MATLAB INTERNAL USE ONLY :: Decode string array into mxArray object containing
* name resolution data.
*/
EXTERN_C LIBEMLRT_API void emlrtNameCaptureMxArrayR2016a(const char* mxInfoEncoded[],
uint32_T uncompressedSize,
const mxArray** mxInfo);
/*
* MATLAB INTERNAL USE ONLY :: Parallel runtime error exception
*/
#ifdef __cplusplus
class EmlrtParallelRunTimeError {
public:
EmlrtParallelRunTimeError();
EmlrtParallelRunTimeError(const EmlrtParallelRunTimeError& e);
~EmlrtParallelRunTimeError();
};
#endif
/*
* MATLAB INTERNAL USE ONLY :: Report if we are in a parallel region
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtIsInParallelRegion(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Enter a parallel region.
*/
EXTERN_C LIBEMLRT_API void emlrtEnterParallelRegion(emlrtConstCTX aTLS,
boolean_T aInParallelRegion);
/*
* MATLAB INTERNAL USE ONLY :: Exit a parallel region.
*/
EXTERN_C LIBEMLRT_API void emlrtExitParallelRegion(emlrtConstCTX aTLS, boolean_T aInParallelRegion);
/*
* MATLAB INTERNAL USE ONLY :: Check if we're running on the MATLAB thread.
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtIsMATLABThread(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Record the occurrence of a parallel warning.
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtSetWarningFlag(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Report a parallel runtime error
*/
EXTERN_C LIBEMLRT_API void emlrtReportParallelRunTimeError(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Ensure active thread is MATLAB
*/
EXTERN_C LIBEMLRT_API void emlrtAssertMATLABThread(emlrtConstCTX aTLS, emlrtMCInfo* aLoc);
/*
* MATLAB INTERNAL USE ONLY :: Push the current jmp_buf environment
*/
EXTERN_C LIBEMLRT_API void emlrtPushJmpBuf(emlrtConstCTX aTLS, jmp_buf* volatile* aJBEnviron);
/*
* MATLAB INTERNAL USE ONLY :: Pop the current jmp_buf environment
*/
EXTERN_C LIBEMLRT_API void emlrtPopJmpBuf(emlrtConstCTX aTLS, jmp_buf* volatile* aJBEnviron);
/*
* MATLAB INTERNAL USE ONLY :: Set the current jmp_buf environment
*/
EXTERN_C LIBEMLRT_API void emlrtSetJmpBuf(emlrtConstCTX aTLS, jmp_buf* aJBEnviron);
/*
* MATLAB INTERNAL USE ONLY :: Get the current jmp_buf environment
*/
EXTERN_C LIBEMLRT_API jmp_buf* emlrtGetJmpBuf(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Create a shallow copy of an mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrtCreateReference(const mxArray* pa);
/*
* MATLAB INTERNAL USE ONLY :: Division by zero error
*/
EXTERN_C LIBEMLRT_API void emlrtDivisionByZeroErrorR2012b(const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
EXTERN_C LIBEMLRT_API void emlrtDivisionByZeroWarningOrError2018b(const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Integer overflow error
*/
EXTERN_C LIBEMLRT_API void emlrtIntegerOverflowErrorR2012b(const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
EXTERN_C LIBEMLRT_API void emlrtIntegerOverflowWarningOrError2018b(const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Raise C heap allocation failure
*/
EXTERN_C LIBEMLRT_API void emlrtHeapAllocationErrorR2012b(const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Error with given message ID and args.
*/
EXTERN_C LIBEMLRT_API void emlrtErrorWithMessageIdR2018a(emlrtConstCTX aTLS,
const emlrtRTEInfo* aInfo,
const char* aMsgID,
const char* aReportID,
int aArgCount,
...);
/*
* MATLAB INTERNAL USE ONLY :: Error with given message ID and args.
*/
EXTERN_C LIBEMLRT_API void emlrtErrorWithMessageIdR2012b(emlrtConstCTX aTLS,
const emlrtRTEInfo* aInfo,
const char* aMsgID,
int32_T aArgCount,
...);
/*
* MATLAB INTERNAL USE ONLY :: Error with given message ID and args.
*/
EXTERN_C LIBEMLRT_API void emlrtErrMsgIdAndTxt(emlrtCTX aTLS,
const char* aMsgID,
int32_T aArgCount,
...);
/*
* MATLAB INTERNAL USE ONLY :: Error with given message ID and explicit message text.
*/
EXTERN_C LIBEMLRT_API void emlrtErrMsgIdAndExplicitTxt(emlrtConstCTX aTLS,
const emlrtRTEInfo* aInfo,
const char* aMsgID,
int32_T aStrlen,
const char* aMsgTxt);
/*
* MATLAB INTERNAL USE ONLY :: Convert a message ID to a heap-allocated LCP string.
* This function is used by Stateflow run-time library only.
*/
EXTERN_C LIBEMLRT_API char* emlrtTranslateMessageIDtoLCPstring(const char* aMsgID);
/*
* MATLAB INTERNAL USE ONLY :: Convert a UTF16 message string to a heap-allocated LCP string.
* This function is used by Stateflow run-time library only.
*/
EXTERN_C LIBEMLRT_API char* emlrtTranslateUTF16MessagetoLCPstring(const CHAR16_T* aUTF16Msg);
typedef struct {
const char* MexFileName;
const char* TimeStamp;
const char* buildDir;
int32_T numFcns;
int32_T numHistogramBins;
} emlrtLocationLoggingFileInfoType;
typedef struct {
const char* FunctionName;
int32_T FunctionID;
int32_T numInstrPoints;
} emlrtLocationLoggingFunctionInfoType;
typedef struct {
real_T NumberOfZeros;
real_T NumberOfPositiveValues;
real_T NumberOfNegativeValues;
real_T TotalNumberOfValues;
real_T SimSum;
real_T HistogramOfPositiveValues[256];
real_T HistogramOfNegativeValues[256];
} emlrtLocationLoggingHistogramType;
typedef struct {
real_T SimMin;
real_T SimMax;
int32_T OverflowWraps;
int32_T Saturations;
boolean_T IsAlwaysInteger;
emlrtLocationLoggingHistogramType* HistogramTable;
} emlrtLocationLoggingDataType;
typedef struct {
int32_T MxInfoID;
int32_T TextStart;
int32_T TextLength;
int16_T Reason;
boolean_T MoreLocations;
} emlrtLocationLoggingLocationType;
/*
* MATLAB INTERNAL USE ONLY :: Get LocationLogging Info
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtLocationLoggingPullLog(const char* const MexFileName,
boolean_T pullCompReportFromMexFunction);
/*
* MATLAB INTERNAL USE ONLY :: Save LocationLogging Info
*/
EXTERN_C LIBEMLRT_API void emlrtLocationLoggingPushLog(
const emlrtLocationLoggingFileInfoType* const fileInfo,
const emlrtLocationLoggingFunctionInfoType* const functionInfoTable,
const emlrtLocationLoggingDataType* const dataTables,
const emlrtLocationLoggingLocationType* const locationTables,
const uint8_T* serializedReport,
size_t sizeofSerializedReport,
const int32_T* numFieldsTables,
const char** fieldNamesTables);
/*
* MATLAB INTERNAL USE ONLY :: Save LocationLogging Info
*/
EXTERN_C LIBEMLRT_API void emlrtLocationLoggingPushLogR2017a(
const emlrtLocationLoggingFileInfoType* const fileInfo,
const emlrtLocationLoggingFunctionInfoType* const functionInfoTable,
const emlrtLocationLoggingDataType* const dataTables,
const emlrtLocationLoggingLocationType* const locationTables,
const int32_T* numFieldsTables,
const char** fieldNamesTables,
const char* serializedReport[],
size_t sizeofSerializedReport);
/*
* MATLAB INTERNAL USE ONLY :: Clear LocationLogging Info
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtLocationLoggingClearLog(const char* const MexFileName);
/*
* MATLAB INTERNAL USE ONLY :: List entries in LocationLogging Info
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtLocationLoggingListLogs(void);
/*
* MATLAB INTERNAL USE ONLY :: Add instrumentation results to FPT Repository
*/
EXTERN_C LIBEMLRT_API void addResultsToFPTRepository(const char* const blkSID);
/*
* MATLAB INTERNAL USE ONLY :: Initialize a runtime stack
*/
EXTERN_C LIBEMLRT_API void emlrtEnterRtStackR2012b(emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Terminate a runtime stack
*/
EXTERN_C LIBEMLRT_API void emlrtLeaveRtStackR2012b(emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Push to runtime stack
*/
EXTERN_C LIBEMLRT_API void emlrtPushRtStackR2012b(const struct emlrtRSInfo* aRSInfo, emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Pop from runtime stack
*/
EXTERN_C LIBEMLRT_API void emlrtPopRtStackR2012b(const struct emlrtRSInfo* aRSInfo, emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Get the address of the Ctrl-C flag.
*/
EXTERN_C LIBEMLRT_API const volatile char* emlrtGetBreakCheckFlagAddressR2012b(void);
/*
* MATLAB INTERNAL USE ONLY :: Check for Ctrl+C (break)
*/
EXTERN_C LIBEMLRT_API void emlrtBreakCheckR2012b(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Equality check for 1-D sizes
*/
EXTERN_C LIBEMLRT_API void emlrtSizeEqCheck1DR2012b(int32_T dim1,
int32_T dim2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Equality check error for size vectors
*/
EXTERN_C LIBEMLRT_API void emlrtSizeEqCheckNDErrorR2021b(const int32_T* dims1,
const int32_T* dims2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Equality check for size vectors
*/
EXTERN_C LIBEMLRT_API void emlrtSizeEqCheckNDR2012b(const int32_T* dims1,
const int32_T* dims2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: equality check
*/
EXTERN_C LIBEMLRT_API void emlrtDimSizeEqCheckR2012b(int32_T dim1,
int32_T dim2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: greater than or equal to check
*/
EXTERN_C LIBEMLRT_API void emlrtDimSizeGeqCheckR2012b(int32_T dim1,
int32_T dim2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: equality or singleton check
*/
EXTERN_C LIBEMLRT_API void emlrtDimSizeImpxCheckR2021b(int32_T dim1,
int32_T dim2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Check size compatibility for A(I1,..IN) = B assignment in MATLAB.
*/
EXTERN_C LIBEMLRT_API void emlrtSubAssignSizeCheckR2012b(const int32_T* dims1,
int32_T nDims1,
const int32_T* dims2,
int32_T nDims2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Check size compatibility for A(I) = B assignment in MATLAB.
*/
EXTERN_C LIBEMLRT_API void emlrtSubAssignSizeCheck1dR2017a(int32_T dim1,
int32_T dim2,
emlrtECInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Allocate thread-local storage.
*/
EXTERN_C LIBEMLRT_API void* emlrtAllocTLS(emlrtConstCTX aMaster, int32_T aTeamTID);
/*
* MATLAB INTERNAL USE ONLY :: Allocate thread local storage for a parallel region.
*/
EXTERN_C LIBEMLRT_API int32_T emlrtAllocRegionTLSs(emlrtCTX aTLS,
boolean_T aInParallelRegion,
int32_T aMaxThreads,
int32_T aNumThreads);
/*
* MATLAB INTERNAL USE ONLY :: Allocate the root thread-local storage.
*/
EXTERN_C LIBEMLRT_API void emlrtUpdateCTX(emlrtConstCTX emlrtCtx, struct emlrtContext* aContext);
/*
* MATLAB INTERNAL USE ONLY :: Allocate the root thread-local storage.
*/
EXTERN_C LIBEMLRT_API void emlrtCreateRootTLSR2021a(emlrtCTX* aRootTLS,
struct emlrtContext* aContext,
EmlrtLockerFunction aLockerFunction,
int32_T aNumProcs,
void* aExceptionBridge);
/*
* MATLAB INTERNAL USE ONLY :: Deallocate the root thread-local storage.
*/
EXTERN_C LIBEMLRT_API void emlrtDestroyRootTLS(emlrtCTX* aRootTLS);
EXTERN_C LIBEMLRT_API void emlrtSetIsInDestructor(emlrtCTX aTLS, bool aValue);
EXTERN_C LIBEMLRT_API void emlrtShouldCleanupOnError(emlrtCTX aTLS, bool aValue);
EXTERN_C LIBEMLRT_API void emlrtCleanupOnException(emlrtCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Set Jit Simulation Mode.
*/
EXTERN_C LIBEMLRT_API void emlrtSetSimThruJIT(emlrtCTX aTLS, boolean_T aSimThruJIT);
EXTERN_C LIBEMLRT_API char* emlrtExtractMessageId2015b(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId);
/*
* MATLAB INTERNAL USE ONLY :: Check the class of an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckClass(const char* msgName,
const mxArray* pa,
const char* className);
/*
* MATLAB INTERNAL USE ONLY :: Check the class of an mxArray pa to be exactly aClassName, otherwise
* error out using aMsgId and aTLS.
*/
EXTERN_C LIBEMLRT_API void emlrtCheckMcosClass2017a(emlrtConstCTX aTLS,
const emlrtMsgIdentifier* aMsgId,
const mxArray* pa,
const char* aClassName);
/*
* MATLAB INTERNAL USE ONLY :: Check the contents of two mxArrays to be equal.
*/
EXTERN_C LIBEMLRT_API void emlrtCheckCtMxArray2018b(emlrtConstCTX aTLS,
const emlrtMsgIdentifier* aMsgId,
const mxArray* rtArray,
const mxArray* ctArray);
/*
* MATLAB INTERNAL USE ONLY :: Check the size, class and complexness of an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckBuiltInR2012b(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* pa,
const char* className,
boolean_T complex,
uint32_T nDims,
const void* pDims);
/*
* MATLAB INTERNAL USE ONLY :: Check the size, class and complexness of a variable-size mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckVsBuiltInR2012b(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* pa,
const char* className,
boolean_T complex,
uint32_T nDims,
const void* pDims,
const boolean_T* aDynamic,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a FI mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckFiR2012b(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* aFi,
boolean_T aComplex,
uint32_T aNDims,
const void* aVDims,
const mxArray* aFimath,
const mxArray* aNumericType);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a variable-size FI mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckVsFiR2012b(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* aFi,
boolean_T aComplex,
uint32_T aNDims,
const void* aVDims,
const boolean_T* aDynamic,
const mxArray* aFimath,
const mxArray* aNumericType);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a static-size struct mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckStructR2012b(emlrtConstCTX aTLS,
const emlrtMsgIdentifier* aMsgId,
const mxArray* s,
int32_T nFields,
const char** fldNames,
uint32_T nDims,
const void* pDims);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a variable-size struct mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckVsStructR2012b(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* s,
int32_T nFields,
const char** fldNames,
uint32_T nDims,
const void* pDims,
const boolean_T* aDynamic,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Check the checksum of an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckArrayChecksumR2018b(emlrtConstCTX,
mxArray const*,
boolean_T globalVar,
int const*,
const char**,
uint32_T const*);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a static-size struct mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckEnumR2012b(emlrtConstCTX aTLS,
const char* enumName,
int32_T nEnumElements,
const char** enumNames,
const int32_T* enumValues);
/*
* MATLAB INTERNAL USE ONLY :: Import a character array.
*/
EXTERN_C LIBEMLRT_API void emlrtImportCharArrayR2015b(emlrtConstCTX aTLS,
const mxArray* aSrc,
char_T* aDst,
int32_T aNumel);
/*
* MATLAB INTERNAL USE ONLY :: Import a character.
*/
EXTERN_C LIBEMLRT_API void emlrtImportCharR2015b(emlrtConstCTX aTLS,
const mxArray* aSrc,
char_T* aDst);
/*
* MATLAB INTERNAL USE ONLY :: Set the actual size of a variable-size array
*/
EXTERN_C LIBEMLRT_API void emlrtSetVsSizesR2008b(const mxArray* pa,
uint32_T nDimsMax,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Import an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtImportArrayR2015b(emlrtConstCTX aTLS,
const mxArray* aIn,
void* aOutData,
int32_T aElementSize,
boolean_T aComplex);
/*
* MATLAB INTERNAL USE ONLY :: Import an mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtImportArrayR2015b_SameComplex(emlrtConstCTX aTLS,
const mxArray* aIn,
void* aOutData,
int32_T aElementSize);
/*
* MATLAB INTERNAL USE ONLY :: Import a FI mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtImportVsFiArrayR2011b(const mxArray* aFiMx,
const mxArray* aIntMx,
void* aOutData,
int32_T aElementSize,
boolean_T aComplex,
uint32_T nDimsMax,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Set the actual sizes of a dynamic FI array
*/
EXTERN_C LIBEMLRT_API void emlrtSetVsFiSizes(const mxArray* aFi,
uint32_T nDimsExpected,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Get double uniform random values in (0,1)
*/
EXTERN_C LIBEMLRT_API void emlrtRandu(real_T* const aRanduBuffer, const int32_T aNumel);
/*
* MATLAB INTERNAL USE ONLY :: Get double normal random values
*/
EXTERN_C LIBEMLRT_API void emlrtRandn(real_T* const aRandnBuffer, const int32_T aNumel);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a static-sized cell mxArray
*/
EXTERN_C LIBEMLRT_API void emlrtCheckCell(emlrtConstCTX aTLS,
const emlrtMsgIdentifier* aMsgId,
const mxArray* s,
uint32_T nDims,
const void* pDims,
const boolean_T* aDynamic);
/*
* MATLAB INTERNAL USE ONLY :: Check the type of a variable-sized cell mxArray
* and assign the size of the mxArray to aOutSizes
*/
EXTERN_C LIBEMLRT_API void emlrtCheckVsCell(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* s,
uint32_T nDims,
const void* pDims,
const boolean_T* aDynamic,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Check a cell mxArray with unassigned base type
*/
EXTERN_C LIBEMLRT_API void emlrtCheckCellWithUnassignedBase(emlrtConstCTX aTLS,
const struct emlrtMsgIdentifier* aMsgId,
const mxArray* pa);
/*
* MATLAB INTERNAL USE ONLY :: Get the library path of a function pointer
*/
EXTERN_C LIBEMLRT_API const char* emlrtGetLibraryPath(const void* pFcn);
/*
* MATLAB INTERNAL USE ONLY :: emlrt strlen function
*/
EXTERN_C LIBEMLRT_API size_t emlrtStrlen(const char*);
/*
* MATLAB INTERNAL USE ONLY :: FFTW MEX Wrapper
*/
EXTERN_C LIBEMLRT_API void* emlrtFFTWMalloc(size_t aSize);
EXTERN_C LIBEMLRT_API void emlrtFFTWFree(void* data);
/*
* MATLAB INTERNAL USE ONLY :: Double 1D complex to complex FFT, this function assumes in and out to
* be interleaved complex.
*/
EXTERN_C LIBEMLRT_API void emlrtFFTW_1D_C2C(const real_T* in,
real_T* out,
int32_T stride,
int32_T fftLen,
int32_T ldx,
int32_T numFFT,
int32_T direction);
EXTERN_C LIBEMLRT_API void emlrtFFTW_1D_R2C(const real_T* in,
real_T* out,
int32_T stride,
int32_T fftLen,
int32_T ldx,
int32_T numFFT,
int32_T direction);
EXTERN_C LIBEMLRT_API void emlrtFFTW_1D_C2R(const real_T* in,
real_T* out,
int32_T stride,
int32_T fftLen,
int32_T ldx,
int32_T numFFT,
int32_T direction);
/*
* MATLAB INTERNAL USE ONLY :: Float 1D complex to complex FFT, this function assumes in and out to
* be interleaved complex.
*/
EXTERN_C LIBEMLRT_API void emlrtFFTWF_1D_C2C(const real32_T* in,
real32_T* out,
int32_T stride,
int32_T fftLen,
int32_T ldx,
int32_T numFFT,
int32_T direction);
EXTERN_C LIBEMLRT_API void emlrtFFTWF_1D_R2C(const real32_T* in,
real32_T* out,
int32_T stride,
int32_T fftLen,
int32_T ldx,
int32_T numFFT,
int32_T direction);
EXTERN_C LIBEMLRT_API void emlrtFFTWF_1D_C2R(const real32_T* in,
real32_T* out,
int32_T stride,
int32_T fftLen,
int32_T ldx,
int32_T numFFT,
int32_T direction);
/*
* MATLAB INTERNAL USE ONLY :: Setter and getter for FFTW plan method.
*/
EXTERN_C LIBEMLRT_API const char* emlrtFFTWGetPlanMethod(void);
EXTERN_C LIBEMLRT_API void emlrtFFTWSetPlanMethod(const char* method);
/*
* MATLAB INTERNAL USE ONLY :: Double FFTW plan import/export/delete.
*/
EXTERN_C LIBEMLRT_API char* emlrtFFTWExportDoublePlan(void);
EXTERN_C LIBEMLRT_API void emlrtFFTWImportDoublePlan(const char* aPlanStr);
EXTERN_C LIBEMLRT_API void emlrtFFTWForgetDoublePlan(void);
/*
* MATLAB INTERNAL USE ONLY :: Double FFTW plan import/export/delete.
*/
EXTERN_C LIBEMLRT_API char* emlrtFFTWExportSinglePlan(void);
EXTERN_C LIBEMLRT_API void emlrtFFTWImportSinglePlan(const char* aPlanStr);
EXTERN_C LIBEMLRT_API void emlrtFFTWForgetSinglePlan(void);
/*
* MATLAB INTERNAL USE ONLY :: Force FFTW to run with single thread or not.
*/
EXTERN_C LIBEMLRT_API void emlrtFFTWSetNumThreads(int32_T numThreads);
/*
* MATLAB INTERNAL USE ONLY :: Check LXE profiler status
*/
EXTERN_C LIBEMLRT_API void emlrtCheckProfilerStatus();
#ifndef __cplusplus
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Function Entry
*/
EXTERN_C LIBEMLRT_API void emlrtMEXProfilingFunctionEntry(const char* fcnUniqKey,
boolean_T isMexOutdated);
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Function Exit
*/
EXTERN_C LIBEMLRT_API void emlrtMEXProfilingFunctionExit(boolean_T isMexOutdated);
#else
// Need a sentinel class to make sure call stack is correct during stack unwinding
struct LIBEMLRT_API emlrtProfilerSentinel {
emlrtProfilerSentinel();
~emlrtProfilerSentinel();
bool Initialized;
bool AlreadyExit;
private:
emlrtProfilerSentinel& operator=(const emlrtProfilerSentinel&);
emlrtProfilerSentinel(const emlrtProfilerSentinel&);
};
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Function Entry
*/
LIBEMLRT_API void emlrtMEXProfilingFunctionEntryCPP(const char* fcnUniqKey,
boolean_T isMexOutdated,
emlrtProfilerSentinel* aSentinel);
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Function Exit
*/
LIBEMLRT_API void emlrtMEXProfilingFunctionExitCPP(emlrtProfilerSentinel* aSentinel);
#endif
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Unregister Function
*/
EXTERN_C LIBEMLRT_API void emlrtProfilerUnregisterMEXFcn(const char* fcnUniqKey,
boolean_T isMexOutdated);
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Register Function
*/
EXTERN_C LIBEMLRT_API void emlrtProfilerRegisterMEXFcn(const char* completeName,
const char* aPath,
const char* aFcnName,
int32_T numLineNos,
const int32_T* lineNos,
boolean_T isMexOutdated);
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Profile Statement
*/
EXTERN_C LIBEMLRT_API void emlrtMEXProfilingStatement(uint32_T aPoint, boolean_T isMexOutdated);
/*
* MATLAB INTERNAL USE ONLY :: MEX Profiling Check MEX File Outdated Function
*/
EXTERN_C LIBEMLRT_API boolean_T emlrtProfilerCheckMEXOutdated(void);
/*
* MATLAB INTERNAL USE ONLY :: Report a detected CUDA runtime error
*/
EXTERN_C LIBEMLRT_API void emlrtCUDAError(uint32_T errcode,
const char* ename,
const char* emsg,
const emlrtRTEInfo* aInfo,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Report a detected CUDA runtime error as a warning
* useful for capturing errors within destructors and throwing those as warnings, so that
* MATLAB does not crash for MEX builds
*/
EXTERN_C LIBEMLRT_API void emlrtCUDAWarning(uint32_T errcode,
const char* ename,
const char* emsg,
const emlrtRTEInfo* aInfo);
/*
* MATLAB INTERNAL USE ONLY :: Report a detected CUDA runtime error (light API)
*/
EXTERN_C LIBEMLRT_API void emlrtThinCUDAError(uint32_T errcode,
const char* ename,
const char* emsg,
const char* paramname,
emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Wrapper of several mxArray Apis
*/
EXTERN_C LIBEMLRT_API void* emlrtMxCalloc(size_t numEl, size_t elSize);
EXTERN_C LIBEMLRT_API void emlrtMxFree(void* in);
EXTERN_C LIBEMLRT_API mxArray* emlrtMxCreateString(const char* aStr);
EXTERN_C LIBEMLRT_API mxArray* emlrtMxCreateDoubleScalar(double v);
EXTERN_C LIBEMLRT_API void* emlrtMxGetData(const mxArray* aMxArray);
EXTERN_C LIBEMLRT_API void emlrtMxSetData(mxArray* aMxArray, void* data);
EXTERN_C LIBEMLRT_API real_T* emlrtMxGetPr(const mxArray* aMxArray);
EXTERN_C LIBEMLRT_API boolean_T* emlrtMxGetLogicals(const mxArray* aMxArray);
EXTERN_C LIBEMLRT_API void* emlrtMxGetImagData(const mxArray* aMxArray);
EXTERN_C LIBEMLRT_API double* emlrtMxGetPi(const mxArray* aMxArray);
EXTERN_C LIBEMLRT_API const mxArray* emlrtMexGetVariablePtr(const char* workspace,
const char* varname);
/*
* MATLAB INTERNAL USE ONLY :: Initilize mxArray from multiword fixed point
*/
EXTERN_C LIBEMLRT_API void emlrtInitMultiwordFXP(const mxArray* mxArray,
const void* inData,
int32_T scaleFactor);
EXTERN_C LIBEMLRT_API char* emlrtGetEnv(const char* aName);
EXTERN_C LIBEMLRT_API void emlrtSetEnv(const char* aName, const char* aVal);
EXTERN_C LIBEMLRT_API void emlrtCaptureInputs(const mxArray** data,
int32_T numInputs,
void* aFcnPtr);
/*
* MATLAB INTERNAL USE ONLY :: Create a numeric matrix mxGPUArray
*/
EXTERN_C LIBEMLRT_API mxGPUArray* emlrtGPUCreateNumericArray(const char* className,
boolean_T nComplexFlag,
int32_T ndim,
const void* pdim);
/*
* MATLAB INTERNAL USE ONLY :: Get read only GPU device pointer from mxGpuArray
*/
EXTERN_C LIBEMLRT_API const void* emlrtGPUGetDataReadOnly(const mxGPUArray* inArray);
/*
* MATLAB INTERNAL USE ONLY :: Get GPU device pointer from mxGpuArray
*/
EXTERN_C LIBEMLRT_API void* emlrtGPUGetData(mxGPUArray* inArray);
/*
* MATLAB INTERNAL USE ONLY :: Get class name from class id
*/
EXTERN_C LIBEMLRT_API const char* emlrtClassIDToClassName(mxClassID classID);
/*
* MATLAB INTERNAL USE ONLY :: Marshall input mxArray and return mxGPUArray
*/
EXTERN_C LIBEMLRT_API const mxGPUArray* emlrt_marshallInGPU(emlrtConstCTX aTLS,
const mxArray* inArray,
const char* id,
const char* className,
boolean_T nComplexFlag,
int32_T ndim,
const void* pdim,
boolean_T marshallByRef);
/*
* MATLAB INTERNAL USE ONLY :: Marshall input mxArray and return mxGPUArray
*/
EXTERN_C LIBEMLRT_API const mxGPUArray* emlrt_marshallInGPUVardim(emlrtConstCTX aTLS,
const mxArray* inArray,
const char* id,
const char* className,
boolean_T nComplexFlag,
int32_T ndim,
const void* pdim,
boolean_T marshallByRef,
const boolean_T* aDynamic,
int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Marshall output mxGPUArray and return mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrt_marshallOutGPU(const mxGPUArray* inArray);
/*
* MATLAB INTERNAL USE ONLY :: Marshall output mxGPUArray and return mxArray
*/
EXTERN_C LIBEMLRT_API const mxArray* emlrt_marshallOutGPUVardim(mxGPUArray* const inArray,
const int32_T aNDims,
const int32_T* aOutSizes);
/*
* MATLAB INTERNAL USE ONLY :: Destroy GPUArray
*/
EXTERN_C LIBEMLRT_API void emlrtDestroyGPUArray(const mxGPUArray* inArray);
/*
* MATLAB INTERNAL USE ONLY :: Deep copy of input to protect it when modified
*/
EXTERN_C LIBEMLRT_API mxArray* emlrtProtectGPUArray(const mxArray* inArray);
/*
* MATLAB INTERNAL USE ONLY :: Deep copy of mxGPUArray
*/
EXTERN_C LIBEMLRT_API mxGPUArray* emlrtGPUCopyGPUArray(const mxGPUArray* inArray);
/*
* MATLAB INTERNAL USE ONLY :: Load gpu library
*/
EXTERN_C LIBEMLRT_API void emlrtInitGPU(emlrtConstCTX aTLS);
/*
* MATLAB INTERNAL USE ONLY :: Exit Time Cleanup
*/
EXTERN_C LIBEMLRT_API void emlrtExitTimeCleanup(struct emlrtContext*);
typedef struct emlrtTimespec {
double tv_sec;
double tv_nsec;
} emlrtTimespec;
/*
* MATLAB INTERNAL USE ONLY :: Get time using monotonic clock
*/
EXTERN_C LIBEMLRT_API int emlrtClockGettimeMonotonic(emlrtTimespec*);
typedef struct emlrtStructTm {
double tm_nsec;
double tm_sec;
double tm_min;
double tm_hour;
double tm_mday;
double tm_mon;
double tm_year;
boolean_T tm_isdst;
} emlrtStructTm;
/*
* MATLAB INTERNAL USE ONLY :: Get wallclock time
*/
EXTERN_C LIBEMLRT_API void emlrtWallclock(emlrtStructTm* aStructTm);
#if defined(_WIN32) || defined(WIN32)
/*
* MATLAB INTERNAL USE ONLY :: Wrapper for nanosleep
*/
EXTERN_C LIBEMLRT_API int emlrtSleepWin64(uint32_T aMilliSeconds);
#else
/*
* MATLAB INTERNAL USE ONLY :: Wrapper for nanosleep
*/
EXTERN_C LIBEMLRT_API int emlrtNanosleep(const emlrtTimespec*);
#endif /* defined(_WIN32) || defined(WIN32) */
/*
* MATLAB INTERNAL USE ONLY :: Sleep for some duration
*/
EXTERN_C LIBEMLRT_API int emlrtSleep(const emlrtTimespec* aEMLRTTimespec);
/*
* MATLAB INTERNAL USE ONLY :: Pause for user input like pause()
*/
EXTERN_C LIBEMLRT_API void emlrtPauseForInput(void);
EXTERN_C LIBEMLRT_API mxArray* emlrtMxCPUtoGPU(const mxArray* pa);
EXTERN_C LIBEMLRT_API mxArray* emlrtMxGPUtoCPU(const mxArray* pa);
/*
* MATLAB INTERNAL USE ONLY :: Profiling instrumentation APIs
*/
EXTERN_C LIBEMLRT_API void emlrtProfilingEnterFunction(const char* function,
uint32_T nBlocks,
uint32_T staticSize,
const char* filename,
uint32_T line);
#ifdef INT_TYPE_64_IS_SUPPORTED
EXTERN_C LIBEMLRT_API void emlrtProfilingNode(uint64_T aSequenceId,
uint64_T aNodeId,
uint64_T aTypeSequenceId,
const char* aSid);
EXTERN_C LIBEMLRT_API void emlrtProfilingNamedNode(uint64_T aSequenceId,
uint64_T aNodeId,
uint64_T aTypeSequenceId,
const char* aSid,
const char* aName);
EXTERN_C LIBEMLRT_API void emlrtProfilingType(uint64_T aTypeSequenceId,
uint64_T aTypeClassId,
uint64_T aTypeInstanceId,
uint64_T aTypeSize,
const char* aName);
#endif
EXTERN_C LIBEMLRT_API void emlrtProfilingExitFunction(void);
EXTERN_C LIBEMLRT_API void emlrtProfilingStart(void);
EXTERN_C LIBEMLRT_API void emlrtProfilingSave(void);
EXTERN_C LIBEMLRT_API void emlrtProfilingFinish(void);
EXTERN_C LIBEMLRT_API void emlrtProfilingClear(void);
/*
* MATLAB INTERNAL USE ONLY :: mxClassID for half mxArray.
*/
#ifndef mxHALF_CLASS
#define mxHALF_CLASS ((mxClassID)(-2357))
#endif
#endif /* emlrt_h */