Verilog有符号和无符号运算设计分析_verilog除法取整

主要内容是对有符号数和无符号数在设计时，数据是怎样传递的，符号位是怎样来的，以及相关的几种运算设计应当遵循怎样的想法。
最近对加减乘除运算很困惑，主要是对于有符号数的运算的困扰，如果运算出现负数怎么办。对于数据的赋值应该是怎样的，里面的数据是怎样存储的。
找来找去不如直接看Verilog标准verilog 2001里面写的很清楚。
具体的部分是在4.1.5小节中讲述的。
几种运算符的使用如下：

说明：
1、 整数除法将截断任何小数部分，也就是向下取整。对于除法运算符（/）或模数运算符（%），如果第二个操作数为零，则整个结果值应为x。模数运算符，例如y % z，当第一个操作数被第二个操作数除时给出余数，因此当z正好除y时为零。模数运算的结果应取第一个操作数的符号。
2、幂运算符（**）的第一个和第二个操作数以及其赋值结果，应当保证，全为有符号数或全为无符号数。如果第一个操作数为零且第二个操作数为非正，或者第一个操作数为负且第二个操作数不是整数值，则幂运算符的结果是未指定的。
对于取模运算符，其各种情况的运算结果如下：

1.数据传递

在理解有符号和无符号数的运算之前，我觉得至少要明白我们在设计中，寄存器都是怎样进行赋值的，数据是怎样进行传递的，只有知道了其存储数据和传递数据的方式了，才能正确使用Verilog代码进行设计有符号数和无符号数的运算。
首先看其定义

有符号数一般定义就是在数据类型前面加上signed，如果不加就是默认成无符号数。

1.1.常量赋值

如果用常量直接对数据进行赋值，如下代码方式：

reg  [3:0] regA;    //无符号
//reg signed [3:0] regA;    //有符号定义
always@(posedge clk)
begin
	regA <= 4'd10;   //正数赋值
	//regA <= 4'd10;  //负数赋值
end
1
2
3
4
5
6
7

结果如上图，如果直接赋值的话，正数是直接按照被赋值寄存器的位宽进行赋值的，而负数，无论是定义的有符号还是无符号寄存器，都是赋值其补码（不包括其符号位）（剩余的按符号位补）。如下图：

这里写一个被赋值寄存器位宽超过赋值的常量位宽的代码进行验证：

reg  [5:0]  a;
initial
begin
	a = 4'd10;     //1
	#4
	a = -4'd10;
end
1
2
3
4
5
6
7

再写一个被赋值的寄存器位宽小于常量位宽的情况：

reg  [2:0]  a;
initial
begin
	a = 4'd10;
	#4
	a = -4'd10;
end
1
2
3
4
5
6
7

仿真显示，跟上面分析的完全一致，所以被赋值的寄存器无论是否有符号定义，其赋值结果都是一样的。
这里需要注意一点，我们在用常量对寄存器进行赋值的时候，代码设计要写成十进制（或者16进制以及8进制）的形式才会按照这种高位补符号位，如果写成二进制，而二进制数据是默认为无符号数的，因此高位是直接补0的（无论赋给有符号数还是无符号数）。因此在设计运算电路的时候，尽量不使用二进制代码

这里在学习的过程中发现了一个常数表示方法：

reg [3:0] regA   //这里设置为4位，最高位作为符号位
always@(posedge clk)
begin
regA <= 3'sd5;
end
1
2
3
4
5

sd表示有符号十进制的意思，也就是说把上面5转换成二进制为101，其第一位为符号位,因此存入regA的数据是101再加上其符号位1101。如果表达式写成这样

regA <= -3'sd5;
1

应当这样进行理解，-5的二进制补码为011则其最高位为0所以最后存入寄存器regA的是0011。

1.2.寄存器赋值

