北邮22级信通院DSP：实验三（1）：FFT变换、IFFT变换（附每步8点变换蝶形图）保姆级讲解+用C++程序实现复数域的FFT变换和IFFT变换

北邮22信通一枚~

跟随课程进度更新北邮信通院DSP的笔记、代码和文章，欢迎关注~

获取更多文章，请访问专栏：

北邮22级信通院DSP_青山入墨雨如画的博客-CSDN博客

目录

一、预备知识

1.1 FFT算法

1.2.1由DFT到FFT

1.2.2 基2时域抽选算法

第一步：

第二步：

第三步：

第四步：

1.2 IFFT算法

1.3快速傅里叶算法拓展

1.4 C++中的complex类型

1.5 C++中的cmath库

1.6 C++中处理程序运行时间的chrono头文件

1.6.1时钟类（Clocks）：

1.6.2时间间隔（Durations）：

1.6.3时间点（Time points）：

1.6.4时间相关函数：

1.7 C++中的functional头文件与function方法       

二、程序设计思路

 2.1 FFT算法的实现

2.2 IFFT算法的实现

2.3FFT算法与IFFT算法的合并

2.4程序运行时间的函数

2.5占用内存空间的函数

三、代码部分

3.1代码部分

3.2运行效果 

一、预备知识

1.1 FFT算法

1.2.1由DFT到FFT

 FFT算法是DFT算法的优化算法，相比于DFT算法，FFT算法“对数式”地减少了运算复杂度，提高了程序运行的效率，节约了内存空间。

FFT简化DFT运算的本质是W因子的性质。

以4点DFT为例：

根据性质，可以化为：

整理可得：

所以：

可以看出，原本需要4^2=16次复数乘的DFT运算，被简化成了只需要进行一步复数乘的FFT运算，运算复杂度大大降低。 

1.2.2 基2时域抽选算法

第一步：

所以：

 以N=8点的FFT为例，所以第一步的蝶形图为：

 以下均以N=8点FFT为例。

第二步：

对x1(n)再奇偶分离得： 

可以发现，X1（k）和X2（k）也可以用X3（k）和X4（k）的线性组合表示。

复数乘法也仅仅为1次。 

 以N=8点的FFT为例，所以第二步的蝶形图为：

第三步：

由于N=2^m，所以可以一直二分分解下去。

直到最后分解为2点序列的FFT运算。

 以N=8点的FFT为例，所以第三步的蝶形图为：

第四步：

完整蝶形图 

1.2 IFFT算法

 IFFT算法是FFT算法的逆过程。

可以发现：

 所以对于N=8的IFFT：

可以看出，迭代的每一步相较于FFT，都多乘了一个1/2。 

N=8点的IFFT蝶形图如下：

1.3快速傅里叶算法拓展

关于基于时间/频率抽选的基2^N的FFT和IFFT算法，感兴趣的同学可以参考这篇博客：

Josh 的复习总结之数字信号处理（Part 5——部分 FFT 蝶形图）_fft蝶形图-CSDN博客

1.4 C++中的complex类型

         C++函数提供了专门用于复数计算的头文件#include<complex>。

        这里的complex需要声明是什么数据类型的complex，比如定义一个double类型的complex变量，我们应该写：

complex<double>complex_1={-1,2};

complex库中为我们提供了很多函数，比如取实部和取虚部运算，加减乘除的基本运算。

1.5 C++中的cmath库

         一些数学处理函数，比如三角函数和反三角函数都包含在cmath库中，加头文件#include<cmath>来导入这个库。

1.6 C++中处理程序运行时间的chrono头文件

  <chrono> 头文件中包含了一些主要的类和函数，而不是函数。这些类和函数用于处理时间相关的操作。以下是一些主要的类和函数：

1.6.1时钟类（Clocks）：

  1. std::chrono::system_clock：提供了当前系统时间的功能。
  2. std::chrono::steady_clock：提供了一个稳定的时钟，用于测量时间间隔。
  3. std::chrono::high_resolution_clock：提供了高精度的时钟，通常用于测量程序的执行时间。

