基于FPGA实现经过Matalb验证的CORDIC算法并Modelsim波形仿真——旋转模式和向量模式

已于 2023-09-10 19:08:48 修改
阅读量2.1k 收藏 52
点赞数 3
分类专栏： FPGA图像处理及仿真测试 图像拼接基础 文章标签： fpga开发 matlab
于 2022-04-25 17:13:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H19981118/article/details/124397171
版权

文章目录


前言

FPGA能容易地实现加减运算，但是计算三角函数或者指数、对数、平方根等很复杂。一般这些复杂函数的计算，会通过查找表或者近似计算（泰勒展开）等技术在FPGA上实现。【查找表方法：比如说要计算三角函数，就可以先采用三角函数基本公式以及和差化积等公式将函数值求出，建立查找表，将求出后的数值存在内存中，需要该数值时进行寻址；泰勒级数展开：会涉及到很多乘除法以及浮点数问题，运算复杂且影响精度】

CORDIC（坐标旋转数字计算方法）算法由J.D.Volder提出，相当于是一个“移位相加“算法，该算法用基本的加减或者移位运算来代替乘法运算，逐渐与目标值逼近，从而最终得到函数的解。另外该算法分别可以在圆坐标系、线性坐标系和双曲线坐标系使用。

CORDIC算法有两种工作模式：旋转模式和向量模式，旋转模式是给定旋转角，计算旋转后的坐标，而向量模式相当于旋转模式的变体（倒推得到），根据旋转后的坐标，得到向量的角度和模值。

因此采用CORDIC算法后，函数就能采用FPGA进行简易地处理，下面主要讲解旋转模式。

旋转模式

首先根据旋转模式下的圆坐标系进行分析学习
根据下图我们可以进行旋转公式推导
在这里插入图片描述

该图展示的是从红色旋转到蓝色，因此根据三角关系即可得到如下旋转数学仿真：
在这里插入图片描述
写成旋转矩阵形式：
在这里插入图片描述
还可以提取cosθ，便于写成tanθ的形式，写成tanθ后就可以转换成2的次幂形式。
在这里插入图片描述
cosθ可以作为伸缩因子，将其去掉，我们就能得到CORDIC的伪旋转，对于伪旋转来说，旋转的角度不变，但是由于除去了cosθ，相当于xy的值乘以了cosθ的倒数，cosθ的倒数 > 1 ，因此向量的模值在旋转的过程中会变大，后续我们会引入参数进行补偿（K）。
在这里插入图片描述
2的次幂形式转换：
在这里插入图片描述
在这里插入图片描述
举例：当逆时针旋转90度的时候在这里插入图片描述
可得到如下的矩阵变换：
在这里插入图片描述
至此，我们就介绍完了旋转的几何原理，该算法就是已知一点坐标以及旋转角度，我们即可求出旋转后点的坐标。此时就涉及到了求取三角函数值的问题，并不适用于FPGA实现，于是采用CORDIC算法进行简化，将三角函数运算转换成移位加法运算。

CORDIC算法原理

该算法主要包括以下几点：
1、将旋转角度θ分成若干个固定大小的角度θi（θ0-θi），同时θi满足如下的公式，可看出已经将正切函数部分转换成了移位操作。（除以i个2，相当于右移i位）。
在这里插入图片描述

2、同时θ 的范围是【-π/2，π/2】，其余超出的角度我们给与一个方向值d来判断角度，也称为符号判决因子，如果旋转角已经大于θ，则di = -1，表示顺时针旋转；如果旋转角已经小于θ，则di = 1，表示旋转为逆时针。因此其每次旋转的角度值为 di*θi，最终得到每次迭代的旋转表达式：
在这里插入图片描述
如下为角度累加器的公式，z为角度叠加值，d为旋转方向
在这里插入图片描述
3、迭代操作得到增益K值

因此当我们进行第一次旋转的时候：（θ0角的旋转方向为d0）

x1 = cosθ0(x0 – d0y0tanθ0)
y1 = cosθ0(y0 + d0x0tanθ0)

