C++ std::polar 函数

2025年3月24日 | 阅读 9 分钟

引言

在 C++ 编程中，标准模板库 (STL) 提供了各种旨在帮助处理复数及其关系的特性。在这些子功能中，std::polar 函数因其是用于将数字的极坐标表示转换为相应复数的最有用的函数之一而脱颖而出。极坐标允许通过两个数值表示一个点：径向坐标或半径（幅值）和角坐标或角度（相位）。这种几何表示法在信号处理、物理学和工程学等物理和数学领域很有用。

在本文中，我们将重点介绍 std::polar 函数、其用法和语法表示，并提供一些支持在 C++ 中转换极坐标的示例代码。

问题陈述

许多数学和工程系统基于极形式复数的利用，以便可以使用两个数字来定义复数空间的一个特定区域

r（或简称为半径）： 表示点到原点的距离。
θ（或简称为相位）： 表示点与 x 轴之间的夹角，从 x 轴正方向顺时针测量。

然而，需要注意的是，在 C++ 中，没有直接处理涉及复数的极坐标系统的设施。因此，任何时候需要使用 C++ 中的复数时，都需要将极坐标转换为常用的直角坐标形式（实部和虚部）。

std::polar 函数提供了一种独特而标准的方法，可以在无需单独指定实部和虚部的情况下，将点从极坐标转换为复数单位。

polar 函数

std::polar 函数来自 C++ 库中的类模板。它是一个函数，允许使用极坐标构建复数。该函数通常表示为

#include <complex>
std::complex<double> std::polar(double r, double theta = 0.0);   

r：指复数的大小（径向）。
theta： 指相对于 x 轴水平方向的相位偏移角度（以弧度为单位）。如果省略，则默认为 0.0。

此函数的结果是 std::complex，其形式为 a+bi 的复数，其中 b 是实部，a 是虚部。实部和虚部根据极坐标得出：

 
real_part = r * cosine(θ)
imaginary_part = r * sine(θ)   

polar 函数的主要重要性

该特性简化了使用三角函数确定数字的实部和虚部的过程。
它保持了正确性，因为转换是在后台以双精度浮点进行的。
角度的默认值使得只提供大小的情况更容易处理，因为没有同时提供角度和大小的选项。

程序 1

#include <iostream>
#include <complex>
#include <cmath> // for M_PI

int main() {
    // Polar coordinates: magnitude = 5, angle = pi/4 radians
    double r = 5.0;
    double theta = M_PI / 4.0;

    // Convert polar coordinates to complex number
    std::complex<double> complex_num = std::polar(r, theta);

    // Display the result
    std::cout << "Complex number (Cartesian form): " << complex_num << std::endl;
    std::cout << "Real part: " << complex_num.real() << std::endl;
    std::cout << "Imaginary part: " << complex_num.imag() << std::endl;

    return 0;
}   

输出

 
Complex number (Cartesian form): (3.53553,3.53553)
Real part: 3.53553
Imaginary part: 3.53553

说明

r = 5.0： 这是复数的幅值。
theta = M_PI / 4.0： 这是相当于 45 度的角度（以弧度为单位）。
std::polar(r, theta) 将极坐标 (r, θ) 转换为复数 (实部, 虚部)。
输出打印，其中实部和虚部都约等于 3.5355。

时间和空间复杂度

时间复杂度：O(1)

std::polar 和 std::cout 操作的时间复杂度为常数。

空间复杂度：O(1)

r、theta 和复数的固定空间。

程序 2

#include <iostream>
#include <complex>

int main() {
    // Polar coordinates: magnitude = 4, angle = 0 (default)
    double r = 4.0;

    // Convert polar coordinates to complex number
    std::complex<double> complex_num = std::polar(r);

    // Display the result
    std::cout << "Complex number (Cartesian form): " << complex_num << std::endl;
    return 0;
}   

输出

 
Complex number (Cartesian form): (4,0)

说明

r = 4.0： 这是幅值。
std::polar(r) 使用默认角度 θ = 0，因此结果复数是纯实的 (4 + 0i)。
输出显示实部为 4，虚部为 0。

时间和空间复杂度

时间复杂度：O(1)

std::polar 函数和打印结果都采用常数时间。

空间复杂度：O(1)

幅值 (r) 和复数的固定空间。没有动态内存分配。

