From bd88c5df9782d2bc9b04d5cb125a5203e2c2584f Mon Sep 17 00:00:00 2001 From: tqfx Date: Mon, 26 Feb 2024 21:16:50 +0800 Subject: [PATCH] rename a_pid_fuzzy_equ to a_fuzzy_equ --- include/a/fuzzy.h | 10 +++++++- include/a/pid.h | 14 +++++------ include/a/pid_fuzzy.h | 27 ++++++++++----------- include/a/pid_neuro.h | 14 +++++------ java/src/pid_fuzzy.c | 5 ++-- java/src/pid_neuro.c | 2 +- javascript/src/a.cpp | 24 ++++++++----------- lua/src/pid.c | 41 +++++++++++++++++--------------- lua/src/pid.h | 14 +++++------ lua/src/pid_fuzzy.c | 58 ++++++++++++++++++++++++++++------------------ lua/src/pid_fuzzy.h | 14 +++++------ lua/src/pid_neuro.c | 44 +++++++++++++++++++---------------- lua/src/pid_neuro.h | 14 +++++------ python/src/a/fuzzy.pxd | 12 ++++++++++ python/src/a/pid_fuzzy.pxi | 5 ++-- python/src/a/pid_neuro.pxi | 2 +- quickjs/src/pid_fuzzy.c | 5 ++-- quickjs/src/pid_neuro.c | 2 +- src/fuzzy.c | 7 +++++- src/pid.c | 20 +++++++--------- src/pid_fuzzy.c | 40 ++++++++++++-------------------- src/pid_neuro.c | 18 +++++--------- test/pid_expert.c | 18 +++++--------- test/pid_expert.h | 14 +++++------ 24 files changed, 220 insertions(+), 204 deletions(-) create mode 100644 python/src/a/fuzzy.pxd diff --git a/include/a/fuzzy.h b/include/a/fuzzy.h index 95228d7..656310b 100644 --- a/include/a/fuzzy.h +++ b/include/a/fuzzy.h @@ -122,12 +122,20 @@ A_INTERN a_float a_fuzzy_cup_bounded(a_float a, a_float b) /*! @brief equilibrium operator + @param[in] a left-hand operand + @param[in] b right-hand operand + @return = \f$ \sqrt{ab}\sqrt{1-(1-a)(1-b)} \f$ +*/ +A_EXTERN a_float a_fuzzy_equ(a_float a, a_float b); + +/*! + @brief equilibrium operator @param[in] gamma gamma operator @param[in] a left-hand operand @param[in] b right-hand operand @return = \f$ (ab)^{1-\gamma}(1-(1-a)(1-b))^{\gamma} \f$ */ -A_EXTERN a_float a_fuzzy_equ(a_float gamma, a_float a, a_float b); +A_EXTERN a_float a_fuzzy_equ_(a_float gamma, a_float a, a_float b); #if defined(LIBA_FUZZY_C) #undef A_INTERN diff --git a/include/a/pid.h b/include/a/pid.h index 24b851c..c2beefd 100644 --- a/include/a/pid.h +++ b/include/a/pid.h @@ -47,13 +47,7 @@ extern "C" { @brief initialize for PID controller @param[in,out] ctx points to an instance of PID controller */ -A_EXTERN void a_pid_init(a_pid *ctx); - -/*! - @brief zeroing for PID controller - @param[in,out] ctx points to an instance of PID controller -*/ -A_EXTERN void a_pid_zero(a_pid *ctx); +#define a_pid_init(ctx) a_pid_zero(ctx) /*! @brief set proportional integral derivative constant for PID controller @@ -91,6 +85,12 @@ A_EXTERN a_float a_pid_pos(a_pid *ctx, a_float set, a_float fdb); */ A_EXTERN a_float a_pid_inc(a_pid *ctx, a_float set, a_float fdb); +/*! + @brief zeroing for PID controller + @param[in,out] ctx points to an instance of PID controller +*/ +A_EXTERN void a_pid_zero(a_pid *ctx); + #if defined(__cplusplus) } /* extern "C" */ namespace a diff --git a/include/a/pid_fuzzy.h b/include/a/pid_fuzzy.h index 3e09a5d..e149970 100644 --- a/include/a/pid_fuzzy.h +++ b/include/a/pid_fuzzy.h @@ -7,6 +7,7 @@ #define LIBA_PID_FUZZY_H #include "pid.h" +#include "fuzzy.h" /*! @ingroup A @@ -35,6 +36,12 @@ extern "C" { #endif /* __cplusplus */ /*! + @brief initialize for fuzzy PID controller + @param[in,out] ctx points to an instance of fuzzy PID controller +*/ +#define a_pid_fuzzy_init(ctx) a_pid_fuzzy_zero(ctx) + +/*! @brief get fuzzy relational operator for fuzzy PID controller @param[in] op enumeration for fuzzy PID controller operator @return fuzzy relational operator for fuzzy PID controller @@ -49,18 +56,6 @@ A_EXTERN a_float (*a_pid_fuzzy_op(unsigned int op))(a_float, a_float); A_EXTERN void a_pid_fuzzy_set_op(a_pid_fuzzy *ctx, unsigned int op); /*! - @brief initialize for fuzzy PID controller - @param[in,out] ctx points to an instance of fuzzy PID controller -*/ -A_EXTERN void a_pid_fuzzy_init(a_pid_fuzzy *ctx); - -/*! - @brief zeroing for fuzzy PID controller - @param[in,out] ctx points to an instance of fuzzy PID controller -*/ -A_EXTERN void a_pid_fuzzy_zero(a_pid_fuzzy *ctx); - -/*! @brief set rule base for fuzzy PID controller @param[in,out] ctx points to an instance of fuzzy PID controller @param[in] order number of order in the square matrix @@ -75,7 +70,7 @@ A_EXTERN void a_pid_fuzzy_rule(a_pid_fuzzy *ctx, unsigned int order, a_float con /*! @brief compute size of memory block for fuzzy PID controller - @param n the maximum number triggered by the rule + @param[in] n the maximum number triggered by the rule */ #define A_PID_FUZZY_BLOCK(n) (sizeof(unsigned int) * (n) * 2 + sizeof(a_float) * (n) * (2 + (n))) @@ -130,6 +125,12 @@ A_EXTERN a_float a_pid_fuzzy_pos(a_pid_fuzzy *ctx, a_float set, a_float fdb); */ A_EXTERN a_float a_pid_fuzzy_inc(a_pid_fuzzy *ctx, a_float set, a_float fdb); +/*! + @brief zeroing for fuzzy PID controller + @param[in,out] ctx points to an instance of fuzzy PID controller +*/ +A_EXTERN void a_pid_fuzzy_zero(a_pid_fuzzy *ctx); + #if defined(__cplusplus) } /* extern "C" */ namespace a diff --git a/include/a/pid_neuro.h b/include/a/pid_neuro.h index a22aba7..073cd52 100644 --- a/include/a/pid_neuro.h +++ b/include/a/pid_neuro.h @@ -39,13 +39,7 @@ extern "C" { @brief initialize for single neuron PID controller @param[in,out] ctx points to an instance of single neuron PID controller */ -A_EXTERN void a_pid_neuro_init(a_pid_neuro *ctx); - -/*! - @brief zeroing for single neuron PID controller - @param[in,out] ctx points to an instance of single neuron PID controller -*/ -A_EXTERN void a_pid_neuro_zero(a_pid_neuro *ctx); +#define a_pid_neuro_init(ctx) a_pid_neuro_zero(ctx) /*! @brief set proportional integral derivative constant for single neuron PID controller @@ -84,6 +78,12 @@ A_EXTERN a_float a_pid_neuro_run(a_pid_neuro *ctx, a_float set, a_float fdb); */ A_EXTERN a_float a_pid_neuro_inc(a_pid_neuro *ctx, a_float set, a_float fdb); +/*! + @brief zeroing for single neuron PID controller + @param[in,out] ctx points to an instance of single neuron PID controller +*/ +A_EXTERN void a_pid_neuro_zero(a_pid_neuro *ctx); + #if defined(__cplusplus) } /* extern "C" */ namespace a diff --git a/java/src/pid_fuzzy.c b/java/src/pid_fuzzy.c index ee13856..cd06dba 100644 --- a/java/src/pid_fuzzy.c +++ b/java/src/pid_fuzzy.c @@ -44,13 +44,12 @@ JNIEXPORT void JNICALL Java_liba_pid_1fuzzy_init(JNIEnv *_env, jobject _obj) jobject _ctx = (*_env)->CallObjectMethod(_env, _obj, L.alloc, (jint)sizeof(a_pid_fuzzy)); a_pid_fuzzy *ctx = (a_pid_fuzzy *)(*_env)->GetDirectBufferAddress(_env, _ctx); (*_env)->SetObjectField(_env, _obj, L.ctx, _ctx); - ctx->pid.kp = 1; ctx->pid.summax = +A_FLOAT_INF; ctx->pid.summin = -A_FLOAT_INF; ctx->pid.outmax = +A_FLOAT_INF; ctx->pid.outmin = -A_FLOAT_INF; - ctx->kp = 1; - ctx->op = a_pid_fuzzy_op(A_PID_FUZZY_EQU); + ctx->kp = ctx->pid.kp = 1; + ctx->op = a_fuzzy_equ; a_pid_fuzzy_init(ctx); } diff --git a/java/src/pid_neuro.c b/java/src/pid_neuro.c index 6c6070a..38625ba 100644 --- a/java/src/pid_neuro.c +++ b/java/src/pid_neuro.c @@ -29,7 +29,7 @@ JNIEXPORT void JNICALL Java_liba_pid_1neuro_init(JNIEnv *_env, jobject _obj) ctx->pid.summin = -A_FLOAT_INF; ctx->pid.outmax = +A_FLOAT_INF; ctx->pid.outmin = -A_FLOAT_INF; - ctx->k = 1; + ctx->k = ctx->pid.kp = 1; ctx->wp = A_FLOAT_C(0.1); ctx->wi = A_FLOAT_C(0.1); ctx->wd = A_FLOAT_C(0.1); diff --git a/javascript/src/a.cpp b/javascript/src/a.cpp index 0bcf134..31b2634 100644 --- a/javascript/src/a.cpp +++ b/javascript/src/a.cpp @@ -401,11 +401,6 @@ struct pid: public a_pid struct pid_fuzzy: public a_pid_fuzzy { - A_INLINE pid_fuzzy *set_op(unsigned int _op) - { - a_pid_fuzzy::set_op(_op); - return this; - } A_INLINE pid_fuzzy *rule(emscripten::val const &_me, emscripten::val const &_mec, emscripten::val const &_mkp, @@ -440,6 +435,11 @@ struct pid_fuzzy: public a_pid_fuzzy val.delete_(val); return this; } + A_INLINE pid_fuzzy *set_op(unsigned int _op) + { + a_pid_fuzzy::set_op(_op); + return this; + } A_INLINE pid_fuzzy *set_block(unsigned int num) { void *ptr = a_alloc(a_pid_fuzzy_block(this), A_PID_FUZZY_BLOCK(num)); @@ -470,16 +470,13 @@ struct pid_fuzzy: public a_pid_fuzzy } A_INLINE pid_fuzzy() { - pid.kp = 1; - pid.ki = 0; - pid.kd = 0; + pid.kp = kp = 1; + pid.ki = ki = 0; + pid.kd = kd = 0; pid.summax = +A_FLOAT_INF; pid.summin = -A_FLOAT_INF; pid.outmax = +A_FLOAT_INF; pid.outmin = -A_FLOAT_INF; - kp = 1; - ki = 0; - kd = 0; me = nullptr; mec = nullptr; mkp = nullptr; @@ -487,9 +484,9 @@ struct pid_fuzzy: public a_pid_fuzzy mkd = nullptr; idx = nullptr; val = nullptr; - op = a_pid_fuzzy_op(A_PID_FUZZY_EQU); order = 0; block = 0; + op = a_fuzzy_equ; a_pid_fuzzy_init(this); } A_INLINE ~pid_fuzzy() @@ -572,10 +569,9 @@ struct pid_neuro: public a_pid_neuro pid.summin = -A_FLOAT_INF; pid.outmax = +A_FLOAT_INF; pid.outmin = -A_FLOAT_INF; - pid.kp = 0; + pid.kp = k = 1; pid.ki = 0; pid.kd = 0; - k = 1; wp = A_FLOAT_C(0.1); wi = A_FLOAT_C(0.1); wd = A_FLOAT_C(0.1); diff --git a/lua/src/pid.c b/lua/src/pid.c index 2215f9f..e843a5a 100644 --- a/lua/src/pid.c +++ b/lua/src/pid.c @@ -14,10 +14,11 @@ int liba_pid_new(lua_State *L) { a_pid *const ctx = lua_newclass(L, a_pid); - a_zero(ctx, sizeof(a_pid)); lua_registry_get(L, liba_pid_new); lua_setmetatable(L, -2); ctx->kp = 1; + ctx->ki = 0; + ctx->kd = 0; ctx->summax = +A_FLOAT_INF; ctx->summin = -A_FLOAT_INF; ctx->outmax = +A_FLOAT_INF; @@ -37,6 +38,8 @@ int liba_pid_init(lua_State *L) luaL_checktype(L, 1, LUA_TUSERDATA); a_pid *const ctx = (a_pid *)lua_touserdata(L, 1); ctx->kp = 1; + ctx->ki = 0; + ctx->kd = 0; ctx->summax = +A_FLOAT_INF; ctx->summin = -A_FLOAT_INF; ctx->outmax = +A_FLOAT_INF; @@ -46,23 +49,6 @@ int liba_pid_init(lua_State *L) } /*** - zeroing for PID controller - @tparam a.pid ctx PID controller userdata - @treturn a.pid PID controller userdata - @function zero -*/ -int liba_pid_zero(lua_State *L) -{ - a_pid *const ctx = (a_pid *)lua_touserdata(L, 1); - if (ctx) - { - a_pid_zero(ctx); - return 1; - } - return 0; -} - -/*** set proportional integral derivative constant for PID controller @tparam a.pid ctx PID controller userdata @tparam number kp proportional constant @@ -149,6 +135,23 @@ int liba_pid_inc(lua_State *L) return 0; } +/*** + zeroing for PID controller + @tparam a.pid ctx PID controller userdata + @treturn a.pid PID controller userdata + @function zero +*/ +int liba_pid_zero(lua_State *L) +{ + a_pid *const ctx = (a_pid *)lua_touserdata(L, 1); + if (ctx) + { + a_pid_zero(ctx); + return 1; + } + return 0; +} + static int liba_pid_set(lua_State *L) { a_pid *const ctx = (a_pid *)lua_touserdata(L, 1); @@ -257,11 +260,11 @@ int luaopen_liba_pid(lua_State *L) static lua_fun const funcs[] = { {"new", liba_pid_new}, {"init", liba_pid_init}, - {"zero", liba_pid_zero}, {"kpid", liba_pid_kpid}, {"run", liba_pid_run}, {"pos", liba_pid_pos}, {"inc", liba_pid_inc}, + {"zero", liba_pid_zero}, }; lua_createtable(L, 0, A_LEN(funcs)); lua_fun_reg(L, -1, funcs, A_LEN(funcs)); diff --git a/lua/src/pid.h b/lua/src/pid.h index 734f679..3373451 100644 --- a/lua/src/pid.h +++ b/lua/src/pid.h @@ -41,13 +41,6 @@ int liba_pid_new(lua_State *L); int liba_pid_init(lua_State *L); /*** - zeroing for PID controller - @treturn a.pid PID controller userdata - @function zero -*/ -int liba_pid_zero(lua_State *L); - -/*** set proportional integral derivative constant for PID controller @tparam number kp proportional constant @tparam number ki integral constant @@ -84,6 +77,13 @@ int liba_pid_pos(lua_State *L); */ int liba_pid_inc(lua_State *L); +/*** + zeroing for PID controller + @treturn a.pid PID controller userdata + @function zero +*/ +int liba_pid_zero(lua_State *L); + #if defined(__cplusplus) } /* extern "C" */ #endif /* __cplusplus */ diff --git a/lua/src/pid_fuzzy.c b/lua/src/pid_fuzzy.c index 2a8ba1d..9625599 100644 --- a/lua/src/pid_fuzzy.c +++ b/lua/src/pid_fuzzy.c @@ -41,15 +41,25 @@ int liba_pid_fuzzy_die(lua_State *L) int liba_pid_fuzzy_new(lua_State *L) { a_pid_fuzzy *const ctx = lua_newclass(L, a_pid_fuzzy); - a_zero(ctx, sizeof(a_pid_fuzzy)); lua_registry_get(L, liba_pid_fuzzy_new); lua_setmetatable(L, -2); + ctx->pid.kp = ctx->kp = 1; + ctx->pid.ki = ctx->ki = 0; + ctx->pid.kd = ctx->kd = 0; ctx->pid.summax = +A_FLOAT_INF; ctx->pid.summin = -A_FLOAT_INF; ctx->pid.outmax = +A_FLOAT_INF; ctx->pid.outmin = -A_FLOAT_INF; - ctx->pid.kp = ctx->kp = 1; - ctx->op = a_pid_fuzzy_op(A_PID_FUZZY_EQU); + ctx->me = 0; + ctx->mec = 0; + ctx->mkp = 0; + ctx->mki = 0; + ctx->mkd = 0; + ctx->idx = 0; + ctx->val = 0; + ctx->order = 0; + ctx->block = 0; + ctx->op = a_fuzzy_equ; a_pid_fuzzy_init(ctx); return 1; } @@ -64,34 +74,19 @@ int liba_pid_fuzzy_init(lua_State *L) { luaL_checktype(L, 1, LUA_TUSERDATA); a_pid_fuzzy *const ctx = (a_pid_fuzzy *)lua_touserdata(L, 1); + ctx->pid.kp = ctx->kp = 1; + ctx->pid.ki = ctx->ki = 0; + ctx->pid.kd = ctx->kd = 0; ctx->pid.summax = +A_FLOAT_INF; ctx->pid.summin = -A_FLOAT_INF; ctx->pid.outmax = +A_FLOAT_INF; ctx->pid.outmin = -A_FLOAT_INF; - ctx->pid.kp = ctx->kp = 1; - ctx->op = a_pid_fuzzy_op(A_PID_FUZZY_EQU); + ctx->op = a_fuzzy_equ; a_pid_fuzzy_init(ctx); return 1; } /*** - zeroing for fuzzy PID controller - @tparam a.pid_fuzzy ctx fuzzy PID controller userdata - @treturn a.pid_fuzzy fuzzy PID controller userdata - @function zero -*/ -int liba_pid_fuzzy_zero(lua_State *L) -{ - a_pid_fuzzy *const ctx = (a_pid_fuzzy *)lua_touserdata(L, 1); - if (ctx) - { - a_pid_fuzzy_zero(ctx); - return 1; - } - return 0; -} - -/*** set fuzzy relational operator for fuzzy PID controller @tparam a.pid_fuzzy ctx fuzzy PID controller userdata @tparam int op enumeration for fuzzy PID controller operator @@ -247,6 +242,23 @@ int liba_pid_fuzzy_inc(lua_State *L) return 0; } +/*** + zeroing for fuzzy PID controller + @tparam a.pid_fuzzy ctx fuzzy PID controller userdata + @treturn a.pid_fuzzy fuzzy PID controller userdata + @function zero +*/ +int liba_pid_fuzzy_zero(lua_State *L) +{ + a_pid_fuzzy *const ctx = (a_pid_fuzzy *)lua_touserdata(L, 1); + if (ctx) + { + a_pid_fuzzy_zero(ctx); + return 1; + } + return 0; +} + static int liba_pid_fuzzy_set(lua_State *L) { a_pid_fuzzy *const ctx = (a_pid_fuzzy *)lua_touserdata(L, 1); @@ -390,7 +402,6 @@ int luaopen_liba_pid_fuzzy(lua_State *L) static lua_fun const funcs[] = { {"new", liba_pid_fuzzy_new}, {"init", liba_pid_fuzzy_init}, - {"zero", liba_pid_fuzzy_zero}, {"op", liba_pid_fuzzy_op}, {"rule", liba_pid_fuzzy_rule}, {"set_block", liba_pid_fuzzy_block}, @@ -398,6 +409,7 @@ int luaopen_liba_pid_fuzzy(lua_State *L) {"run", liba_pid_fuzzy_run}, {"pos", liba_pid_fuzzy_pos}, {"inc", liba_pid_fuzzy_inc}, + {"zero", liba_pid_fuzzy_zero}, }; lua_createtable(L, 0, A_LEN(enums) + A_LEN(funcs)); lua_int_reg(L, -1, enums, A_LEN(enums)); diff --git a/lua/src/pid_fuzzy.h b/lua/src/pid_fuzzy.h index d7288b4..cfc2a44 100644 --- a/lua/src/pid_fuzzy.h +++ b/lua/src/pid_fuzzy.h @@ -49,13 +49,6 @@ int liba_pid_fuzzy_new(lua_State *L); int liba_pid_fuzzy_init(lua_State *L); /*** - zeroing for fuzzy PID controller - @treturn a.pid_fuzzy fuzzy PID controller userdata - @function zero -*/ -int liba_pid_fuzzy_zero(lua_State *L); - -/*** set fuzzy relational operator for fuzzy PID controller @tparam int op enumeration for fuzzy PID controller operator @treturn a.pid_fuzzy fuzzy PID controller userdata @@ -120,6 +113,13 @@ int liba_pid_fuzzy_pos(lua_State *L); */ int liba_pid_fuzzy_inc(lua_State *L); +/*** + zeroing for fuzzy PID controller + @treturn a.pid_fuzzy fuzzy PID controller userdata + @function zero +*/ +int liba_pid_fuzzy_zero(lua_State *L); + #if defined(__cplusplus) } /* extern "C" */ #endif /* __cplusplus */ diff --git a/lua/src/pid_neuro.c b/lua/src/pid_neuro.c index 85656ff..03e3136 100644 --- a/lua/src/pid_neuro.c +++ b/lua/src/pid_neuro.c @@ -14,14 +14,15 @@ int liba_pid_neuro_new(lua_State *L) { a_pid_neuro *const ctx = lua_newclass(L, a_pid_neuro); - a_zero(ctx, sizeof(a_pid_neuro)); lua_registry_get(L, liba_pid_neuro_new); lua_setmetatable(L, -2); ctx->pid.summax = +A_FLOAT_INF; ctx->pid.summin = -A_FLOAT_INF; ctx->pid.outmax = +A_FLOAT_INF; ctx->pid.outmin = -A_FLOAT_INF; - ctx->k = 1; + ctx->pid.kp = ctx->k = 1; + ctx->pid.ki = 0; + ctx->pid.kd = 0; ctx->wp = A_FLOAT_C(0.1); ctx->wi = A_FLOAT_C(0.1); ctx->wd = A_FLOAT_C(0.1); @@ -39,6 +40,9 @@ int liba_pid_neuro_init(lua_State *L) { luaL_checktype(L, 1, LUA_TUSERDATA); a_pid_neuro *const ctx = (a_pid_neuro *)lua_touserdata(L, 1); + ctx->pid.kp = 1; + ctx->pid.ki = 0; + ctx->pid.kd = 0; ctx->pid.summax = +A_FLOAT_INF; ctx->pid.summin = -A_FLOAT_INF; ctx->pid.outmax = +A_FLOAT_INF; @@ -52,23 +56,6 @@ int liba_pid_neuro_init(lua_State *L) } /*** - zeroing for single neuron PID controller - @tparam a.pid_neuro ctx single neuron PID controller userdata - @treturn a.pid_neuro single neuron PID controller userdata - @function zero -*/ -int liba_pid_neuro_zero(lua_State *L) -{ - a_pid_neuro *const ctx = (a_pid_neuro *)lua_touserdata(L, 1); - if (ctx) - { - a_pid_neuro_zero(ctx); - return 1; - } - return 0; -} - -/*** set proportional integral derivative constant for single neuron PID controller @tparam a.pid_neuro ctx single neuron PID controller userdata @tparam number k proportional output coefficient @@ -160,6 +147,23 @@ int liba_pid_neuro_inc(lua_State *L) return 0; } +/*** + zeroing for single neuron PID controller + @tparam a.pid_neuro ctx single neuron PID controller userdata + @treturn a.pid_neuro single neuron PID controller userdata + @function zero +*/ +int liba_pid_neuro_zero(lua_State *L) +{ + a_pid_neuro *const ctx = (a_pid_neuro *)lua_touserdata(L, 1); + if (ctx) + { + a_pid_neuro_zero(ctx); + return 1; + } + return 0; +} + static int liba_pid_neuro_set(lua_State *L) { a_pid_neuro *const ctx = (a_pid_neuro *)lua_touserdata(L, 1); @@ -288,11 +292,11 @@ int luaopen_liba_pid_neuro(lua_State *L) static lua_fun const funcs[] = { {"new", liba_pid_neuro_new}, {"init", liba_pid_neuro_init}, - {"zero", liba_pid_neuro_zero}, {"kpid", liba_pid_neuro_kpid}, {"wpid", liba_pid_neuro_wpid}, {"run", liba_pid_neuro_run}, {"inc", liba_pid_neuro_inc}, + {"zero", liba_pid_neuro_zero}, }; lua_createtable(L, 0, A_LEN(funcs)); lua_fun_reg(L, -1, funcs, A_LEN(funcs)); diff --git a/lua/src/pid_neuro.h b/lua/src/pid_neuro.h index dd1c035..6fa8f96 100644 --- a/lua/src/pid_neuro.h +++ b/lua/src/pid_neuro.h @@ -44,13 +44,6 @@ int liba_pid_neuro_new(lua_State *L); int liba_pid_neuro_init(lua_State *L); /*** - zeroing for single neuron PID controller - @treturn a.pid_neuro single neuron PID controller userdata - @function zero -*/ -int liba_pid_neuro_zero(lua_State *L); - -/*** set proportional integral derivative constant for single neuron PID controller @tparam number k proportional output coefficient @tparam number kp proportional learning constant @@ -89,6 +82,13 @@ int liba_pid_neuro_run(lua_State *L); */ int liba_pid_neuro_inc(lua_State *L); +/*** + zeroing for single neuron PID controller + @treturn a.pid_neuro single neuron PID controller userdata + @function zero +*/ +int liba_pid_neuro_zero(lua_State *L); + #if defined(__cplusplus) } /* extern "C" */ #endif /* __cplusplus */ diff --git a/python/src/a/fuzzy.pxd b/python/src/a/fuzzy.pxd new file mode 100644 index 0000000..d56cd91 --- /dev/null +++ b/python/src/a/fuzzy.pxd @@ -0,0 +1,12 @@ +from a cimport * + +cdef extern from "a/fuzzy.h": + a_float a_fuzzy_not(a_float x) + a_float a_fuzzy_cap(a_float a, a_float b) + a_float a_fuzzy_cap_algebra(a_float a, a_float b) + a_float a_fuzzy_cap_bounded(a_float a, a_float b) + a_float a_fuzzy_cup(a_float a, a_float b) + a_float a_fuzzy_cup_algebra(a_float a, a_float b) + a_float a_fuzzy_cup_bounded(a_float a, a_float b) + a_float a_fuzzy_equ(a_float a, a_float b) + a_float a_fuzzy_equ_(a_float gamma, a_float a, a_float b) diff --git a/python/src/a/pid_fuzzy.pxi b/python/src/a/pid_fuzzy.pxi index 82c25ea..e4eca3c 100644 --- a/python/src/a/pid_fuzzy.pxi +++ b/python/src/a/pid_fuzzy.pxi @@ -1,4 +1,5 @@ from a cimport * +from a.fuzzy cimport * from a.pid_fuzzy cimport * cdef class pid_fuzzy: @@ -20,8 +21,8 @@ cdef class pid_fuzzy: self.ctx.pid.summin = -A_FLOAT_INF self.ctx.pid.outmax = +A_FLOAT_INF self.ctx.pid.outmin = -A_FLOAT_INF - self.ctx.kp = 1 - a_pid_fuzzy_set_op(&self.ctx, A_PID_FUZZY_EQU) + self.ctx.kp = self.ctx.pid.kp = 1 + self.ctx.op = a_fuzzy_equ a_pid_fuzzy_init(&self.ctx) def op(self, op: int): a_pid_fuzzy_set_op(&self.ctx, op) diff --git a/python/src/a/pid_neuro.pxi b/python/src/a/pid_neuro.pxi index ece573d..777783e 100644 --- a/python/src/a/pid_neuro.pxi +++ b/python/src/a/pid_neuro.pxi @@ -8,7 +8,7 @@ cdef class pid_neuro: self.ctx.pid.summin = -A_FLOAT_INF self.ctx.pid.outmax = +A_FLOAT_INF self.ctx.pid.outmin = -A_FLOAT_INF - self.ctx.k = 1 + self.ctx.k = self.ctx.pid.kp = 1 self.ctx.wp = 0.1 self.ctx.wi = 0.1 self.ctx.wd = 0.1 diff --git a/quickjs/src/pid_fuzzy.c b/quickjs/src/pid_fuzzy.c index 639f793..d27a013 100644 --- a/quickjs/src/pid_fuzzy.c +++ b/quickjs/src/pid_fuzzy.c @@ -29,13 +29,12 @@ static JSValue liba_pid_fuzzy_ctor(JSContext *ctx, JSValueConst new_target, int JSValue proto, clazz = JS_UNDEFINED; a_pid_fuzzy *const self = (a_pid_fuzzy *)js_mallocz(ctx, sizeof(a_pid_fuzzy)); if (!self) { return JS_EXCEPTION; } - self->pid.kp = 1; self->pid.summax = +A_FLOAT_INF; self->pid.summin = -A_FLOAT_INF; self->pid.outmax = +A_FLOAT_INF; self->pid.outmin = -A_FLOAT_INF; - self->kp = 1; - self->op = a_pid_fuzzy_op(A_PID_FUZZY_EQU); + self->kp = self->pid.kp = 1; + self->op = a_fuzzy_equ; a_pid_fuzzy_init(self); proto = JS_GetPropertyStr(ctx, new_target, "prototype"); if (JS_IsException(proto)) { goto fail; } diff --git a/quickjs/src/pid_neuro.c b/quickjs/src/pid_neuro.c index 70c0798..0425e91 100644 --- a/quickjs/src/pid_neuro.c +++ b/quickjs/src/pid_neuro.c @@ -21,7 +21,7 @@ static JSValue liba_pid_neuro_ctor(JSContext *ctx, JSValueConst new_target, int self->pid.summin = -A_FLOAT_INF; self->pid.outmax = +A_FLOAT_INF; self->pid.outmin = -A_FLOAT_INF; - self->k = 1; + self->k = self->pid.kp = 1; self->wp = A_FLOAT_C(0.1); self->wi = A_FLOAT_C(0.1); self->wd = A_FLOAT_C(0.1); diff --git a/src/fuzzy.c b/src/fuzzy.c index 72e9b24..2487d54 100644 --- a/src/fuzzy.c +++ b/src/fuzzy.c @@ -2,7 +2,12 @@ #include "a/fuzzy.h" #include "a/math.h" -a_float a_fuzzy_equ(a_float gamma, a_float a, a_float b) +a_float a_fuzzy_equ(a_float a, a_float b) +{ + return a_float_sqrt(a * b) * a_float_sqrt(1 - (1 - a) * (1 - b)); +} + +a_float a_fuzzy_equ_(a_float gamma, a_float a, a_float b) { return a_float_pow(a * b, 1 - gamma) * a_float_pow(1 - (1 - a) * (1 - b), gamma); } diff --git a/src/pid.c b/src/pid.c index 32f75a2..cf110ad 100644 --- a/src/pid.c +++ b/src/pid.c @@ -1,16 +1,5 @@ #include "a/pid.h" -void a_pid_init(a_pid *ctx) -{ - ctx->sum = 0; - ctx->out = 0; - ctx->fdb = 0; - ctx->var = 0; - ctx->err = 0; -} - -void a_pid_zero(a_pid *ctx) { a_pid_init(ctx); } - void a_pid_kpid(a_pid *ctx, a_float kp, a_float ki, a_float kd) { ctx->kp = kp; @@ -74,3 +63,12 @@ a_float a_pid_inc_(a_pid *ctx, a_float fdb, a_float err) ctx->err = err; return ctx->out; } + +void a_pid_zero(a_pid *ctx) +{ + ctx->sum = 0; + ctx->out = 0; + ctx->fdb = 0; + ctx->var = 0; + ctx->err = 0; +} diff --git a/src/pid_fuzzy.c b/src/pid_fuzzy.c index 3e8c082..b3f1017 100644 --- a/src/pid_fuzzy.c +++ b/src/pid_fuzzy.c @@ -1,33 +1,25 @@ #include "a/pid_fuzzy.h" -#include "a/fuzzy.h" -#include "a/math.h" #include "a/mf.h" -A_HIDDEN a_float a_pid_fuzzy_equ(a_float a, a_float b); -a_float a_pid_fuzzy_equ(a_float a, a_float b) -{ - return a_float_sqrt(a * b) * a_float_sqrt(1 - (1 - a) * (1 - b)); -} - a_float (*a_pid_fuzzy_op(unsigned int op))(a_float, a_float) { switch (op) { - case A_PID_FUZZY_CUP_BOUNDED: - return a_fuzzy_cup_bounded; - case A_PID_FUZZY_CUP_ALGEBRA: - return a_fuzzy_cup_algebra; - case A_PID_FUZZY_CUP: - return a_fuzzy_cup; - case A_PID_FUZZY_CAP_BOUNDED: - return a_fuzzy_cap_bounded; - case A_PID_FUZZY_CAP_ALGEBRA: - return a_fuzzy_cap_algebra; + default: + case A_PID_FUZZY_EQU: + return a_fuzzy_equ; case A_PID_FUZZY_CAP: return a_fuzzy_cap; - case A_PID_FUZZY_EQU: - default: - return a_pid_fuzzy_equ; + case A_PID_FUZZY_CAP_ALGEBRA: + return a_fuzzy_cap_algebra; + case A_PID_FUZZY_CAP_BOUNDED: + return a_fuzzy_cap_bounded; + case A_PID_FUZZY_CUP: + return a_fuzzy_cup; + case A_PID_FUZZY_CUP_ALGEBRA: + return a_fuzzy_cup_algebra; + case A_PID_FUZZY_CUP_BOUNDED: + return a_fuzzy_cup_bounded; } } @@ -108,10 +100,6 @@ out: return counter; } -void a_pid_fuzzy_init(a_pid_fuzzy *ctx) { a_pid_init(&ctx->pid); } - -void a_pid_fuzzy_zero(a_pid_fuzzy *ctx) { a_pid_zero(&ctx->pid); } - void a_pid_fuzzy_rule(a_pid_fuzzy *ctx, unsigned int order, a_float const *me, a_float const *mec, a_float const *mkp, a_float const *mki, a_float const *mkd) { @@ -236,3 +224,5 @@ a_float a_pid_fuzzy_inc(a_pid_fuzzy *ctx, a_float set, a_float fdb) a_pid_fuzzy_out_(ctx, err - ctx->pid.err, err); return a_pid_inc_(&ctx->pid, fdb, err); } + +void a_pid_fuzzy_zero(a_pid_fuzzy *ctx) { a_pid_zero(&ctx->pid); } diff --git a/src/pid_neuro.c b/src/pid_neuro.c index b4c3653..a266b42 100644 --- a/src/pid_neuro.c +++ b/src/pid_neuro.c @@ -1,17 +1,5 @@ #include "a/pid_neuro.h" -void a_pid_neuro_init(a_pid_neuro *ctx) -{ - a_pid_init(&ctx->pid); - ctx->ec = 0; -} - -void a_pid_neuro_zero(a_pid_neuro *ctx) -{ - a_pid_zero(&ctx->pid); - ctx->ec = 0; -} - void a_pid_neuro_kpid(a_pid_neuro *ctx, a_float k, a_float kp, a_float ki, a_float kd) { a_pid_kpid(&ctx->pid, kp, ki, kd); @@ -61,3 +49,9 @@ a_float a_pid_neuro_inc_(a_pid_neuro *ctx, a_float fdb, a_float err, a_float ec) ctx->ec = ec; return ctx->pid.out; } + +void a_pid_neuro_zero(a_pid_neuro *ctx) +{ + a_pid_zero(&ctx->pid); + ctx->ec = 0; +} diff --git a/test/pid_expert.c b/test/pid_expert.c index b0fc1ee..4ae4ba3 100644 --- a/test/pid_expert.c +++ b/test/pid_expert.c @@ -3,18 +3,6 @@ #pragma GCC diagnostic ignored "-Wfloat-equal" #endif /* -Wfloat-equal */ -void a_pid_expert_init(a_pid_expert *ctx) -{ - a_pid_init(&ctx->pid); - ctx->ec = 0; -} - -void a_pid_expert_zero(a_pid_expert *ctx) -{ - a_pid_zero(&ctx->pid); - ctx->ec = 0; -} - void a_pid_expert_kpid(a_pid_expert *ctx, a_float kp, a_float ki, a_float kd) { a_pid_kpid(&ctx->pid, kp, ki, kd); @@ -61,3 +49,9 @@ out: ctx->ec = ec; return ctx->pid.out; } + +void a_pid_expert_zero(a_pid_expert *ctx) +{ + a_pid_zero(&ctx->pid); + ctx->ec = 0; +} diff --git a/test/pid_expert.h b/test/pid_expert.h index 09fc999..5c94018 100644 --- a/test/pid_expert.h +++ b/test/pid_expert.h @@ -30,13 +30,7 @@ extern "C" { @brief initialize for expert PID controller @param[in,out] ctx points to an instance of expert PID controller */ -A_EXTERN void a_pid_expert_init(a_pid_expert *ctx); - -/*! - @brief zeroing for expert PID controller - @param[in,out] ctx points to an instance of expert PID controller -*/ -A_EXTERN void a_pid_expert_zero(a_pid_expert *ctx); +#define a_pid_expert_init(ctx) a_pid_expert_zero(ctx) /*! @brief set proportional integral derivative constant for expert PID controller @@ -56,6 +50,12 @@ A_EXTERN void a_pid_expert_kpid(a_pid_expert *ctx, a_float kp, a_float ki, a_flo */ A_EXTERN a_float a_pid_expert_iter(a_pid_expert *ctx, a_float set, a_float fdb); +/*! + @brief zeroing for expert PID controller + @param[in,out] ctx points to an instance of expert PID controller +*/ +A_EXTERN void a_pid_expert_zero(a_pid_expert *ctx); + #if defined(__cplusplus) } /* extern "C" */ namespace a -- 2.11.4.GIT