模糊控制器原理笔记（附简单demo以及MATLAB相关操作）

起源

1965年美国自动控制理论专家L．A．Zadeh首次提出了模糊集合理论，1974年英国E．H．Mamdani首先将模糊控制应用于锅炉和蒸汽机的自动控制。目前，模糊控制(Fuzzy Control)作为90年代的高新技术，得到非常广泛的应用，被公认为简单而有效的控制技术。

模糊控制是以模糊集合论模糊语言变量和模糊逻辑推理为基础的微机数字控制。它是模拟人的思维，构造一种非线性控制，以满足复杂的，不确定的过程控制的需要。

概念

模糊（Fuzzy）控制是用语言归纳操作人员的控制策略，运用语言变量和模糊集合理论形成控制算法的一种控制。模糊控制的最重要特征是不需要建立被控对象精确的数学模型，只要求把现场操作人员的经验和数据总结成较完善的语言控制规则，从而能够对具有不确定性、不精确性、噪声以及非线性、时变性、时滞等特征的控制对象进行控制。模糊控制系统的鲁棒性强，尤其适用于非线性、时变、滞后系统的控制

模糊控制的基本结构

模糊控制器的输入变量与输出变量

模糊控制器的输入、输出变量

模糊控制器是模仿人的一种控制。在对被控对象进行控制的过程中，一般根据设定值与被控量的偏差、偏差变化EC和偏差变化的速率ER进行决策。人对偏差最敏感，其次是偏差的变化，再次是偏差变化的速率。因此，模糊控制器的输入变量通常取、和EC或者, EC和ER，分别构成所谓一维、二维和三维模糊控制器。一维模糊控制器的动态性能不佳，通常用于一阶被控对象，二维模糊控制器的控制性能和控制复杂性都比较好，是目前广泛采用的一种形式。并且，一般选择增量算法作为模糊控制器的输出变量。

描述输入、输出变量的词汇

在模糊控制中，输入、输出变量大小是以语言形式描述的，因此要选择描述这些变量的词汇。我们的日常语言中对各种事物和变量的描述，总是习惯于分为三个等级，例如，物体的大小分为大、中、小；运动的速度分为快、中、慢；年龄的大小分为老、中、青。实际应用中一般都选用“大、中、小”三个词汇来描述模糊控制器的输入、输出变量的状态，再加上正、负两个方向和零状态，共有7个词汇，即
{负大，负中，负小，零，正小，正中，正大}
一般用这些词的英文字头缩写，即
{NB, NM, NS, O, PS, PM, PB}
一般情况下，选择上述7个词汇比较合适，但也可以多选或少选。选择较多的词汇，可以精确描述变量，提高控制精度，但会使控制规则变得复杂；选择的词汇过少，则对变量的描述过于粗糙，导致控制器的性能变差。

变量的模糊量

某个变量变化的实际范围称为该变量的基本论域。记偏差的基本论域为，偏差变化的基本论域为，模糊控制器的输出变量（系统的控制量）的基本论域为。显然，基本论域内的量是精确量，因而模糊控制器的输入和输出都是精确量，但是模糊控制算法需要模糊量。因此，输入的精确量（数字量）需要转换为模糊量，这个过程称为“模糊化”（Fuzzification）；另一方面，模糊算法所得到的模糊控制量需要转换为精确的控制量，这个过程称为“清晰化”或者“反模糊化”（Defuzzification）。
比较实用的模糊化方法是将基本论域分为n个档次，即取变量的模糊子集论域为

从基本论域到模糊子集论域的转换公式为
(3.16)
增加论域中的元素个数可以提高控制精度，但增大了计算量，而且模糊控制效果的改善并不明显。一般选择模糊论域中所含元素的个数为模糊语言词集总数的两倍以上，以确保各模糊集能较好地覆盖论域，避免出现失控现象。例如在选择上述7个词汇的情况下，可选择E和EC的论域均为

选择模糊控制器的输出变量即系统的控制量U的论域为

隶属度

为了实现模糊化，要在上述离散化了的精确量与表示模糊语言的模糊量之间建立关系，即确定论域中的每个元素对各个模糊语言变量的隶属度。
隶属度是描述某个确定量隶属于某个模糊语言变量的程度。例如，在上述和EC的论域中，+6隶属于（正大），隶属度为1.0；+5也隶属于，但隶属度要比+6差，可取为0.8；+4隶属于的程度更小，隶属度可取为0.4；显然-6～0就不隶属于了，所以隶属度取为0。
确定隶属度的值要根据实际问题的具体情况而定。实验研究结果表明，人进行控制活动时的模糊概念一般可以用正态型模糊变量描述。下面给出常用的确定模糊变量隶属度的赋值表，如表3.1、表3.2和表3.3所示。