1.6.2时间间隔（Durations）：

  1. std::chrono::duration：表示一段时间的长度，可以与时钟一起使用来表示时间间隔。
  2. std::chrono::nanoseconds、std::chrono::microseconds、std::chrono::milliseconds、std::chrono::seconds、std::chrono::minutes、std::chrono::hours：表示不同单位的时间间隔。

1.6.3时间点（Time points）：

  1. std::chrono::time_point：表示时钟上的一个特定时间点。
  2. std::chrono::system_clock::time_point、std::chrono::steady_clock::time_point、std::chrono::high_resolution_clock::time_point：表示特定时钟上的时间点。

1.6.4时间相关函数：

  1. std::chrono::duration_cast：用于执行时间间隔的单位转换。
  2. std::chrono::time_point_cast：用于执行时间点的时钟转换。
  3. std::chrono::high_resolution_clock::now()、std::chrono::steady_clock::now()、std::chrono::system_clock::now()：获取当前时间点。

1.7 C++中的functional头文件与function方法       

  <functional> 是 C++ 标准库中的头文件，其中包含了一组模板类和函数，用于支持函数对象（即可被调用的对象，如函数指针、lambda 表达式等）的操作和处理。

        其中，std::function 是一个模板类，可以用来包装各种可调用对象，包括函数指针、函数对象、成员函数指针、lambda 表达式等，从而实现统一的调用接口。

        使用 std::function，可以将不同类型的可调用对象赋值给同一个 std::function 对象，然后通过调用 std::function 对象来间接调用被包装的可调用对象，而无需关心其具体类型。这样可以提高代码的灵活性和可维护性。

        例如：

#include <functional>
#include <iostream>void foo(int x) {std::cout << "foo: " << x << std::endl;
}int main() {std::function<void(int)> func = foo; // 将函数指针 foo 赋值给 funcfunc(42); // 调用 func，间接调用了 fooreturn 0;
}

         这段代码中，std::function<void(int)> 声明了一个函数对象 func，其参数为 int 类型，返回类型为 void。然后，将函数指针 foo 赋值给了 func，最后通过 func 来调用函数 foo。

二、程序设计思路

 2.1 FFT算法的实现

        以下，均以N=8点FFT为例讲解。

        FFT算法的本质在于递归调用，每次对序列二分之后，对更小的序列继续做FFT变换，直到进行到最底端时候，返回所有现场。

根据以上思路，我们首先对序列做奇偶二分：

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}//…
}

 对每一部分更小的序列，使用FFT算法；

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换//…
}

直到进行到两点FFT变换，做该变换并逐层向上溯回，依次返回所有现场；

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

以N=8的序列为例，第一步将8点序列奇偶二分，

执行到fft(even, inverse);和fft(odd, inverse);

 

分别对两个N=4的子序列进行FFT变换，这里保存现场。

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       //执行到这步，并保存现场。fft(odd, inverse);                        //执行到这步，并保存现场。
}

 对每一个N=4的子序列，进行奇偶二分。

重新执行下面的代码：

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       //执行到这步，并保存现场。fft(odd, inverse);                        //执行到这步，并保存现场。
}

 对每一个N=4的输入序列，都得到两个N=2的子序列。

执行到fft(even, inverse);和fft(odd, inverse);

 

分别对两个N=2的子序列进行FFT变换，这里保存现场。

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       //执行到这步，并保存现场。fft(odd, inverse);                        //执行到这步，并保存现场。
}

执行之后，对每个输入的N=2的新序列，会奇偶二分之后产生两个N=1的子序列。

之后执行这部分代码：

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换
}

 

 

之后开始大规模返回现场。

首先对于N=1的两个序列结果，返回N=2序列保留的现场，执行这些代码：

