精华内容
下载资源
问答
  • 约束条件下多元函数条件极值的充分条件,杨斌,沙春宏,在等约束条件下用 乘数法、多元隐函数求导法以及有条件极值化无条件极值的方法推导证明了多元函数极值的充分条件,并给出易于计�
  • 带有约束条件的遗传算法MATLAB源程序
  • 约束条件下智能飞行器航迹快速规划多约束条件下智能飞行器航迹快速规划
  • matlab遗传算法求多目标函数有无约束条件的最优解项目
  • 本代码是基于有约束条件的寻优问题,采用APSO可以加快寻优的速度,修改参数比较简单,目标函数和上下限根据自身的需要进行改动,,可以实现目标函数的寻优
  • 约束条件

    千次阅读 2020-04-06 16:06:17
    如图-1所示设置约束条件 图-1 1.2 步骤 实现此案例需要按照如下步骤进行。 步骤一:设置约束 1)在db2库里创建t2表时设置字段约束条件 mysql> mysql> create database db2; //建库 Query OK, 1 row ...

    1.1 问题

    具体要求如下:

    如图-1所示设置约束条件
    

    在这里插入图片描述
    图-1

    1.2 步骤

    实现此案例需要按照如下步骤进行。

    步骤一:设置约束

    1)在db2库里创建t2表时设置字段约束条件

    mysql>
    mysql> create database db2; //建库
    Query OK, 1 row affected (0.00 sec)
    mysql> use  db2; //切换库
    Database changed
    mysql> create table  t2 (  //建表
        -> class   char(9),
        -> name    char(10) not null  ,
        -> age     tinyint  not null default  19 ,
        -> likes   set("a","b","c","d")  default  "a,b"
        -> );
    Query OK, 0 rows affected (0.05 sec)
    mysql> desc t2; //查看表结构
    +-------+----------------------+------+-----+---------+-------+
    | Field | Type                 | Null | Key | Default | Extra |
    +-------+----------------------+------+-----+---------+-------+
    | class | char(9)              | YES  |     | NULL    |       |
    | name  | char(10)             | NO   |     | NULL    |       |
    | age   | tinyint(4)           | NO   |     | 19      |       |
    | likes | set('a','b','c','d') | YES  |     | a,b     |       |
    +-------+----------------------+------+-----+---------+-------+
    4 rows in set (0.00 sec)
    mysql>
    mysql> insert into  t2  values (null,"bob",29,"c,d");
    Query OK, 1 row affected (0.05 sec)
    mysql> insert into  t2(class,name) values ("nsd1902","tom");
    Query OK, 1 row affected (0.05 sec)
    mysql> insert into  t2  values (null,null,null,null);
    ERROR 1048 (23000): Column 'name' cannot be null  //不允许赋null值
    MariaDB [db2]>
    MariaDB [db2]> select  * from db2.t1;  //查看记录
    +---------+------+-----+-------+
    | class   | name | age | likes |
    +---------+------+-----+-------+
    | NULL    | bob  |  29 | c,d   |
    | nsd1902 | tom  |  19 | a,b   |
    +---------+------+-----+-------+
    2 rows in set (0.00 sec)
    mysql>
    
    展开全文
  • 获得全国研究生数学建模三等奖 代码供大家学习参考讨论 2019年第十六届中国研究生数学建模竞赛F题 多约束条件下智能飞行器航迹快速规划
  • 计算系统的设计其实就是在玩约束条件的游戏。一个设计良好的系统就像是个定制化的运输箱:它的外部有锁扣和手柄,但从里面装的东西来看其内部设计,却往往给人印象不佳。如果要设计一个优雅简洁的容器,你应该聚焦在...
  • 1.设置主键约束: 主键约束是最常用的一种约束,设置主键约束的关键字是PRIMARY KEY。 语法形式: ①.定义字段是时主键约束 col_name data_type PRIMARY KEY ②.定义所有字段后设置主键约束 PRIMARY KEY (col...
  • NSGA2 约束条件处理的方法,包括非线性约束。
  • 对非线性约束条件下的优化问题提出了三个广义投影梯度方法。算法A能够求解非线性不等式约束优化问题。在此基础上,又提出了能够求解非线性等式和不等式约束优化问题的算法B.进一步,通过简化算法A,又给出了能够专门...
  • MySQL创建表和约束条件(四)

    千次阅读 多人点赞 2019-11-15 14:09:16
    我们在创建表的命令时, 用这么两个东西, 列级别约束条件和表级别约束条件约束条件是干什么用的呢? 用什么作用效果呢? 数据库是存储,管理和操作数据的的仓库, 而表是真正存储数据的, 更准确的说,所有的...

    古语有云: 万恶淫为首,百善孝为先。 我们后辈当自勉。

    上一章简单介绍了 MySQL的数据类型(三),如果没有看过,请观看上一章

    一. 创建表

    上一章时,我们学习了 MySQL的数据类型, 就像Java 知道了 int,string 之后,就该学习类了, 现在,我们知道了数据类型,就该去学习表 Table了。

    在创建表时,一定要在 database 里面进行创建, 既先使用 use 数据库名来选择数据库, 再进行创建, 否则会提示 “No database selected” 的错误。

    创建表语句:

    		create table 表名(
    				列名1  数据类型  [列级别约束条件] [默认值],
    				列名2  数据类型  [列级别约束条件] [默认值],
    				......
    				列名n  数据类型  [列级别约束条件] [默认值],
    
    				[表级别约束条件]
    	
    		);
    

    其中 表名,列名1,列名2,列名n 就像Java 里面的变量一样,不能用关键字。 但与Java 不同的是, MySQL不区分大小写。 这一点,与HTML一样。

    一.一 查询该数据库下所有的表

    使用 show tables; 命令进行查询该数据库下的表。

    要先使用 use 数据 库名先选择数据库。 使用 yuejl数据库。

    有图片。

    查询所具有的表 show tables;

    有图片。

    这个表 t 是上一章在测试timestamp时创建的。

    一.二 创建一个简单的表 temp1

    创建一个简单的表, 里面只有一个字段 name, 类型是 varchar 类型, 长度是10.

    不要忘记 先 use 数据库名 来选择数据库。

    按照上面的创建表的语句进行创建:

     create table t2(
        name varchar(10)
       );
    

    有图片

    一.三 创建一个复杂的表 temp2

    创建一个复杂的表,与老蝴蝶常用的User.java 类一样,具有 id(int类型),name(varchar类型),sex(varchar类型),age(int类型),description(varchar类型) 五个字段。

    (创建时,要按照一定的层次进行书写,这样显的帅气。)

    create table t3(
         id int(11),
         name varchar(20),
        sex varchar(10),
         age int(3),
        description varchar(100)
       );
    

    有图片。

    一.四 展示所有的表

    用 show tables; 命令进行展示

    有图片。

    刚才的两个表 t2,t3 放置到这里面了。

    一.五 创建表时常见错误

    1 . 表名已经存在, 会报 表已经存在的错误
    有图片。

    2 . 列名最后一个 写添加了 , 号, 报错。

    有图片

    3 . 列与列之间,没有加 ,号报错

    有图片。

    要想 用sql语句创建表时,不报错,只有多练,多写。 前期学习者建议用sql去创建表,不建议使用数据库连接工具去创建表。

    二. 约束条件

    二.一 约束条件的由来

    我们在创建表的命令时, 用这么两个东西, 列级别约束条件和表级别约束条件。 约束条件是干什么用的呢? 用什么作用效果呢?

    数据库是存储,管理和操作数据的的仓库, 而表是真正存储数据的, 更准确的说,所有的数据都是放置在表里面的。 我们希望在存储数据之前,就希望能对数据进行一下验证, 就像 Web网站里面的前端验证和后端数据验证, 登录过滤器,权限过滤器一样, 使正确的数据才能够正常的插入,使错误的数据不能够正常插入,提示报错, 使表有个自我检查的功能。 数据库设计者们发现有这么几个常用的小验证,小约束:

    1 . 这个列上面的属性值 必须要存在。 这就是非空约束

    2 . 这个列上面的属性值必须要唯一,不能重复。 这就是唯一约束

    3 . 这个列或者这两个列可以唯一确定这一行,这一行能够通过这个列或者这两列与 其他的行区别开来。 这就是主键约束

    4 . 这个列上的值如果没有手动填充值,数据库表默认提供一下,如性别,没有填写,默认是男。 这就是默认值约束

    5 . 这个列的值是往上增加的,并且与它上一行的值有关系。 如 num次数, 它上一行的值是1, 它这一行的值是2, 它下一行的值是 3 ,下下一行的值是4。 希望这个1,2,3,4 是表自己递增的, 并不是手动插入的。 这就是自增约束。

    6 . 这个列上的值,一定来源于其他表中的值,并不是凭空出现的。发生在两个表之间。 如员工的部门属性的值,一定来源于部门表中的值。 这就是外键约束

    7 . 这个列上的值,只能是规定好的值,不能是其他以外的值。 如性别, 只能是男或者女。 手动添加其他值,包括 保密,未知,太监,人妖 之类的,都不能正确插入。 这叫做检查约束(MySQL数据库中不起作用)。

    其中,1,2,3,4,5,7 是发生在一个表内的约束, 而6是发生在两个表之间的约束。

    上面专业的说法,叫做 数据完整性。

    数据完整性分为三个部分:

    1 . 实体完整性

    2 . 域完整性

    3 . 引用完整性

    实体完整性这项规则要求每个数据表都必须有主键,而作为主键的所有字段,其属性必须是独一及非空值。

    限制字段中的数据必须乎合预设的数据类型。

    参照的完整性不允许关系中有不存在的实体引用。

    使用约束,可以很方便的保证插入数据的正确性,避免逻辑错误数据的出现,但不能保证业务错误数据的出现。 业务错误数据,需要通过业务流程控制来避免。

    二.二 约束条件的分类

    • 主键约束 Primary Key (简称 PK)
    • 非空约束 Not Null
    • 唯一约束 Unique
    • 外键约束 Foreign Key (简称 FK)
    • 默认约束 Default
    • 检查约束 Check(MySQL中不起作用)
    • 自增约束 AUTO_INCREMENT

    下面,老蝴蝶分别对其进行详细的讲解。

    三. 主键约束 Primary Key

    主键约束 分为两种, 一种是 单字段主键, 另外一种是多字段联合主键。

    三.一 单字段主键

    1 . 在创建字段时, 指定 列级别约束条件

     			列名  数据类型   Primary Key  [默认值]
    

    如:

    create table pk4(
         id int(11) primary key,
       	 name varchar(10)
        );
    

    有图片。

    2 . 在创建完所有列之后, 指定 表级别约束条件

    	[constraint 约束名] primary key (列名)
    

    其中, 约束名通常命名为: PK_表名。 常常省略 constraint 约束名, 直接用 primary key (列名)

     create table pk5(
        id int(11),
        name varchar(10),
        primary key (id)
       );
    

    有图片。

    三.二 多字段联合主键

    多字段联合主键只能使用 表级别约束条件

    	[constraint 约束名]  primary key (列名1,列名2)
    

    也常常省略 constraint 约束名。

    如 创建学生与课程 的成绩表。 其中,学生编号和课程编号是联合 主键。

     create table pk6(
        stuId int(11),  -- 学生编号
         courseId int(11), -- 课程编号
         score double(5,2),
        primary key (stuId,courseId)
      );
    

    在这里插入图片描述

    三.三 演示主键约束

    用 pk4 表做例子吧。 (关于数据的插入,后面章节会详细讲解)

    1 . 先插入一个编号为 1,名称为两个蝴蝶飞 的记录。

    insert into pk4(id,name) values(1,'两个蝴蝶飞');
    

    有图片。

    2 . 再插入一个编号为1,名称为老蝴蝶的记录。

    insert into pk4(id,name) values(1,'老蝴蝶');
    

    有图片。

    编号 id是重复的,不能重复性插入, 会报错。

    四. 非空约束 not null

    只能指定一个单字段为非空约束,没有联合字段做为非空约束。 可以让多个字段都为非空约束。

    	列名  数据类型  not null [默认值]
    

    四.一 创建非空约束

    活学活用,将前面的主键约束再练习一遍。

      create table n7(
        id int(11) primary key,
        name varchar(20) not null
       );
    


    注意,只有这一种写法。 没有 not null (name) 作为表级别约束条件的, 只能放在列级别约束。

    四.二 演示非空约束

    1 . name有值, 正常插入

    insert into n7(id,name) values(1,'两个蝴蝶飞');
    

    有图片。

    2 . name 没有值 或者插入值为 null

    insert into n7(id) values(2);
    

    有图片。

    insert into n7(id,name) values(2,null);
    

    有图片。

    五. 唯一约束 Unique

    可以为空,MySQL也允许其他的列也可以为null.这一点不像SQL Server 数据库。

    五.一 创建列约束条件的 唯一约束

    命令:

    	列名  数据类型  unique 
    

    创建语句:

    create table u8(
        id int(11) primary key,
        name varchar(20) unique
    );
    

    有图片。

    五.二 创建表约束条件的 唯一约束

    也可以创建表级别的唯一约束

    [constraint 唯一约束名] unique (列名)
    

    创建语句:

    	create table u9(
        	 id int(11) primary key,
       		 name varchar(20),
        	unique (name)
        );
    

    在这里插入图片描述

    五.二 演示唯一约束

    以 u8 表为例。

    1 .先插入一条数据, id为1, name为两个蝴蝶飞

    insert into u8(id,name) values(1,'两个蝴蝶飞');
    

    有图片。

    2 . 再创造一条数据, id为3, name仍然为两个蝴蝶飞。 name 重复了。

    insert into u8(id,name) values(3,'两个蝴蝶飞');
    

    在这里插入图片描述

    3 . 但可以插入一条空的值, 如name 的值插入为 null

    insert into u8(id,name) values(4,null);
    

    有图片。

    但 null的值,可以有多个。 再插入 id为5,名称仍然为null 的。

    insert into u8(id,name) values(5,null);
    

    有图片。

    查询一下: select * from u8;

    有图片。

    说明,唯一约束可以插入多个 null的值,并不是唯一的null值。

    六. 默认约束 default

    命令:

    	列名  数据类型  default 默认值
    

    默认约束是,如果不填入这个属性值,就用默认值代替,如果填入了,哪怕填入的值是空,也用填入的值。

    六.一 创建默认约束

    令 性别默认是 男.

    create table d10(
        id int(11) primary key,
         name varchar(20),
         sex varchar(10) default '男'
       );
    

    在这里插入图片描述

    六.二 演示默认约束

    1 . 插入一条正常的数据, 性别是男。

     insert into d10(id,name,sex) values(1,'两个蝴蝶飞','男');
    

    有图片。

    2 . 插入一条正常的数据,性别是女.

     insert into d10(id,name,sex) values(2,'精灵妹','女');
    

    有图片。

    3 . 插入一条数据,不指定性别。

     insert into d10(id,name) values(3,'老蝴蝶');
    

    有图片。

    4 . 插入一条数据,性别为null 值。

    insert into d10(id,name,sex) values(4,'岳泽霖',null);
    

    在这里插入图片描述

    5 . 查询刚才的数据 select * from d10;

    有图片。

    七 检查约束 check (MySQL数据库被分析,但是会被忽略)

    七.一 MySQL 创建列级别约束 (不起作用)

    命令:

    	列名  数据类型 check (sql表达式)
    

    可以放置值列表, 表示插入的值必须在值列表里面。 也可以放置sql表达式,表示插入的值必须符合sql表达式

    1 . 创建和演示 性别只能是男或者女

    create table d11(
         id int(11) primary key,
         name varchar(20),
         sex varchar(10) check(sex in ('男','女'))
       );
    

    有图片。

    插入性别是男 数据。

    insert into d11(id,name,sex) values(1,'两个蝴蝶飞','男');
    

    有图片

    插入性别是保密的数据

    insert into d11(id,name,sex) values(2,'老蝴蝶','保密');
    

    有图片。

    发现,竟然可以插入, 检查约束并没有起作用。

    去谷歌一下, 里面提到了 MySQL 检查约束不起作用的问题。

    CHECK
    The CHECK clause is parsed but ignored by all storage engines. See Section 1.8.2.3, “Foreign Key Differences”

    但MySQL 可以使用其他的方式来代替, 如enum 枚举类型,或者触发器。 但老蝴蝶这儿不讲解。

    为了系统的连贯性,另外检查约束 check 确实我也不太懂,所以决定用 Oracle 数据库来讲解。 Oracle 数据库支持 检查约束 Check.

    以下的内容,都是用Oracle 进行创建的。 plsql工具。

    七.二 Oracle 创建列级别约束 (起作用)

    1 . 创建和演示性别只能是男或者女

    创建表:

     create table t1(
           id int primary key,
           name varchar2(20),
           sex varchar(10) check(sex in ('男','女')) -- 也可以用  check(sex='男' or sex='女')
         );
    

    插入数据:

    	insert into t1(id,name,sex) values(1,'两个蝴蝶飞','男'); -- 正常插入
         insert into t1(id,name,sex) values(2,'老蝴蝶','保密'); -- 会提示错误
    

    有图片。

    检查约束好使。

    2 . 创建和演示 年龄必须大于18岁 小于60

    创建表:

    create table t2(
               id int primary key,
               name varchar2(20),
               age int check(age>=18 and age<=60)
          );
    

    插入数据:

    	 insert into t2(id,name,age) values(1,'两个蝴蝶飞',20); -- 正常插入
          
          insert into t2(id,name,age) values(2,'岳泽霖',16); -- 会提示错误
          
          insert into t2(id,name,age) values(3,'老蝴蝶',62); --会提示错误
    

    有图片。

    检查约束好使。

    七.三 Oracle 创建表级别约束 (起作用)

    与列级别约束 基本类似 。

    创建表:

     create table t3(
               id int primary key,
               name varchar2(20),
               sex varchar(10),
               check(sex in ('男','女')) -- 也可以用  check(sex='男' or sex='女')
           );
    

    插入数据:

     	  insert into t3(id,name,sex) values(1,'两个蝴蝶飞','男'); -- 正常插入
          insert into t3(id,name,sex) values(2,'老蝴蝶','保密'); -- 会提示错误
    

    年龄的那个类似:

    创建表:

    create table t4(
               id int primary key,
               name varchar2(20),
               age int,
               check(age>=18 and age<=60)
          );
    

    插入数据:

    	 insert into t4(id,name,age) values(1,'两个蝴蝶飞',20); -- 正常插入
          
          insert into t4(id,name,age) values(2,'岳泽霖',16); -- 会提示错误
          
          insert into t4(id,name,age) values(3,'老蝴蝶',62); --会提示错误
    

    八. 自增约束 AUTO_INCREMENT

    自增约束,只能用于整数类型,默认开始值是1,每次增加1,用于数据库生成不重复的主键。(但在高并发环境下,这种方式生成的主键不一定正确)

    	列名  数据类型  AUTO_INCREMENT
    

    八.一 创建自增约束

     create table a12(
         id int(11) primary key auto_increment,
         name varchar(20)
       );
    

    有图片

    八.二 演示自增约束

    1 . 插入第一个数据,不插入id 的值

    insert into a12(name) values('两个蝴蝶飞');
    

    有图片。

    2 . 插入第二个数据,不插入id的值

    insert into a12(name) values('老蝴蝶');
    

    有图片

    3 . 查询数据

    有图片。

    九. 外键约束 Foreign Key

    外键约束不像上面的那些约束,是发生在一个表之间的, 外键约束 Foreign Key 是发生在两个表之间的, 这两个表,一个叫主表(父表), 一个叫从表(子表)。 其中,在子表里面定义外键约束, 引用主表中的主键。 外键可以是一列也可以是多列, 但一般都是一列。 一个表里面可以给多个列都定义外键。 就像 员工的课程成绩表一样, 员工编号是员工表的外键, 课程编号是课程表的外键。 外键是参数完整性, 里面的值可以为null值, 但如果不为null值, 则必须是主表主键的某个值。 注意,子表的外键必须引用的是主表的主键,主表的 unqiue 属性都不行,必须是主键。

    九.一 创建外键约束 Foreign Key

    命令:

    	[constraint 外键约束名] foreign key (列名)  references 主表名(主键列名)
    

    是表级别的约束条件。

    建议是用户自己手动添加外键约束名, constraint 外键约束名 不省略。

    常见的部门和员工表。 即员工表里面的部门编号一定是部门表的主键。

    1 . 创建部门表 dept

    create table dept(
        id int(11) primary key,
        name varchar(20)
        );
    

    有图片。

    2 .创建员工表 user

    create table user(
        id int(11) primary key,
         name varchar(20),
         description varchar(100),
         deptId int(11),
         constraint fk_user_deptId foreign key(deptId) references dept(id)
        );
    

    有图片。

    创建外键成功。

    九.二 外键约束演示

    1 . 先往部门表里面插入两条数据

    insert into dept(id,name) values(1,'信息部'),(2,'开发部');
    

    有图片。

    2 .往user 表里面插入 部门编号为 1的数据, 是正确的数据

     insert into user(id,name,description,deptId) values(1,'两个蝴蝶飞','一个快乐的程序员',1);
    

    有图片。

    3 . 往user 表里面插入部门编号为3的数据。 没有这个部门,是错误的数据。

     insert into user(id,name,description,deptId) values(2,'老蝴蝶','一个快乐的程序员',3);
    

    有图片。

    报外键约束的错误。 子表中插入父表中主键没有的属性值会报错。

    4 . 删除父表中的数据, 即删除父表中 部门编号为1的那条数据

    delete from dept where id=1;
    

    有图片。

    因为父表中的数据在子表中被引用了,所以是无法直接删除的, 可以先将子表中引用的那条数据删除,或者将deptId 更新成null, 再删除父表中的数据才可以。

    update user set deptId=null where id=1;
    
    delete from dept where id=1;
    

    有图片。

    十. 查看表结构

    十.一 describe 表名/desc 表名 查看

    describe user;
    

    有图片。

    也可以用简写的形式 : desc 表名

    desc user;
    

    有图片。

    侧重点是各个列的信息。

    其中:

    1. filed      指的是列名
    2. type     指的是列名的数据类型
    3. null     表示该列是否可以存储null值
    4. key     是否已经编制索引。 PRI 表示主键,UNI 表示 unique 索引的一部分, MUL 表示可允许出现多次
    5. Default      是否有默认值
    6. extra:     该列的附加信息, 如AUTO_INCREMENT

    十.一 show create table 表名 查看

    show create table user\G	
    

    有图片。

    会将创建 table 时的sql 语句打印出来, 还包括引擎和编码格式。

    侧重点是sql 创建语句。

    加\G 不加 \G 都可以, 加\G 可以使显示结果更加直观。



    谢谢!!!
    展开全文
  • 三次样条插值端点约束条件的构造与Matlab实现.pdf
  • MATLAB实现粒子群算法的进阶讲解(多维+约束条件

    万次阅读 多人点赞 2019-11-12 18:46:53
    我们在之前的博客中,对粒子群算法的实现进行了讲解,主要讲解了粒子...3,如果目标函数存在约束条件,该如何编写代码? 本节就基于之前博客的内容,出现的问题,以及这两天我的一些学习,来对上述问题进行一个解答。

    我们在之前的博客中,对粒子群算法的实现进行了讲解,主要讲解了粒子群算法的产生,实现步骤,并且通过代码来实现了当输入变量为n维向量时的粒子群算法。
    许多网友对之前的代码有些疑惑,并且提到了几个问题:
    1,对于之前的代码,觉得有些看不懂?
    2,如果输入变量不再是n维向量,而是n*n维的矩阵,甚至n*n*n…维的矩阵,该如何编写代码?
    3,如果目标函数存在约束条件,该如何编写代码?
    本节就基于之前博客的内容,出现的问题,以及这两天我的一些学习,来对上述问题进行一个解答。

    上一讲博客链接在此:(https://blog.csdn.net/DBLLLLLLLL/article/details/82965722)

    1.自变量为2维向量的粒子群算法

    首先还是从最简单的开始,关于自变量为2维的粒子群算法,其代码的实现过程可以参考上一讲的博客,这里我对于该代码进行了一些改进。主要改进就是增加了一个自适应变异机制,即每次算法计算周期,都有一定的概率随机改变某一个个体的数值,从而提高了整个粒子群的寻优能力。关于这个能力,感兴趣的人可以尝试将代码中的自适应变异的代码段注释掉,观察结果,可以有更直观的感受。

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %  下面这个函数叫做Schaffer函数,最小值在(0,0)处,为0
    fun= @(a,b)(0.5+(sin(sqrt(a.^2+b.^2)).^2-0.5)./((1+0.001.*(a.^2+b.^2)).^2));
    %  绘图函数,可舍弃
    figure(1);
    [x0_1, x0_2]=meshgrid(-5:0.1:5);
    y0=fun(x0_1,x0_2);
    mesh(x0_1, x0_2, y0);
    hold on;
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                         % 初始种群个数
    dim = 2;                           % 空间维数
    ger = 300;                       % 最大迭代次数     
    xlimit = [ -5,5 ; -5 ,5 ];        % 设置位置参数限制(矩阵的形式可以多维)
    vlimit = [ -1.5,1.5 ; -1.5,1.5]; % 设置速度限制
    c_1 = 0.8;                       % 惯性权重
    c_2 = 0.5;                       % 自我学习因子
    c_3 = 0.5;                       % 群体学习因子 
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    %  绘图(可舍弃)
     for i = 1:dim
        pop_x(i,:) = xlimit(i, 1) + (xlimit(i, 2) - xlimit(i, 1)) * rand(1, sizepop);%初始种群的位置
    end    
    pop_v = rand(dim, sizepop);                   % 初始种群的速度
    gbest = pop_x;                                % 每个个体的历史最佳位置
    fitness_gbest = fun(pop_x(1,:),pop_x(2,:));   % 每个个体的历史最佳适应度
    zbest = pop_x(:,1);                          % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    plot3(gbest(1,:),gbest(2,:),fun(gbest(1,:),gbest(2,:)), 'ro');title('初始状态图');
    hold on;
    figure(2);
    mesh(x0_1, x0_2, y0);
    hold on;
    plot3(gbest(1,:),gbest(2,:),fun(gbest(1,:),gbest(2,:)), 'ro');
    hold on;
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    times = 1;                       %用于显示,可舍弃
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        
        %    更新速度并对速度进行边界处理 
        pop_v =  c_1 * pop_v  + c_2 * rand *(gbest - pop_x) + c_3 * rand *(repmat(zbest, 1, sizepop) - pop_x);% 速度更新
        for i=1:dim 
            for j=1:sizepop
                if  pop_v(i,j)>vlimit(i,2)
                    pop_v(i,j)=vlimit(i,2);
                end
                if  pop_v(i,j) < vlimit(i,1)
                    pop_v(i,j)=vlimit(i,1);
                end
            end
        end 
        
        %    更新位置并对位置进行边界处理
        pop_x = pop_x + pop_v;% 位置更新
        % 边界位置处理
        for i=1:dim 
            for j=1:sizepop
                if  pop_x(i,j)>xlimit(i,2)
                    pop_x(i,j)=xlimit(i,2);
                end
                if  pop_x(i,j) < xlimit(i,1)
                    pop_x(i,j)=xlimit(i,1);
                end
            end
        end
        
        %    自适应变异
        for j=1:sizepop
            if rand > 0.85
                i=ceil(dim*rand);
                pop_x(i,j)=xlimit(i, 1) + (xlimit(i, 2) - xlimit(i, 1)) * rand;
            end
        end
        
        %    计算新种群各个个体位置的适应度
        fitness_pop = fun(pop_x(1,:),pop_x(2,:)) ; % 当前所有个体的适应度
        
        %    新适应度与个体历史最佳适应度做比较
        for j = 1:sizepop      
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end 
        end
        
        %    个体历史最佳适应度与种群历史最佳适应度做比较
        for j = 1:sizepop  
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        if times >= 10        %显示函数 可以舍去
            cla;
            mesh(x0_1, x0_2, y0);
            plot3(pop_x(1,:),pop_x(2,:),fun(pop_x(1,:),pop_x(2,:)), 'ro');title('状态位置变化');
            pause(0.5);
            times=0;
        end
        
        iter = iter+1;
        times=times+1;        %显示函数 可以舍去
    end
    %% 迭代结果输出
    
    figure(3);plot(record);title('收敛过程')
    figure(4);
    mesh(x0_1, x0_2, y0);
    hold on;
    plot3(pop_x(1,:),pop_x(2,:),fun(pop_x(1,:),pop_x(2,:)), 'ro');title('最终状态图');
    
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    
    

    2.自变量为n维向量的粒子群算法

    根据自变量为2位的粒子群算法的代码,我们可以很容易就类比出来自变量为n维的粒子群算法的代码。这里很多人对于这个类比过程不太擅长,那我把已经写好的5维的代码发出来供大家参考。

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %    下列函数为Rastrigin函数,是一个多峰值的函数,在0向量处取得全局最小值0
    fun= @(X)(sum((X.^2-10*cos(2*pi*X)+10),1));
    
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                    % 初始种群个数
    dim = 5;                          % 空间维数
    ger = 200;                       % 最大迭代次数     
    xlimit_max = 5.12*ones(dim,1);    % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -5.12*ones(dim,1);
    vlimit_max = 1*ones(dim,1);       % 设置速度限制
    vlimit_min = -1*ones(dim,1);
    c_1 = 0.8;                        % 惯性权重
    c_2 = 0.5;                        % 自我学习因子
    c_3 = 0.5;                        % 群体学习因子 
    
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    for i=1:dim
        for j=1:sizepop
            pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;
            pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
        end
    end    
    gbest = pop_x;                                % 每个个体的历史最佳位置
    fitness_gbest = fun(pop_x);                   % 每个个体的历史最佳适应度
    zbest = pop_x(:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop
            %    更新速度并对速度进行边界处理 
            pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
            for i=1:dim
                if  pop_v(i,j) > vlimit_max(i)
                    pop_v(i,j) = vlimit_max(i);
                end
                if  pop_v(i,j) < vlimit_min(i)
                    pop_v(i,j) = vlimit_min(i);
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
            for i=1:dim
                if  pop_x(i,j) > xlimit_max(i)
                    pop_x(i,j) = xlimit_max(i);
                end
                if  pop_x(i,j) < xlimit_min(i)
                    pop_x(i,j) = xlimit_min(i);
                end
            end
            
            %    进行自适应变异
            if rand > 0.85
                i=ceil(dim*rand);
                pop_x(i,j)=xlimit_min(i) + (xlimit_max(i) - xlimit_min(i)) * rand;
            end
      
            %    计算新种群各个个体位置的适应度
    
            fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度
    
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        iter = iter+1;
    
    end
    %% 迭代结果输出
    
    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    

    3.自变量为n维向量且存在约束条件的粒子群算法

    解决了输入为n维向量的粒子群算法的代码,接下来我们来看,当存在约束条件时,如何构造这个算法。这里采用的思想是,对每一个粒子进行判断,判断该粒子的取值是否满足约束条件,如果满足,则进行正常的适应度计算,如果不满足,则将该粒子的适应度直接赋值为一个很大的数(求最小值时赋值成大数,求最大值时应该赋值成小数)。具体代码实现如下:

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %    下列函数为:
    %    y=0.072*x1+0.063*x2+0.057*x3+0.05*x4+0.032*x5+0.0442*x6+0.0675*x7+7
    %    约束条件为:
    %    0.072*x1+0.063*x2+0.057*x3+0.05*x4+0.032*x5+0.0442*x6+0.0675*x7<=264.4
    %    128*x1+78.1*x2+64.1*x3+43*x4+58.1*x5+36.9*x6+50.5*x7<=67919
    a=[0.072,0.063,0.057,0.05,0.032,0.0442,0.0675];
    b=[0.072,0.063,0.057,0.005,0.032,0.0442,0.0675];
    c=[128,78.1,64.1,43,58.1,36.9,50.5];
    fun= @(X)(a*X+7);
    cons1= @(X)(b*X<=264.4);
    cons2= @(X)(c*X>=-20);
    %% 设置种群参数
    %   需要自行配置
    sizepop = 500;                         % 初始种群个数
    dim = 7;                           % 空间维数
    ger = 500;                       % 最大迭代次数    
    xlimit_max = 50*ones(dim,1);     % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -50*ones(dim,1);
    vlimit_max = 1*ones(dim,1);      % 设置速度限制
    vlimit_min = -1*ones(dim,1);
    c_1 = 0.8;                       % 惯性权重
    c_2 = 0.5;                       % 自我学习因子
    c_3 = 0.5;                       % 群体学习因子 
    
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    for i=1:dim
        for j=1:sizepop
            pop_x(i,j) = xlimit_min(i)+(xlimit_max(i) - xlimit_min(i))*rand;  % 初始种群的位置
            pop_v(i,j) = vlimit_min(i)+(vlimit_max(i) - vlimit_min(i))*rand;  % 初始种群的速度
        end
    end                 
    gbest = pop_x;                                % 每个个体的历史最佳位置
    for j=1:sizepop
        if cons1(pop_x(:,j))
            if cons2(pop_x(:,j))
                fitness_gbest(j) = fun(pop_x(:,j));                      % 每个个体的历史最佳适应度
            else
                fitness_gbest(j) = 10^10; 
            end
        else
            fitness_gbest(j) = 10^10; 
        end  
    end                  
    zbest = pop_x(:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    进行约束条件判断并计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop
            %    更新速度并对速度进行边界处理 
            pop_v(:,j)= c_1 * pop_v(:,j) + c_2*rand*(gbest(:,j)-pop_x(:,j))+c_3*rand*(zbest-pop_x(:,j));% 速度更新
            for i=1:dim
                if  pop_v(i,j) > vlimit_max(i)
                    pop_v(i,j) = vlimit_max(i);
                end
                if  pop_v(i,j) < vlimit_min(i)
                    pop_v(i,j) = vlimit_min(i);
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,j) = pop_x(:,j) + pop_v(:,j);% 位置更新
            for i=1:dim
                if  pop_x(i,j) > xlimit_max(i)
                    pop_x(i,j) = xlimit_max(i);
                end
                if  pop_x(i,j) < xlimit_min(i)
                    pop_x(i,j) = xlimit_min(i);
                end
            end
            
            %    进行自适应变异
            if rand > 0.85
                i=ceil(dim*rand);
                pop_x(i,j)=xlimit_min(i) + (xlimit_max(i) - xlimit_min(i)) * rand;
            end
      
            %    进行约束条件判断并计算新种群各个个体位置的适应度
            if cons1(pop_x(:,j))
                if cons2(pop_x(:,j))
                    fitness_pop(j) = fun(pop_x(:,j));                      % 当前个体的适应度
                else
                    fitness_pop(j) = 10^10; 
                end
            else
                fitness_pop(j) = 10^10; 
            end
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,j) = pop_x(:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        iter = iter+1;
    
    end
    %% 迭代结果输出
    
    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    

    4.自变量为n*n维矩阵且存在约束条件的粒子群算法

    有些网友说,自己所要解决的情况,输入变量不仅仅是一个n维的向量,而是一个n*n维的矩阵,甚至n*n*n*…维的空间矩阵。想要采用粒子群算法,该如何实现呢?
    其实每一个n*n维矩阵,可以看成是n维向量,每个向量的元素又是一个向量,这样不断嵌套得到的。因此总的来说,整个代码的框架并没有太大的变化,仅仅是将原来的计算多嵌套几层就好。
    代码如下:

    %% 清空环境
    clc;clear all;close all;
    %% 目标函数
    %    该函数的变量是一个3*4的矩阵形式的变量
    %    cons1=@(X)(1);表示无约束条件
    %    cons1=@(X)(sum(sum(X))>=0);可以尝试添加约束条件
    a=[2.5,4.5,-2];
    b=[2;4.2;4;-4];
    c=[1,2,3,4;-4,-3,-2,-1;1,3,2,4];
    fun= @(X)(sum(sum(c.*X.^2))+a*X*b);
    cons1=@(X)(sum(sum(X))>=0);    
    %% 设置种群参数
    %   需要自行配置
    %   下文中所有出现dim2,或者:的地方,都需要根据实际的矩阵维度来进行更改
    sizepop = 500;                         % 初始种群个数
    dim1 = 3;                           % 空间维数
    dim2 = 4;
    ger = 500;                       % 最大迭代次数    
    xlimit_max = 50*ones(dim1,dim2,1);     % 设置位置参数限制(矩阵的形式可以多维)
    xlimit_min = -50*ones(dim1,dim2,1);
    vlimit_max = 1*ones(dim1,dim2,1);      % 设置速度限制
    vlimit_min = -1*ones(dim1,dim2,1);
    c_1 = 0.8;                       % 惯性权重
    c_2 = 0.5;                       % 自我学习因子
    c_3 = 0.5;                       % 群体学习因子 
    
    %% 生成初始种群
    %  首先随机生成初始种群位置
    %  然后随机生成初始种群速度
    %  然后初始化个体历史最佳位置,以及个体历史最佳适应度
    %  然后初始化群体历史最佳位置,以及群体历史最佳适应度
    for i_1=1:dim1
        for i_2=1:dim2      
            for j=1:sizepop
                pop_x(i_1,i_2,j) = xlimit_min(i_1,i_2)+(xlimit_max(i_1,i_2) - xlimit_min(i_1,i_2))*rand;  % 初始种群的位置
                pop_v(i_1,i_2,j) = vlimit_min(i_1,i_2)+(vlimit_max(i_1,i_2) - vlimit_min(i_1,i_2))*rand;  % 初始种群的速度
            end
        end
    end                 
    gbest = pop_x;                                % 每个个体的历史最佳位置
    for j=1:sizepop                               % 每个个体的历史最佳适应度
        if cons1(pop_x(:,:,j))                      % 约束条件       
            fitness_gbest(j)=fun(pop_x(:,:,j));                    
        else
            fitness_gbest(j) = 10^10; 
        end  
    end   
    zbest = pop_x(:,:,1);                           % 种群的历史最佳位置
    fitness_zbest = fitness_gbest(1);             % 种群的历史最佳适应度
    for j=1:sizepop
        if fitness_gbest(j) < fitness_zbest       % 如果求最小值,则为<; 如果求最大值,则为>; 
            zbest = pop_x(:,:,j);
            fitness_zbest=fitness_gbest(j);
        end
    end
    
    
    %% 粒子群迭代
    %    更新速度并对速度进行边界处理    
    %    更新位置并对位置进行边界处理
    %    进行自适应变异
    %    进行约束条件判断并计算新种群各个个体位置的适应度
    %    新适应度与个体历史最佳适应度做比较
    %    个体历史最佳适应度与种群历史最佳适应度做比较
    %    再次循环或结束
    
    iter = 1;                        %迭代次数
    record = zeros(ger, 1);          % 记录器
    while iter <= ger
        for j=1:sizepop
            %    更新速度并对速度进行边界处理 
            pop_v(:,:,j)= c_1 * pop_v(:,:,j) + c_2*rand*(gbest(:,:,j)-pop_x(:,:,j))+c_3*rand*(zbest-pop_x(:,:,j));% 速度更新
            for i_1=1:dim1
                for i_2=1:dim2
                    if  pop_v(i_1,i_2,j) > vlimit_max(i_1,i_2)
                        pop_v(i_1,i_2,j) = vlimit_max(i_1,i_2);
                    end
                    if  pop_v(i_1,i_2,j) < vlimit_min(i_1,i_2)
                        pop_v(i_1,i_2,j) = vlimit_min(i_1,i_2);
                    end                
                end
            end
            
            %    更新位置并对位置进行边界处理
            pop_x(:,:,j) = pop_x(:,:,j) + pop_v(:,:,j);% 位置更新
            for i_1=1:dim1
                for i_2=1:dim2
                    if  pop_x(i_1,i_2,j) > xlimit_max(i_1,i_2)
                        pop_x(i_1,i_2,j) = xlimit_max(i_1,i_2);
                    end
                    if  pop_x(i_1,i_2,j) < xlimit_min(i_1,i_2)
                        pop_x(i_1,i_2,j) = xlimit_min(i_1,i_2);
                    end
                end
            end
            
            %    进行自适应变异
            if rand > 0.85
                i_1=ceil(dim1*rand);
                i_2=ceil(dim2*rand);
                pop_x(i_1,i_2,j)=xlimit_min(i_1,i_2) + (xlimit_max(i_1,i_2) - xlimit_min(i_1,i_2)) * rand;
            end
          
      
            %    进行约束条件判断并计算新种群各个个体位置的适应度
            if cons1(pop_x(:,:,j))                                       % 约束条件
                fitness_pop(j) = fun(pop_x(:,:,j));                      % 当前个体的适应度
            else
                fitness_pop(j) = 10^10; 
            end
            
            %    新适应度与个体历史最佳适应度做比较
            if fitness_pop(j) < fitness_gbest(j)       % 如果求最小值,则为<; 如果求最大值,则为>; 
                gbest(:,:,j) = pop_x(:,:,j);               % 更新个体历史最佳位置            
                fitness_gbest(j) = fitness_pop(j);     % 更新个体历史最佳适应度
            end   
            
            %    个体历史最佳适应度与种群历史最佳适应度做比较
            if fitness_gbest(j) < fitness_zbest        % 如果求最小值,则为<; 如果求最大值,则为>; 
                zbest = gbest(:,:,j);                    % 更新群体历史最佳位置  
                fitness_zbest=fitness_gbest(j);        % 更新群体历史最佳适应度  
            end    
        end
        
        record(iter) = fitness_zbest;%最大值记录
        
        iter = iter+1;
    
    end
    %% 迭代结果输出
    
    plot(record);title('收敛过程')
    disp(['最优值:',num2str(fitness_zbest)]);
    disp('变量取值:');
    disp(zbest);
    
    展开全文
  • 遗传算法是计算数学中用于解决最佳化的搜索算法,是进化算法的一种,本文档以无约束条件的案例形式,讲解遗传算法。
  • 整数分拆以及等差数列多重约束条件下全排列的生成法,杜瑞卿,刘广亮,为了能够实现整数分拆有序和无序的全部排列和组合,以及任意等差数列的全排列生成及其在多重约束条件下的全排列生成,详细论证了
  • 数据库表的约束条件

    千次阅读 2020-08-16 20:54:35
    deptno varchar(20) primary key, --列级约束条件 dname varchar(20), location varchar(40) ); 表级主键约束演示: create table dept_htlwk( deptno varchar(20) , dname varchar(20) , location varchar(40) ,

    1.主键约束

    主键约束可以用两种方式定义:列级主键约束和表级主键约束

    列级主键约束演示:

    create table dept_htlwk(
    deptno varchar(20) primary key, --列级约束条件 
    dname varchar(20),
    location varchar(40)
    );
    

    表级主键约束演示:

    create table dept_htlwk( 
    deptno varchar(20) ,
    dname varchar(20) ,
    location varchar(40) ,
    constraint dept_htlwk_deptno_pk primary key (deptno) );
    

    2.非空约束

    非空约束只有列级定义方式,即非空约束只能定义在列级

    create table dept_htlwk_bak1(
    deptno varchar(20) primary key,
    dname varchar(30) not null,//非空约束
    location varchar(50));
    

    非空约束如何命名?

    create table dept_htlwk_bak1(
    deptno varchar(20) primary key,
    dname varchar(30) constraint dept_htlwk_bak1_dname_nn not null,//非空约束
    location varchar(50));
    

    3.唯一约束

    唯一约束可以用两种方式定义:列级唯一约束和表级唯一约束

    列级唯一约束演示:

    create table student(
    student_id bigint(20) primary key,
    student_name varchar(30) not null,
    email varchar(30) unique,
    student_age tinyint(3));
    

    表级唯一约束演示:

     create table student(
    student_id bigint(20),
    student_name varchar(30) not null,
    email varchar(30),
    age tinyint(3),
    constraint student_id_pk primary key(student_id),//表级主键约束
    constraint student_email_uk unique(email) );//表级唯一约束
    

    4.检查约束

    检查约束可以用两种方式定义:列级检查约束和表级检查约束

    列级检查约束演示:

    create table student(
    student_id bigint(20) primary key,
    student_name varchar(30) not null,
    email varchar(30) unique,
    age tinyint(3) check(age > 10),
    gender char(1) check(gender in('F', 'M') ) --'F'代表女生 ;'M'代表男生
    );
    

    表级检查约束演示:

    create table student( 
    student_id bigint(20),
    student_name varchar(10) not null,
    email varchar(30),
    age tinyint(3),
    gender char(1), --'F'代表女生 ;'M'代表男生
    constraint student_id_pk primary key(student_id),
    constraint student_email_uk unique(email),
    constraint student_age_ck check(age > 10),
    constraint student_gender_ck check(gender in('F', 'M', 'f', 'm'))
     );
    

    MySQL关于check约束无效的解决办法

    5.外键约束

    外键约束只有表级定义方式,即外键约束只能定义在表级

    外键约束演示:

    create table student( 
    student_id bigint(20),
    student_name varchar(20) not null, 
    email varchar(30) unique,
    gender char(1),
    age tinyint(3),
    major_id bigint(20),
    constraint student_id_pk primary key(student_id),
    constraint student_gender_ck check (gender in ('F','M','f','m')),
    constraint student_major_id_fk foreign key (major_id) references major(major_id) on delete set null);
    

    解释:
    on delete set null 一旦主表数据删除,从表关联数据置为null
    on delete cascade 级联删除,主表数据删除,从表关联数据也删除

    展开全文
  • Python数模笔记-模拟退火算法(2)约束条件的处理

    千次阅读 多人点赞 2021-05-03 09:31:10
    最优化问题的三要素是决策变量、目标函数和约束条件。 线性规划(Linear programming),是研究线性约束条件下线性目标函数的极值问题的优化方法,常用于解决利用现有的资源得到最优决策的问题。 简单的线性规划问题...
  • MySQL常见约束条件

    万次阅读 多人点赞 2018-12-02 15:36:23
    约束条件:限制表中的数据,保证添加到数据表中的数据准确和可靠性!凡是不符合约束的数据,插入时就会失败! 约束条件在创建表时可以使用, 也可以修改表的时候添加约束条件 1、约束条件分类: 1)not null :非空...
  • 基于粒子群算法的线性规划+带约束条件的求解

    千次阅读 多人点赞 2019-03-26 23:36:53
    先学运筹学,有自己数学建模,把抽象问题具体成数学模型,在用智能算法求解,运筹学的请自己图书馆借书看,求解看下面...我是一直想学带约束条件的,因为可以作后面很多用途,但是一直没找到,智能算法的原理也比较...
  • 为了获得约束条件下温度与晶体匹配角的关系,建立了约束条件下晶体匹配角热敏感性的分析方法。利用有限元分析法,计算约束条件下温度变化产生的热应力和热形变分布;将热光效应、弹光效应以及热形变引入到匹配角的...
  • 注意:添加约束条件必须在插入数据之前,在插入数据之后就不能再添加约束! 非空约束(NOT NULL) 要求属性不能为空,不允许插入null值。 唯一约束(UNIQUE) 要求属性为唯一值,不允许出现相同数据。 主键约束...
  • Oracle数据库违反唯一约束条件

    千次阅读 2021-03-09 16:33:27
    Oracle数据库违反唯一约束条件 问题 ORA-00001: 违反唯一约束条件 (xxx.SYS_C0014310) 原因 数据库的ID值,小于序列的next number值,由于表中的ID值是唯一的,所以select max(id) from test 查的该ID大于Sequences...
  • 拉格朗日乘数法 寻找变量受一个或多个条件所限制的多元函数极 值方法。将n个变量和k个约束的最优问题转换为 n+k变量的方程组极值问题...几何问题:目标函数为一个椭圆,约束条件为直线,最优问题在几何上表现为,椭圆经
  • 约束条件下蚁群算法解无人机轨迹规划,其中包含了2019年研究生数学建模竞赛解答的python代码,提供了蚁群算法解决无人机多约束条件下的航迹规划问题
  • 为了解决线性规划问题中减少约束条件的灵敏度分析问题,采用理论和实证分析的方法,提出了一种新的减少约束条件的灵敏度分析的最优方案获得方法,分别讨论了含有辅助变量与不含辅助变量时减少约束条件求得最优解的方法...
  • oracle查询约束条件

    千次阅读 2019-08-06 14:30:55
    查找约束的方法如下: ( 1 ) 查找某表上的约束 select * from user_constraints where table_name= ‘MEDIA’ (2)查找到约束所在的表 SELECT * FROM USER_CONSTRAINTS WHERE CONSTRAINT_NAME = ‘PK_MEDIA’...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 336,366
精华内容 134,546
关键字:

约束条件