liba 0.1.15

An algorithm library based on C/C++
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/*!
 @file fuzzy.h
 @brief fuzzy operator
*/

#ifndef LIBA_FUZZY_H
#define LIBA_FUZZY_H

#include "a.h"

/*!
 @ingroup liba
 @addtogroup a_fuzzy fuzzy operator
 @{
*/

#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
#if defined(LIBA_FUZZY_C)
#undef A_INTERN
#define A_INTERN A_INLINE
#endif /* LIBA_FUZZY_C */

/*!
 @brief complementary operator
 @param[in] x membership
 @return = \f$ 1-x \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_not(a_float x);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_not(a_float x) { return 1 - x; }
#endif /* A_HAVE_INLINE */

/*!
 @brief fuzzy intersection operator
 @param[in] a left-hand operand
 @param[in] b right-hand operand
 @return = \f$ \min(a,b) \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_cap(a_float a, a_float b);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_cap(a_float a, a_float b) { return A_MIN(a, b); }
#endif /* A_HAVE_INLINE */

/*!
 @brief algebraic product operator
 @param[in] a left-hand operand
 @param[in] b right-hand operand
 @return = \f$ ab \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_cap_algebra(a_float a, a_float b);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_cap_algebra(a_float a, a_float b) { return a * b; }
#endif /* A_HAVE_INLINE */

/*!
 @brief bounded product operator
 @param[in] a left-hand operand
 @param[in] b right-hand operand
 @return = \f$ \max(a+b-1,0) \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_cap_bounded(a_float a, a_float b);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_cap_bounded(a_float a, a_float b)
{
    a_float const c = a + b - 1;
    return A_MAX(c, 0);
}
#endif /* A_HAVE_INLINE */

/*!
 @brief fuzzy union operator
 @param[in] a left-hand operand
 @param[in] b right-hand operand
 @return = \f$ \max(a,b) \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_cup(a_float a, a_float b);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_cup(a_float a, a_float b) { return A_MAX(a, b); }
#endif /* A_HAVE_INLINE */

/*!
 @brief algebraic sum operator
 @param[in] a left-hand operand
 @param[in] b right-hand operand
 @return = \f$ a+b-ab \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_cup_algebra(a_float a, a_float b);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_cup_algebra(a_float a, a_float b) { return a + b - a * b; }
#endif /* A_HAVE_INLINE */

/*!
 @brief bounded sum operator
 @param[in] a left-hand operand
 @param[in] b right-hand operand
 @return = \f$ \min(a+b,1) \f$
*/
#if !defined A_HAVE_INLINE || defined(LIBA_FUZZY_C)
A_EXTERN a_float a_fuzzy_cup_bounded(a_float a, a_float b);
#endif /* A_HAVE_INLINE */
#if defined(A_HAVE_INLINE) || defined(LIBA_FUZZY_C)
A_INTERN a_float a_fuzzy_cup_bounded(a_float a, a_float b)
{
    a_float const c = a + b;
    return A_MIN(c, 1);
}
#endif /* A_HAVE_INLINE */

/*!
 @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);

#if defined(LIBA_FUZZY_C)
#undef A_INTERN
#define A_INTERN static A_INLINE
#endif /* LIBA_FUZZY_C */
#if defined(__cplusplus)
} /* extern "C" */
#endif /* __cplusplus */

/*! @} a_fuzzy */

#endif /* a/fuzzy.h */