fis.hpp

 
#ifndef QLIBS_FIS
#define QLIBS_FIS
 
#include <include/qlibs_types.hpp>

namespace qlibs {

    namespace fis {


        enum shapeMF {
            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,           
            trampmf,        
            FIS_NUM_MFS        
        };

        enum deFuzzMethod {
            centroid = 0,   
            bisector,       
            mom,            
            lom,            
            som,            
            wtaver,         
            wtsum,          
            FIS_NUM_DEFUZZ      
        };

        enum paramValue {
            FIS_MIN = 0,   
            FIS_PROD,      
            FIS_MAX,       
            FIS_PROBOR,    
            FIS_SUM        
        };

        enum parameter {
            FIS_Implication,   
            FIS_Aggregation,   
            FIS_AND,           
            FIS_OR,            
            FIS_EvalPoints     
        };

        enum type {
            Mamdani = 0,        
            Sugeno,             
            Tsukamoto           
        };

        enum deFuzzState {
            FIS_DEFUZZ_INIT,
            FIS_DEFUZZ_COMPUTE,
            FIS_DEFUZZ_END
        };

        class core;
        class instance;
        template<type fType, size_t numberOfInputs, size_t numberOfOutputs, size_t numberOfInputSets, size_t numberOfOutputSets, size_t numberOfRules>
        class system;
 
        class ioBase {
            protected:
                real_t min{ -1.0_re };
                real_t max{ 1.0_re };
                real_t value{ 0.0_re };
            public:
                virtual ~ioBase() {};
                ioBase() = default;
            friend class instance;
            friend class core;
            template<type fType, size_t numberOfInputs, size_t numberOfOutputs, size_t numberOfInputSets, size_t numberOfOutputSets, size_t numberOfRules>
            friend class system;
        };

        class input : public ioBase {
            public:
                input() = default;
                virtual ~input() {};
            friend class instance;
            friend class core;
            template<type fType, size_t numberOfInputs, size_t numberOfOutputs, size_t numberOfInputSets, size_t numberOfOutputSets, size_t numberOfRules>
            friend class system;
        };

        class output : public ioBase {
            private:
                instance *owner{ nullptr };
                real_t *xag{ nullptr };
                real_t *yag{ nullptr };
                real_t res{ 0.01_re };
                real_t x{ 0.0_re };
                real_t y{ 0.0_re };
                real_t v[ 4 ] = { 0.0_re, 0.0_re, 0.0_re, 0.0_re };
                inline void getNextX( const size_t i ) noexcept
                {
                    x = min + ( ( static_cast<real_t>( i ) + 0.5_re )*res );
                }
            public:
                output() = default;
                virtual ~output() {};
                bool storeAggregatedRegion( real_t *xData,
                                            real_t *yData,
                                            const size_t n ) noexcept;
                template <size_t numberOfPoints>
                bool storeAggregatedRegion( real_t (&xData)[ numberOfPoints ],
                                            real_t (&yData)[ numberOfPoints ] ) noexcept
                {
                    return storeAggregatedRegion( xData, yData, numberOfPoints );
                }
            friend class instance;
            friend class core;
            template<type fType, size_t numberOfInputs, size_t numberOfOutputs, size_t numberOfInputSets, size_t numberOfOutputSets, size_t numberOfRules>
            friend class system;
        };

