**Abstract**

In this work, a general purpose fuzzy controller which allows the fuzzy set ZE to be used anywhere in decision tables is proposed to handle the class of monotone functions. For guaranteed convergence and accuracy, the rules on the selection of fuzzy sets based on the defuzzification method mean-of-inversion (MOI) are given and proved. Such a guideline can relieve the users' burden on testing accuracy after design. In addition, these imposed restrictions on the selection of fuzzy sets are not unusual in the design of fuzzy controllers. Thus, the optimization on convergence speed is possible for the proposed fuzzy controller in various applications.

*Keywords*: Control
theory; Fuzzy sets; Monotone functions; Guaranteed accuracy; Decision
tables

**1. Introduction**

Since the introduction of fuzzy logic [22-23] and the fuzzy controllers [1, 9], as mentioned in [10], the lack of rigorous stability analysis was the primary reason for the slow acceptance of fuzzy controllers outside Japan. In the literature, some models for stability analysis had been proposed [2, 5-8, 11-14]; however, those models either imposed many restrictions on the design of controllers or else focused on the analysis after the design was completed. Though the use of fuzzy controllers as universal approximators has been studies in the literature [3-4], they either only proved what can be achieved instead of how to achieve it or else required a complex analysis to acquire proper design details in real applications. Sometimes, the price of those analyses could be very high. Thus, most of the time, the verification of accuracy of fuzzy controllers is done via simulations instead of theoretical analysis.

This work was partially inspired by the author's
experiments on image compression [16-19]. Although the lossy JPEG
model is one of the most widely used digital image compression
techniques for both grayscale and color still images [15], the
compression results are not predictable in advance due to a wide
variety of image data. For a picture of *MxN* pixels with
*P* grayscale levels, there are up to
possible combinations. With this extremely large number of combinations,
it is very difficult for any lossy compression model to predict
the relation of its parameters to the compression results, e.g.,
mean square error. Therefore, in a sense, the compression and
distortion ratios depend heavily on the source image data.

Fig. 1 shows the relation of the JPEG input parameter
*Quality* and the distortion ratio AGE (average grayscale
error) on 15 USC pictures using the JPEG model developed by Independent
JPEG Group. Those 15 USC pictures include eight 256x256 pictures
(Girl-1, Couple, Lady, Girl-II, House, Tree, Ball-I, and Ball-II)
and seven 512x512 pictures (Splash, Girl-III, Baboon, Lena, F16,
Park, and Pepper). The ratio AGE is defined by

(1)

where *G* is the maximum grayscale levels of
pictures and MAE (mean-absolute-error) is defined as

(2)

where and
are the corresponding frames in the original and reconstructed
pictures, respectively, *N* is the dimension of the input
vector *I* (or frame *M)*, and *F* is the total
number of frames. As seen in Fig. 1, each image has its own unique
curve which can only be known via simulations. Therefore, our
aim is to design a fuzzy controller that can deal with a large
collection of monotone functions so it is not necessary to change
the controller's configuration from function (or image in the
application of JPEG) to function.

For achieving better trade-off between distortion
and compression ratios, incorporating a fuzzy controller with
the JPEG model to achieve the automatic control during compression
process on the source side was proposed in [16]. The relation
of JPEG (including coder and decoder) and the fuzzy controller
on source side is depicted in Fig. 2 where the plant was the JPEG
model in those experiments.

As shown in Fig. 2, the plant can be characterized as

(3)

where *c* and *a* are the input and the
output of the plant, respectively, the function *f* is a
monotone function, and *e* is one of the two inputs to the
fuzzy controller and is defined as

(4)

where is the value of *e*
at step *t*, is the desired output
for the plant, and is the output value
of the plant at step *t*. The other input *p* to the
fuzzy controller at step *t* is

(5)

where and
are the maximum and the minimum values in the input domain *C,*
respectively, and . *E* and *P*
are the universal sets of *e* and *p*, respectively.
*C*, *E*, and *P* are FINITE sets of real numbers.
Without loss of generality, we assume there are *N* ()
fuzzy subsets for the fuzzy variable *e* as

(6)

As for the fuzzy variable *p*, there are *D*
() fuzzy subsets as

(7)

To help readers get the better picture of the designed fuzzy controller, the author briefly describes its mechanism used in one of simulations in [20] and summarizes the simulation results as follows:

