MATHLIB_types.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************/
 
#ifndef MATHLIB_TYPES_H_
#define MATHLIB_TYPES_H_ 1
 
/******************************************************************************/
/*                                                                            */
/* Includes                                                                   */
/*                                                                            */
/******************************************************************************/
 
#include <c7x.h>
#include <inttypes.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
/******************************************************************************/
/*                                                                            */
/* Defines                                                                    */
/*                                                                            */
/******************************************************************************/
 
#define MATHLIB_TEST_OUTPUT_HEAP 0
#if defined(_HOST_BUILD)
// Valgrind works better when output is in the heap (it
// can't track statically allocated memory), so
// in host emulation mode, place test outputs in the heap rather than statically
// allocated MSMC
#define MATHLIB_TEST_OUTPUT_MSMC MATHLIB_TEST_OUTPUT_HEAP
#else
#define MATHLIB_TEST_OUTPUT_MSMC 1
#endif
 
#ifdef _HOST_BUILD
#define restrict
#endif
 
// debug print macro
#if !defined(MATHLIB_DEBUGPRINT)
#define MATHLIB_DEBUGPRINT 0 
#endif
 
#define MATHLIB_PRINTF(fmt, ...)                                                                                       \
   do {                                                                                                                \
      fprintf(stdout, fmt, __VA_ARGS__);                                                                               \
   } while (0)
 
#if MATHLIB_DEBUGPRINT > 0
#define MATHLIB_DEBUGPRINTFN(N, fmt, ...)                                                                              \
   do {                                                                                                                \
      if (MATHLIB_DEBUGPRINT >= (N)) {                                                                                 \
         fprintf(stdout, "MATHLIB debug %s - %d: " fmt, __FUNCTION__, __LINE__, __VA_ARGS__);                          \
      }                                                                                                                \
   } while (0)
 
#else // MATHLIB_DEBUGPRINT == 0
 
#define MATHLIB_DEBUGPRINTFN(N, fmt, ...)
 
#endif // #if MATHLIB_DEBUGPRINT
 
#ifdef __cplusplus
#include <c7x_scalable.h> // for device scalability
extern "C" {
#endif /* __cplusplus */
 
/******************************************************************************/
/*                                                                            */
/* Typedes                                                                    */
/*                                                                            */
/******************************************************************************/
 
typedef enum {
   MATHLIB_SUCCESS                      = 0, 
   MATHLIB_ERR_FAILURE                  = 1, 
   MATHLIB_ERR_INVALID_VALUE            = 2, 
   MATHLIB_ERR_INVALID_TYPE             = 3, 
   MATHLIB_ERR_INVALID_DIMENSION        = 4, 
   MATHLIB_ERR_NULL_POINTER             = 5, 
   MATHLIB_ERR_NOT_IMPLEMENTED          = 6, 
   MATHLIB_ERR_NOT_EQUAL_WIDTH_STRIDE   = 7, 
   MATHLIB_ERR_NOT_ALIGNED_PTRS_STRIDES = 8, 
   MATHLIB_ERR_NOT_ALIGNED_WIDTHS = 9,       
   MATHLIB_ERR_BUFFER_TOO_SMALL   = 10,      
   MATHLIB_ERR_INVALID_ACTIVATION = 11,      
   MATHLIB_ERR_INVALID_SHIFT      = 12,      
   MATHLIB_ERROR_MAX              = 13,
} MATHLIB_STATUS_NAME;
 
typedef MATHLIB_STATUS_NAME MATHLIB_STATUS; 
 
typedef struct {
   bool             callCheckParams = false; 
   bool             callInit        = true;  
   __SE_TEMPLATE_v1 se0Params;               
   __SE_TEMPLATE_v1 se1Params;               
   __SA_TEMPLATE_v1 sa0Params;               
   size_t           blockSize = 0;           
} MATHLIB_SESA1DSequential_t;
 
typedef enum _MATHLIB_data_type_e {
 
   // standard fixed-point integer datatypes
   MATHLIB_INT8   = 0, 
   MATHLIB_INT16  = 1, 
   MATHLIB_INT32  = 2, 
   MATHLIB_INT64  = 3, 
   MATHLIB_INT128 = 4, 
   // standard fixed-point unsigned integer datatypes
   MATHLIB_UINT8   = 5,  
   MATHLIB_UINT16  = 6,  
   MATHLIB_UINT24  = 7,  
   MATHLIB_UINT32  = 8,  
   MATHLIB_UINT64  = 9,  
   MATHLIB_UINT128 = 10, 
   // standard floating-point datatypes
   MATHLIB_FLOAT16 = 11, 
   MATHLIB_FLOAT32 = 12, 
   MATHLIB_FLOAT64 = 13  
} MATHLIB_data_type_e;
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* MATHLIB_TYPES_H_ */