除法器的实现（恢复余数、不恢复余数、级数展开、Newton-Raphson）

已于 2022-06-03 12:39:40 修改
阅读量3.6k 收藏 46
点赞数 8
分类专栏： 基础知识 文章标签： fpga开发
于 2022-06-03 12:33:47 首次发布
欢迎点赞哦!
本文链接：https://blog.csdn.net/lum250/article/details/125111667
版权

文章目录

参考《基于FPGA的数字信号处理（第二版）》，对其中的除法器算法进行仿真。

1 基于恢复余数（Restoring）算法的除法器

Restoring 算法无法直接用于与有符号数，对于有符号数需要先转换为无符号数。然后根据除数与被除数的符号判断商与余数的符号。

1.1 原理

被除数（Dividend）5621 / 除数（Divisor）3 = 商（Quotient）1873 … 余数（Remainder）2

       1873
     _______
  3 |  5621
    /  3000
       ____
       2621
       2400  
       ____
        221
        210
        ___
         11
          9
          _
          2

r i = r i + 1 − q i ⋅ D ⋅ 1 0 i r_i = r_{i+1}-q_i·D·10^i ri​=ri+1​−qi​⋅D⋅10i

q i q_i qi​通过部分余数的正负确定，如果余数为负表示 q i q_i qi​较大，需要将其恢复到部分余数为正以获取正确的 q i q_i qi​，这便是“恢复”的含义。

用恢复余数算法表示上式计算过程：

q i q_i qi​余数是否恢复
q 3 = 1 q_3=1 q3​=15621-3×10^3×1=2621
q 3 = 2 q_3=2 q3​=25621-3×10^3×2=-379 q 3 q_3 q3​恢复为1，余2621
q 2 = 1 q_2=1 q2​=12621-3×10^2×1=2321
q 2 = 2 q_2=2 q2​=22621-3×10^2×2=2021
…………
q 2 = 8 q_2=8 q2​=82621-3×10^2×8=221
q 2 = 9 q_2=9 q2​=92621-3×10^2×9=-79 q 2 q_2 q2​恢复为8，余221
…………
q 1 = 7 q_1=7 q1​=7221-3×10^1×7=11
q 1 = 8 q_1=8 q1​=8221-3×10^1×8=-19 q 1 q_1 q1​恢复为7，余11
…………
q 0 = 3 q_0=3 q0​=311-3×10^0×3=2
q 0 = 4 q_0=4 q0​=411-3×10^0×4=-1 q 0 q_0 q0​恢复为3，余2

得 q 3 q 2 q 1 q 0 {q_3q_2q_1q_0} q3​q2​q1​q0​ = 1873，R=2。

以上是十进制算法，对于二进制：

r i = r i + 1 − q i ⋅ D ⋅ 2 i r_i = r_{i+1}-q_i·D·2^i ri​=ri+1​−qi​⋅D⋅2i

q i q_i qi​只能取0或1，所以每位只需一次运算即可判断是否恢复。

此外还需确定各参数的字长：假定除数D为 nbit，商Q为 nbit，则 Q ≤ 2 n − 1 Q\le2^n-1 Q≤2n−1。由于R<D，所以R的位宽可以设置为 nbit。则被除数Y:
Y = D ⋅ Q + R < ( 2 n − 1 ) D + D = 2 n D Y=D·Q+R < (2^n-1)D+D=2^nD Y=D⋅Q+R<(2n−1)D+D=2nD
意味着Y的高 nbit 小于D。

基于 restoring 算法的无符号数除法运算具有如下特征：

  1. 各参数字长：被除数为 2nbit，除数、商和余数为 nbit。
  2. 被除数的高 nbit 需小于 除数。
  3. 算法需迭代 n次。

算法流程：

在这里插入图片描述

基本运算单元（移位和减法）硬件架构：
在这里插入图片描述

延时分析：
上述硬件架构运算 latency 为2，对于 nbit 商，需要 2n latency。去掉寄存输出可降低延迟。

1.1 Verilog 实现

流水线实现方式比较简单，这里实现运算单元分时复用。