Experiments were performed on 15 USC images which
have been widely used in image compression experiments and include
eight 256x256 images and seven 512x512 images with 256 grayscales.
Ten random initial values (38, 58, 13, 15, 51, 27, 10, 19, 12,
and 86) of *q* generated by the random number generation
function rand() in the standard C programming environment are
used to test the accuracy of the fuzzy controller. The function
used to describe the behavior of JPEG is

where g (or *a* as in Eq. 3) is the generated
AGE, and *q* (or *c* as in Eq. 3) is the value of parameter
Quality. Various components of the designed fuzzy controller are
introduced as follows:

(1) **The** **fuzzy sets**: Seven fuzzy subsets
are used--PB (positive big), PM (positive medium), PS (positive
small), ZE (zero), NS (negative small), NM (negative medium),
and NB (negative big).

For the input in Fig. 2 and the entries of decision tables, the following fuzzy subsets are used.

*NB*(-100, -50, -20),
*NM*(-45, -25, -5), *NS*(-20, -10, 0),

*ZE*(-5, 0, 5),

*PS*(0, 10, 20), *PM*(5,
25, 45), *PB*(20, 50, 100)

For the input in Fig. 2, the following fuzzy subsets are used.

NB (-100, -6, -3) NM (-5, -3, -1) NS (-2, -1, 0)

ZE (-0.5, 0, 0.5)

PS (0, 1, 2) PM (1, 3, 5) PB (3, 6, 100)

The fuzzy subsets PM, PS, ZE, NS, NM are the triangular type of fuzzy sets which can be characterized by three values: right boundary R, center C, and left boundary L, as shown in Fig. 3.

Thus, for an input crisp value *x*, the membership
value of *x* on a triangular type of fuzzy subset *A*
is calculated as

(8)

The fuzzy subset *NB* is the trapezoidal type
of fuzzy set as depicted in Fig. 4 and can be characterized by
two values, right boundary R and center C.

Thus, for an input crisp value *x*, the membership
value of *x* on the fuzzy subset *NB* is calculated
as

(9)

The fuzzy subset *PB* is also the trapezoidal
type of fuzzy set as depicted in Fig. 5 and can be characterized
by two values, left boundary L and center C.

Thus, for an input crisp value *x*, the membership
value of *x* on the fuzzy subset *PB* is calculated
as

(10)

(2) **The decision table**:

As shown in Table 1, when we deal with non-increasing
monotone functions, the upper part of decision table should use
those fuzzy subsets on the positive side of the universal Q. For
example, if the generated AGE is bigger than the desired output,
we should increase the value of *c*, i.e., ,
to decrease the AGE. Additionally, when overshooting occurs, that
is, those entries in either upper-left or lower-right parts are
fired, we decrease the magnitude of adjustment; for example, we
use fuzzy subset PM instead of PB for the entry in the upper-left
corner.

The membership grade of the decision table entry
*ij*, , is calculated by the fuzzy-min
operator as

where is the membership function defined in Eqs. 8-10, , and . The example given will illustrate how the membership values of entries are calculated. For example, the entry at row 3 and column 2 can be translated into the following if-then rule:

If is NS and
is NM, then * *is PS.

where *a* is a fuzzy variable which uses the
same universe and fuzzy subsets as *p* in this work. For
example, if (1) and ,
(2) and , then
.

(3) **The defuzzification method**: MOI is introduced
in Section 2, the mechanism of the fuzzy controller.

For the performance of controllers, guaranteed accuracy is used and measured in terms of successful trials defined as follows:

**Definition 1**. Successful
Trials: For a desired output , we say
that the fuzzy controller succeeds at a trial if any of the following
conditions is met:

Case 1: If for a non-increasing
monotone function (or for a non-decreasing
monotone function) where and
are the minimum and maximum values in the input domain *C*,
then exactly one of two following conditions is met:

(i) The final output where
is the final value of *c* after
convergence.

(ii) If there exists no such that and , then either or where is the biggest value(s) smaller than , and is the smallest value(s) bigger than .

Case 2:

(i) For a non-increasing monotone function, if , then .

(ii) For a non-decreasing monotone function, if , then .

Case 3:

(i) For a non-increasing monotone function, if , then .

(ii) For a non-decreasing monotone function, if , then .

The simulation results of three test points are summarized as follows:

As shown in Fig. 1, despite a few images that exhibit slight non-monotonicity toward one end of the plot, the designed fuzzy controller still produced all successful trials as seen in Table 2.