建立模糊控制规则

模糊控制是语言控制，因此要用语言归纳专家的手动控制策略，从而建立模糊控制规则表。手动控制策略一般都可以用条件语句加以描述。条件语句的基本类型为
if A or B and C or D then U
下面介绍一种根据系统输出的误差及误差的变化趋势，消除误差的模糊控制规则。该规则用下述21条模糊条件语句来描述。

[1]if E = NB or NM and EC = NB or NM then U = PB
[2]if E = NB or NM and EC = NS or O then U = PB
[3]if E = NB or NM and EC = PS then U = PM
[4]if E = NB or NM and EC = PM or PB then U = O
[5]if E = NS and EC = NB or NM then U = PM
[6]if E = NS and EC = NS or O then U = PM
[7]if E = NS and EC = PS then U = O
[8]if E = NS and EC = PM or PB then U = NS
[9]if E = NO or PO and EC = NB or NM then U = PM
[10]if E = NO or PO and EC = NS then U = PS
[11]if E = NO or PO and EC = O then U = O
[12]if E = NO or PO and EC = PS then U = NS
[13]if E = NO or PO and EC = PM or PB then U = NM
[14]if E = PS and EC = NB or NM then U = PS
[15]if E = PS and EC = NS then U = O
[16]if E = PS and EC = O or PS then U = NM
[17]if E = PS and EC = PM or PB then U = NM
[18]if E = PM or PB and EC = NB or NM then U = O
[19]if E = PM or PB and EC = NS then U = NM
[20]if E = PM or PB and EC = O or PS then U = NB
[21]if E = PM or PB and EC = PM or PB then U = NB

以上21条模糊条件语句可以归纳为模糊控制规则表3.4

模糊关系与模糊推理

模糊控制规则实际上是一组多重条件语句，可以表示为从偏差论域到控制论域的模糊关系矩阵 R ，通过偏差的模糊向量E’ 和偏差变化的模糊向量 EC’ ，与模糊关系矩阵 R 的合成进行模糊推理，得到控制量的模糊向量，然后采用“反模糊化”方法将模糊控制向量转换为精确量。
根据模糊集合和模糊关系理论，对于不同类型的模糊规则可用不同的模糊推理方法。下面仅介绍其中的对if A then B类型的模糊规则的推理。
若已知输入为 A ，则输出为 B ；若现在已知输入为 A’ ，则输出 B’ 用合成规则求取：
(3.17)
其中模糊关系 R 定义为

例如，已知当输入的模糊集合和输出的模糊集合分别为

这里采用模糊集合的Zadeh表示法，其中a_i , b_i , 表示模糊集合所对应的论域中的元素，μ_i 而表示相应的隶属度，“—”不表示分数的意思。

则当输入
B’由下式求取，即

则
在上述运算中，“ ∩ ”为取小运算，“ ∪ ”为取大运算。
由于系统的控制规则库是由若干条规则组成的，因此对于每一条推理规则都可以得到一个相应的模糊关系。n条规则就有n个模糊关系：R1,R2,R3…Rn ，对于整个系统的全部控制规则所对应的模糊关系可对 Rn个模糊关系 ( Ri i=0,1,2,3…n )取“并”操作得到，即

模糊控制向量的模糊判决

由上述得到的控制量是一个模糊集合，需要采用“反模糊化”方法将模糊控制项转换为精确量。下面介绍两种简单实用的方法。

最大隶属度法

这种方法是在模糊控制向量中，取隶属度最大的控制量作为模糊控制器的输出。例如，当得到模糊控制向量为
(3.24)
由于控制量隶属于等级5的隶属度为最大，所以取控制量为

这种方法的优点是简单易行，缺点是完全排除了其他隶属度较小的控制量的影响和作用，没有充分利用取得的信息。

加权平均判决法

为了克服最大隶属度法的缺点，可以采用加权平均判决法，即
(3.25)
例如 则

模糊控制表