第二次旋转的时候：(将上面的x1 和 y1 代入并提取cosθ)

x2 = cosθ1(x1 – d1y1tanθ1) = cosθ1cosθ0(x0 – d0y0tanθ0 – d1y0tanθ1 –d1d0 x0tanθ1 tanθ0)
y2 = cosθ1(y1 + d1x1tanθ1) = cosθ1cosθ0(y0 +d0x0tanθ0 + d1x0tanθ1 – d1d0y0tanθ1 tanθ0)

当进行到第n次旋转，即可得到n个cos相乘，我们将其规定为K（增益），当i的次数很大时，K的值趋于一个常数。K的数值需要根据迭代次数来确定，同时迭代次数确定后，k的值也能确定出来，我们就可以将这个误差值K预先存储下来，迭代结束后就可以对旋转后的xy进行补偿校正。
由于如下公式以及tanθi = 2^(-i)
在这里插入图片描述
则
在这里插入图片描述
4、把所有tanθi = 2^(-i)对应的旋转角度和正切值制成一张表如下，便于存储为查找表。
于是任意的旋转角θ，都能由下表的不同θi进行多次累加旋转得到。
在这里插入图片描述

CORDIC算法最终公式

经过CORDIC算法原理分析以及推导，我们可以得到最终的公式：
通过下面公式可看出，对应三角函数运算转化为了基本的加减和移位运算。
补充：当计算向量模值的时候，角度累加器Z 可忽略，只用前两个公式即可。
在这里插入图片描述

当FPGA进行计算的时候，每次迭代运算需要需要步骤：

1次查表【每次迭代都会有一个相对固定角度的累加，这个角度就是公式中2^(-i)对应的角度值，一个i对应一个角度值，用查找表实现】
三次加法【xyz的累加】
2次移位（每迭代一次，xy要分别进行一次移位）

最终公式的数学矩阵形式：
在这里插入图片描述
通常简化操作如下：
在这里插入图片描述

Matlab实现CORDIC算法（旋转模式）

close all;
clear;
clc;
% 初始化
die = 16;     %迭代次数
x = zeros(die+1,1);
y = zeros(die+1,1);
z = zeros(die+1,1);
x(1) = 0.607253;   %初始设置
z(1) = pi/6;    %待求角度θ
%迭代操作
for i = 1:die
    if z(i) >= 0% 判断旋转角度是逆时针还是顺时钟
        d = 1;  % 逆时针
    else
        d = -1; %顺时针旋转
    end
    % CORDIC算法是三个公式
    x(i+1) = x(i) - d*y(i)*(2^(-(i-1)));
    y(i+1) = y(i) + d*x(i)*(2^(-(i-1)));
    z(i+1) = z(i) - d*atan(2^(-(i-1)));
end
cosa = vpa(x(17),10)
sina = vpa(y(17),10)
c = vpa(z(17),10)

FPGA实现

旋转角度需要提前存在ROM中，另外还需要用到加法器和移位操作。根据输入： X Y Z 得到 输出：旋转后的 X’ 和 Y‘
在这里插入图片描述
单次迭代的框图：

**旋转角度：**通过xy的最高有效位进行XOR异或操作，我们即可判断xy最高有效位的同号还是异号，从而判断出旋转角度 d 是 -1 还是 1 。
**选择信号：**根据公式，当X进行加法运算的时候，Y进行减法运算，或者X减法Y加法，因此二者的选择是互为相反，而选择信号均来自XOR结果，因此在Y的选择器处进行了取反操作，为保证与X互为相反的加减运算。（起到控制加减法的作用）
二选一多路器：根据选择信号来判断是进行加法还是减法操作。

在这里插入图片描述
两次迭代框图：
两次迭代就是逻辑的复制。
在这里插入图片描述本文的学习资料参考包含verilog代码及测试文件。该代码采用如下的数学矩阵来计算。
首先确定迭代次数以及增益K的数值，然后根据查找表的角度值即可实现。

在这里插入图片描述