Although simulations indicate that the designed controller
worked very well, a theoretical analysis for accuracy is preferred.
In [21], for non-increasing discrete monotone
functions, a fuzzy controller based on the defuzzification method
mean-of-inversion (MOI) and the following decision table Table
3 for guaranteed convergence and accuracy was proposed and proved.
In Table 3, (for )
are fuzzy subsets on the negative side of *E*,
(for ) are fuzzy subsets on the positive
side of *E, and * is the fuzzy subset
*ZE* on *E*. Similarly, (for
) are fuzzy subsets on the negative side
of *P*, (for )
are fuzzy subsets on the positive side of *P,* and* *
is the fuzzy subset *ZE* on *P*.

Although fuzzy controllers are well known for their
ease of design, the analysis and testing (verification) of accuracy
is very difficult in general. Therefore, the set of rules for
guaranteed accuracy proposed in [21] is very useful; otherwise,
thousands of simulations may be needed to verify the accuracy
of design. In spite of the usefulness of guaranteed accuracy,
one of the restrictions could affect the system convergence speed
is the restriction in which fuzzy subset ZE can only be used in
the column *l* and the row *k* as shown in Table 3.
In this work, a new set of rules on the selection of fuzzy subsets
was proposed to eliminate this restriction, that is, we allow
the fuzzy subset ZE to be used anywhere in the decision table,
and still keep the guaranteed accuracy intact. Thus, to guarantee
the controller always produces the successful trials, the feedback
from the controller to the plant must
not be 0 until one of the conditions of Definition 1 is met. The
rest of the paper is organized as follows: Section 2 describes
the mechanism of the proposed fuzzy controller. The proofs of
convergence and accuracy are given in Sections 3 and 4, respectively.
Finally, the conclusions and discussions are given in Section
5.

**2. The mechanism of the fuzzy controller**

In this work, the decision tables used by the fuzzy
controller in Fig. 2 are depicted in Tables 4 (for non-increasing
monotone functions) and 5 (for non-decreasing monotone functions).
As seen in Table 4, the restriction where the fuzzy subset ZE
can only be used in the row *k* and the column *l* has
been eliminated. Since the output of the fuzzy controller
is a crisp value on *P*, for simplicity, we assume that the
entries of the decision table also use the same group of fuzzy
subsets as the input *p* does.

(1) **The decision tables**:

In Tables 4 and 5, the meanings of ,
*, *, ,
*,* and* *
are as defined in Table 3. Table 6 is an example of Table 4. As
seen in Tables 4-6, the fuzzy subset ZE is allowed to be used
at any position of decision tables.

The membership grade of the decision table entry
*ij*, , is calculated by the fuzzy-min
operator as

(11)

where is the membership function, , and .

(2) **The fuzzy sets**:

In order to obtain guaranteed accuracy, the following general restrictions are imposed on .

(i) A special triangular fuzzy subset *ZE*

(12)

is the only fuzzy subset across 0 in the input distribution
*E* and

(13)

(ii) For a crisp input value
and , there exists at least one fuzzy
subset *i*, such that for .

(iii) (14)

Similarly, the following restrictions are imposed on .

(i) A special triangular fuzzy subset *ZE*

(15)

is the only fuzzy subset across 0 in the distribution
*P* and

(16)

(ii) For a crisp input value
and , there exists at least one fuzzy
subset *j*, such that for .

(iii) (17)

In addition, the following restriction is needed for guaranteed accuracy as well.

**Restriction S**. If the
fuzzy subset ZE is assigned to the entry *ij* (row *i *and
column *j*) where and ,
then the fuzzy subsets for the two input variables *e* and
*p* must be chosen as follows:

For those crisp values and , there exists at least one entry in the decision tables such that

(i) min(, ) > 0 if the fuzzy subset of entry is not ZE, or

(ii) 1 > min(, ) > 0 if the fuzzy subset of entry is ZE.

**Example 1**: A group of
fuzzy subsets meets the criteria above.

(1) The fuzzy subsets on *P*

*NB*(-100, -50, -20), *NM*(-45,
-25, -5), *NS*(-20, -10, 0),

*ZE*(-5, 0, 5),

*PS*(0, 10, 20), *PM*(5,
25, 45), *PB*(20, 50, 100).

(2) The fuzzy subsets on *E*