模糊关系、模糊推理以及模糊判决的运算可以离线进行，最后得到模糊控制器输入量的量化等级 , EC与输出量即系统控制量的量化等级之间 的确定关系，这种关系通常称为“控制表”。对应于前面介绍的21条控制规则的“控制表”如表3.5所列。
模糊控制表可以离线求出，作为文件存储在计算机中，计算机实时控制时只要将A/D转换得到的偏差和偏差变化 ec 进行量化，得到相应的等级 E 和 EC ，然后从文件中直接查询所需采取的控制策略。

确定实际的控制量

显然，实际的控制量 应为从控制表中查到的量化等级 乘以比例因子。设实际的控制量 的变化范围为[a, b]，量化等级为{ -n,-n+1,…,0,…,n-1,n }，则实际的控制量应为

若 a=-y_u,b=y_u ，则

例如在上述二维模糊控制器中，当 E 和 EC 的量化等级分别为-3和+1时，由控制表查得 U=3 ，则模糊控制器输出的实际控制量应为 u=3y_u/7 。

简单demo

基于VC6.0,输入e表示输出误差，ec表示误差变化率,代码源于互联网

#include <stdio.h>
#include "math.h"
#define PMAX    100   
#define PMIN    - 100  
#define DMAX    100    
#define DMIN    - 100          
#define FMAX    100       /*语言值的满幅值*/
int PFF[4] = {0, 12, 24, 48};
/*输入量D语言值特征点*/
int DFF[4] = {0, 16, 32, 64};
/*输出量U语言值特征点*/
int UFF[7] = {0, 15, 30, 45, 60, 75, 90};
/*采用了调整因子的规则表,大误差时偏重误差,小误差时偏重误差变化*/
/*a0=0.3,a1=0.55,a2=0.74,a3=0.89   */   int rule[7][7] = {
    //误差变化率 -3,-2,-1, 0, 1, 2, 3     // 误差     
      {
     -6,
     -6,
     -6,
     -5,
     -5,
     -5,
     -4,
 },   //   -3   
      {
     -5,
     -4,
     -4,
     -3,
     -2,
     -2,
     -1,
 },   //   -2 
      {
     -4,
     -3,
     -2,
     -1,
     0,
     1,
     2,
 },   //   -1 
      {
     -4,
     -3,
     -1,
     0,
     1,
     3,
     4,
 },   //    0 
      {
     -2,
     -1,
     0,
     1,
     2,
     3,
     4,
 },   //    1 
      {
     1,
     2,
     2,
     3,
     4,
     4,
     5,
 },   //    2 
      {4, 5, 5, 5, 6, 6, 6}};
   //    3

    /**********************************************************/
    int   Fuzzy(int P, int D)   /*模糊运算引擎*/
{
    int    U;
               /*偏差,偏差微分以及输出值的精确量*/
        unsigned int   PF[2],
        DF[2], UF[4];
       /*偏差,偏差微分以及输出值的隶属度*/
        int    Pn,
        Dn, Un[4];
    long   temp1, temp2;
          

        /*隶属度的确定*/
        /*根据PD的指定语言值获得有效隶属度*/
        if (P > -PFF[3] && P < PFF[3])
    {
            if (P <= -PFF[2])    
        {
               Pn = -2;
               PF[0] = FMAX * ((float)(-PFF[2] - P) / (PFF[3] - PFF[2]));
        }
            else if (P <= -PFF[1])   
  
        {
                Pn = -1;
                PF[0] = FMAX * ((float)(-PFF[1] - P) / (PFF[2] - PFF[1]));
              
        }
            else if (P <= PFF[0])   
  
        {
                Pn = 0;
                PF[0] = FMAX * ((float)(-PFF[0] - P) / (PFF[1] - PFF[0]));
              
        }
            else if (P <= PFF[1])   
  
        {
                Pn = 1;
            PF[0] = FMAX * ((float)(PFF[1] - P) / (PFF[1] - PFF[0]));
              
        }
            else if (P <= PFF[2]) 
  
        {
                Pn = 2;
            PF[0] = FMAX * ((float)(PFF[2] - P) / (PFF[2] - PFF[1]));
              
        }
            else if (P <= PFF[3])   
  
        {
                Pn = 3;
            PF[0] = FMAX * ((float)(PFF[3] - P) / (PFF[3] - PFF[2]));
              
        }
                          
   
    }
    else if (P <= -PFF[3])   
  
    {
            Pn = -2;
           PF[0] = FMAX;
          
    }
    else if (P >= PFF[3])   
  
    {
            Pn = 3;
           PF[0] = 0;
          
    }
    PF[1] = FMAX - PF[0];
       if (D > -DFF[3] && D < DFF[3])
    {
            if (D <= -DFF[2])    
        {
               Dn = -2;
            DF[0] = FMAX * ((float)(-DFF[2] - D) / (DFF[3] - DFF[2]));
        }
            else if (D <= -DFF[1])   
  
        {
                Dn = -1;
                DF[0] = FMAX * ((float)(-DFF[1] - D) / (DFF[2] - DFF[1]));
              
        }
            else if (D <= DFF[0])   
  
        {
                Dn = 0;
                DF[0] = FMAX * ((float)(-DFF[0] - D) / (DFF[1] - DFF[0]));
              
        }
            else if (D <= DFF[1])   
  
        {
                Dn = 1;
                DF[0] = FMAX * ((float)(DFF[1] - D) / (DFF[1] - DFF[0]));
              
        }
            else if (D <= DFF[2])   
  
        {
                Dn = 2;
            DF[0] = FMAX * ((float)(DFF[2] - D) / (DFF[2] - DFF[1]));
              
        }
            else if (D <= DFF[3])   
  
        {
                Dn = 3;
            DF[0] = FMAX * ((float)(DFF[3] - D) / (DFF[3] - DFF[2]));
              
        }
           
   
    }
    else if (D <= -DFF[3])   
  
    {
            Dn = -2;
            DF[0] = FMAX;
          
    }
    else if (D >= DFF[3])   
  
    {
           Dn = 3;
           DF[0] = 0;
          
    }
    DF[1] = FMAX - DF[0];
    /*使用误差范围优化后的规则表rule[7][7]*/
    /*输出值使用13个隶属函数,中心值由UFF[7]指定*/
    /*一般都是四个规则有效*/
    Un[0] = rule[Pn - 1 + 3][Dn - 1 + 3];
    Un[1] = rule[Pn + 3][Dn - 1 + 3];
    Un[2] = rule[Pn - 1 + 3][Dn + 3];
       Un[3] = rule[Pn + 3][Dn + 3];
    if (PF[0] <= DF[0])
           UF[0] = PF[0];
    else
           UF[0] = DF[0];
    if (PF[1] <= DF[0])
           UF[1] = PF[1];
    else
           UF[1] = DF[0];
    if (PF[0] <= DF[1])
           UF[2] = PF[0];
    else
           UF[2] = DF[1];
    if (PF[1] <= DF[1])
           UF[3] = PF[1];
    else
           UF[3] = DF[1];
    /*同隶属函数输出语言值求大*/
       if (Un[0] == Un[1])
    {
           if (UF[0] > UF[1])
    UF[1] = 0;
           else     UF[0] = 0;
    }
    if (Un[0] == Un[2])
    {
           if (UF[0] > UF[2])
    UF[2] = 0;
           else     UF[0] = 0;
    }
    if (Un[0] == Un[3])
    {
           if (UF[0] > UF[3])
    UF[3] = 0;
           else     UF[0] = 0;
    }
    if (Un[1] == Un[2])
    {
           if (UF[1] > UF[2])
    UF[2] = 0;
           else     UF[1] = 0;
    }
    if (Un[1] == Un[3])
    {
           if (UF[1] > UF[3])
    UF[3] = 0;
           else     UF[1] = 0;
    }
    if (Un[2] == Un[3])
    {
           if (UF[2] > UF[3])
    UF[3] = 0;
           else     UF[2] = 0;
    }

    /*重心法反模糊*/
    /*Un[]原值为输出隶属函数标号，转换为隶属函数值*/
    if (Un[0] >= 0)
           Un[0] = UFF[Un[0]];
    else
           Un[0] = -UFF[-Un[0]];
    if (Un[1] >= 0)
           Un[1] = UFF[Un[1]];
    else
           Un[1] = -UFF[-Un[1]];
    if (Un[2] >= 0)
           Un[2] = UFF[Un[2]];
    else
           Un[2] = -UFF[-Un[2]];
    if (Un[3] >= 0)
           Un[3] = UFF[Un[3]];
    else
           Un[3] = -UFF[-Un[3]];
       temp1 = UF[0] * Un[0] + UF[1] * Un[1] + UF[2] * Un[2] + UF[3] * Un[3];
    temp2 = UF[0] + UF[1] + UF[2] + UF[3];
    U = temp1 / temp2;
    return U;
}