`timescale 1ns/1ps

module div_restoring_pip (
    input             I_sys_clk  ,
    input             I_reset_n  ,
    input             I_valid    ,
    input      [15:0] I_dividend ,
    input      [7:0]  I_divisor  ,
    output reg        O_valid    ,
    output reg [7:0]  O_quotient ,
    output reg [7:0]  O_remainder
);
//--- internal signal definitions ---
//=== parameter definitions ===			
                                   
//=== reg definitions ===  
reg        R_valid           ;			
reg [7:0]  R_divisor         ;
reg [3:0]  R_index_cnt       ;
reg [15:0] R_remainder_t     ;
reg [15:0] R_di              ;
reg [7:0]  R_quotient        ;
reg        R_restoring_valid ;


//=== wire definitions === 	
wire        W_restoring_valid;
wire        W_quotient       ;			
wire [15:0] W_remainder      ;                                   
                                    
//--- Main body of code ---   
// 非流水线处理，需要 blocking
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_valid    <= 1'b0;
        R_divisor  <= 1'b0;
    end 
    else
    begin
        R_valid    <= I_valid;
        if (I_valid)
        begin
            R_divisor  <= I_divisor ;
        end
    end
end

// 共计算8位的商
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_index_cnt <= 4'd0;
    end 
    else
    begin
        if (I_valid)
        begin
            R_index_cnt <= 4'd8;
        end 
        else if (W_restoring_valid)
        begin
            R_index_cnt <= R_index_cnt - 4'd1;
        end
    end
end

// 得到下一次计算的输入
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_remainder_t <= 16'd0;
        R_di <= 16'd0;
    end 
    else
    begin
        if (I_valid)
        begin
            R_remainder_t <= I_dividend ;
            R_di <= I_divisor << 3'd7;
        end
        else if (W_restoring_valid)
        begin
            R_remainder_t <= W_remainder ;
            R_di <= R_divisor << (R_index_cnt-2);
        end
    end
end

// 保存每位的商
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_quotient <= 8'd0;
    end 
    else
    begin
        if (I_valid)
        begin
            R_quotient <= 8'd0;
        end
        else if (W_restoring_valid)
        begin
            R_quotient <= {R_quotient[6:0], W_quotient};
        end
    end
end

// 输出
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        O_valid     <= 1'd0;
        O_quotient  <= 8'd0;
        O_remainder <= 8'd0;
    end 
    else
    begin
        if (W_restoring_valid && (R_index_cnt == 4'd1))
        begin
            O_valid     <= 1'd1;
            O_quotient  <= {R_quotient[6:0], W_quotient};
            O_remainder <= W_remainder;
        end
        else 
        begin
            O_valid     <= 1'd0;
            O_quotient  <= 8'd0;
            O_remainder <= 8'd0;
        end
    end
end

always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_restoring_valid <= 1'b0;
    end 
    else
    begin
        R_restoring_valid <= W_restoring_valid;
    end
end

restoring restoring_u (
    .I_sys_clk(I_sys_clk),
    .I_reset_n(I_reset_n),
    .I_valid  (R_valid | (R_restoring_valid && (R_index_cnt != 4'd0))),
    .I_R      (R_remainder_t),
    .I_Di     (R_di),
    .O_valid  (W_restoring_valid),
    .O_Q      (W_quotient),
    .O_R      (W_remainder)  
);

endmodule


module restoring (
    input             I_sys_clk,
    input             I_reset_n,
    input             I_valid,
    input      [15:0] I_R,
    input      [15:0] I_Di,
    output reg        O_valid,
    output reg        O_Q,
    output reg [15:0] O_R
);
//--- internal signal definitions ---
//=== parameter definitions ===			
                                
//=== reg definitions ===  		
reg        R_valid;		
reg [15:0] R_d1;
reg [15:0] R_d2; 

//=== wire definitions === 				
                                    
                                    
//--- Main body of code ---   
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_valid <= 1'b0;
        R_d1 <= 16'd0;
        R_d2 <= 16'd0;
    end 
    else
    begin
        R_valid <= I_valid;
        R_d1 <= I_R;
        R_d2 <= I_R - I_Di;
    end
end

always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        O_valid <= 1'b0;
        O_Q <= 16'd0;
        O_R <= 16'd0;
    end 
    else
    begin
        O_valid <= R_valid;
        if (R_valid)
        begin
            O_Q <= ~R_d2[15];
            O_R <= R_d2[15] ? R_d1 : R_d2;
        end
        else 
        begin
            O_Q <= 16'd0;
            O_R <= 16'd0;
        end
    end
end

endmodule

仿真结果：
在这里插入图片描述

2 基于不恢复余数（Non-Restoring）算法的除法器

2.1 原理

恢复余数第k位迭代：
r k = r k + 1 − q k ⋅ D ⋅ 2 k r_k = r_{k+1}-q_k·D·2^k rk​=rk+1​−qk​⋅D⋅2k
若 r k < 0 r_k<0 rk​<0 表明 q k = 0 q_k=0 qk​=0，使得 $ r_k = r_{k+1} > 0 $ ，下一位（k-1位）迭代变为：
r k − 1 = r k − D ⋅ 2 k − 1 = r K + 1 − D ⋅ 2 k − 1 r_{k-1} = r_{k}-D·2^{k-1} = r_{K+1}-D·2^{k-1} rk−1​=rk​−D⋅2k−1=rK+1​−D⋅2k−1

如果不恢复余数， r k r_k rk​ 保留为负值$r_{k+1}-D·2^k $，下一位（k-1位）迭代为：
r k − 1 = r k − D ⋅ 2 k − 1 = r K + 1 − D ⋅ 2 k − D ⋅ 2 k − 1 = r K + 1 − 3 ⋅ D ⋅ 2 k − 1 r_{k-1} = r_{k}-D·2^{k-1} = r_{K+1}-D·2^{k}-D·2^{k-1}= r_{K+1}-3·D·2^{k-1} rk−1​=rk​−D⋅2k−1=rK+1​−D⋅2k−D⋅2k−1=rK+1​−3⋅D⋅2k−1

上式的结果是错的，如果将k-1位迭代改为：
r k − 1 = r k + D ⋅ 2 k − 1 = r K + 1 − D ⋅ 2 k + D ⋅ 2 k − 1 = r K + 1 − D ⋅ 2 k − 1 r_{k-1} = r_{k}+D·2^{k-1} = r_{K+1}-D·2^{k}+D·2^{k-1}= r_{K+1}-D·2^{k-1} rk−1​=rk​+D⋅2k−1=rK+1​−D⋅2k+D⋅2k−1=rK+1​−D⋅2k−1

这个结果是对的了。所以 Non-Restoring 算法流程为：

在这里插入图片描述

Non-Restoring 算法的相比 Restoring 算法的特征：

  1. q i q_i qi​ 取决于 r i r_i ri​ 的正负。而不是预先假定为1，再根据 r i r_i ri​ 的正负修正。
  2. r i r_i ri​ 的正负同时决定了下次迭代执行加法还是减法。
  3. r 0 r_0 r0​ 的正负决定是否需要余数校正。若为负，最终余数为 r 0 + D r_0+D r0​+D。

基本迭代单元硬件架构：
在这里插入图片描述

以 33/7 为例，Non-Restoring 算法迭代过程：

k余数 r k r_k rk​ q i q_i qi​
333
233-1×7×2^2=5 q 2 = 1 q_2=1 q2​=1
15-1×7×2^1=-9 q 1 = 0 q_1=0 q1​=0
0-9+1×7×2^1=-2 q 1 = 0 q_1=0 q1​=0
最终计算结果为 Q=3’b100=4，余数为-2。需要对余数进行校正，最终余数为 r 0 + D = − 2 + 7 = 5 r_0+D=-2+7=5 r0​+D=−2+7=5。

2.1 Verilog 实现

注意：实现有待优化，复杂的组合逻辑需要插入pipeline才能用于高速处理。

`timescale 1ns/1ps