高级测试功能

在使用 std::polar 函数时，还必须考虑一些边缘情况：假设半径为负：根据维度，负半径可能导致一些不期望的结果，因为半径通常被视为正数。除非您假设的是非传统的定义，否则建议在代码中避免 r< 0。
精度问题： 由于数字的性质，应避免对非常小或非常大的幅值或角度进行四舍五入，这可能会在此公式中出现。C++ 在大多数实际应用中都能很好地处理这种情况，但在处理极值时仍需牢记这一点。

程序 3

#include <iostream>
#include <complex>
#include <cmath> // for trigonometric functions and M_PI

int main() {
    const int size = 5;
    double magnitudes[size] = {3.0, 4.0, 5.0, 6.0, 7.0};  // Magnitudes (r)
    double angles[size] = {M_PI/6, M_PI/4, M_PI/3, M_PI/2, M_PI};  // Angles (θ in radians)
    
    std::complex<double> complex_numbers[size];

    // Create an array of complex numbers using polar coordinates
    for (int i = 0; i < size; ++i) {
        complex_numbers[i] = std::polar(magnitudes[i], angles[i]);
    }

    // Display the complex numbers in Cartesian form
    std::cout << "Complex numbers (Cartesian form):" << std::endl;
    for (int i = 0; i < size; ++i) {
        std::cout << "Complex number " << i+1 << ": " << complex_numbers[i] << std::endl;
    }

    // Perform mathematical operations: Calculate the sum of all complex numbers
    std::complex<double> sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += complex_numbers[i];
    }

    // Display the sum
    std::cout << "\nSum of all complex numbers: " << sum << std::endl;

    // Perform mathematical operations: Calculate the product of all complex numbers
    std::complex<double> product = 1;
    for (int i = 0; i < size; ++i) {
        product *= complex_numbers[i];
    }

    // Display the product
    std::cout << "Product of all complex numbers: " << product << std::endl;

    return 0;
}   

输出

 
Complex numbers (Cartesian form):
Complex number 1: (2.59808,1.5)
Complex number 2: (2.82843,2.82843)
Complex number 3: (2.5,4.33013)
Complex number 4: (3.67394e-16,6)
Complex number 5: (-7,8.57253e-16)

Sum of all complex numbers: (0.926503,14.6586)
Product of all complex numbers: (1781.91,1781.91)

说明

复数数组： 我们引入了两个数组，分别是幅值和角度，其中幅值和角度组合以表示极坐标。
创建复数： 使用循环，对于每组极坐标，使用 std::polar 创建一个相应的复数。
显示笛卡尔形式： 结果复数以笛卡尔形式（实部 + 虚部）输出。
求和与乘积： 计算所有复数的总和以及所有复数的乘积，展示了如何在 C++ 中对复数进行操作。

时间和空间复杂度

时间复杂度：O(n)

用于创建、显示、求和和乘法的循环每次运行 n 次。

空间复杂度：O(n)

幅值、角度和复数的数组都占用与 n 成比例的空间。

程序 4

#include <iostream>
#include <vector>
#include <complex>
#include <cmath>  // For sin, cos, and M_PI
#include <iomanip> // For controlling the precision of output

const double PI = M_PI;

// Function to compute the DFT of a given signal
std::vector<std::complex<double>> computeDFT(const std::vector<std::complex<double>>& inputSignal) {
    int N = inputSignal.size();
    std::vector<std::complex<double>> dftResult(N);

    // DFT formula: X(k) = sum( x(n) * exp(-2 * pi * i * k * n / N) )
    for (int k = 0; k < N; ++k) {
        std::complex<double> sum(0.0, 0.0);

        for (int n = 0; n < N; ++n) {
            double angle = -2 * PI * k * n / N;
            std::complex<double> expTerm = std::polar(1.0, angle); // e^(i * angle)
            sum += inputSignal[n] * expTerm;
        }
        dftResult[k] = sum;
    }
    return dftResult;
}

// Function to convert complex numbers to polar coordinates (magnitude and phase)
void displayPolarForm(const std::vector<std::complex<double>>& complexNumbers) {
    std::cout << "\nDFT Result in Polar Form (Magnitude, Phase in Radians):\n";
    for (size_t i = 0; i < complexNumbers.size(); ++i) {
        double magnitude = std::abs(complexNumbers[i]);
        double phase = std::arg(complexNumbers[i]);
        std::cout << "X(" << i << "): Magnitude = " << magnitude
                  << ", Phase = " << phase << " radians\n";
    }
}