void fft(vector<Complex>& a) 
{//这些部分已经执行过了，这里就以……形式标注，方便大家理解// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

之后对于N=2的两个序列结果，返回N=4序列保留的现场，执行这些代码：

void fft(vector<Complex>& a) 
{//这些部分已经执行过了，这里就以……形式标注，方便大家理解// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

之后对于N=4的两个序列结果，返回N=8序列保留的现场，执行这些代码：

void fft(vector<Complex>& a) 
{//这些部分已经执行过了，这里就以……形式标注，方便大家理解// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

最终修改了传入的变量vector<Complex>& a；

2.2 IFFT算法的实现

由于IFFT算法相较于FFT算法，只变了两个地方，一个是W因子的幂次由正变负，一个是每次迭代时候应多乘一个1/2的项，原因见上面：1.2 IFFT算法

所以对IFFT的实现， 代码部分与FFT非常类似：

void ifft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}ifft(even, inverse);                       // 对偶数项进行递归IFFT变换ifft(odd, inverse);                        // 对奇数项进行递归IFFT变换// 计算旋转因子的角度double angle = 2 * PI / n;                Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果a[i] /= 2;a[i + n / 2] /= 2;w *= wn; // 更新旋转因子}
}

有关递归调用的过程请类比FFT。 

2.3FFT算法与IFFT算法的合并

由于FFT和IFFT的算法基本相同，我们可以将两个算法做一个合并，在传入的形参中新增bool型一个变量，用于判断是否为IFFT变换，如果是的话，就在FFT变换的基础上新增一些操作。

FFT和IFFT合并算法如下：

// FFT算法函数，参数 a 是输入的复数向量，
// inverse 表示是否进行逆变换，默认为 false
void fft(vector<Complex>& a, bool inverse = false) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换// 计算旋转因子的角度double angle = (inverse ? 2 : -2) * PI / n;       //false的话是-2，正变换;true的话是2，逆变换Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果if (inverse) {                                             // 如果是逆变换，则需要除以2a[i] /= 2;a[i + n / 2] /= 2;}w *= wn; // 更新旋转因子}
}// IFFT算法函数，参数 a 是输入的复数向量
void ifft(vector<Complex>& a) 
{fft(a, true); // 调用 FFT 函数，inverse 参数设置为 true，进行逆变换
}

2.4程序运行时间的函数

// 计算运行时间
template<typename Func>
void measureTime(Func func, const string& msg) {auto start = chrono::high_resolution_clock::now();func(); // 执行传入的函数auto end = chrono::high_resolution_clock::now();chrono::duration<double> duration = end - start;cout << msg << "运行时间：" << duration.count() * 1000 << " ms" << endl;
}

         需要加头文件#include <chrono>和#include <functional> 

         形参 msg 是用来传递一条描述性的消息，用于在输出中标识这次时间测量的内容。在输出中，这个消息会和执行时间一起显示，使得输出更具可读性，方便理解每次测量所针对的操作。

         auto start = chrono::high_resolution_clock::now();用于获取当前时间点；

        在 <chrono> 头文件中，duration 表示一段时间的长度，以指定的时间单位表示。它是一个模板类，可以根据需要指定不同的时间单位（如秒、毫秒、微秒等）。

        使用方法是首先创建一个 duration 对象，然后可以通过成员函数 count() 获取该持续时间的值，并根据需要转换为所需的时间单位。

        例如，对于 chrono::duration<double>，可以通过 count() 获取持续时间的双精度浮点数值，表示秒数。如果需要将其转换为毫秒，则可以乘以 1000。

2.5占用内存空间的函数

template<typename T>
size_t memoryUsage(const vector<T>& vec) {return vec.size() * sizeof(T);
}

        这段代码计算了一个 vector 对象所占用的内存大小。它通过 vec.size() 获取 vector 中元素的数量，然后乘以 sizeof(T)，其中 T 是 vector 存储的元素类型，表示每个元素所占用的内存大小。

三、代码部分

3.1代码部分