void main()
{
    int a = 0, e, ec;
    /*int nowpoint,p1,p2=1;
FILE *in,*out;
in=fopen("in.txt","r");
out=fopen("out.txt","w");*/
    //while(!feof(in))
    while (1)
    {
          
   //fscanf(in,"%d",&nowpoint);
   //p1=nowpoint;
   //e=0-nowpoint;
   //ec= p1-p2;
   printf("请输入e:");
           scanf("%d", &e);
                printf("请输入ec:");
           scanf("%d", &ec);
           a = Fuzzy(e, ec);
           //fprintf(out,"%d   ",a);
   //printf("%d:   ",p1);
        printf("e: %d     ec: %d    ", e, ec);
           printf("a: %d   \n", a);
           //p2=p1;
    }
    //fclose(in);
    //fclose(out);
}

Matlab模糊控制工具箱

Matlab模糊控制工具箱为模糊控制器的设计提供了一种非常便捷的途径，通过它我们不需要进行复杂的模糊化、模糊推理及反模糊化运算，只需要设定相应参数，就可以很快得到我们所需要的控制器，而且修改也非常方便。下面将根据模糊控制器设计步骤，一步步利用Matlab工具箱设计模糊控制器。

首先我们在Matlab的命令窗口（command window）中输入fuzzy，回车就会出来这样一个窗口。