*NB*(-100, -6, -2.5), *NM*(-5.25,
-3, -0.75), *NS*(-2, -1, 0),

*ZE*(-0.5, 0, 0.5),

*PS*(0, 1, 2), *PM*(0.75,
3, 5.25), *PB*(2.5, 6, 100).

(3) **The defuzzification method**:

As for defuzzification, we use the mean-of-inversion (MOI) method to calculate (for ), the feedback from the controller to JPEG, [16, 21]

(18)

where *N* and *D* are the number of rows
and columns in the decision table, respectively.

In order to guarantee that is no larger than in terms of crisp value, is decided by the following algorithm:

**Step 1**. Calculate the
corresponding crisp values of fuzzy membership
value .

(19)

where *A* is the corresponding fuzzy subset
of and is the
inverse function of which is the membership
function of fuzzy subset *A*. Note that there might be more
than one value generated by .

**Step 2**. Adjust these inverse
values for accuracy.

Case 1. Non-increasing monotone functions:

(20)

Case 2. Non-decreasing monotone functions:

(21)

**Step 3**. Adjust each inverse
value for guaranteed convergence.

(22)

**Step 4**. Pick the largest
absolute value of , ,
and .

In addition, after the calculation of Eq. 18 is adjusted as follows:

**Step 1**. If overshooting
occurs and ,

; (23)

otherwise,

(24)

where *m* is a positive integer and *u*
is the measure unit in the domain *C* ().

**Step 2**. The new input
is calculated as

(25)

where and
are the maximum and minimum values in the input domain *C*.
Whenever , a special signal **STOP**
is generated to stop the adjusting process.

** 3. Guaranteed Convergence**

The convergence of this general purpose fuzzy controller for discrete monotone functions is guaranteed by the following three conditions (as will be proved in Theorem 3):

(i) The absolute value of the current adjustment is no larger than that of the previous adjustment , that is, in the case of no overshooting.

(ii) The absolute value of the current adjustment
is smaller than that of the previous
adjustment , that is,
in the case of overshooting where *u* is the measure unit
of input *c* and .

(iii) , that is, the discrete input domain is bounded.

**Lemma 1**. At step *t+*1,
.

**Proof**: According to Eqs.
25 and 5, there are three different cases (exclusive of the first
three conditions of Eq. 25).

Case 1. : Since and , . Thus, .

Case 2. : Since , and , . Thus, .

Case 3. : .

**Lemma 2**. At step *t*,
.

**Proof**: According to Eq.
22, the absolute values of all inverse values
are no larger than , that is,
for and . According
to Eq. 18,

Thus, after the calculation of Eq. 18, . In the process of adjusting (Eqs. 23 and 24), we have two cases.

Case 1. Overshooting and : According to Eq. 23, will be adjusted such that because .

Case 2. In all other situations: Since *u* is
the measure unit of *c,* all (for
) are adjusted to *nu* where *n*
is an integer according to Eqs. 23 and 24; so does
according to Eqs. 25 and 5. Thus,

(i) if , then since before the adjustment;

(ii) if , then .

Therefore, according to Eqs. 23 and 24, after the adjustment if no overshooting occurred; otherwise, .

**Theorem 3**. The absolute
values of the feedback produced by the
fuzzy controller using the MOI method form a non-increasing monotone
series. More specifically, if
and have the same signs; otherwise, .

**Proof**: Based on Lemmas
1 and 2, if no overshooting occurs; otherwise,
.

In summary, the produced by the fuzzy controller using the MOI method are a non-increasing monotone series. Therefore, since the input domain is discrete and bounded, after a finite steps of adjustment, the adjusting process will terminate, that is, for .

**4. Guaranteed Accuracy**

We now prove the guaranteed accuracy.

**Lemma 4. **At step t, all
non-zero in Eq. 18 have same signs, that
is, they are all either positive or negative values.

**Proof**:

Case 1. Non-increasing monotone functions and : According to definition (Eq. 4),

.

Since (fuzzy subset *ZE*)
is the only fuzzy subset across 0,

Thus, according to Eq. 11 (the fuzzy min-operator),

In addition, the positive are adjusted to 0 according to Eq. 20. Therefore, there are no positive values in Eq. 18, that is, all according to Table 4.

Case 2. Non-increasing monotone functions and :

.

Since

,

In addition, the negative are adjusted to 0 according to Eq. 20. Therefore, there are no negative values in Eq. 18, that is, all according to Table 4.