#include<iostream>                                        // 输入输出流头文件
#include <complex>                                        // 包含复数类型的头文件
#include <vector>                                         // 包含向量容器的头文件
#include <cmath>                                          // 包含数学函数的头文件
#include <chrono>                                         // 用于处理程序运行时间的头文件
#include <functional>                                     // 引入 <functional> 头文件用于使用 std::function方法
using namespace std;//用反三角函数定义常数PI
const double PI = acos(-1.0);// 定义复数类型
typedef complex<double> Complex;// FFT算法函数，参数 a 是输入的复数向量，
// inverse 表示是否进行逆变换，默认为 false
void fft(vector<Complex>& a, bool inverse = false) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换// 计算旋转因子的角度double angle = (inverse ? 2 : -2) * PI / n;       //false的话是-2，正变换;true的话是2，逆变换Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果if (inverse) {                                             // 如果是逆变换，则需要除以2a[i] /= 2;a[i + n / 2] /= 2;}w *= wn; // 更新旋转因子}
}// IFFT算法函数，参数 a 是输入的复数向量
void ifft(vector<Complex>& a) 
{fft(a, true); // 调用 FFT 函数，inverse 参数设置为 true，进行逆变换
}// 计算运行时间
template<typename Func>
void measureTime(Func func, const string& msg) {auto start = chrono::high_resolution_clock::now();func(); // 执行传入的函数auto end = chrono::high_resolution_clock::now();chrono::duration<double> duration = end - start;cout << msg << "运行时间：" << duration.count() * 1000 << " ms" << endl;
}// 计算内存占用
template<typename T>
size_t memoryUsage(const vector<T>& vec) {return vec.size() * sizeof(T);
}int main() 
{system("color 0A");// 输入序列vector<Complex> input = { (1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,9),(9,1) };// 执行FFT变换fft(input);// 打印FFT变换结果cout << "FFT 变换结果：" << endl << endl;for (const auto& val : input) {cout << val << endl;}cout << endl;// 执行IFFT变换ifft(input);// 打印IFFT变换结果cout << "IFFT 变换结果：" << endl << endl;for (const auto& val : input) {cout << val << endl;}cout << endl;// 计算 IFFT 变换的运行时间measureTime([&input]() {ifft(input);}, "IFFT");// 计算内存占用cout << "内存占用：" << memoryUsage(input) << " bit" << endl;return 0;
}

3.2运行效果 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://xiahunao.cn/news/3016496.html

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

华为：三层交换机与路由器连通上网实验

华为：三层交换机与路由器连通上网实验

三层交换机是一种网络交换机&#xff0c;可以实现基于IP地址的高效数据转发和路由功能&#xff0c;通常用于大型企业、数据中心和校园网络等场景。此外&#xff0c;三层交换机还支持多种路由协议&#xff08;如OSPF、BGP等&#xff09;&#xff0c;以实现更为复杂的网络拓扑结构…
阅读更多...
重装win11系统后找不到WiFi

重装win11系统后找不到WiFi

由于电脑崩溃重装了系统&#xff0c;win11,装完之后WiFi图标不见了且网络适配器根本没有无线网络选项。 右键电脑》管理》网络适配器。 在刚装好系统时候并没有前两项&#xff0c;查了很多资料&#xff0c;比如 关机14s 重启&#xff0c;还有通过服务配置 WLAN AutoConfig 都…
阅读更多...
【嵌入式DIY实例】-基于GSM的远程灌溉系统

【嵌入式DIY实例】-基于GSM的远程灌溉系统

基于GSM的远程灌溉系统 文章目录 基于GSM的远程灌溉系统1、硬件准备与接线2、软件准备3、代码实现本文将详细介绍如何搭建通过使用手机实现对灌溉系统的远程控制。该系统利用全球移动通信系统（GSM）技术在灌溉系统和移动电话之间建立通信。该系统建立在流行的开源微控制器平台…
阅读更多...
IP规划案例

IP规划案例