下面我们都是在这样一个窗口中进行模糊控制器的设计。

1．确定模糊控制器结构：即根据具体的系统确定输入、输出量。
这里我们可以选取标准的二维控制结构，即输入为误差e和误差变化ec，输出为控制量u。注意这里的变量还都是精确量。相应的模糊量为E，EC和U，我们可以选择增加输入(Add Variable来实现双入单出控制结构。

2．输入输出变量的模糊化：即把输入输出的精确量转化为对应语言变量的模糊集合。
首先我们要确定描述输入输出变量语言值的模糊子集，如{NB，NM，NS，ZO，PS，PM，PB}，并设置输入输出变量的论域，例如我们可以设置误差E（此时为模糊量）、误差变化EC、控制量U的论域均为{-3，-2，-1，0，1，2，3}；然后我们为模糊语言变量选取相应的隶属度函数。
在模糊控制工具箱中，我们在Member Function Edit中即可完成这些步骤。首先我们打开Member Function Edit窗口.


然后分别对输入输出变量定义论域范围，添加隶属函数，以E为例，设置论域范围为[-3 3]，添加隶属函数的个数为7.

然后根据设计要求分别对这些隶属函数进行修改，包括对应的语言变量，隶属函数类型。

3．模糊推理决策算法设计：即根据模糊控制规则进行模糊推理，并决策出模糊输出量。
首先要确定模糊规则，即专家经验。对于我们这个二维控制结构以及相应的输入模糊集，我们可以制定49条模糊控制规则（一般来说，这些规则都是现成的，很多教科书上都有），如图。

制定完之后，会形成一个模糊控制规则矩阵，然后根据模糊输入量按照相应的模糊推理算法完成计算，并决策出模糊输出量。
4．对输出模糊量的解模糊：模糊控制器的输出量是一个模糊集合，通过反模糊化方法判决出一个确切的精确量，凡模糊化方法很多，我们这里选取重心法。
5．然后Export to disk，即可得到一个.fis文件，这就是你所设计的模糊控制器。
前面我们已经利用模糊控制工具箱设计好了一个模糊控制器（假定我们存为fuzzy1.fis），参见：
下面我们检验一下，看看我们的控制器到底怎么样。以一个简单的电机控制为例，我们在Simulink中建立了它的模糊控制系统如下：

在用这个控制器之前，需要用readfis指令将fuzzy1.fis加载到matlab的工作空间，比如我们用这样的指令：myFLC=readfis（‘fuzzy1.fis’）；就创建了一个叫myFLC的结构体到工作空间，并在fuzzy logic controller中参数设为：myFLC。
可以看到，在模糊控制器的输入和输出均有一个比例系数，我们叫它量化因子，它反映的是模糊论域范围与实际范围之间的比例关系，例如，模糊控制器输入输出的论域范围均为[-3，3]，而实际误差的范围是[-10，10]，误差变化率范围是[-100，100]，控制量的范围是[-24，24]，那么我们就可以算出量化因子分别为0.3，0.03，8。量化因子的选取对于模糊控制器的控制效果有很大的影响，因此要根据实际情况认真选取哦。
好，现在我们可以设定仿真步长，比如定步长的10ms，就可以运行了。
运行后，产生这样一个错误：
MinMax blocks do not accept ‘boolean’ signals. The input signal(s of block ‘test_fuzzy/Fuzzy Logic Controller/FIS Wizard/Defuzzification1/Max (COA’ must be one of the MATLAB ‘uint8’, ‘uint16’, ‘uint32’, ‘int8’, ‘int16’, ‘int32’, ‘single’, or ‘double’ data types
我想很多朋友做模糊控制的时候都会遇到这个情况。没关系，这里提供两个解决办法：
1．直接在Defuzzification1这个模块中的那个比较环节后加入数据类型转换模块，将boolean转化为double型，或者双击那个比较模块，选中show additional parameters，将输出数据类型改为specify via dialog，然后选uint(8即可；但是在仿真之后，又会发现很多地方都存在这个问题，因此你不得不一个一个去修改，如果你不怕累的话。
2．第二个方法是最简单的，直接在simulation parameters->advanced将boolean logic signals选为off，强烈推荐你用这个。
好了，这些都解决了，我们就可以仿真了，例如给个方波信号，可以得到仿真曲线如下

常见问题

近来，好多研友反应从论坛下载的模块不能打开，其实这个问题好早就有人提出，也讨论了一些解决方法。为了方便大家，我整理了一下相关内容，并置顶讨论，大家如果有新的见解和解决方法，提出来大家共同探讨。
1.问题产生的原因：
（1）matlab版本的不同，比如用6.5打开7.0时，7.0的一些模块6.5没有；
（2）模型中含有不能识别的字符，比如中文等等，尤其是matlab对中文的支持不是很好（不知道是不是D版的原因）。
2.解决的办法
（1）在工作空间中输入下列命令，然后打开。
bdclose all;
Enc=‘windows-1252’;
set_param(0,‘CharacterEncoding’,Enc;
（2）用
bdclose all
set_param(0, ‘CharacterEncoding’, ‘ISO-8859-1’
即可打开6.5中编辑的带中文的mdl文件
同样如果要在7.0的模型里用中文注释，然后保存，就需要
set_param(‘ModelName’, ‘SavedCharacterEncoding’, ‘ISO-8859-1’
这里ModelName是你的mdl模型名，而且必须被打开了。（by chen1974
（3）用记事本打开
为了大家更加清楚，我给大家截了一些图片：）
a. 打不开文件，出现错误：
Warning: Unable to load model file ‘C:\MATLAB7\work\demo.mdl’. Run “bdclose all; set_param(0, ‘CharacterEncoding’, Enc” where Enc is one of Shift_JIS, windows-1252, ISO-8859-1, then load the model. The first character that is not supported in the current character encoding setting (‘ibm-1386_P100-2002’ occurs on line 37, byte offset 22. To correctly load models with non-ASCII characters, you must explicitly use the character encoding that was used to save the file. Type “help slCharacterEncoding” for more information on setting character encoding and to learn more about which encodings are commonly found on your platform.
/> In general\private\openmdl at 13
In open at 130
In uiopen at 151
b. 右键点击用写字板或记事本打开，发现原来是有汉字不能识别，将其改为英文即可，存盘退出。
c.出现问题的参数是“LastModifiedBy”，这是最后修改模型人的名字；假如你的机子装系统的时候个人名字和单位填的是中文的话就要注意了， 你装matlab时默认得也是这个中文名字，如果不改的话就会出现这个问题了。所以大家尽量用英文（包括S－function的注释），以避免不必要的麻 烦！
然后就可以打开了：）
3.最后给大家几点建议：
（1）建议大家都统一用matlab7.0版本的，一些7.0.1等等如无必要，就不要装了。顺便说一下，有人说装了matlab7.0以后，系统进程里有一个Matlab Server.exe，占用内存很大，去掉的方法就是在管理工具－>服务中将的启动类型由“自动”改为”禁止“就可以了。
（2）尽量避免用中文！
1）装matlab的时候，注意你的用户及单位一定要用英文或数字，不要用中文；
2）自己封装的模块名字不要用中文，模型中的注释也要用英文；
3）文件存放的路径也要用英文，如：C:\MATLAB7\work\matwav。
暂时先想到这么多，以后有的话会继续补充。