开根号

最新推荐文章于 2024-04-16 15:49:52 发布
最新推荐文章于 2024-04-16 15:49:52 发布
阅读量770 收藏
点赞数
分类专栏： FPGA

`timescale 1ns / 100ps

module cordic_sqrt(
 rst_n,
 clk,
 din,
 sqrt_valid_in,
 dout,
 sqrt_valid_out
);

//=========================================================
// Interface definition
//=========================================================
input                 rst_n;
input                 clk;
input    [17:0]             din;
input                       sqrt_valid_in;
   
output   [17:0]             dout;
output                      sqrt_valid_out;
//=========================================================
// Interface type
//=========================================================
reg      [17:0]             dout;
reg                         sqrt_valid_out;

//=========================================================
// Local parameters
//=========================================================
parameter FRAC_LEN      = 9;

//=========================================================
// Internal signal definition
//=========================================================
reg      [18:0]             x1;
reg      [18:0]             y1;
reg      [19:0]             x2;
reg      [19:0]             y2;
reg      [21:0]             x3;
reg      [21:0]             y3;
reg      [24:0]             x4;
reg      [24:0]             y4;
reg      [28:0]             x5;
reg      [28:0]             y5;
reg      [31:0]             x6;
reg      [31:0]             y6;
reg      [32:0]             x7;
reg      [32:0]             y7;
reg      [33:0]             x8;

wire     [17:0]             xs1, ys1;
wire     [18:0]             xs2, ys2;
wire     [20:0]             xs3, ys3;
wire     [23:0]             xs4, ys4;
wire     [25:0]             xs5, ys5;
wire     [25:0]             xs6, ys6;
wire     [25:0]             xs7, ys7;
wire     [25:0]             xs8;

reg      [3:0]              shift_cnt;
reg      [3:0]              shift_cnt_d1;
reg      [3:0]              shift_cnt_d2;
reg      [9:0]              valid_d;
//=========================================================
// shift_cnt process
//=========================================================
always @(posedge clk or negedge rst_n)
 if (!rst_n)
  shift_cnt <= 4'd0;
 else if (sqrt_valid_in) begin
  if (din[17])
   shift_cnt <= 4'd8;
  else if (din[16] || din[15])
   shift_cnt <= 4'd7;
  else if (din[14] || din[13])
   shift_cnt <= 4'd6;
  else if (din[12] || din[11])
   shift_cnt <= 4'd5;
  else if (din[10] || din[9])
   shift_cnt <= 4'd4;
  else if (din[8] || din[7])
   shift_cnt <= 4'd3;
  else if (din[6] || din[5])
   shift_cnt <= 4'd2;
  else if (din[4] || din[3])
   shift_cnt <= 4'd1;
  else
   shift_cnt <= 4'd0;
 end
 
//=========================================================
// shift_cnt_d1 process
//========================================================= 
always @ (posedge clk or negedge rst_n)
 if (!rst_n) begin
  shift_cnt_d1 <= 4'd0;
  shift_cnt_d2 <= 4'd0;
 end
 else begin
  shift_cnt_d1 <= shift_cnt;
  shift_cnt_d2 <= shift_cnt_d1;
 end
 
//=========================================================
// x1, y1 process
//=========================================================
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x1 <= 19'd0;
  y1 <= 19'd0;
 end
 else if (sqrt_valid_in) begin
  if (din[16] || din[15]) begin
   x1 <=  {1'b0, din} + 19'b0_0001_0000_0000_0000_00;
   y1 <=  {1'b0, din} - 19'b0_0001_0000_0000_0000_00;
  end
  else if (din[14] || din[13]) begin
   x1 <=  {1'b0, din} + 19'b0_0000_0100_0000_0000_00;
   y1 <=  {1'b0, din} - 19'b0_0000_0100_0000_0000_00;
  end
  else if (din[12] || din[11]) begin
   x1 <=  {1'b0, din} + 19'b0_0000_0001_0000_0000_00;
   y1 <=  {1'b0, din} - 19'b0_0000_0001_0000_0000_00;  
  end
  else if (din[10] || din[9]) begin
   x1 <=  {1'b0, din} + 19'b0_0000_0000_0100_0000_00;
   y1 <=  {1'b0, din} - 19'b0_0000_0000_0100_0000_00;  
  end
  else if (din[8] || din[7]) begin
   x1 <=  {1'b0, din} + 19'b0_0000_0000_0001_0000_00;
   y1 <=  {1'b0, din} - 19'b0_0000_0000_0001_0000_00;  
  end
  else if (din[6] || din[5]) begin
   x1 <=  {1'b0, din} + 19'b0_0000_0000_0000_0100_00;
   y1 <=  {1'b0, din} - 19'b0_0000_0000_0000_0100_00;  
  end
  else if (din[4] || din[3]) begin
   x1 <=  {1'b0, din} + 19'b0_0000_0000_0000_0001_00;
   y1 <=  {1'b0, din} - 19'b0_0000_0000_0000_0001_00;  
  end
  else begin
   x1 <=  {1'b0, din} + 19'b0_0000_0000_0000_0000_01;
   y1 <=  {1'b0, din} - 19'b0_0000_0000_0000_0000_01;
  end
 end
 
//=========================================================
// xs1, ys1 process
//=========================================================  
RndTrim #(.IB(19),.NT(1),.NR(0))RndRrim_inst1(.din(x1),.dout(xs1)); 

RndTrim #(.IB(19),.NT(1),.NR(0))RndTrim_inst2(.din(y1),.dout(ys1));  
 
//=========================================================
// x2, y2 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x2 <= 20'd0;
  y2 <= 20'd0;
 end
 else if (!ys1[17]) begin
  x2 <=  {1'b0, xs1, 1'b0} - {2'b00, ys1};
  y2 <=  {1'b0, ys1, 1'b0} - {2'b00, xs1};
 end
 else begin
  x2 <=  {1'b0, xs1, 1'b0} + {2'b00, ys1};
  y2 <=  {1'b0, ys1, 1'b0} + {2'b00, xs1};
 end
 
//=========================================================
// xs2, ys2 process
//=========================================================  
RndTrim #(.IB(20),.NT(1),.NR(0))RndRrim_inst3(.din(x2),.dout(xs2)); 

RndTrim #(.IB(20),.NT(1),.NR(0))RndTrim_inst4(.din(y2),.dout(ys2));  

//=========================================================
// x3, y3 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x3 <= 22'd0;
  y3 <= 22'd0;
 end
 else if (!ys2[18]) begin
  x3 <=  {xs2[18], xs2, 2'b00} - {{3{ys2[18]}}, ys2};
  y3 <=  {ys2[18], ys2, 2'b00} - {{3{xs2[18]}}, xs2};
 end
 else begin
  x3 <=  {xs2[18], xs2, 2'b00} + {{3{ys2[18]}}, ys2};
  y3 <=  {ys2[18], ys2, 2'b00} + {{3{xs2[18]}}, xs2};
 end
 
//=========================================================
// xs3, ys3 process
//=========================================================  
RndTrim #(.IB(22),.NT(1),.NR(0))RndRrim_inst5(.din(x3),.dout(xs3)); 

RndTrim #(.IB(22),.NT(1),.NR(0))RndTrim_inst6(.din(y3),.dout(ys3));   
  
//=========================================================
// x4, y4 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x4 <= 25'd0;
  y4 <= 25'd0;
 end
 else if (!ys3[20]) begin
  x4 <=  {xs3[20], xs3, 3'b000} - {{4{ys3[20]}}, ys3};
  y4 <=  {ys3[20], ys3, 3'b000} - {{4{xs3[20]}}, xs3};
 end
 else begin
  x4 <=  {xs3[20], xs3, 3'b000} + {{4{ys3[20]}}, ys3};
  y4 <=  {ys3[20], ys3, 3'b000} + {{4{xs3[20]}}, xs3};
 end  
 
//=========================================================
// xs4, ys4 process
//=========================================================  
RndTrim #(.IB(25),.NT(1),.NR(0))RndRrim_inst7(.din(x4),.dout(xs4)); 

RndTrim #(.IB(25),.NT(1),.NR(0))RndTrim_inst8(.din(y4),.dout(ys4)); 

//=========================================================
// x5, y5 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x5 <= 29'd0;
  y5 <= 29'd0;
 end
 else if (!ys4[23]) begin
  x5 <=  {xs4[23], xs4, 4'b0000} - {{5{ys4[23]}}, ys4};
  y5 <=  {ys4[23], ys4, 4'b0000} - {{5{xs4[23]}}, xs4};
 end
 else begin
  x5 <=  {xs4[23], xs4, 4'b0000} + {{5{ys4[23]}}, ys4};
  y5 <=  {ys4[23], ys4, 4'b0000} + {{5{xs4[23]}}, xs4};
 end    

//=========================================================
// xs5, ys5 process
//=========================================================  
RndTrim #(.IB(29),.NT(1),.NR(2))RndRrim_inst9 (.din(x5),.dout(xs5)); 

RndTrim #(.IB(29),.NT(1),.NR(2))RndTrim_inst10(.din(y5),.dout(ys5));  

//=========================================================
// x6, y6 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x6 <= 32'd0;
  y6 <= 32'd0;
 end
 else if (!ys5[25]) begin
  x6 <=  {xs5[25], xs5, 5'b00000} - {{6{ys5[25]}}, ys5};
  y6 <=  {ys5[25], ys5, 5'b00000} - {{6{xs5[25]}}, xs5};
 end
 else begin
  x6 <=  {xs5[25], xs5, 5'b00000} + {{6{ys5[25]}}, ys5};
  y6 <=  {ys5[25], ys5, 5'b00000} + {{6{xs5[25]}}, xs5};
 end 

//=========================================================
// xs6, ys6 process
//=========================================================  
RndTrim #(.IB(32),.NT(1),.NR(5))RndRrim_inst11(.din(x6),.dout(xs6)); 

RndTrim #(.IB(32),.NT(1),.NR(5))RndTrim_inst12(.din(y6),.dout(ys6));   

//=========================================================
// x7, y7 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x7 <= 33'd0;
  y7 <= 33'd0;
 end
 else if (!ys6[25]) begin
  x7 <=  {xs6[25], xs6, 6'b000000} - {{7{ys6[25]}}, ys6};
  y7 <=  {ys6[25], ys6, 6'b000000} - {{7{xs6[25]}}, xs6};
 end
 else begin
  x7 <=  {xs6[25], xs6, 6'b000000} + {{7{ys6[25]}}, ys6};
  y7 <=  {ys6[25], ys6, 6'b000000} + {{7{xs6[25]}}, xs6};
 end 

//=========================================================
// xs7, ys7 process
//=========================================================  
RndTrim #(.IB(33),.NT(1),.NR(6))RndRrim_inst13(.din(x7),.dout(xs7)); 

RndTrim #(.IB(33),.NT(1),.NR(6))RndTrim_inst14(.din(y7),.dout(ys7)); 

//=========================================================
// x8 process
//========================================================= 
always @(posedge clk or negedge rst_n)
 if (!rst_n) begin
  x8 <= 34'd0;
 end
 else if (!ys7[25]) begin
  x8 <=  {xs7[25], xs7, 7'b0000000} - {{8{ys7[25]}}, ys7};
 end
 else begin
  x8 <=  {xs7[25], xs7, 7'b0000000} + {{8{ys7[25]}}, ys7};
 end 
 
//=========================================================
// xs8 process
//=========================================================  
RndTrim #(.IB(34),.NT(1),.NR(7))RndRrim_inst15(.din(x8),.dout(xs8));  

// K = 10011010010000001
// K = 78977
// <<7   <<10   <<12   <<13   <<16
reg      [33 : 0]           sum1;
reg      [38 : 0]           sum2;
reg      [42 : 0]           sum3;
wire     [39 : 0]           sum4;
reg      [43 : 0]           sum;
//=========================================================
// sum1 process
//========================================================= 
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  sum1     <= 34'd0;
 else
  sum1     <= {{8{xs8[25]}}, xs8} + {xs8[25], xs8, 7'b0000_000};

//=========================================================
// sum2 process
//=========================================================   
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  sum2 <=  39'd0;
 else
  sum2 <=  {{3{xs8[25]}}, xs8, 10'b0000_0000_00} + {xs8[25], xs8, 12'b0000_0000_0000};

//=========================================================
// sum3 process
//=========================================================  
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  sum3 <=  43'd0;
 else
  sum3 <=  {{4{xs8[25]}}, xs8, 13'b0000_0000_0000_0} + {xs8[25], xs8, 16'b0000_0000_0000_0000};
 
//=========================================================
// sum4 process
//=========================================================  
assign sum4 = {{6{sum1[33]}}, sum1} + {sum2[38], sum2};

//=========================================================
// sum process
//=========================================================  
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  sum  <= 44'd0;
 else
  sum  <= {sum3[42], sum3} + {{4{sum4[39]}}, sum4};

wire           [17: 0]    result_0;
wire           [17: 0]    result_1;
wire           [17: 0]    result_2;
wire           [17: 0]    result_3;
wire           [17: 0]    result_4;
wire           [17: 0]    result_5;
wire           [17: 0]    result_6;
wire           [17: 0]    result_7; 
//=========================================================
// result_i process 
//=========================================================  
RndTrim #(.IB(44),.NT(10),.NR(16))RndRrim_inst16(.din(sum),.dout(result_0));  
 
RndTrim #(.IB(44),.NT(9 ),.NR(17))RndRrim_inst17(.din(sum),.dout(result_1));  
 
RndTrim #(.IB(44),.NT(8 ),.NR(18))RndRrim_inst18(.din(sum),.dout(result_2)); 

RndTrim #(.IB(44),.NT(7 ),.NR(19))RndRrim_inst19(.din(sum),.dout(result_3)); 

RndTrim #(.IB(44),.NT(6 ),.NR(20))RndRrim_inst20(.din(sum),.dout(result_4)); 

RndTrim #(.IB(44),.NT(5 ),.NR(21))RndRrim_inst21(.din(sum),.dout(result_5)); 

RndTrim #(.IB(44),.NT(4 ),.NR(22))RndRrim_inst22(.din(sum),.dout(result_6)); 

RndTrim #(.IB(44),.NT(3 ),.NR(23))RndRrim_inst23(.din(sum),.dout(result_7));

//=========================================================
// dout process
//=========================================================  
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  dout <= 18'd0;
 else if (valid_d[9]) begin
 if (shift_cnt_d2 == 4'd0)
  dout <= result_0;
 else if (shift_cnt_d2 == 4'd1)
  dout <= result_1;
 else if (shift_cnt_d2 == 4'd2)
  dout <= result_2;
 else if (shift_cnt_d2 == 4'd3)
  dout <= result_3;
 else if (shift_cnt_d2 == 4'd4)
  dout <= result_4;
 else if (shift_cnt_d2 == 4'd5)
  dout <= result_5; 
 else if (shift_cnt_d2 == 4'd6)
  dout <= result_6;
 else if (shift_cnt_d2 == 4'd7)
  dout <= result_7;
 else if (shift_cnt_d2 == 4'd8)
  dout <= 18'd0;  
 end
 else
  dout <= 18'd0;
  
//=========================================================
// valid_d process
//========================================================= 
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  valid_d <= 1'b0;
 else
  valid_d <= {valid_d[8:0], sqrt_valid_in};
  
//=========================================================
// sqrt_valid_out process
//=========================================================   
always @ (posedge clk or negedge rst_n)
 if (!rst_n)
  sqrt_valid_out <= 1'b0;
 else if (valid_d[9])
  sqrt_valid_out <= 1'b1;
 else
  sqrt_valid_out <= 1'b0;
 
endmodule 

eric_arrow
关注
专栏目录
python开根号_python开根号_python 开根号_python开根号函数 - 云+社区 - 腾讯云
weixin_39631467的博客
11-20 3759
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！语法以下是sqrt()方法的语法 -import mathmath.sqrt( x )python注意 -此函数不可直接访问，需要导入math模块，然后需要使用math静态对象调用此函数。 2，开n次方利用pow(a, b)函数即可。 需要开a的r次方则pow(a, 1.0r)......
python开根号_python的开根号
weixin_39884872的博客
11-20 4452
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！语法以下是sqrt()方法的语法 -import mathmath.sqrt( x )python注意 -此函数不可直接访问，需要导入math模块，然后需要使用math静态对象调用此函数。 2，开n次方利用pow(a, b)函数即可。 需要开a的r次方则pow(a, 1.0r)......
python三种方法开根号（穷举法、二分法、牛顿拉夫逊法）
weixin_46395175的博客
09-18 4326
python三种方法开根号（穷举法、二分法、牛顿拉夫逊法）
开根号函数_MATLAB常用函数汇总
weixin_42370320的博客
01-15 3314
版本：matlab2020持续更新中......函数作用举栗子clear清除工作区中的所有变量clearclc清除命令行中的所有代码clcpi圆周率(matlab区分大小写)πinv(A)矩阵求逆求矩阵A的逆：inv(A)vpa(x,k)求数值解，保留k位有效数字x=vpa(sin(1/3), 2) ⇨x=0.33real()求复数的实部x = real(1+2i) ⇨ x = 1simplify...
MatLab 中计算开根号
wcqlwyt的博客
06-22 8644
1. 方法 例如 如果对4要开根号 可以输入函数如下 &gt;&gt; sqrt(4) 2方法 根号其实是1/2次方 &gt;&gt; 4^(
C++实现开根号的方法
10-09
总结来说，C++中实现开根号主要依赖于`<cmath>`库中的`sqrt`函数，通过合理地使用和处理参数，可以方便地进行平方根计算。在实际编程中，确保输入的合法性以及处理可能的异常情况是十分重要的。
sqrt.rar_FPGA 开方_FPGA 开方_FPGA 开根号_Verilog开平方根_verilog开方
07-14
VERILOG描述的开平方模块核，开方运算是FPGA或ASIC设计中所需要的核心运算模块。
python开根号实例讲解
09-16
在Python编程语言中，开根号是一项常见的数学操作，尤其在处理几何、物理或数据分析问题时。本篇文章将深入探讨如何在Python中进行开根号的计算，包括平方根和其他次方根的求解。 首先，我们要了解平方根。平方根是...
用开根号求素数_manner4ep_C++_素数开根号_求素数；_求素数开方_
10-04
`用开根号求素数.exe`是编译后的可执行文件，可以直接在支持C++的环境中运行，无需再次编译。 通过这种方式，初学者不仅可以学习到C++的基本语法，还能理解素数的性质以及如何优化算法以提高效率。这种方法不仅适用...
编程开根号系统教学：C语言开根号.cpp
最新发布
07-13
内有源代码，写得是如何开根号，欢迎下载。 内有源代码，写得是如何开根号，欢迎下载。 内有源代码，写得是如何开根号，欢迎下载。 内有源代码，写得是如何开根号，欢迎下载。 内有源代码，写得是如何开...
基于FPGA快速平方根算法的实现
12-10
只是基于FPGA快速平方根算法的实现，基于FPGA快速平方根算法的实现
chatgpt赋能python：Python开根号：从入门到精通
tulingtest的博客
06-06 478
在数学中，开根号是求一个数的平方根的运算，即将一个数x开平方得到的数就是该数的平方根y，表示为y=√x。平方根是数学中的基本概念，应用广泛。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于AI+职场+办公方向。下图是课程的整体大纲下图是。
python中开根号_python中根号怎么表示
weixin_39942213的博客
11-21 4034
sqrt() 方法返回数字x的平方根。以下是 sqrt() 方法的语法:（推荐学习：Python视频教程）import mathmath.sqrt( x )注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。参数x -- 数值表达式。返回值返回数字x的平方根。实例以下展示了使用 sqrt() 方法的实例：#!/usr/bin/pythonimport math ...
在matlab中开根号,请问，在matlab里面如果输入开方号（根号）？如9的开方怎么写？...
weixin_34313315的博客
03-16 2028
sqrt(9)nthroot(8,3)人家想求的就是实数根把，不信你试试(-8)^(1/3)和nthroot(-8,3)你就知道区别了很多人不知道nthroot这个函数，用指数的方法画x的3次方根的图像结果发现x时的图像不对，我今天算是来科普了www.mh456.com防采集。sqrt(9)nthroot(8,3)人家想求2113的就是实数根把，不信你试5261试(-8)^(1/3)和nthroo...
chatgpt赋能python：Python中的开根号函数-从介绍到结论
tutan123321的博客
05-30 1938
开根号是指将一个数的平方根（平方根是一个数乘以自己等于该数的数字）作为结果输出。例如，求4的平方根，等于2。数学符号表示为√4=2。开根号是数学和物理学的基本操作之一，因为许多自然现象都具有平方或立方关系。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于。
Python中如何表示根号?
oldboyedu1的博客
04-16 4214
要使用NumPy库中的根号运算，需要首先安装该库。而在Python中根号也有着十分重要的作用，那么Python中如何表示根号?与math模块类似，Python中的cmath模块提供了复数运算功能。如果需要计算复数的平方根，则可以使用该模块中的sqrt()函数。Python有一个内置的math模块，提供了大量的数学功能，包括根号功能。可以使用该模块中的sqrt()函数来计算一个数的平方根。在Python中，可以使用**运算符来表示乘方运算。因此，对于求平方根的情况，可以使用该运算符来计算。
Python-开根号的几种方式
热门推荐
害怕也得前进
08-22 17万+
Python中对数字进行开根号运算
matlab开根号_matlab基本计算
weixin_30456153的博客
01-15 1万+
这里介绍的内容是使用MATLAB进行基本的数学计算，完成的是类似计算机计算数学算式的功能，这篇文章基本可以帮助你学会所有基本的matlab计算方法。 1. 基本计算 MATLAB中的基本的运算符号为： + - * / ^四则运算规则和平时使用的计算器相同，使用MATLAB进行计算时也需要注意计算的顺序，先加减后乘除，需要改顺序的时候需要使用括号。接下来是通过具体的例子进行计算的学...
【Python】三种方式妙开根号
TUSTer_的博客
01-17 1万+
前言： 大家好啊！又是我TUSTer_! python里有自带的库math，cmath,和函数pow来开根号。下边让我带你了解他们吧！记得一键三连！ 一，math库 使用math库里的sqr()函数，在math库里边有很多数学函数，如三角函数sin（），pi-π等等： import math print(math.sqr(4)) 输出结果：2 二，cmath库 cmath多用于复数，负数的开平方。 import cmath print(cmath.sqr(4+0j)) 输出结果：（2+0.
markdown 开根号
03-01
2. 在`<sup>`和`</sup>`之间输入要开根号的数值或表达式。 例如，要在Markdown中显示开根号的数值，可以按照以下格式编写： ``` √数值 ``` 其中，将`数值`替换为实际要开根号的数值。 示例：要显示开根号的数值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值