qfis.h

 
#ifndef QFIS_H
#define QFIS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
    #include <stdlib.h>
    #include <stdint.h>
    #include <limits.h>
 
    typedef enum {
        custommf = 0,   
        trimf,          
        trapmf,         
        gbellmf,        
        gaussmf,        
        gauss2mf,       
        sigmf,          
        dsigmf,         
        psigmf,         
        pimf,           
        smf,            
        zmf,            
        singletonmf,    
        concavemf,      
        spikemf,        
        linsmf,         
        linzmf,         
        rectmf,         
        cosmf,          
        constantmf,     
        linearmf,       
        tlinsmf,        
        tlinzmf,        
        tconcavemf,     
        tsigmf,         
        tsmf,           
        tzmf,           
        _NUM_MFS         //skipcq: CXX-E2000
    } qFIS_MF_Name_t;
 
    typedef enum {
        centroid = 0,   
        bisector,       
        mom,            
        lom,            
        som,            
        wtaver,         
        wtsum,          
        _NUM_DFUZZ       //skipcq: CXX-E2000
    } qFIS_DeFuzz_Method_t;
 
    typedef enum {
        qFIS_MIN = 0,   
        qFIS_PROD,      
        qFIS_MAX,       
        qFIS_PROBOR,    
        qFIS_SUM        
    } qFIS_ParamValue_t;
 
    typedef enum {
        qFIS_Implication,   
        qFIS_Aggregation,   
        qFIS_AND,           
        qFIS_OR,            
        qFIS_EvalPoints     
    } qFIS_Parameter_t;
 
    typedef enum {
        Mamdani = 0,        
        Sugeno,             
        Tsukamoto           
    } qFIS_Type_t;
 
    typedef enum {
        DeFuzz_Init,
        DeFuzz_Compute,
        DeFuzz_End
    } qFIS_DeFuzzState_t;
    /*cstat -MISRAC2012-Dir-4.8*/
    
    typedef struct
    {
        float min, max, value;
    } qFIS_IO_Base_t;
    typedef struct
    {
        qFIS_IO_Base_t b;
    } qFIS_Input_t;
 
    typedef struct
    {
        qFIS_IO_Base_t b;
        void *owner;
        float *xag, *yag;
        float res, x, y, data[ 4 ];
    } qFIS_Output_t;
 
    /*cstat +MISRAC2012-Dir-4.8*/
    
    typedef float (*qFIS_MF_Fcn_t)( const qFIS_IO_Base_t * const in, const float *p, const size_t n );
    typedef struct
    {
        qFIS_MF_Fcn_t shape;
        const float *points;
        float fx, h;
        size_t index;
    } qFIS_MF_t;
 
    #define FIS_RULE_ITEM_SIZE  1
 
    #if ( FIS_RULE_ITEM_SIZE == 1 )
 
        typedef int8_t qFIS_Rules_t;
        #define FIS_RULES_MIN_VALUE     INT8_MIN
    #else
        typedef int16_t qFIS_Rules_t;
        #define FIS_RULES_MIN_VALUE     INT16_MIN
    #endif
 
    typedef int qFIS_Tag_t;
    typedef float (*qFIS_DeFuzz_Fcn_t)( qFIS_Output_t * const o, const qFIS_DeFuzzState_t stage );
    typedef struct _qFIS_s //skipcq: CXX-E2000
    {
        qFIS_Input_t *input;
        qFIS_Output_t *output;
        qFIS_MF_t *inMF, *outMF;
        float (*andOp)( const float a, const float b );
        float (*orOp)( const float a, const float b );
        float (*implicate)( const float a, const float b );
        float (*aggregate)( const float a, const float b );
        size_t (*inferenceState)( struct _qFIS_s * const f, size_t i );
        size_t (*aggregationState)( struct _qFIS_s * const f, size_t i );
        qFIS_DeFuzz_Fcn_t deFuzz;
        float *ruleWeight;
        float *wi;
        const qFIS_Rules_t *rules;
        size_t rule_cols;
        size_t nInputs, nOutputs;
        size_t nMFInputs, nMFOutputs;
        size_t nPoints;
        size_t nRules, ruleCount;
        float rStrength;
        qFIS_Rules_t lastConnector;
        qFIS_Type_t type;
    } qFIS_t;
 
    #define _QFIS_RULES_END         ( FIS_RULES_MIN_VALUE + 1 ) //skipcq: CXX-E2000
    #define _QFIS_AND               ( FIS_RULES_MIN_VALUE + 2 ) //skipcq: CXX-E2000
    #define _QFIS_OR                ( FIS_RULES_MIN_VALUE + 3 ) //skipcq: CXX-E2000
    #define _QFIS_THEN              ( FIS_RULES_MIN_VALUE + 4 ) //skipcq: CXX-E2000
 
    #define _QFIS_IF_STATEMENT      ,                   //skipcq: CXX-E2000
    #define _QFIS_AND_STATEMENT     +1),_QFIS_AND,      //skipcq: CXX-E2000
    #define _QFIS_OR_STATEMENT      +1),_QFIS_OR,       //skipcq: CXX-E2000
    #define _QFIS_THEN_STATEMENT    +1),_QFIS_THEN,     //skipcq: CXX-E2000
    #define _QFIS_IS_STATEMENT      ,(                  //skipcq: CXX-E2000
    #define _QFIS_IS_NOT_STATEMENT  ,-(                 //skipcq: CXX-E2000
    #define _QFIS_END_STATEMENT     +1)                 //skipcq: CXX-E2000
    /*Rules build keywords*/
 
    #define QFIS_RULES_BEGIN        ( FIS_RULES_MIN_VALUE )
 
    #define QFIS_RULES_END          ,_QFIS_RULES_END
 
    #define IF                      _QFIS_IF_STATEMENT
    #define AND                     _QFIS_AND_STATEMENT
    #define OR                      _QFIS_OR_STATEMENT
    #define THEN                    _QFIS_THEN_STATEMENT
    #define IS                      _QFIS_IS_STATEMENT
    #define IS_NOT                  _QFIS_IS_NOT_STATEMENT
    #define END                     _QFIS_END_STATEMENT
 
    int qFIS_SetParameter( qFIS_t * const f,
                           const qFIS_Parameter_t p,
                           const qFIS_ParamValue_t x );
 
    int qFIS_SetDeFuzzMethod( qFIS_t * const f,
                              qFIS_DeFuzz_Method_t m );
 
    int qFIS_Setup( qFIS_t * const f,
                    const qFIS_Type_t t,
                    qFIS_Input_t * const inputs,
                    const size_t ni,
                    qFIS_Output_t * const outputs,
                    const size_t no,
                    qFIS_MF_t * const mf_inputs,
                    const size_t nmi,
                    qFIS_MF_t * const mf_outputs,
                    const size_t nmo,
                    const qFIS_Rules_t * const r,
                    float *wi,
                    const size_t n
                    );
 
    int qFIS_InputSetup( qFIS_Input_t * const v,
                         const qFIS_Tag_t t,
                         const float min,
                         const float max );
 
    int qFIS_OutputSetup( qFIS_Output_t * const v,
                          const qFIS_Tag_t t,
                          const float min,
                          const float max );
 
    int qFIS_SetInput( qFIS_Input_t * const v,
                       const qFIS_Tag_t t,
                       const float value );
 
    float qFIS_GetOutput( const qFIS_Output_t * const v,
                          const qFIS_Tag_t t );
 
    int qFIS_SetMF( qFIS_MF_t * const m,
                    const qFIS_Tag_t io,
                    const qFIS_Tag_t mf,
                    const qFIS_MF_Name_t s,
                    qFIS_MF_Fcn_t custom_mf,
                    const float *cp,
                    const float h );
 
    int qFIS_StoreAggregatedRegion( qFIS_Output_t * const o,
                                    const qFIS_Tag_t t,
                                    float *x,
                                    float *y,
                                    const size_t n );
 
    int qFIS_Fuzzify( qFIS_t * const f );
 
    int qFIS_Inference( qFIS_t * const f );
 
    int qFIS_DeFuzzify( qFIS_t * const f );
 
    int qFIS_SetRuleWeights( qFIS_t * const f,
                             float *rWeights );
 
#ifdef __cplusplus
}
#endif
 
#endif