Case 3. :

.

Thus, according to Eqs. 20 and 21, all .

Case 4. Non-decreasing monotone functions and :

.

Since

In addition, the negative are adjusted to 0 according to Eq. 21. Therefore, there are no negative values in Eq. 18, that is, all according to Table 5.

Case 5. Non-decreasing monotone functions and :

.

Since

In addition, the positive are adjusted to 0 according to Eq. 21. Therefore, there are no positive values in Eq. 18, that is, all according to Table 5.

**Theorem 5**. At step t,
The feedback if and only if one of the
three following conditions is met.

(1) All fired fuzzy subsets in the decision table are fuzzy subset ZE with membership values 1.

(2) Overshooting occurs and
where *u* is the minimum measure unit of input *c*.

(3) .

**Proof**: According to Eqs.
23 and 24, is equal to 0 if and only
if either

(i) and overshooting occurs. (Thus, the second condition of Theorem 5 is proved.), or

(ii) in Eq. 18.

Since there exists at least one in Eq. 18, if and only if

(according to Lemma 4)

where and .
Since the fuzzy subset *ZE* is the only fuzzy subset across
0 in the domain *P* and (according
to Eq. 16), the inverse value if and
only if either

[i] (according to Eqs. 16
and 17) (Note: For simplicity, we assume that
use the same group of fuzzy subsets as the input *p.)*, or

[ii] as defined in Eqs. 20 and 21.

Thus, the first and third conditions of Theorem 5 are proved as well.

**Lemma 6**. The adjusting
process is stop if and only if one of the three following conditions
is met.

(i)

(ii)

(iii)

**Proof**: The special signal
**STOP** is the only way to stop the adjusting process. According
to Eq. 25, the three conditions above will make ;
thus, a special signal **STOP **is generated.

If there exists no fuzzy subset ZE assigned to entries
*ij* (row *i *and column *j*) of Table 4 where
and , then Table
4 is reduced to Table 3. Since there is one additional restriction
(**Restriction S**) on the selection of fuzzy subsets for the
proposed fuzzy controllers in this work, the fuzzy subsets in
this work are the subset of those in [21]. As proved in [21],
the fuzzy controllers will always yield successful trials.

For Tables 4 and 5 with fuzzy subset ZE at entry
*ij* where and ,
the guaranteed accuracy will be proved as follows:

**Lemma 7**. For a non-increasing
monotone function and the fuzzy subset
ZE is assigned to entries *ij* (row *i *and column *j*)
of Table 4 where and ,
**if** (i) either overshooting does not occur or ,
and (ii) one of the following three conditions is true: (1) ,
, and **Restriction S**, (2) ,
(3) , **then**
when and, respectively,
when .

**Proof**: As can be seen
in the Case 1 of Lemma 4, all when
according to Table 4. However, none of the three conditions of
Theorem 5 is met here. (According to **Restriction S**, Eqs.
11, 13, and 16, the first condition of Theorem 5 is not true.)
Hence, . Similarly, as seen in the Case
2 of Lemma 4, when .

**Theorem 8**. For a non-increasing
monotone function and the fuzzy subset
ZE is assigned to the entries *ij* of Table 4 where
and , **if** (i)
and (ii) , , and
**Restriction S** where is the desired
output, *m* is an integer, and *s* is either a positive
integer or 0; **then** the final input is in the interval .

**Proof**: For serial inputs

Case 1. : Since ,
the adjusting process will stop at step *t* according to
Theorem 5 and Lemma 6.

Case 2. :

(i) Overshooting (): Since , . Therefore, according to Lemma 7, and because , , and .

(ii) No overshooting (): According to Lemma 7, and .

Case 3. :

(i) Overshooting (): Since , . Therefore, according to Lemma 7, and because , , and .

(ii) No overshooting (): According to Lemma 7, and .

**Theorem 9**. For a non-increasing
monotone function and the fuzzy subset
ZE is assigned to entries *ij* of Table 4 where
and , **if** (i)
and (ii) , , and
**Restriction S**, **then** either
or where is
the final value of *c* after convergence.

**Proof**: For serial inputs
,

Case 1. : As seen in the Case 2 of Theorem 8, .

Case 2. : ()

(i) Overshooting (): Since , . Therefore, according to Lemma 7, and because , , and .

(ii) No overshooting (): According to Lemma 7, and .