        using mfFunction = real_t (*)( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
 
        class core {
            protected:
                enum defuzzMembers {
                    yMax = 0,
                    xSmallest = 1,
                    xLargest = 2 ,
                    sp = 3,
                    sum_xy = 0,
                    sum_y = 1,
                    halfArea = 2,
                    currentArea = 3,
                    sum_wz = 0,
                    sum_w = 1,
                };
                virtual ~core() {}
                core() = default;
                static real_t bound( real_t y,
                                     const real_t minValue = 0.0_re,
                                     const real_t maxValue= 1.0_re );
                static real_t Min( const real_t a,
                                   const real_t b );
                static real_t Prod( const real_t a,
                                    const real_t b );
                static real_t Max( const real_t a,
                                   const real_t b );
                static real_t ProbOr( const real_t a,
                                      const real_t b );
                static real_t Sum( const real_t a,
                                   const real_t b );
 
                static real_t TriMF( const ioBase * const in,
                                     const real_t *p,
                                     const size_t n );
                static real_t TrapMF( const ioBase * const in,
                                      const real_t *p,
                                      const size_t n );
                static real_t GBellMF( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
                static real_t GaussMF( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
                static real_t Gauss2MF( const ioBase * const in,
                                        const real_t *p,
                                        const size_t n );
                static real_t SigMF( const ioBase * const in,
                                     const real_t *p,
                                     const size_t n );
                static real_t TSigMF( const ioBase * const in,
                                      const real_t *p,
                                      const size_t n );
                static real_t DSigMF( const ioBase * const in,
                                      const real_t *p,
                                      const size_t n );
                static real_t PSigMF( const ioBase * const in,
                                      const real_t *p,
                                      const size_t n );
                static real_t SMF( const ioBase * const in,
                                   const real_t *p,
                                   const size_t n );
                static real_t TSMF( const ioBase * const in,
                                    const real_t *p,
                                    const size_t n );
                static real_t ZMF( const ioBase * const in,
                                   const real_t *p,
                                   const size_t n );
                static real_t LinSMF( const ioBase * const in,
                                      const real_t *p,
                                      const size_t n );
                static real_t LinZMF( const ioBase * const in,
                                      const real_t *p,
                                      const size_t n );
                static real_t TZMF( const ioBase * const in,
                                    const real_t *p,
                                    const size_t n );
                static real_t PiMF( const ioBase * const in,
                                    const real_t *p,
                                    const size_t n );
                static real_t SingletonMF( const ioBase * const in,
                                           const real_t *p,
                                           const size_t n );
                static real_t ConcaveMF( const ioBase * const in,
                                         const real_t *p,
                                         const size_t n );
                static real_t TConcaveMF( const ioBase * const in,
                                          const real_t *p,
                                          const size_t n );
                static real_t SpikeMF( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
                static real_t TLinSMF( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
                static real_t TLinZMF( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
                static real_t TRampMF( const ioBase * const in,
                                       const real_t *p,
                                       const size_t n );
                static real_t RectangleMF( const ioBase * const in,
                                           const real_t *p,
                                           const size_t n );
                static real_t CosineMF( const ioBase * const in,
                                        const real_t *p,
                                        const size_t n );
                static real_t ConstantMF( const ioBase * const in,
                                          const real_t *p,
                                          const size_t n );
                static real_t LinearMF( const ioBase * const in,
                                        const real_t *p,
                                        const size_t n );
 
                static real_t deFuzzCentroid( output * const o,
                                            const deFuzzState stage );
                static real_t deFuzzBisector( output * const o,
                                            const deFuzzState stage );
                static real_t deFuzzLOM( output * const o,
                                        const deFuzzState stage );
                static real_t deFuzzSOM( output * const o,
                                        const deFuzzState stage );
                static real_t deFuzzMOM( output * const o,
                                        const deFuzzState stage );
                static real_t deFuzzWtAverage( output * const o,
                                            const deFuzzState stage );
                static real_t deFuzzWtSum( output * const o,
                                        const deFuzzState stage );
        };

        class mf {
            private:
                mfFunction shape{ nullptr };
                const real_t *points{ nullptr };
                real_t fx{ 0.0_re };
                real_t h{ 0.0_re };
                size_t index{ 0U };
                inline size_t getIndex( void ) const
                {
                    return index;
                }
                inline real_t membership( const ioBase * const io,
                                          size_t n = 1U )
                {
                    fx = ( nullptr != shape ) ? h*shape( io, points, n ) : 0.0_re;
                    return fx;
                }
            public:
                virtual ~mf() {};
                mf() = default;
                friend class instance;
        };

        #define FIS_RULE_ITEM_SIZE  1
 
        #if ( FIS_RULE_ITEM_SIZE == 1 )
            using rules = int8_t;
            constexpr fis::rules FIS_RULES_MIN_VALUE = INT8_MIN;
        #else
            using rules = int16_t;
            constexpr fis::rules FIS_RULES_MIN_VALUE = INT16_MIN;
        #endif

        using tag = rules;
        /*cstat -MISRAC++2008-0-1-4_b*/
        constexpr fis::rules Q_FIS_RULES_BEGIN    = FIS_RULES_MIN_VALUE;
        constexpr fis::rules Q_FIS_RULES_END      = FIS_RULES_MIN_VALUE + 1;
        constexpr fis::rules Q_FIS_AND            = FIS_RULES_MIN_VALUE + 2;
        constexpr fis::rules Q_FIS_OR             = FIS_RULES_MIN_VALUE + 3;
        constexpr fis::rules Q_FIS_THEN           = FIS_RULES_MIN_VALUE + 4;
        /*cstat +MISRAC++2008-0-1-4_b*/
        #define Q_FIS_IF_STATEMENT      ,
        #define Q_FIS_AND_STATEMENT     +1),fis::Q_FIS_AND,
        #define Q_FIS_OR_STATEMENT      +1),fis::Q_FIS_OR,
        #define Q_FIS_THEN_STATEMENT    +1),fis::Q_FIS_THEN,
        #define Q_FIS_IS_STATEMENT      ,(
        #define Q_FIS_IS_NOT_STATEMENT  ,-(
        #define Q_FIS_END_STATEMENT     +1)

        #define FIS_RULES_BEGIN         fis::Q_FIS_RULES_BEGIN
        #define FIS_RULES_END           ,fis::Q_FIS_RULES_END
        #define IF                      Q_FIS_IF_STATEMENT
        #define AND                     Q_FIS_AND_STATEMENT
        #define OR                      Q_FIS_OR_STATEMENT
        #define THEN                    Q_FIS_THEN_STATEMENT
        #define IS                      Q_FIS_IS_STATEMENT
        #define IS_NOT                  Q_FIS_IS_NOT_STATEMENT
        #define END                     Q_FIS_END_STATEMENT
 
 
    using deFuzzFunction = real_t (*)( output * const o, const deFuzzState stage );
    using fuzzyOperator = real_t (*)( const real_t a, const real_t b );

     class instance: public core, private nonCopyable {
        using methods_fcn = real_t (*)( const real_t a, const real_t b );
 
        template<type fType, size_t numberOfInputs, size_t numberOfOutputs, size_t numberOfInputSets, size_t numberOfOutputSets, size_t numberOfRules>
        friend class system;
 
        private:
            input *xInput{ nullptr };
            output *xOutput{ nullptr };
            mf *inMF{ nullptr };
            mf *outMF{ nullptr };
            methods_fcn andOp{ &Min };
            methods_fcn orOp{ &Max };
            methods_fcn implicate{ &Min };
            methods_fcn aggregate{ &Max };
            size_t (instance::*inferenceState)( size_t i );
            size_t (instance::*aggregationState)( size_t i );
            deFuzzFunction deFuzz{ &deFuzzCentroid };
            real_t *ruleWeight{ nullptr };
            real_t *wi{ nullptr };
            const rules *xRules{ nullptr };
            size_t rules_cols{ 0U};
            size_t nInputs{ 0 };
            size_t nOutputs{ 0 };
            size_t nMFInputs{ 0U };
            size_t nMFOutputs{ 0U };
            size_t nPoints{ 100 };
            size_t nRules{ 0U };
            size_t ruleCount{ 0U };
            real_t rStrength{ 0.0_re };
            rules lastConnector;
            type xType{ Mamdani };
            bool setMF( mf *m,
                        const tag io,
                        const tag mf,
                        const shapeMF s,
                        mfFunction customMf,
                        const real_t *cp,
                        const real_t h ) noexcept;
            static real_t parseFuzzValue( mf * const mfIO,
                                          rules index ) noexcept;
            fuzzyOperator getFuzzOperator( void ) noexcept;
            size_t inferenceAntecedent( size_t i ) noexcept;
            size_t inferenceReachEnd( size_t i ) noexcept;
            size_t aggregationFindConsequent( size_t i ) noexcept;
            size_t inferenceConsequent( size_t i ) noexcept;
            void fuzzyAggregate( void ) noexcept;
            static const size_t INFERENCE_ERROR;
            tag lastTag{ -1 };
        public:
            instance() = default;
            virtual ~instance() {}

            bool setup( const type t,
                 input * const inputs,
                 const size_t ni,
                 output * const outputs,
                 const size_t no,
                 mf * const mf_inputs,
                 const size_t nmi,
                 mf * const mf_outputs,
                 const size_t nmo,
                 const rules * const r,
                 const size_t n,
                 real_t *rWeights = nullptr ) noexcept;

            template <size_t numberInputs, size_t numberOutputs, size_t numberMFinputs, size_t numberMFOutputs, size_t numberRules>
            bool setup( const type t,
                 input (&inputs)[ numberInputs ],
                 output (&outputs)[ numberOutputs ],
                 mf (&mf_inputs)[ numberMFinputs ],
                 mf (&mf_outputs)[ numberMFOutputs ],
                 const rules * const r,
                 real_t (&rWeights)[ numberRules ] ) noexcept
            {
                return setup( t, inputs, numberInputs, outputs, numberOutputs, mf_inputs, numberMFinputs, mf_outputs, numberMFOutputs, r, numberRules, rWeights );
            }

            bool setupInput( const tag t,
                             const real_t Min,
                             const real_t Max ) noexcept;
            bool setupOutput( const tag t,
                              const real_t Min,
                              const real_t Max ) noexcept;

            bool setupInputMF( const tag io,
                               const tag mf,
                               const shapeMF s,
                               const real_t *cp,
                               const real_t h = 1.0_re ) noexcept
            {
                return ( ( nullptr != inMF ) && ( nMFInputs > 0U ) ) ? setMF( inMF, io, mf, s, nullptr, cp, h ) : false;
            }

            bool setupInputMF( const tag io,
                               const tag mf,
                               mfFunction customMfs,
                               const real_t *cp,
                               const real_t h = 1.0_re ) noexcept
            {
                return ( ( nullptr != inMF ) && ( nMFInputs > 0U ) ) ? setMF( inMF, io, mf, custommf, customMfs, cp, h ) : false;
            }

            bool setupOutputMF( const tag io,
                                const tag mf,
                                const shapeMF s,
                                const real_t *cp,
                                const real_t h = 1.0_re ) noexcept
            {
                return ( ( nullptr != outMF ) && ( nMFOutputs > 0U ) ) ? setMF( outMF, io, mf, s, nullptr, cp, ( ( Mamdani == xType ) ? h : 1.0_re ) ) : false;
            }

            bool setupOutputMF( const tag io,
                                const tag mf,
                                mfFunction customMfs,
                                const real_t *cp,
                                const real_t h = 1.0_re ) noexcept
            {
                return ( ( nullptr != outMF ) && ( nMFOutputs > 0U ) ) ? setMF( outMF, io, mf, custommf, customMfs, cp, ( ( Mamdani == xType ) ? h : 1.0_re ) ) : false;
            }

            bool setInput( const tag t,
                           const real_t value ) noexcept;

            bool getOutput( const tag t,
                            real_t &value ) const noexcept;

            bool setParameter( const parameter p,
                               const paramValue x ) noexcept;

            bool setDeFuzzMethod( deFuzzMethod m ) noexcept;

            bool fuzzify( void ) noexcept;

            bool deFuzzify( void ) noexcept;

            bool inference( void ) noexcept;

            bool setRuleWeights( real_t *rWeights ) noexcept;

            bool isInitialized( void ) const {
                return ( nullptr != xInput );
            }

            explicit operator bool() const noexcept {
                return isInitialized();
            }

            size_t getNumberOfPoints( void ) const noexcept
            {
                return nPoints;
            }

            real_t operator[]( tag outTag ) const
            {
                /*cstat -CERT-STR34-C*/
                return ( static_cast<size_t>( outTag ) < nOutputs ) ? xOutput[ outTag ].value :  xInput[ nOutputs -1 ].value;
                /*cstat +CERT-STR34-C*/
            }

            instance& operator<<( const tag& t ) {
                if ( static_cast<size_t>( t ) < nInputs ) {
                    lastTag = t;
                }
                return *this;
            }

            instance& operator<<( const int& value ) {
                if ( lastTag >= 0 ) {
                    xInput[ lastTag ].value = static_cast<real_t>(value);
                }
                return *this;
            }

            instance& operator<<( const real_t& value ) {
                if ( lastTag >= 0 ) {
                    xInput[ lastTag ].value = value;
                }
                return *this;
            }
 
        friend class core;
    };

    template<type fType, size_t numberOfInputs, size_t numberOfOutputs, size_t numberOfInputSets, size_t numberOfOutputSets, size_t numberOfRules>
    class system {
        private:
            instance sys;
            const rules *xRules;
            input inputs[ numberOfInputs ];
            output outputs[ numberOfOutputs ];
            mf MFin[ numberOfInputSets ], MFout[ numberOfOutputSets ];
            real_t ruleStrength[ numberOfRules ];
        public:
            constexpr system( const rules *r ) : xRules( r ) {};

            inline bool setup( void )
            {
                return sys.setup( fType,
                                  inputs, numberOfInputs,
                                  outputs, numberOfOutputs,
                                  MFin, numberOfInputSets,
                                  MFout, numberOfOutputSets,
                                  xRules, numberOfRules,
                                  ruleStrength );
            }

            inline bool setupInput( const tag t,
                                    const real_t Min,
                                    const real_t Max ) noexcept
            {
                return sys.setupInput( t, Min, Max );
            }

            inline bool setupOutput( const tag t,
                                     const real_t Min,
                                     const real_t Max ) noexcept
            {
                return sys.setupOutput( t, Min, Max );
            }

            inline bool setupInputMF( const tag io,
                                      const tag mf,
                                      const shapeMF s,
                                      const real_t *cp,
                                      const real_t h = 1.0_re ) noexcept
            {
                return sys.setupInputMF( io, mf, s, cp, h );
            }

            inline bool setupInputMF( const tag io,
                                      const tag mf,
                                      mfFunction customMfs,
                                      const real_t *cp,
                                      const real_t h = 1.0_re ) noexcept
            {
                return sys.setupInputMF( io, mf, customMfs, cp, h );
            }

            inline bool setupOutputMF( const tag io,
                                       const tag mf,
                                       const shapeMF s,
                                       const real_t *cp,
                                       const real_t h = 1.0_re ) noexcept
            {
                return sys.setupOutputMF( io, mf, s, cp, h );
            }

            inline bool setupOutputMF( const tag io,
                                       const tag mf,
                                       mfFunction customMfs,
                                       const real_t *cp,
                                       const real_t h = 1.0_re ) noexcept
            {
                return sys.setupOutputMF( io, mf, customMfs, cp, h );
            }

            inline bool fuzzify( void ) noexcept
            {
                return sys.fuzzify();
            }

            inline bool deFuzzify( void ) noexcept
            {
                return sys.deFuzzify();
            }

            inline bool inference( void ) noexcept
            {
                return sys.inference();
            }

            inline bool setInput( const tag t,
                                  const real_t value ) noexcept
            {
                return sys.setInput( t, value );
            }

            inline bool getOutput( const tag t,
                                   real_t &value ) const noexcept
            {
                return sys.getOutput( t, value );
            }

            inline bool setParameter( const parameter p,
                                      const paramValue x ) noexcept
            {
                return sys.setParameter( p, x );
            }

            inline bool setDeFuzzMethod( deFuzzMethod m ) noexcept
            {
                return sys.setDeFuzzMethod( m );
            }

            inline bool setRuleWeights( real_t *rWeights ) noexcept
            {
                return sys.setRuleWeights( rWeights );
            }

            size_t getNumberOfPoints( void ) const noexcept
            {
                return sys.nPoints;
            }

            real_t operator[]( tag outTag ) const
            {
                /*cstat -CERT-STR34-C*/
                return ( static_cast<size_t>( outTag ) < sys.nOutputs ) ? sys.xOutput[ outTag ].value :  sys.xInput[ sys.nOutputs -1 ].value;
                /*cstat +CERT-STR34-C*/
            }

            system& operator<<( const tag& t ) {
                if ( static_cast<size_t>( t ) < sys.nInputs ) {
                    sys.lastTag = t;
                }
                return *this;
            }

            system& operator<<( const int& value ) {
                if ( sys.lastTag >= 0 ) {
                    sys.xInput[ sys.lastTag ].value = static_cast<real_t>( value );
                }
                return *this;
            }

            system& operator<<( const real_t& value ) {
                if ( sys.lastTag >= 0 ) {
                    sys.xInput[ sys.lastTag ].value = value;
                }
                return *this;
            }

            bool isInitialized( void ) const {
                return sys.isInitialized();
            }

            explicit operator bool() const noexcept {
                return sys.isInitialized();
            }
 
    };

    }
 
}
 
#endif /*QLIBS_FIS*/