int main() {
    // Input signal (in time domain)
    std::vector<std::complex<double>> inputSignal = {
        {1.0, 0.0}, {2.0, 0.0}, {3.0, 0.0}, {4.0, 0.0}
    };

    // Display the input signal
    std::cout << "Input Signal (Time Domain):\n";
    for (size_t i = 0; i < inputSignal.size(); ++i) {
        std::cout << "x(" << i << ") = " << inputSignal[i] << "\n";
    }

    // Compute the DFT
    std::vector<std::complex<double>> dftResult = computeDFT(inputSignal);

    // Display the DFT result in Cartesian form
    std::cout << "\nDFT Result (Frequency Domain, Cartesian Form):\n";
    for (size_t i = 0; i < dftResult.size(); ++i) {
        std::cout << "X(" << i << ") = " << dftResult[i] << "\n";
    }

    // Display the DFT result in Polar Form
    displayPolarForm(dftResult);

    return 0;
}   

输出

 
Input Signal (Time Domain):
x(0) = (1,0)
x(1) = (2,0)
x(2) = (3,0)
x(3) = (4,0)

DFT Result (Frequency Domain, Cartesian Form):
X(0) = (10,0)
X(1) = (-2,2)
X(2) = (-2,-9.79717e-16)
X(3) = (-2,-2)

DFT Result in Polar Form (Magnitude, Phase in Radians):
X(0): Magnitude = 10, Phase = 0 radians
X(1): Magnitude = 2.82843, Phase = 2.35619 radians
X(2): Magnitude = 2, Phase = -3.14159 radians
X(3): Magnitude = 2.82843, Phase = -2.35619 radians

说明

输入信号
- 时域中的信号称为 inputSignal，可以表示为复数向量。基本上，所有这些值通常是 (1.0, 2.0, 3.0, 4.0)，但 DFT 也适用于复数值。
离散傅里叶变换 (DFT)

它利用角度并将其表示为极形式复数。

笛卡尔输出

变换后的信号或 DFT 结果以笛卡尔形式（实部 + 虚部）显示。

极坐标输出

DFT 的分量也以极坐标形式给出，使用频率分量的幅值和相位，分别使用 std::abs 和 std::arg 的标准形式。

使用的函数

std::polar： 分析角度并以复指数表示形式给出结果。
std::abs： 此函数类似于复数模，它以 e 的形式确定复数的长度或模。
std::arg： 这是一个运算符，用于求解进行了一些操作的复数的参数。

时间和空间复杂度

时间复杂度：O(N²)

对于每个频率 bin k，内部循环（计算求和）会经过 N 次迭代，共有 N 个频率 bin。因此，时间复杂度为 O(N²)。

空间复杂度：O(N)

输入信号、DFT 结果、总和和中间变量 expTerm 占用 N 阶的空间。因此，空间复杂度为 O(N)。

结论

总之，std::polar 函数是 C++ 程序员在将极坐标转换为复数时可用的强大函数，这反过来使得处理数学工程中的复数变得容易。该函数的便利之处在于它无需从模和相位中分离即可导出实部和虚部，从而减轻了开发人员的工作量。

使用 std::polar 允许 C++ 程序员超越 C++，在复数的极坐标和笛卡尔坐标之间无缝过渡，并在多个领域方便地执行复杂计算。

下一个主题C++ 中的异常处理和对象销毁

C++ std::polar 函数

引言

问题陈述

polar 函数

polar 函数的主要重要性

程序 1

说明

时间和空间复杂度

程序 2

说明

时间和空间复杂度

高级测试功能

程序 3

说明

时间和空间复杂度

程序 4

说明

时间和空间复杂度

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ std::polar 函数

引言

问题陈述

polar 函数

polar 函数的主要重要性

程序 1

说明

时间和空间复杂度

程序 2

说明

时间和空间复杂度

高级测试功能

程序 3

说明

时间和空间复杂度

程序 4

说明

时间和空间复杂度

结论

相关帖子

C++ 中翻转数字的开关位（除首位和末位外）

在 C++ 中通过重复步骤和模运算转换数组