Case 3. :

(i) Either overshooting with or no overshooting (): According to Lemma 7, and because , , and .

(ii) Overshooting with : (according to Theorem 5) and (according to Eq. 25).

Case 4. : ()

(i) Either overshooting with or no overshooting (): According to Lemma 7, and because , , and .

(ii) Overshooting with : (according to Theorem 5) and (according to Eq. 25).

**Lemma 10**. For a non-increasing
monotone function and the fuzzy subset
ZE is assigned to entries *ij* of Table 4 where
and , **if** (i)
and (ii) , , and
**Restriction S**, **then** where
is the final value of *c* after
convergence.

**Proof**: Since ,
according to Lemma 7, because of no overshooting.
The value of *c* will continue to decrease until ,
and according to Eq. 25. Since ,
(according to Lemma 7 and );
thus, the adjusting process will stop at step *t+*1* *according
to Lemma 6.

**Lemma 11**. For a non-increasing
monotone function and the fuzzy subset
ZE is assigned to the entries *ij* of Table 4 where
and , **if** (i)
and (ii) , , and
**Restriction S**, **then** where
is the final value of *c* after
convergence.

**Proof**: Since
for , according to Lemma 7,
because of no overshooting. The value of *c* will continue
to increase until , and
according to Eq. 25. Since ,
(according to Lemma 7 and ); thus, the
adjusting process will stop at step *t+*1 according to Lemma
6.

**Theorem 12**. For a non-increasing
monotone function and the fuzzy subset
ZE is assigned to entries *ij* of Table 4 where
and , **if** (i) ,
(ii) , and (iii) **Restriction S**,
**then** the controller will always produce the successful
trial as defined in Definition 1

**Proof**: Based on the conclusions
on Theorems 8 and 9, Lemmas 10 and 11, and Definition 1, the fuzzy
controller using Table 4 as the decision table will always yield
the successful trial.

For non-decreasing monotone functions, guaranteed accuracy can be proved in a similar way. In summary, if the fuzzy controller is configured as described in Fig. 2 and Section 2, the successful trial as defined in Definition 1 can be always obtained for discrete monotone functions.

**5. Conclusions and Discussions**

In this work, the fuzzy controller which utilizes the defuzzification method mean-of-inversion (MOI) [16, 21] and the decision tables Tables 4 and 5 is proposed. In this proposed fuzzy controller, the fuzzy subset ZE is allowed to use at any place of decision tables to optimize the convergence speed in various applications. We prove that the accuracy in terms of successful trials defined in Definition 1 for discrete monotone functions can be obtained as long as the following rules on the selection of fuzzy subsets are used.

(1) A special triangular fuzzy subset *ZE* is
the only fuzzy subset across 0 in the distribution *E* and

.

(2) For a crisp input value and , there exists at least one for .

(3)

(4) If the fuzzy subset ZE is assigned to the entry
*ij* (row *i *and column *j*) of decision tables
where and , then
(as seen in Example 1) there exists at least one entry
such that either

[1] min(, ) > 0 if the fuzzy subset of entry is not ZE

or

[2] 1 > min(, ) > 0 if the fuzzy subset of entry is ZE.

Similar restrictions are also imposed on another
variable *p* as defined in Eq. 5. Strictly speaking, these
restrictions are quite common in the design of fuzzy controllers.
Thus, the proposed fuzzy controller can be very flexible in terms
of the selection of fuzzy subsets for various applications, and
the optimization of convergence speed is possible via simulations.

Although fuzzy controllers are well known for their ease of design, the analysis and testing (verification) of accuracy is very difficult in general. Thus, the set of rules for guaranteed accuracy proposed in this work is very useful since the selection of fuzzy sets according to the proposed rules is the only requirement to obtain accuracy for monotone functions. In addition, the proposed fuzzy controller is quite robust and can work in a less than perfect environment, e.g. neural nets, as shown in [17-18]. The possible application of the fuzzy controller utilized MOI on other mathematical functions is the ongoing research direction.

**Acknowledgments**

The author would like to thank Dr. A. H. Sung for his helpful suggestions.

**References**

[1] S. Assilian, Artificial Intelligence in the control of Real Dynamic Systems, Ph.D. Thesis, Queen Mary College (London, 1974).

[2] M. Braae and D.A. Rutherford, Theoretical and
Linguistic Aspects of the Fuzzy Logic Controller, *Automatic*
**15** (1979) 553-577.