module divider (
    input             I_sys_clk  ,
    input             I_reset_n  ,
    input             I_valid    ,
    input      [15:0] I_dividend ,
    input      [7:0]  I_divisor  ,
    output reg        O_valid    ,
    output reg [7:0]  O_quotient ,
    output reg [7:0]  O_remainder
);

//--- internal signal definitions ---
//=== parameter definitions ===			
                                  
//=== reg definitions ===  				
reg [3:0]  R_index_cnt;
reg        R_valid    ;
reg [15:0] R_remainder;
reg [7:0]  R_divisor  ;
reg [15:0] R_remainder_t;
reg [7:0]  R_quotient_t;

//=== wire definitions === 				                                  

                                    
//--- Main body of code ---  
always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_valid     <= 1'b0;
        R_remainder <= 16'd0;
        R_divisor   <= 8'd0;
    end 
    else
    begin
        R_valid     <= I_valid;
        if (I_valid)
        begin
            R_remainder <= I_dividend;
            R_divisor   <= I_divisor ;
        end
    end
end

always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_index_cnt <= 4'd0;
    end 
    else
    begin
        if (R_valid)
        begin
            R_index_cnt <= 4'd8;
        end
        else if (|R_index_cnt)
        begin
            R_index_cnt <= R_index_cnt - 4'd1;
        end
    end