整个OSPF环境IP基于172.16.0.0/16划分 172.16.0.0/16 先分成2个网段&#xff08;OSPF RIP&#xff09;&#xff0c;借1位172.16.0.0/17 ---OSPF 再按区域划分&#xff08;5个区域&#xff09;&#xff0c;借3位 172.16.0.0/20 ---Area 0 三个环回 MGRE 4个网…
阅读更多...
Vulnhub项目：NAPPING: 1.0.1

Vulnhub项目：NAPPING: 1.0.1

1、靶机介绍 靶机地址&#xff1a;Napping: 1.0.1 ~ VulnHub 2、渗透过程 老规矩&#xff0c;先探测&#xff0c;靶机ip&#xff1a;192.168.56.152 本机ip&#xff1a;192.168.56.146 来看一看靶机开放哪些端口&#xff0c;nmap一下 nmap -sS -sV -A -T5 192.168.56.152 开…
阅读更多...
软件系统测试方案书（测试计划-Word原件）

软件系统测试方案书（测试计划-Word原件）

2 引言 2.1 编写目的 2.3 测试人员 2.4 项目背景 2.5 测试目标 2.6 简写和缩略词 2.7 参考资料 2.8 测试提交文档 2.9 测试进度 3 测试环境 3.1 软硬件环境 4 测试工具 5 测试策略 5.1 测试阶段划分及内容 5.1.1 集成测试 5.1.2 系统测试 5.1.2.1 功能测试 5.…
阅读更多...
PXE批量安装

PXE批量安装

系统装机的三种引导方式 u盘光盘网络装机 光盘&#xff1a; 1.类似于usb模式 2.刻录模式 系统安装过程 加载boot loader Boot Loader 是在操作系统内核运行之前运行的一段小程序。通过这段小程序&#xff0c;我们可以初始化硬件设备、建立内存空间的映射图&#xff0c;从…
阅读更多...
「C++ 内存管理篇 00」指针

「C++ 内存管理篇 00」指针

目录 一、变量&#xff0c;变量名和指针 1. 什么是变量&#xff1f; 2. 变量名和指针 3. 使用指针获取数据 二、指针变量和数组变量 三、编译器对指针的等级有着严格的检查 四、指针的加减 1. 存放指针的变量的加减 2. 存放指针的变量的自增自减 3. 两个指针相减 一、变量&…
阅读更多...
网络基础——路由

网络基础——路由

网络基础——路由 要想网络畅通&#xff0c;应让网络中的路由器知道如何转发数据包到各个网段。路由器根据路由表来转发数据包&#xff0c;而路由表是通过直连网络、静态路由以及动态路由来构建的。 route命令&#xff0c;底层是使用ioctl实现&#xff1b;ip命令&#xff0c;…
阅读更多...
OFD(Open Fixed-layout Document)

OFD(Open Fixed-layout Document)

OFD(Open Fixed-layout Document) &#xff0c;是由工业和信息化部软件司牵头中国电子技术标准化研究院成立的版式编写组制定的版式文档国家标准&#xff0c;属于中国的一种自主格式&#xff0c;要打破政府部门和党委机关电子公文格式不统一&#xff0c;以方便地进行电子文档的…
阅读更多...
TP3602 同步升压型直流/直流稳压器芯片IC

TP3602 同步升压型直流/直流稳压器芯片IC

一般描述 该TP3602是高效率的同步&#xff0c;PWM升压DC/DC转换器优化&#xff0c;提供一个高效的解决方案&#xff0c;以中等功率系统。该器件工作在0.9V至4.4V的输入电压下&#xff0c;具有1.4MHz的固定频率开关。这些特性允许使用微小、低轮廓电感器和陶瓷电容器&…
阅读更多...
windows系统远程执行脚本部署项目操作手册

windows系统远程执行脚本部署项目操作手册