上一节已经分析了常量赋值到寄存器，因此下面的理解应该就很轻松了，可以提前思考一下，如果是无符号寄存器传数据，应该是位宽不够时，向高位补0，如果是有符号寄存器传数据，此时应该就是跟常量赋值类似，位宽不够，向高位补符号位。下面进行验证。
注：
上面已经说了被赋值的寄存器的定义是否为signed，其赋值的方案都是一样的，因此下面验证时，被赋值的寄存器均设置为无符号了。

1.2.1.无符号寄存器传数据

reg  [3:0]  a;
reg  [6:0]  b;   //验证高位补什么数据
reg  [1:0]  c;   //验证位宽较低时怎样截数据 
always@(posedge clk)
begin
	b <=  a;
	c <=  a;
end
initial
begin
	clk = 1;
	#4
	a= 4'b1010;
	#4
	a= 4'b0101;
    #20
	$stop;
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

从仿真的二进制结果来看，将a定义成无符号数的时候，如果被赋值寄存器的位宽较大，则向高位补0，较小，则直接截取对应低位。与前面的想法一样。

1.2.2.有符号寄存器传数据

这里只将上面的a和b定义成有符号数即可。

reg	signed 	[3:0]  a;
reg signed	[6:0]  b;    //当a的输入也是有符号数的时候，b可以不定义成无符号数。
						 //因为默认向高位补符号位
1
2
3

为什么b也定义成有符号数：因为如果不这样，当写代码的时候a的输入用二进制表示的，会导致不能向高位补符号位，而是补0，这里把b也定义成有符号数，就是为了实现当a的位宽不够时，能够向高位补符号位。

同样看二进制结果，因为a和b被定义成了有符号寄存器，所以最高位为符号位，则在赋值的时候，向高位补符号位，而不是0。

综上：
所有的常数赋值，正数的数据都是直接转换成二进制，然后向高位补符号位，最后存入寄存器中，而负数数据都是转换成二进制补码，然后向高位补符号位，存入寄存器中的。

1.3.总结

对各种传输数据进行一个总结：

有符号常量就是指用10进制、16进制、8进制的表示，无符号常量就是指2进制表示。
因此我们在进行有符号运算的时候，一定要保证输入输出都定义成有符号数，同时也要注意输入寄存器的输入端的数据是有符号还是无符号，以及他们的位宽是多少。

2.运算

2.1.加法

2.1.1.无符号

代码：

reg [3:0] a,b;
reg [4:0] c;    //结果多写一位，主要是防止溢出。
always@(posedge clk)
begin
	c <=  a + b;
end
1
2
3
4
5
6

仿真正确。

2.1.2.有符号

代码：

reg signed [3:0] a,b;  //实际上，前面已经说了，无论输入是否定义成有符号数，其存入的数据都是补码。但是加法器的输出必须被定义成有符号数，这样才能正确传递符号位。
reg signed [4:0] c;    //结果多写一位，主要是防止溢出。
always@(posedge clk)
begin
	c <=  a + b;
end
1
2
3
4
5
6

对于输入的数据a和b（位宽width），我们需要保证输入数据的绝对值最大不超过width-1也就是范围在-2^(width-1)~2^(width-1)；
测试：

a = 4'd4;     
b = -4'd3;     
#20
a = -4'd4;
b = 4'd2;
#20
1
2
3
4
5
6

验证正确。
注:
如果输入或输出均不定义成有符号数
其运算出的结果应当是这样的，综合之后使用的是5位加法器，其最终结果如果转换成有符号，为-15，无符号，则为17 。

因此在设计的时候，还是全部带上有符号数，这样也方便后续数据传递。

2.2.减法

2.2.1.无符号

代码：

reg [3:0] a,b;  
reg [4:0] c;    //结果多写一位，主要是防止溢出。
always@(posedge clk)
begin
	c <=  a - b;
end
1
2
3
4
5
6

测试

注：
无符号肯定要保证输入输出都是正数才行，也就是被减数必须大于等于减数。

2.2.2.有符号

代码：

reg signed [3:0] a,b;
reg signed  [4:0] c;    //结果多写一位，主要是防止溢出。
always@(posedge clk)
begin
	c <=  a - b;
