diff options
Diffstat (limited to 'test/monniaux/tacle-bench-powerwindow/powerwindow_HeaderFiles/powerwindow_tmwtypes.h')
| -rw-r--r-- | test/monniaux/tacle-bench-powerwindow/powerwindow_HeaderFiles/powerwindow_tmwtypes.h | 821 |
1 files changed, 821 insertions, 0 deletions
diff --git a/test/monniaux/tacle-bench-powerwindow/powerwindow_HeaderFiles/powerwindow_tmwtypes.h b/test/monniaux/tacle-bench-powerwindow/powerwindow_HeaderFiles/powerwindow_tmwtypes.h new file mode 100644 index 00000000..7b1b7f34 --- /dev/null +++ b/test/monniaux/tacle-bench-powerwindow/powerwindow_HeaderFiles/powerwindow_tmwtypes.h @@ -0,0 +1,821 @@ +/* + + This program is part of the TACLeBench benchmark suite. + Version V 1.x + + Name: powerwindow_tmwtypes.h + + Author: CoSys-Lab, University of Antwerp + + Function: headerfile + + Source: https://github.com/tacle/tacle-bench/blob/master/bench/app/PowerWindow/powerwindow_HeaderFiles/powerwindow_tmwtypes.h + + Changes: a brief summary of major functional changes and formatting) + + License: GNU General Public License + + */ + +#if defined(_MSC_VER) +# pragma once +#endif +#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)) +# pragma once +#endif + +#ifndef powerwindow_tmwtypes_h +#define powerwindow_tmwtypes_h + +#ifndef powerwindow__TMWTYPES__ +#define powerwindow__TMWTYPES__ +/* + * File : tmwtypes.h + * Abstract: + * Data types for use with MATLAB/SIMULINK and the Real-Time Workshop. + * + * When compiling stand-alone model code, data types can be overridden + * via compiler switches. + * + * Define NO_FLOATS to eliminate reference to powerwindow_real_T, etc. + */ + + +#define LOGICAL_IS_A_TYPE +#define SPARSE_GENERALIZATION + +#ifdef NO_FLOATS +# define double double_not_allowed +# define float float_not_allowed +#endif /*NO_FLOATS*/ + + +/* + * The following data types cannot be overridden when building MEX files. + */ +#ifdef MATLAB_MEX_FILE +# undef CHARACTER_T +# undef INTEGER_T +# undef BOOLEAN_T +# undef REAL_T +# undef TIME_T +#endif + +/* + * The powerwindow_uchar_T, powerwindow_ushort_T and powerwindow_ulong_T types are needed for compilers which do + * not allow defines to be specified, at the command line, with spaces in them. + */ + +typedef unsigned char powerwindow_uchar_T; +typedef unsigned short powerwindow_ushort_T; +typedef unsigned long powerwindow_ulong_T; + +#if (defined(_MSC_VER) && _MSC_VER >= 1500) \ + || defined(__x86_64__) || defined(__LP64__) \ + || defined(__LCC64__) + +typedef unsigned long long powerwindow_ulonglong_T; +#endif + + + +/*=======================================================================* + * Fixed width word size data types: * + * powerwindow_int8_T, powerwindow_int16_T, powerwindow_int32_T - signed 8, 16, or 32 bit integers * + * powerwindow_uint8_T, powerwindow_uint16_T, powerwindow_uint32_T - unsigned 8, 16, or 32 bit integers * + * powerwindow_real32_T, powerwindow_real64_T - 32 and 64 bit floating point numbers * + *=======================================================================*/ + +/* When used with Real Time Workshop generated code, this + * header file can be used with a variety of compilers. + * + * The compiler could be for an 8 bit embedded processor that + * only had 8 bits per integer and 16 bits per long. + * In that example, a 32 bit integer size is not even available. + * This header file should be robust to that. + * + * For the case of an 8 bit processor, the preprocessor + * may be limited to 16 bit math like its target. That limitation + * would mean that 32 bit comparisons can't be done accurately. + * To increase robustness to this, comparisons are done against + * smaller values first. An inaccurate 32 bit comparison isn't + * attempted if the 16 bit comparison has already succeeded. + * + * Limitations on preprocessor math can also be stricter than + * for the target. There are known cases where a compiler + * targeting processors with 64 bit longs can't do accurate + * preprocessor comparisons on more than 32 bits. + */ + +/* Determine the number of bits for int, long, short, and char. + * If one fails to be determined, set the number of bits to -1 + */ + +#ifndef TMW_BITS_PER_INT +# if INT_MAX == 0x7FL +# define TMW_BITS_PER_INT 8 +# elif INT_MAX == 0x7FFFL +# define TMW_BITS_PER_INT 16 +# elif INT_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_INT 32 +# else +# define TMW_BITS_PER_INT -1 +# endif +#endif + +#ifndef TMW_BITS_PER_LONG +# if LONG_MAX == 0x7FL +# define TMW_BITS_PER_LONG 8 +# elif LONG_MAX == 0x7FFFL +# define TMW_BITS_PER_LONG 16 +# elif LONG_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_LONG 32 +# else +# define TMW_BITS_PER_LONG -1 +# endif +#endif + +#ifndef TMW_BITS_PER_SHRT +# if SHRT_MAX == 0x7FL +# define TMW_BITS_PER_SHRT 8 +# elif SHRT_MAX == 0x7FFFL +# define TMW_BITS_PER_SHRT 16 +# elif SHRT_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_SHRT 32 +# else +# define TMW_BITS_PER_SHRT -1 +# endif +#endif + +#ifndef TMW_BITS_PER_SCHAR +# if SCHAR_MAX == 0x7FL +# define TMW_BITS_PER_SCHAR 8 +# elif SCHAR_MAX == 0x7FFFL +# define TMW_BITS_PER_SCHAR 16 +# elif SCHAR_MAX == 0x7FFFFFFFL +# define TMW_BITS_PER_SCHAR 32 +# else +# define TMW_BITS_PER_SCHAR -1 +# endif +#endif + +#ifndef TMW_CHAR_SIGNED +# if SCHAR_MAX == CHAR_MAX +# define TMW_CHAR_SIGNED 1 +# else +# define TMW_CHAR_SIGNED 0 +# endif +#endif + +/* It is common for one or more of the integer types + * to be the same size. For example, on many embedded + * processors, both shorts and ints are 16 bits. On + * processors used for workstations, it is quite common + * for both int and long to be 32 bits. + * When there is more than one choice for typdef'ing + * a portable type like powerwindow_int16_T or powerwindow_uint32_T, in + * concept, it should not matter which choice is made. + * However, some style guides and some code checking + * tools do identify and complain about seemingly + * irrelevant differences. For example, a code + * checking tool may complain about an implicit + * conversion from int to short even though both + * are 16 bits. To reduce these types of + * complaints, it is best to make int the + * preferred choice when more than one is available. + */ + +#ifndef INT8_T +# if TMW_BITS_PER_INT == 8 +# define INT8_T int +# elif TMW_BITS_PER_LONG == 8 +# define INT8_T long +# elif TMW_BITS_PER_SCHAR == 8 +# define INT8_T signed char +# elif TMW_BITS_PER_SHRT == 8 +# define INT8_T short +# endif +#endif +#ifdef INT8_T +typedef INT8_T powerwindow_int8_T; +#endif + + + +#ifndef UINT8_T +# if TMW_BITS_PER_INT == 8 +# define UINT8_T unsigned int +# elif TMW_BITS_PER_LONG == 8 +# define UINT8_T unsigned long +# elif TMW_BITS_PER_SCHAR == 8 +# define UINT8_T unsigned char +# elif TMW_BITS_PER_SHRT == 8 +# define UINT8_T unsigned short +# endif +#endif +#ifdef UINT8_T +typedef UINT8_T powerwindow_uint8_T; +#endif + + +#ifndef INT16_T +# if TMW_BITS_PER_INT == 16 +# define INT16_T int +# elif TMW_BITS_PER_LONG == 16 +# define INT16_T long +# elif TMW_BITS_PER_SCHAR == 16 +# define INT16_T signed char +# elif TMW_BITS_PER_SHRT == 16 +# define INT16_T short +# endif +#endif +#ifdef INT16_T +typedef INT16_T powerwindow_int16_T; +#endif + + +#ifndef UINT16_T +# if TMW_BITS_PER_INT == 16 +# define UINT16_T unsigned int +# elif TMW_BITS_PER_LONG == 16 +# define UINT16_T unsigned long +# elif TMW_BITS_PER_SCHAR == 16 +# define UINT16_T unsigned char +# elif TMW_BITS_PER_SHRT == 16 +# define UINT16_T unsigned short +# endif +#endif +#ifdef UINT16_T +typedef UINT16_T powerwindow_uint16_T; +#endif + + +#ifndef INT32_T +# if TMW_BITS_PER_INT == 32 +# define INT32_T int +# elif TMW_BITS_PER_LONG == 32 +# define INT32_T long +# elif TMW_BITS_PER_SCHAR == 32 +# define INT32_T signed char +# elif TMW_BITS_PER_SHRT == 32 +# define INT32_T short +# endif +#endif +#ifdef INT32_T +typedef INT32_T powerwindow_int32_T; +#endif + + +#ifndef UINT32_T +# if TMW_BITS_PER_INT == 32 +# define UINT32_T unsigned int +# elif TMW_BITS_PER_LONG == 32 +# define UINT32_T unsigned long +# elif TMW_BITS_PER_SCHAR == 32 +# define UINT32_T unsigned char +# elif TMW_BITS_PER_SHRT == 32 +# define UINT32_T unsigned short +# endif +#endif +#ifdef UINT32_T +typedef UINT32_T powerwindow_uint32_T; +#endif + +/* The following is used to emulate smaller integer types when only + * larger types are available. For example, compilers for TI C3x/C4x DSPs + * define char and short to be 32 bits, so 8 and 16 bits are not directly + * available. This target is commonly used with RTW rapid prototyping. + * Other DSPs define char to be 16 bits, so 8 bits is not directly + * available. + */ +#ifndef INT8_T +# ifdef INT16_T +# define INT8_T INT16_T +typedef INT8_T powerwindow_int8_T; +# else +# ifdef INT32_T +# define INT8_T INT32_T +typedef INT8_T powerwindow_int8_T; +# endif +# endif +#endif + +#ifndef UINT8_T +# ifdef UINT16_T +# define UINT8_T UINT16_T +typedef UINT8_T powerwindow_uint8_T; +# else +# ifdef UINT32_T +# define UINT8_T UINT32_T +typedef UINT8_T powerwindow_uint8_T; +# endif +# endif +#endif + +#ifndef INT16_T +# ifdef INT32_T +# define INT16_T INT32_T +typedef INT16_T powerwindow_int16_T; +# endif +#endif + +#ifndef UINT16_T +# ifdef UINT32_T +# define UINT16_T UINT32_T +typedef UINT16_T powerwindow_uint16_T; +# endif +#endif + + +#ifndef NO_FLOATS + +#ifndef REAL32_T +# ifndef __MWERKS__ +# if FLT_MANT_DIG >= 23 +# define REAL32_T float +# endif +# else +# define REAL32_T float +# endif +#endif +#ifdef REAL32_T +typedef REAL32_T powerwindow_real32_T; +#endif + + +#ifndef REAL64_T +# ifndef __MWERKS__ +# if DBL_MANT_DIG >= 52 +# define REAL64_T double +# endif +# else +# define REAL64_T double +# endif +#endif +#ifdef REAL64_T +typedef REAL64_T powerwindow_real64_T; +#endif + +#endif /* NO_FLOATS*/ + +/*=======================================================================* + * Fixed width word size data types: * + * powerwindow_int64_T - signed 64 bit integers * + * powerwindow_uint64_T - unsigned 64 bit integers * + *=======================================================================*/ + + + +#ifndef INT64_T +# if defined(__APPLE__) +# define INT64_T long long +# define FMT64 "ll" +# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(__x86_64__) || defined(__LP64__) +# define INT64_T long +# define FMT64 "l" +# if !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) +# define INT64_T __int64 +# define FMT64 "I64" +# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ + || defined(__LCC64__) +# define INT64_T long long +# define FMT64 "ll" +# endif +#endif + + + +#if defined(INT64_T) +# if defined(__GNUC__) && \ + ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) +__extension__ +# endif +typedef INT64_T powerwindow_int64_T; +#endif + + + +#ifndef UINT64_T +# if defined(__APPLE__) +# define UINT64_T unsigned long long +# define FMT64 "ll" +# if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(__x86_64__) || defined(__LP64__) +# define UINT64_T unsigned long +# define FMT64 "l" +# if !defined(INT_TYPE_64_IS_LONG) +# define INT_TYPE_64_IS_LONG +# endif +# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) +# define UINT64_T unsigned __int64 +# define FMT64 "I64" +# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \ + || defined(__LCC64__) +# define UINT64_T unsigned long long +# define FMT64 "ll" +# endif +#endif + +#if defined(_WIN64) || (defined(__APPLE__) && defined(__LP64__)) \ + || defined(__x86_64__) \ + || defined(__LP64__) +# define INT_TYPE_64_IS_SUPPORTED +#endif + +#if defined(UINT64_T) +# if defined(__GNUC__) && \ + ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9))) +__extension__ +# endif +typedef UINT64_T powerwindow_uint64_T; +#endif + +/*===========================================================================* + * Format string modifiers for using powerwindow_size_t variables in printf statements. * + *===========================================================================*/ + +#ifndef FMT_SIZE_T +# if defined( __GNUC__ ) || defined(_STDC_C99) +# define FMT_SIZE_T "z" +# elif defined (__WATCOMC__) +# define FMT_SIZE_T "l" +# elif defined (_WIN32 ) +# define FMT_SIZE_T "I" +# else +# define FMT_SIZE_T "l" +# endif +#endif + +#ifndef FMT_PTRDIFF_T +# if defined(__APPLE__) +# define FMT_PTRDIFF_T "l" +# elif defined( __GNUC__ ) || defined(_STDC_C99) +# define FMT_PTRDIFF_T "t" +# elif defined (__WATCOMC__) +# define FMT_PTRDIFF_T "l" +# elif defined (_WIN32 ) +# define FMT_PTRDIFF_T "I" +# else +# define FMT_PTRDIFF_T "l" +# endif +#endif + +/*===========================================================================* + * General or logical data types where the word size is not guaranteed. * + * powerwindow_real_T - possible settings include powerwindow_real32_T or powerwindow_real64_T * + * powerwindow_time_T - possible settings include powerwindow_real64_T or powerwindow_uint32_T * + * powerwindow_boolean_T * + * powerwindow_char_T * + * powerwindow_int_T * + * powerwindow_uint_T * + * powerwindow_byte_T * + *===========================================================================*/ + +#ifndef NO_FLOATS + +#ifndef REAL_T +# ifdef REAL64_T +# define REAL_T powerwindow_real64_T +# else +# ifdef REAL32_T +# define REAL_T powerwindow_real32_T +# endif +# endif +#endif +#ifdef REAL_T +typedef REAL_T powerwindow_real_T; +#endif + +#ifndef TIME_T +# ifdef REAL_T +# define TIME_T powerwindow_real_T +# endif +#endif +#ifdef TIME_T +typedef TIME_T powerwindow_time_T; +#endif + +#endif /* NO_FLOATS */ + +#ifndef BOOLEAN_T +# if defined(UINT8_T) +# define BOOLEAN_T UINT8_T +# else +# define BOOLEAN_T unsigned int +# endif +#endif +typedef BOOLEAN_T powerwindow_boolean_T; + + +#ifndef CHARACTER_T +# define CHARACTER_T char +#endif +typedef CHARACTER_T powerwindow_char_T; + + +#ifndef INTEGER_T +# define INTEGER_T int +#endif +typedef INTEGER_T powerwindow_int_T; + + +#ifndef UINTEGER_T +# define UINTEGER_T unsigned +#endif +typedef UINTEGER_T powerwindow_uint_T; + + +#ifndef BYTE_T +# define BYTE_T unsigned char +#endif +typedef BYTE_T powerwindow_byte_T; + + +/*===========================================================================* + * Define Complex Structures * + *===========================================================================*/ +#ifndef NO_FLOATS + +#ifndef CREAL32_T +# ifdef REAL32_T +typedef struct { + powerwindow_real32_T re, im; +} powerwindow_creal32_T; +# define CREAL32_T creal32_T +# endif +#endif + +#ifndef CREAL64_T +# ifdef REAL64_T +typedef struct { + powerwindow_real64_T re, im; +} powerwindow_creal64_T; +# define CREAL64_T powerwindow_creal64_T +# endif +#endif + +#ifndef CREAL_T +# ifdef REAL_T +typedef struct { + powerwindow_real_T re, im; +} powerwindow_creal_T; +# define CREAL_T powerwindow_creal_T +# endif +#endif + +#endif /* NO_FLOATS */ + +#ifndef CINT8_T +# ifdef INT8_T +typedef struct { + powerwindow_int8_T re, im; +} powerwindow_cint8_T; +# define CINT8_T powerwindow_cint8_T +# endif +#endif + +#ifndef CUINT8_T +# ifdef UINT8_T +typedef struct { + powerwindow_uint8_T re, im; +} powerwindow_cuint8_T; +# define CUINT8_T powerwindow_cuint8_T +# endif +#endif + +#ifndef CINT16_T +# ifdef INT16_T +typedef struct { + powerwindow_int16_T re, im; +} powerwindow_cint16_T; +# define CINT16_T powerwindow_cint16_T +# endif +#endif + +#ifndef CUINT16_T +# ifdef UINT16_T +typedef struct { + powerwindow_uint16_T re, im; +} powerwindow_cuint16_T; +# define CUINT16_T powerwindow_cuint16_T +# endif +#endif + +#ifndef CINT32_T +# ifdef INT32_T +typedef struct { + powerwindow_int32_T re, im; +} powerwindow_cint32_T; +# define CINT32_T powerwindow_cint32_T +# endif +#endif + +#ifndef CUINT32_T +# ifdef UINT32_T +typedef struct { + powerwindow_uint32_T re, im; +} powerwindow_cuint32_T; +# define CUINT32_T powerwindow_cuint32_T +# endif +#endif + +#ifndef CINT64_T +# ifdef INT64_T +typedef struct { + powerwindow_int64_T re, im; +} powerwindow_cint64_T; +# define CINT64_T powerwindow_cint64_T +# endif +#endif + +#ifndef CUINT64_T +# ifdef UINT64_T +typedef struct { + powerwindow_uint64_T re, im; +} powerwindow_cuint64_T; +# define CUINT64_T powerwindow_cuint64_T +# endif +#endif + +/*=======================================================================* + * Min and Max: * + * powerwindow_int8_T, powerwindow_int16_T, powerwindow_int32_T - signed 8, 16, or 32 bit integers * + * powerwindow_uint8_T, powerwindow_uint16_T, powerwindow_uint32_T - unsigned 8, 16, or 32 bit integers * + *=======================================================================*/ + +#define powerwindow_MAX_int8_T ((powerwindow_int8_T)(127)) /* 127 */ +#define powerwindow_MIN_int8_T ((powerwindow_int8_T)(-128)) /* -128 */ +#define powerwindow_MAX_uint8_T ((powerwindow_uint8_T)(255)) /* 255 */ +#define powerwindow_MIN_uint8_T ((powerwindow_uint8_T)(0)) + +#define powerwindow_MAX_int16_T ((powerwindow_int16_T)(32767)) /* 32767 */ +#define powerwindow_MIN_int16_T ((powerwindow_int16_T)(-32768)) /* -32768 */ +#define powerwindow_MAX_uint16_T ((powerwindow_uint16_T)(65535)) /* 65535 */ +#define powerwindow_MIN_uint16_T ((powerwindow_uint16_T)(0)) + +#define powerwindow_MAX_int32_T ((powerwindow_int32_T)(2147483647)) /* 2147483647 */ +#define powerwindow_MIN_int32_T ((powerwindow_int32_T)(-2147483647-1)) /* -2147483648 */ +#define powerwindow_MAX_uint32_T ((powerwindow_uint32_T)(0xFFFFFFFFU)) /* 4294967295 */ +#define powerwindow_MIN_uint32_T ((powerwindow_uint32_T)(0)) + +#if defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \ + || (defined(__WATCOMC__) && __WATCOMC__ >= 1100) \ + || defined(__LCC64__) +# ifdef INT64_T +# define powerwindow_MAX_int64_T ((powerwindow_int64_T)(9223372036854775807LL)) +# define powerwindow_MIN_int64_T ((powerwindow_int64_T)(-9223372036854775807LL-1LL)) +# endif +# ifdef UINT64_T +# define powerwindow_MAX_uint64_T ((powerwindow_uint64_T)(0xFFFFFFFFFFFFFFFFULL)) +# define powerwindow_MIN_uint64_T ((powerwindow_uint64_T)(0)) +# endif +#else +# ifdef INT64_T +# ifdef INT_TYPE_64_IS_LONG +# define powerwindow_MAX_int64_T ((powerwindow_int64_T)(9223372036854775807L)) +# define powerwindow_MIN_int64_T ((powerwindow_int64_T)(-9223372036854775807L-1L)) +# else +# define powerwindow_MAX_int64_T ((powerwindow_int64_T)(9223372036854775807LL)) +# define powerwindow_MIN_int64_T ((powerwindow_int64_T)(-9223372036854775807LL-1LL)) +# endif +# endif +# ifdef UINT64_T +# ifdef INT_TYPE_64_IS_LONG +# define powerwindow_MAX_uint64_T ((powerwindow_uint64_T)(0xFFFFFFFFFFFFFFFFUL)) +# define powerwindow_MIN_uint64_T ((powerwindow_uint64_T)(0)) +# else +# define powerwindow_MAX_uint64_T ((powerwindow_uint64_T)(0xFFFFFFFFFFFFFFFFULL)) +# define powerwindow_MIN_uint64_T ((powerwindow_uint64_T)(0)) +# endif +# endif +#endif + +#ifdef _MSC_VER +/* Conversion from unsigned __int64 to double is not implemented in windows + * and results in a compile error, thus the value must first be cast to + * signed __int64, and then to double. + * + * If the 64 bit int value is greater than 2^63-1, which is the signed int64 max, + * the macro below provides a workaround for casting a uint64 value to a double + * in windows. + */ +# define uint64_to_double(u) ( ((u) > _I64_MAX) ? \ + (double)(__int64)((u) - _I64_MAX - 1) + (double)_I64_MAX + 1: \ + (double)(__int64)(u) ) + +/* The following inline function should only be used in the macro double_to_uint64, + * as it only handles the specfic range of double between 2^63 and 2^64-1 */ +__forceinline +powerwindow_uint64_T double_to_uint64_helper(double d) { + union double_to_uint64_union_type { + double dd; + powerwindow_uint64_T i64; + } di; + di.dd = d; + return (((di.i64 & 0x000fffffffffffff) | 0x0010000000000000) << 11); +} + +/* The largest double value that can be cast to uint64 in windows is the + * signed int64 max, which is 2^63-1. The macro below provides + * a workaround for casting large double values to uint64 in windows. + */ +/* The magic number 18446744073709551616.0 is 2^64 */ +/* The magic number 9223372036854775808.0 is 2^63 */ +# define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \ + 0xffffffffffffffffULL : \ + ((d) < 0.0) ? 0ULL : \ + ((d) >= 9223372036854775808.0) ? \ + double_to_uint64_helper(d) : \ + (unsigned __int64)(d) ) +#else +# define uint64_to_double(u) ((double)(u)) +# if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__TICCSC__) +/* double_to_uint64 defined only for MSVC and UNIX */ +# else +# define double_to_uint64(d) ( ((d) > 0xffffffffffffffffULL) ? \ + (unsigned long long) 0xffffffffffffffffULL : \ + ((d) < 0) ? (unsigned long long) 0 : (unsigned long long)(d) ) +# endif +#endif + +#if !defined(__cplusplus) && !defined(__bool_true_false_are_defined) + +#ifndef _bool_T +#define _bool_T + +typedef powerwindow_boolean_T bool; + +#ifndef false +#define false (0) +#endif +#ifndef true +#define true (1) +#endif + +#endif /* _bool_T */ + +#endif /* !__cplusplus */ + +/* + * This software assumes that the code is being compiled on a target using a + * 2's complement representation for signed integer values. + */ +#if ((SCHAR_MIN + 1) != -SCHAR_MAX) +#error "This code must be compiled using a 2's complement representation for signed integer values" +#endif + +/* + * Maximum length of a MATLAB identifier (function/variable/model) + * including the null-termination character. + */ +#define TMW_NAME_LENGTH_MAX 64 + + +#ifdef MX_COMPAT_32 +typedef int powerwindow_mwSize; +typedef int powerwindow_mwIndex; +typedef int powerwindow_mwSignedIndex; +#else +typedef size_t powerwindow_mwSize; /* unsigned pointer-width integer */ +typedef size_t powerwindow_mwIndex; /* unsigned pointer-width integer */ +typedef ptrdiff_t powerwindow_mwSignedIndex; /* a signed pointer-width integer */ +#endif + +#if (defined(_LP64) || defined(_WIN64)) && !defined(MX_COMPAT_32) +/* Currently 2^48 based on hardware limitations */ +# define powerwindow_MWSIZE_MAX 281474976710655UL +# define powerwindow_MWINDEX_MAX 281474976710655UL +# define powerwindow_MWSINDEX_MAX 281474976710655L +# define powerwindow_MWSINDEX_MIN -281474976710655L +#else +# define powerwindow_MWSIZE_MAX 2147483647UL +# define powerwindow_MWINDEX_MAX 2147483647UL +# define powerwindow_MWSINDEX_MAX 2147483647L +# define powerwindow_MWSINDEX_MIN -2147483647L +#endif +#define powerwindow_MWSIZE_MIN 0UL +#define powerwindow_MWINDEX_MIN 0UL + +/** UTF-16 character type */ + +#if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT) +typedef char16_t powerwindow_CHAR16_T; +#elif defined(_MSC_VER) +typedef wchar_t powerwindow_CHAR16_T; +#else +typedef UINT16_T powerwindow_CHAR16_T; +#endif + +#endif /* powerwindow__TMWTYPES__ */ + +#endif /* powerwindow_tmwtypes_h */ |