end

always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_remainder_t <= 16'd0;
    end 
    else
    begin
        if (I_valid)
        begin
            R_remainder_t <= I_dividend;
        end
        else if (|R_index_cnt)
        begin
            R_remainder_t <= R_remainder_t[15] ? (R_remainder_t + (R_divisor << (R_index_cnt-2))) : (R_remainder_t - (R_divisor << (R_index_cnt-2))) ;
        end
    end
end

always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        R_quotient_t <= 8'd0;
    end 
    else
    begin
        if (I_valid)
        begin
            R_quotient_t <= 8'd0;
        end
        else if (|R_index_cnt && (R_index_cnt <= 4'd7))
        begin
            R_quotient_t <= {R_quotient_t[6:0], ~R_remainder_t[15]};
        end
    end
end


always @(posedge I_sys_clk or negedge I_reset_n)
begin
    if(~I_reset_n) 
    begin
        O_valid     <= 1'd0;
        O_quotient  <= 8'd0;
        O_remainder <= 16'd0;
    end 
    else
    begin
        if (R_index_cnt == 4'd1)
        begin
            O_valid     <= 1'd1;
            O_quotient  <= {R_quotient_t[6:0], ~R_remainder_t[15]};
            O_remainder <= R_remainder_t[15] ? (R_remainder_t + R_divisor) : R_remainder_t;
        end
        else 
        begin
            O_valid     <= 1'd0;
            O_quotient  <= 8'd0;
            O_remainder <= 16'd0;
        end
    end
end

endmodule

仿真结果：
在这里插入图片描述

2.2 用于有符号数的改进

在这里插入图片描述

3 基于级数展开算法的除法器

将D归一化为[0.5,1)，定义：
f ( x ) = 1 D = 1 1 + x f(x)=\frac{1}{D}=\frac{1}{1+x} f(x)=D1​=1+x1​
根据Taylor级数展开：
f ( x ) = 1 1 + x = 1 − x + x 2 − x 3 + x 4 − . . . f(x)=\frac{1}{1+x}=1-x+x^2-x^3+x^4-... f(x)=1+x1​=1−x+x2−x3+x4−...
进一步改写为：
1 D = ( 1 − x ) ( 1 + x 2 ) ( 1 + x 4 ) ( 1 + x 8 ) ( 1 + x 16 ) ( 1 + x 32 ) . . . \frac{1}{D}=(1-x)(1+x^2)(1+x^4)(1+x^8)(1+x^{16})(1+x^{32})... D1​=(1−x)(1+x2)(1+x4)(1+x8)(1+x16)(1+x32)...

又有：
1 + x n = 2 − ( 1 − x n ) 1+x^n=2-(1-x^n) 1+xn=2−(1−xn)

则 1/D 的求解过程为：

  1. 制作查找表，存储 ( 1 − x ) ( 1 + x 2 ) ( 1 + x 4 ) (1-x)(1+x^2)(1+x^4) (1−x)(1+x2)(1+x4)
  2. 1 − x 8 = [ ( 1 − x ) ( 1 + x 2 ) ( 1 + x 4 ) ] ( 1 + x ) 1-x^8=[(1-x)(1+x^2)(1+x^4)](1+x) 1−x8=[(1−x)(1+x2)(1+x4)](1+x)，进行1次乘法运算
  3. 1 + x 8 = 2 − ( 1 − x 8 ) 1+x^8=2-(1-x^8) 1+x8=2−(1−x8)，进行一次加法运算
  4. 1 − x 16 = ( 1 − x 8 ) ( 1 + x 8 ) 1-x^{16}=(1-x^8)(1+x^8) 1−x16=(1−x8)(1+x8)，进行1次乘法运算
  5. 1 + x 16 = 2 − ( 1 − x 16 ) 1+x^{16}=2-(1-x^{16}) 1+x16=2−(1−x16)，进行一次加法运算
  6. 1 − x 32 = ( 1 − x 16 ) ( 1 + x 16 ) 1-x^{32}=(1-x^{16})(1+x^{16}) 1−x32=(1−x16)(1+x16)，进行1次乘法运算
  7. 1 + x 32 = 2 − ( 1 − x 32 ) 1+x^{32}=2-(1-x^{32}) 1+x32=2−(1−x32)，进行一次加法运算
    … 直到达到需要的精度。

步骤1查找表的指标：深度和宽度。宽度取决于数据位宽，即系统精度。深度取决于地址位宽，即除数D的位宽。为节省内存可取D的高m-1位。

在这里插入图片描述

D为[0.5,1)，则符号位S为0。

若要求最大误差为 ϵ \epsilon ϵ ,则需满足：

m ≥ l o g 2 ( 1 ϵ ) + 2 m \ge log_2(\frac{1}{\epsilon})+2 m≥log2​(ϵ1​)+2

因式求解需 3次乘法和 3次加法。1/D求解中因式相乘需3次乘法。最终 Y/D 1次乘法。共7次乘法，3次加法。

在这里插入图片描述

4.2 Verilog 实现

摆烂了 😃

4 基于 Newton-Raphson 算法的除法器

4.1 原理

基本思想：将非线性方程线性化，以线性方程的解逼近非线性方程的解。
构造：
f ( x ) = 1 x − D f(x)=\frac{1}{x}-D f(x)=x1​−D

求解其解1/D，迭代过程：
在这里插入图片描述

构造函数，然后基于 Newton-Raphson 算法求解，与级数展开算法本质一致，都是求1/D，只是出发点不同。

lu-ming.xyz
关注
  • 8
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数字电路设计之牛顿迭代法计算除法的verilog实现
I AM BACK
10-06 8443
牛顿迭代法（Newton's method）又称为牛顿-拉夫逊（拉弗森）方法（Newton-Raphson method），它是牛顿在17世纪提出的一种在实数域和复数域上近似求解方程的方法。多数方程不存在求根公式，因此求精确根非常困难，甚至不可能，从而寻找方程的近似根就显得特别重要。方法使用函数f(x）的泰勒级数的前面几项来寻找方程f(x) = 0的根。牛顿迭代法是求方程根的重要方法之一，其最
【HDL系列】除法器(1)——恢复余数法
纸上谈芯的专栏
07-27 4407
目录 一、Paper-Pencil Division Algorithm 二、恢复余数法(Restoring Division Algorithm) 三、Verilog设计 本期介绍二进制除法器中的恢复余数法（Restoring Division Algorithm）。 一、Paper-Pencil Division Algorithm 在小学的时候，我们已经掌握了通过除法列式求出商和余数，也就是长除法，如果除数为一位数，则可简化为短除法。又因为可以用纸笔计算，很多外文中称之为Paper-Pen
数字IC经典电路（3）——经典除法器的实现（除法器简介及Verilog实现）
HFUT90S的博客
03-27 1万+
除法器是一种用于执行除法运算的电路或器件。在数字电路中，除法器经常被用作重要的计算单元，其主要功能是将一个数除以另一个数并给出商和余数。与加法器和减法器类似，除法器也属于算术逻辑单元(ALU)的一种。不同的是，加法器和减法器能够执行加法和减法运算，但不能执行除法运算。因此，在数字电路中，需要引入除法器来执行除法运算。除法器通常由两个输入，也就是被除数和除数，以及两个输出，也就是商和余数。当除法器接收到被除数和除数时，它会执行除法运算并给出商和余数。
原码的恢复余数除法和加减交替除法
热门推荐
CaiYuxingzzz的博客
03-21 1万+
原码的除法分讲两种，一种是恢复余数法，一种是加减交替法 恢复余数法 过程为： ① 对被除数和除数取绝对值，先做被除数-除数。 ② 判断余数是否小于0，若是，则加上除数的补，否则减去除数的补 ③ 移位，重复步骤② 直到移位次数等于除数的位数，上商的次数为移位次数+1。 直接上题： x=-0.1011, y=-0.1101, 求[x/y]原。 解： ① 先求绝对值，x_=0.1011, y_=0....
原码除法（恢复余数法）
qiandididi的博客
07-28 2019
原码除法（恢复余数法）
除法器原理之恢复余数法
最新发布
gsp12356的博客
01-21 665
本文全程将以 124除以3 为例进行求商和取模过程的讲解被除数：dividend除数：divisor商：quotient余数：remainder。
基于FPGA开发 Verilog 除法器设计
GJZGRB的博客
11-16 306
dividend ({remainder_t[N_ACT-M-i+1], dividend_t[N_ACT-M-i+1][N_ACT-M-i]}), //余数与原始被除数单bit数据拼接。.dividend_kp (dividend_t[N_ACT-M]), //原始被除数信息传递。.dividend_ci (dividend[N_ACT-M-1:0]), //原始被除数。
Newton-Raphson.rar_Newton-Raphson法_Newton–Raphson_Raphson_newton
07-14
**牛顿-拉夫森（Newton-Raphson）迭代法** 牛顿-拉夫森法是一种在数学和工程计算中广泛使用的数值方法，用于求解非线性方程。该方法基于函数的泰勒展开式，通过迭代逼近来寻找方程的根。其基本思想是假设目标函数在...
Newton-raphson.rar_newton_newton-raphson
07-15
牛顿-拉弗森方法（Newton-Raphson Method）是一种在数学和工程计算中广泛使用的迭代法，用于求解非线性方程。这个“Newton-raphson.rar”压缩包包含了一个用MATLAB语言实现的牛顿-拉弗森算法。MATLAB是一种强大的...
NEWTON-RAPHSON.rar_newton_newton-raphson
07-15
NEWTONS RAPHSONS METHODS IN MATLAB
Newton-Raphson 倒数近似、1/x 和 1/sqrt(x)：倒数的 Newton-Raphson 近似，即 1/x 和平方根倒数与精度测试夹具一起提供。-matlab开发
05-29
实时控制器中的倒数计算在计算上非常昂贵。 倒数的牛顿-拉夫森近似以牺牲精度为代价节省了计算成本。 如果计算输入信号的倒数，并且信号本身从一个执行周期到下一个执行周期的变化有限，则先前计算的 Newton-Raphson 倒数用作对新迭代的初始“猜测”。 这导致准确性的大幅提高。 迭代次数可以根据需要的精度进行修改。 可以在以下位置找到分析： 福勒、DL 和詹姆斯 E. 史密斯。 “通过倒数近似实现除法的准确、高速实现。” 第 9 届计算机算术研讨会论文集。 IEEE，1989 年。
用verilog实现除法器(两种方法）
02-26
一、 实验目的与要求： 用verilog语言编写出一个除法器的代码，并在modelsim中进行功能仿真，认真的完成实验报告。 二、 实验设备（环境）及要求： 在modelsim环境下编写代码与测试程序，并仿真； 在synplify pro下编译，设置硬件并综合。 三、 实验内容及步骤： 1、 选择除法器的算法，本实验开始采用的是减法实现除法器的例子（比如十进制中的a/b，可先比较a与b的大小，如果a>b,则商加1，a<=a-b,再进行比较大小，直到a<b,商不变，余数为a）; 2、 选择好算法，进行verilog语言编程，再写好testbench并进行编译与功能仿真； 3、 在中进行初步综合； 4、 完成实验报告；
除法器的Verilog实现
12-07
包含有符号除法器以及无符号除法器的Verilog源码，同时带有tb文件用于仿真测试，在Vivado和Modelsim上验证通过
niudunfa.zip_newton_newton-raphson_泰勒法_牛顿法
09-23
牛顿法（英语：Newton's method）又称为牛顿-拉弗森方法（英语：Newton-Raphson method），它是一种在实数域和复数域上近似求解方程的方法。方法使用函数f(x)的泰勒级数的前面几项来寻找方程f(y)=0的根
Newton-Raphson法：Newton-Raphson算法的简单应用-matlab开发
05-31
在MATLAB环境中，Newton-Raphson法可以轻松实现，帮助我们找到单变量方程f(x) = 0的根。 **算法原理** 1. **初始化**：选择一个初始猜测值x0。 2. **构建切线**：计算函数f(x)在x0处的导数f'(x0)，这代表了函数在...
5.6 除法器的实现
bangren3304的博客
07-09 1515
计算机组成 5 乘法器和除法器 5.6 除法器的实现 现在，我们已经将除法的运算过程用适合硬件实现的方法描述出来了，那么就可以着手开始设计真正的硬件的除法器了。那么在这一节，我们将首先整理出一个除法器的工作流程，然后通过一个事例来分析除法器的结构和它的工作原理。 我们首先来看一个32位除法器的工作流程。 首先进行初始化工作，然后进入正式的工作步骤。我们要注意，余数和被除数是共享一个寄...
verilog实现除法器运算
纯分享，内容不固定，平时学到什么发什么（非涉密内容），没有积分的话下载内容可以在相关博客下评论区留邮箱，看见了都会发的。
03-15 3250
本文通过verilog实现了一个位宽参数可配置的除法运算模块
计算机组成原理-恢复余数法
c++爱好者
10-18 6681
关于恢复余数法总结： 若为负数： 1.首先，则上商0； 2.第二步，无需左移 3.第三步，加上除数的绝对值的补码； 4.第四步，变成正数后，无需上商，但需要左移，然后加上除数的绝对值的负数的补码； （若还是负数的话，则反复操作以上步骤）； 正数： 1.首先，上商1； 2，第二步，左移一位； 3.第三步，加上除数的绝对值的负数的补码； ...
计组之数据运算：7、定点数原码除法运算(恢复余数法、加减交替法)
千寻瀑
09-22 1万+
7、定点数原码除法运算思维导图原码恢复余数法原理实现（类比十进制）机器实现与硬件构成手算实现缺点原码加减交替法分析手算实现补码加减交替法对比 思维导图 原码恢复余数法 先看一下十进制除法的原理 1、x / y = a …… b 等价于x = ay + b 原理实现（类比十进制） 机器实现与硬件构成 1、初始化 2、结果(中间省略) 1、当数据就位后，商的最低位上1，被除数-除数的值放入ACC 2、判断正负，若为正，说明上1够减，此时ACC与MQ逻辑左移；若ACC值为负时，说明上1不够减，
newton-raphson法matlab
03-16
Newton-Raphson法是一种数值计算方法，用于求解非线性方程组或函数的根。它是一种迭代方法，通过不断逼近函数的根来得到最终的解。在MATLAB中，可以使用fzero函数来实现Newton-Raphson法。具体使用方法可以参考MATLAB官方文档或相关教程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lu-ming.xyz

觉得有用的话点个赞吧 :)

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值