end
1
2
3
4
5
6

这里看一下硬件电路的实现：
代码：

module top(
	input clk,
	input signed [3:0] a,
	input signed [3:0] b,
	output  [4:0] o
);
reg signed [3:0] a0,b0;  //实际上，前面已经说了，无论输入是否定义成有符号数，其存入的数据都是补码。但是加法器的输出必须被定义成有符号数，这样才能正确传递符号位。
reg signed [4:0] c;    //结果多写一位，主要是防止溢出。
always@(posedge clk)
begin
	a0 <= a;
	b0 <= b;
	c <=  a0 - b0;
end
assign o = c;
endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

结果如上图，是通过加法器来实现减法运算的，通过综合出的电路可知道
是一个6位的加法器
被减数和减数经过一位拼接送入加法器A端，即

A[5:0] = {a0[3],a0,1'b1}
B[5:0] = {~{a0[3],a0},1'b1}
1
2

然后加法器输出舍弃最低位，输出到下一级寄存器，即

c[4:0] = OUT[5:1]
1

这里手算一下：

2.3.除法

2.3.1.无符号

除法比较简单，结果就是两数相除之后取整

reg  [3:0] a,b;
reg   [3:0] c;    //结果不需要扩展，因为除完只会变小，不会变大
always@(posedge clk)
begin
	c <=  a / b;
end
1
2
3
4
5
6

module top(
	input clk,
	input signed [3:0] a,
	input signed [3:0] b,
	output  [3:0] o
);
reg  [3:0] a0,b0;  
reg  [3:0] c;   
always@(posedge clk)
begin
	a0 <= a;
	b0 <= b;
	c <=  a0 / b0;
end
assign o = c;
endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.3.2.有符号

reg  signed [3:0] a,b;
reg  signed [4:0] c;    //结果多写一位，主要是防止溢出。
always@(posedge clk)
begin
	c <=  a / b;
end
1
2
3
4
5
6

可见其结果的符号与两个操作数有关，也就是符合我们正常的除法运算规律。

module top(
	input clk,
	input signed [3:0] a,
	input signed [3:0] b,
	output signed [3:0] o
);
reg  signed [3:0] a0,b0;  
reg  signed [3:0] c;    
always@(posedge clk)
begin
	a0 <= a;
	b0 <= b;
	c <=  a0 / b0;
end

assign o = c;

endmodule
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

查看最后综合出来的电路，有符号和无符号的电路都是一样的，但是其内部不知道是怎样算的，不过功能是正确的。

2.3.3.实现除法的四舍五入

1. 移位实现
   有时候在硬件算法中，实现最多的就是除以2ⁿ 而且大部分是要求四舍五入。
   如果要求四舍五入，假设被除数为a，我们要除以2²，结果设为c；

wire signed [3:0] a;
wire signed [3:0] c;
assign c = (a + 2) >>> 2;//加上2的n-1次方再进行移位
1
2
3

2. 除法实现

—待更新—

2.4乘法

2.4.1.无符号

reg   [3:0] a,b;
reg  [7:0] c;    
always@(posedge clk)
begin
	c <=  a * b ;
end
1
2
3
4
5
6

2.4.2.有符号

reg  signed [3:0] a,b;
reg  signed [7:0] c;      //输出的位宽只需要大于等于a和b的位宽之和减一就可以了
always@(posedge clk)
begin
	c <=  a * b ;
end
1
2
3
4
5
6

易错

在设计的时候尝尝会有常数参与运算，当进行有符号运算时，比如

wire signed [3:0] a;
wire signed [7:0] c;      
assign c = a + 3'd2;
1
2
3

如果输入端有负数，这就会导致结果出现错误，如下图的第三组和第五组。

如果将表达式写成

assign c = a + 2;
1

或改成

wire signed [2:0] data;
assign data = 2'd2;
assign c = a + data;
1
2
3

结果：

这样才是正确的。
所以在设计的时候，需要注意这个点。