CORDIC旋转模式的verilog代码

该代码中将迭代次数设置为16，以下是代码的学习理解：

//*********************************************************
//用该模块的时候需要给予一个角度theta
//已知角thea，求正弦sinθ（sin_theta）和余弦cosθ（cos_theta）

//思想:若向量模值为1，则其x坐标就是余弦值，y坐标就是正弦值。
//利用这一点，从(K,0)处迭代旋转至θ处的单位矢量即可。

//*********************************************************

module cordic_A(
	input clk,
	input rst_n,
	input  [15:0]theta, /给予角度
	output reg [15:0]sin_theta, // 正弦值 y
	output reg [15:0]cos_theta  //余弦值 x
);
//给定增益k
parameter Kn  = 'd19898;    // 0.607253*2^15
parameter iKn = 'd53961;    // 1.64676*2^15 

parameter arctan_0 = 8192    ;  // arctan(1/2)
parameter arctan_1 = 4836    ;  // arctan(1/2^1)
parameter arctan_2 = 2555    ;  // arctan(1/2^2)
parameter arctan_3 = 1297    ;  // arctan(1/2^3)
parameter arctan_4 = 651     ;  // arctan(1/2^4)
parameter arctan_5 = 326     ;  // arctan(1/2^5)
parameter arctan_6 = 163     ;  // arctan(1/2^6)
parameter arctan_7 = 81      ;  // arctan(1/2^7)
parameter arctan_8 = 41      ;  // arctan(1/2^8)
parameter arctan_9 = 20      ;  // arctan(1/2^9)
parameter arctan_10 = 10     ;  // arctan(1/2^10)
parameter arctan_11 = 5      ;  // arctan(1/2^11)

reg signed [15:0] x [11:0];
reg signed [15:0] y [11:0];
reg signed [15:0] z [11:0];

wire [15:0]x_tmp;
wire [15:0]y_tmp;

reg signed [15:0]theta_1;
wire [2:0] Quadrant;//theta角所在的象限

// 象限判断
assign Quadrant = theta[15:14] + 1;