[3] J.J. Buckley, "Sugeno Type Controllers are
Universal Controllers," *Fuzzy Sets and Systems* **53**
(1993) 299-304.

[4] J.L. Castro, "Fuzzy Logic Controllers are
Universal Approximators," *IEEE Trans. Syst. Man. Cybern.
***25** (4) (1995) 629-635.

[5] S.S. Farinwata and G. Vachtsevanos, Stability
Analysis of the Fuzzy Logic Controller, in* IEEE International
Conf. on Fuzzy Systems* '93 1377-1382.

[6] G.-C. Hwang and S.-C. Lin, A stability approach
to fuzzy control design for non-linear systems, *Fuzzy Sets
and Systems* **48** (1992) 279-287.

[7] C. Jianqin and C. Laijiu, Study on stability
of fuzzy closed-loop control systems, *Fuzzy Sets and Systems*
**57** (1993) 159-168.

[8] J.B. Kiszka, M.M. Gupta, and P.N. Nikiforuk,
Energetistic Stability of Fuzzy Dynamic Systems, *IEEE Trans.
Syst. Man Cybern.* **15** (5) (1985) 783-792.

[9] E.M. Mamdani, Applications of Fuzzy Algorithms
for Simple Dynamic Plants, *Proc. IEEE* **21** (12) (1974)
1585-1588.

[10] E.M. Mamdani, Twenty Years of Fuzzy Control:
Experiences Gained and Lessons Learnt, in *Proc. of IEEE International
Conf. on Fuzzy Systems* '93, 339-344.

[11] A. Pagni, R. Poluzzi, and G. Rizzotto, Automatic
Synthesis, Analysis and Implementation of a Fuzzy Controller,
in* Proc. od IEEE International Conf. on Fuzzy Systems* '93
105-110.

[12] K.S. Ray and D.D. Majumder, Application of Circle
Criteria for Stability Analysis of Linear SISO and MIMO Systems
Associated with Fuzzy Logic Controller, *IEEE Trans. Syst. Man,
Cybern.* **14 **(2) (1984) 345-349.

[13] K. Tanaka and M. Sugeno, Stability analysis
and design of fuzzy control systems, *Fuzzy Sets and Systems*
**45** (1992) 135-156.

[14] K. Tanaka and M. Sano, Fuzzy Stability Criterion
of a class of Nonlinear Systems, *Information Sciences* **71**
(1993) 3-26.

[15] G. K. Wallace, "The JPEG still Picture
Compression Standard," *Communications of the ACM* **34**
(4) (1991) 30-44.

[16] C.J. Wu and A.H. Sung, The Application of Fuzzy
Logic to JPEG, *IEEE Trans. Consumer Electronics* **40 **(4)
(1994) 976-984.

[17] C.J. Wu, A.H. Sung, and H.S. Soliman, "A
Fuzzy ART Network with Fuzzy Control for Image Data Compression,"
in *Proc. of IASTED Int. Conf. on Modeling, Simulation and Control
in the Process Industry* (Otiwa, Canada, 1994) 95-98.

[18] C.J. Wu, A.H. Sung, and H.S. Soliman, "An
ART Network with Fuzzy Controller for Image Data Compression,"
in *Proc. of IEEE Int. Conf. on Fuzzy Systems *(Orlando,
FL, 1994) 1743-1748.

[19] C.J. Wu and A.H. Sung, "Comparison of the
MOI, the COA, and the MOM Methods in the application of JPEG,"
in *Proc. of IEEE Int. Conference on Systems, Man and Cybernetics*
(Vancouver, British Columbia, Canada, 1995) 2019-2024.

[20] C.J. Wu, "A General Purpose Fuzzy Controller for JPEG and Monotone functions," Ph.D. Thesis, New Mexico Tech (Socorro, New Mexico, 1995).

[21] C.J. Wu and A.H. Sung, A General Purpose Fuzzy
Controller for Monotone Function, *IEEE Trans. Syst. Man. Cybern.,*
to appear*.*

[22] L.A. Zadeh, Fuzzy Sets, *Inform. Contr.*
**8 **(1965) 338-353.

[23] L.A. Zadeh, Outline of a New Approach to the
Analysis of Complex Systems and Decision Processes, *IEEE Trans.
Syst. Man. Cybern.* **3** (1) (1973) 28-44.