windows系统远程执行脚本部署项目操作手册 windows系统远程执行脚本部署项目 如果频繁的需要部署项目到远程的服务器上,每次要手动上传项目,然后停止项目,启动项目,很麻烦,像Linux天生支持远程执行脚本 Windows借助工具也可以做到. 安装WinSCP软件 自行下载软件或关注我的公…
阅读更多...
PXE批量网络装机和Kickstart无人值守安装

PXE批量网络装机和Kickstart无人值守安装

一、PXE定义 PXE&#xff08;preboot execute environment&#xff09;:用于通过网络来引导系统的标准&#xff0c;工作在Client/Server模式&#xff08;也称为CS模式&#xff09;&#xff0c;允许客户机通过网络从远程服务器上下载引导镜像&#xff0c;并加载安装文件或整个操…
阅读更多...
[C++][数据结构]哈希1：哈希函数的介绍与线性探测的实现

[C++][数据结构]哈希1：哈希函数的介绍与线性探测的实现

前言 学完了二叉树&#xff0c;我们要学当前阶段数据结构的最后一个内容了&#xff1a;哈希&#xff01;&#xff01; 引入 先来介绍两个用哈希封装的两个容器&#xff1a;unordered_map unordered_set 与map和set的不同&#xff1a; map/set是双向迭代器&#xff0c;而另…
阅读更多...
OSPF链路状态数据库

OSPF链路状态数据库

原理概述 OSPF是一种基于链路状态的动态路由协议&#xff0c;每台OSPF路由器都会生成相关的LSA&#xff0c;并将这些LSA通告出去。路由器收到LSA后&#xff0c;会将它们存放在链路状态数据库LSDB中。 LSA有多种不同的类型&#xff0c;不同类型的LSA的功能和作用是不同的&…
阅读更多...
书生·浦语大模型实战营之XTuner多模态训练与测试

书生·浦语大模型实战营之XTuner多模态训练与测试

书生浦语大模型实战营之XTuner多模态训练与测试 目录 XTuner多模态训练与测试给LLM装上电子眼&#xff1a;多模态LLM原理简介文本单模态文本图像多模态 电子眼&#xff1a;LLaVA方案简介LLaVA训练阶段示意图LLaVA测试阶段示意图 项目实践环境准备XTuner安装概述Pretrain阶段Fi…
阅读更多...
部署YUM仓库以及NFS共享服务

部署YUM仓库以及NFS共享服务

YUM仓库部署 一.YUM概述 YUM仓库源是一种软件包管理工具&#xff0c;用于在Linux系统上安装、更新和删除软件包。YUM仓库源包含了软件包的元数据信息和实际的软件包文件。用户可以通过配置YUM仓库源&#xff0c;从中下载和安装软件包。 常见的YUM仓库源包括&#xff1a; 本…
阅读更多...
前端学习|第四章

前端学习|第四章

CSS学习|第三章 前言十五、精灵图十六、字体图标十七、CSS 三角的做法十八、用户界面样式十九、vertical-align 属性应用二十、溢出文字省略号显示二十一、常见布局技巧 前言 小白开始干前端 生命不息&#xff0c;学习不止~~ 以下内容源于黑马前端教程&#xff0c;纯属搬运工…
阅读更多...
W801学习笔记十九：古诗学习应用——下

W801学习笔记十九：古诗学习应用——下

经过前两章的内容&#xff0c;背唐诗的功能基本可以使用了。然而&#xff0c;仅有一种模式未免显得过于单一。因此&#xff0c;在本章中对其进行扩展&#xff0c;增加几种不同的玩法&#xff0c;并且这几种玩法将采用完全不同的判断方式。 玩法一&#xff1a;三分钟限时挑战—…
阅读更多...
数据结构---动态数组

数据结构---动态数组

一、数据结构基本理论 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。强调数据元素之间的关系 算法五个特性&#xff1a; 输入、输出、有穷、确定、可行 数据结构分类&#xff1a; 逻辑结构&#xff1a;集合、线性结构、树形结构、图形结构 物理…
阅读更多...
最新文章

Copyright @ 2022~2023