always@(*)
begin
	begin
		theta_1 <= {2'b00,theta[13:0]};
		if(Quadrant==1)
		begin
			theta_1 <= theta;
		end
		else if(Quadrant==2)
		begin
			theta_1 <= 32768 - theta;
		end
		else if(Quadrant==3)
		begin
			theta_1 <= theta - 32768;
		end
		else if(Quadrant==4)
		begin
			theta_1 <= 65536 - theta;
		end
	end
end
//指定迭代次数为16次。
always@(posedge clk or negedge rst_n)
begin
	if(!rst_n)
	begin
		x[0] <= 16'd0;
		y[0] <= 16'd0;
		z[0] <= 16'd0;
	end
	else
	begin
		x[0] <= Kn;
		y[0] <= 16'd0;
		z[0] <= theta_1;
	end
end

always@(posedge clk or negedge rst_n) // i=0
begin
	if(!rst_n)
	begin
		x[1] <= 16'd0;
		y[1] <= 16'd0;
		z[1] <= 16'd0;
	end
	else
	begin
		if(z[0][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[1] <= x[0] + y[0];
			y[1] <= y[0] - x[0];
			z[1] <= z[0] + arctan_0;
		end          // 剩余角度为正数，顺时针旋转，d=+1
		else
		begin
			x[1] <= x[0] - y[0];
			y[1] <= y[0] + x[0];
			z[1] <= z[0] - arctan_0;
		end
	end
end

// >>>符号表示算术右移，不改变符号位
always@(posedge clk or negedge rst_n) // i=1
begin
	if(!rst_n)
	begin
		x[2] <= 16'd0;
		y[2] <= 16'd0;
		z[2] <= 16'd0;
	end
	else
	begin
		if(z[1][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[2] <= x[1] + (y[1] >>> 1);
			y[2] <= y[1] - (x[1] >>> 1);
			z[2] <= z[1] + arctan_1;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[2] <= x[1] - (y[1] >>> 1);
			y[2] <= y[1] + (x[1] >>> 1);
			z[2] <= z[1] - arctan_1;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=2
begin
	if(!rst_n)
	begin
		x[3] <= 16'd0;
		y[3] <= 16'd0;
		z[3] <= 16'd0;
	end
	else
	begin
		if(z[2][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[3] <= x[2] + (y[2] >>> 2);
			y[3] <= y[2] - (x[2] >>> 2);
			z[3] <= z[2] + arctan_2;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[3] <= x[2] - (y[2] >>> 2);
			y[3] <= y[2] + (x[2] >>> 2);
			z[3] <= z[2] - arctan_2;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=3
begin
	if(!rst_n)
	begin
		x[4] <= 16'd0;
		y[4] <= 16'd0;
		z[4] <= 16'd0;
	end
	else
	begin
		if(z[3][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[4] <= x[3] + (y[3] >>> 3);
			y[4] <= y[3] - (x[3] >>> 3);
			z[4] <= z[3] + arctan_3;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[4] <= x[3] - (y[3] >>> 3);
			y[4] <= y[3] + (x[3] >>> 3);
			z[4] <= z[3] - arctan_3;
		end
	end
end


always@(posedge clk or negedge rst_n) // i=4
begin
	if(!rst_n)
	begin
		x[5] <= 16'd0;
		y[5] <= 16'd0;
		z[5] <= 16'd0;
	end
	else
	begin
		if(z[4][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[5] <= x[4] + (y[4] >>> 4);
			y[5] <= y[4] - (x[4] >>> 4);
			z[5] <= z[4] + arctan_4;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[5] <= x[4] - (y[4] >>> 4);
			y[5] <= y[4] + (x[4] >>> 4);
			z[5] <= z[4] - arctan_4;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=5
begin
	if(!rst_n)
	begin
		x[6] <= 16'd0;
		y[6] <= 16'd0;
		z[6] <= 16'd0;
	end
	else
	begin
		if(z[5][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[6] <= x[5] + (y[5] >>> 5);
			y[6] <= y[5] - (x[5] >>> 5);
			z[6] <= z[5] + arctan_5;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[6] <= x[5] - (y[5] >>> 5);
			y[6] <= y[5] + (x[5] >>> 5);
			z[6] <= z[5] - arctan_5;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=6
begin
	if(!rst_n)
	begin
		x[7] <= 16'd0;
		y[7] <= 16'd0;
		z[7] <= 16'd0;
	end
	else
	begin
		if(z[6][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[7] <= x[6] + (y[6] >>> 6);
			y[7] <= y[6] - (x[6] >>> 6);
			z[7] <= z[6] + arctan_6;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[7] <= x[6] - (y[6] >>> 6);
			y[7] <= y[6] + (x[6] >>> 6);
			z[7] <= z[6] - arctan_6;
		end
	end
end


always@(posedge clk or negedge rst_n) // i=7
begin
	if(!rst_n)
	begin
		x[8] <= 16'd0;
		y[8] <= 16'd0;
		z[8] <= 16'd0;
	end
	else
	begin
		if(z[7][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[8] <= x[7] + (y[7] >>> 7);
			y[8] <= y[7] - (x[7] >>> 7);
			z[8] <= z[7] + arctan_7;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[8] <= x[7] - (y[7] >>> 7);
			y[8] <= y[7] + (x[7] >>> 7);
			z[8] <= z[7] - arctan_7;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=8
begin
	if(!rst_n)
	begin
		x[9] <= 16'd0;
		y[9] <= 16'd0;
		z[9] <= 16'd0;
	end
	else
	begin
		if(z[8][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[9] <= x[8] + (y[8] >>> 8);
			y[9] <= y[8] - (x[8] >>> 8);
			z[9] <= z[8] + arctan_8;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[9] <= x[8] - (y[8] >>> 8);
			y[9] <= y[8] + (x[8] >>> 8);
			z[9] <= z[8] - arctan_8;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=9
begin
	if(!rst_n)
	begin
		x[10] <= 16'd0;
		y[10] <= 16'd0;
		z[10] <= 16'd0;
	end
	else
	begin
		if(z[9][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[10] <= x[9] + (y[9] >>> 9);
			y[10] <= y[9] - (x[9] >>> 9);
			z[10] <= z[9] + arctan_9;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[10] <= x[9] - (y[9] >>> 9);
			y[10] <= y[9] + (x[9] >>> 9);
			z[10] <= z[9] - arctan_9;
		end
	end
end

always@(posedge clk or negedge rst_n) // i=10
begin
	if(!rst_n)
	begin
		x[11] <= 16'd0;
		y[11] <= 16'd0;
		z[11] <= 16'd0;
	end
	else
	begin
		if(z[10][15]) // 剩余角度为负数，顺时针旋转，d=-1
		begin
			x[11] <= x[10] + (y[10] >>> 10);
			y[11] <= y[10] - (x[10] >>> 10);
			z[11] <= z[10] + arctan_10;
		end          // 剩余角度为正数，逆时针旋转，d=+1
		else
		begin
			x[11] <= x[10] - (y[10] >>> 10);
			y[11] <= y[10] + (x[10] >>> 10);
			z[11] <= z[10] - arctan_10;
		end
	end
end

// 溢出判断
assign x_tmp = x[11][15]==1 ? 16'h7FFF : x[11];
assign y_tmp = y[11][15]==1 ? 16'h7FFF : y[11];
//assign x_tmp = x[11];
//assign y_tmp = y[11];

always@(posedge clk or negedge rst_n) // i=11
begin
	if(!rst_n)
	begin
		sin_theta <= 16'd0;
		cos_theta <= 16'd0;
	end
	else
	begin
		if(Quadrant == 3'd1)
		begin
			sin_theta <= y_tmp;
			cos_theta <= x_tmp;
		end
		else if(Quadrant == 3'd2)
		begin
			sin_theta <= y_tmp;
			cos_theta <= -x_tmp;
		end
		else if(Quadrant == 3'd3)
		begin
			sin_theta <= -y_tmp;
			cos_theta <= -x_tmp;
		end
		else if(Quadrant == 3'd4)
		begin
			sin_theta <= -y_tmp;
			cos_theta <= x_tmp;
		end
		else
		begin
			sin_theta <= sin_theta;
			cos_theta <= cos_theta;
		end
	end
end
endmodule

对CORDIC算法进行封装，同时给与一个旋转角度60度。

module top(

				input clk,
				input rst_n,

				output 	 signed [31:0]	Sin,
				output 	 signed [31:0]	Cos

);

cordic_A inst1(
		.clk(clk),
		.rst_n(rst_n),
		.angle(60),
		.start(start),
		
		.Sin(Sin),
		.Cos(Cos),
		.finished(finished)
		
);
endmodule

RTL图

得到如下的RTL图：
在这里插入图片描述

可以看到给与60度旋转角，根据旋转角，采用CORDIC算法即可得到最终的正余弦值。

对CORDIC算法tb仿真

`timescale 1ns/1ns

module cordic_Atb();


integer i;

reg clk,rst_n;
reg [15:0] theta;
wire [15:0]sin_theta,cos_theta;


cordic_A u0(
	.clk       (clk      ),
	.rst_n     (rst_n    ),
	.theta     (theta    ),
	.sin_theta (sin_theta),
	.cos_theta (cos_theta)
);

initial
begin
    #0 clk = 1'b0;
    #10 rst_n = 1'b0;
    #10 rst_n = 1'b1;
    #10000000 $stop;
end 
always #10
begin
    clk = ~clk;
end


initial
begin
    #0 theta = 16'd20;  //初始化角度为20
   for(i=0;i<10000;i=i+1)
	begin
		#400;
		theta <= theta + 16'd20; //每延迟400ns，角度加20
	end
end 


endmodule

仿真波形如下：
可看到我们得到了正余弦值。
在这里插入图片描述显示正余弦波的方式：在这里插入图片描述
在这里插入图片描述

向量模式

向量模式相当于旋转模式的倒推，是将给定的向量旋转到X轴上，因此我们就有了旋转后的坐标，根据旋转后的坐标（梯度模值），可确定处旋转的角度（梯度方向）。
在这里插入图片描述
寄存器X值为梯度模值，符号判决因子d与寄存器y的值相反，得到d后，仍然使用旋转模式中推到的角度累加器Z来计算梯度方向。
在这里插入图片描述

Fighting_FPGA
关注
专栏目录
三维空间坐标的旋转算法详解_CORDIC算法详解(一)CORDIC 算法之圆周系统之旋转模式...
weixin_39627699的博客
12-04 1802
CORDIC算法详解(一)- CORDIC 算法之圆周系统之旋转模式( Rotation Mode )文章目录CORDIC算法详解(一)- CORDIC 算法之圆周系统之旋转模式( Rotation Mode )1 CORDIC 算法之圆周系统及其数学应用1.1 圆周系统之旋转模式( Rotation Mode )1.2 思考1.3 CORDIC算法应用1.3.1 目标旋转角度的正、 余...
FPGA图像处理功能仿真，Modelsim联合Matlab
m0_56760332的博客
01-09 1213
在使用FPGA进行图像处理时，常常需要对所写的Verilog代码进行功能性仿真，在很多情况下，对图像处理效果的判断单从数据上观察并不明显，故使用Model Sim进行图像数据的处理后，将处理后的数据保存到 .txt 中，通过Matlab将存储图像的数据的文本文件转为图像格式的 .jpg等等。
三角函数与其他复杂函数在C语言中的实现：CORDIC算法、泰勒公式、查表法与math库详解
初心不忘产学研的博客
04-25 3287
在C语言中实现三角函数，通常有四种主要方法：CORDIC算法、泰勒公式展开、查表法以及直接调用C语言的标准数学库。接下来我们将详细介绍这四种方法，并探讨其他可能的补充实现手段。
详解CORDIC算法以及Verilog实现并且调用Xilinx CORDIC IP核进行验证
最新发布
主要分享学习中的知识和遇到的问题
09-20 1125
CORDIC（COordinate Rotation DIgital Computer）算法是一种用于计算三角函数、双曲函数、对数、指数和平方根等数学函数的迭代算法。对于硬件电路来说，计算三角函数不像CPU那样方便，如果使用大量的乘法器和加法器，那么整个硬件电路会消耗很多资源，因此cordic算法就有效地解决了乘法器和加法器的问题，它的主要优点是：可以使用简单的加法和位移操作，而不需要乘法和除法，从而适合在硬件中实现三角函数的计算，特别是数字信号处理（DSP）和嵌入式系统中。
FPGA算法学习(1) -- Cordic（圆周系统之旋转模式）
weixin_30263073的博客
07-01 526
三角函数的计算是个复杂的主题，有计算机之前，人们通常通过查找三角函数表来计算任意角度的三角函数的值。这种表格在人们刚刚产生三角函数的概念的时候就已经有了，它们通常是通过从已知值（比如sin(π/2)=1）开始并重复应用半角和和差公式而生成。 现在有了计算机，三角函数表便推出了历史的舞台。但是像我这样的喜欢刨根问底的人，不禁要问计算机又是如何计算三角函数值的呢。最容易想到的办法就是利用级数展开，比如...
Matlab实现CORDIC算法
01-12
用Matlab的.m文件实现CORDIC算法用于产生正弦波，代码浅显易懂，该代码对于指导CORDIC算法在FPGA等可编程器件下的实现具有参考意义。
cordic_cordicMATLAB_
09-29
使用matlab编程，实现了cordic算法，为FPGA上的cordic代码编写提供有力支持。
CORDIC算法 旋转模式
06-03
CORDIC 旋转模式 verilog程序.V文件 需要读者自己建立工程
THU通信信号处理课程实验项目-基于NLMS算法均衡器的设计和实现matalb源码.zip
07-20
THU通信信号处理课程实验项目-基于NLMS算法均衡器的设计和实现matalb源码.zipTHU通信信号处理课程实验项目-基于NLMS算法均衡器的设计和实现matalb源码.zipTHU通信信号处理课程实验项目-基于NLMS算法均衡器的设计和...
粒子群优化算法的寻优算法——非线性函数极值寻优.zip_matalb_启发式算法_极值优化_粒子群优化_粒子群寻优
09-23
粒子群优化算法（Particle Swarm Optimization, PSO）是一种在复杂多维空间中寻找全局最优解的仿生算法，源于对鸟群和鱼群集体行为的研究。该算法通过模拟群体中的个体（粒子）在搜索空间中的移动和更新，来逐步逼近...
基于Matalb实现MIMO-OFDM系统容量仿真.zip
04-21
2.领域：智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，更多内容可点击博主头像 3.内容：标题所示，对于介绍可点击主页搜索博客 4.适合人群：本科，硕士...
CORDIC算法 向量模式
06-02
CORDIC 向量模式 verilog 实现反正切
cordic:Matlab中实现的cordic算法
05-16
亲切的 Matlab中实现的cordic算法
CORDIC 算法：使用 CORDIC 的角度正弦和余弦函数-matlab开发
06-01
M 已发布的文件解释了cordic 算法，其中包含获得三角函数正弦和余弦的函数。 使用 Simulink 呈现相同的工作，这些工作相互补充。
CORDIC算法MATLAB代码.zip_arctan_cordic_cordic MATLAB_cordic tan
09-20
坐标旋转数字计算机算法利用简单的移位和加法实现sin，cos，tan，arctan等函数的计算，适合计算机处理，速度快。
matlab cordic算法,CORDIC算法
weixin_31970409的博客
03-19 931
CORDIC算法From Wikipedia, the free encyclopediaCORDIC (digit-by-digit method, Volder's algorithm) (forCOordinate Rotation DIgital Computer)is a simple and efficient algorithm to calculate hyperbolic and...
CORDIC算法详解（一）- CORDIC 算法之圆周系统之旋转模式（ Rotation Mode )
大熊
08-21 6254
版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/Pieces_thinking/article/details/83512820 CORDIC算法详解（一）- CORDIC 算法之圆周系统之旋转模式（ Rotation Mode ) 网上有很多类似的介绍，但是本文会结合实例进行...
FPGA实现Cordic算法——向量模式
qq_42151264的博客
09-08 1639
;FPGA中运算三角函数，浮点数的能力有限，而cordic算法能够将三角函数运算转换为简单的移位和加减法进行迭代得到近似结果，能够有效降低运算代价，提升运算效率。
MATALB实现LM算法
11-08
MATLAB中可以使用`lsqnonlin`函数来实现LM算法。该函数可以用于非线性最小二乘问题的求解，其中包括LM算法。使用该函数时，需要提供一个函数句柄，该函数句柄用于计算残差。同时，还需要提供一个初始点作为算法的起点。下面是一个使用`lsqnonlin`函数实现LM算法的示例代码： ```matlab % 定义残差函数 function r = residual(x) % 计算残差 r = [x(1) + 2*x(2) + 3*x(3) - 6; x(1)^2 + x(2)^2 + x(3)^2 - 14; exp(x(1)) + x(2) - x(3)^3 - 25]; end % 定义初始点 x0 = [1; 1; 1]; % 使用lsqnonlin函数求解最小二乘问题 options = optimoptions('lsqnonlin', 'Algorithm', 'levenberg-marquardt'); x = lsqnonlin(@residual, x0, [], [], options); disp(x); ``` 在上述代码中，我们定义了一个残差函数`residual`，该函数用于计算残差。然后，我们定义了一个初始点`x0`，并使用`lsqnonlin`函数求解最小二乘问题。其中，我们使用了`optimoptions`函数来设置算法为LM算法。最后，我们输出了求解得到的最优解`x`。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Fighting_FPGA

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值