当前位置：文江博客话题详情

作为一名程序员，你会如何解释虚数？

发布于 2024-07-14 19:01:31 字数 190 浏览 3 评论 0原文

作为一名程序员，我认为擅长数学是我的工作，但我很难理解虚数。我尝试过谷歌和 wikipedia 但没有运气，所以我希望程序员可以向我解释，给我一个 <= 0 的数字平方的例子，一些示例用法等......

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

情域 2024-07-21 19:01:31

我想这个博客条目是一个很好的解释：

关键词是旋转（与负数的方向相反，负数就像虚数一样奇怪：< em>什么都没有？）

alt text

就像负数建模翻转一样，<虚数可以模拟任何在二维“X”和“Y”之间旋转的东西。或者任何具有循环、循环关系的东西

回复收藏 0 原文

白馒头 2024-07-21 19:01:31

问题：我不仅是一名程序员，而且还是一名数学家。
解决方案：无论如何，都要努力前进。

复数并没有什么真正神奇的地方。他们创立的初衷是认为实数存在问题。如果你有一个方程 x^2 + 4，它永远不会为零，而 x^2 - 2 两次为零。因此，数学家们非常生气，希望始终存在次数至少为 1 的多项式的零（想要一个“代数闭”域），并创建了一些任意数 j，使得 j = sqrt(-1)。所有的规则都从那里开始落实（尽管它们以不同的方式更准确地重新组织 - 具体来说，你实际上不能正式地说“嘿这个数字是负数的平方根”）。如果有j这个数，就可以得到j的倍数。你可以将实数加到 j 上，这样你就得到了复数。复数运算与二项式运算类似（故意如此）。

复合体的真正问题并不在于这一切，而在于事实上您无法定义一个系统来获得小于和大于的普通规则。所以实际上，你已经到达了根本没有定义它的地方。在二维空间中这是没有意义的。因此，老实说，我实际上无法回答“给我一个 <= 0 的数字平方的例子”，尽管如果您将其平方视为实数而不是复数，则“j”是有意义的。

至于用途，我个人在处理分形时最常使用它们。曼德布罗分形背后的想法是，它是一种绘制 z = z^2 + c 及其沿实虚轴散度的方法。

回复收藏 0 原文

街道布景 2024-07-21 19:01:31

你可能还会问为什么会有负数存在？它们的存在是因为您想要表示某些方程的解，例如：x + 5 = 0。同样的事情也适用于虚数，您想要紧凑地表示以下形式的方程的解：x^2 + 1 = 0。

这是一种方法我已经看到它们在实践中被使用。在 EE 中，您经常处理正弦波或可以分解为正弦波的函数。（例如，参见傅立叶级数）。

因此，您经常会看到以下形式的方程的解：

f(t) = A*cos(wt)

此外，您通常希望表示从该函数移动某个相位的函数。 90 度相移将为您提供一个正弦函数。

g(t) = B*sin(wt)

通过组合这两个函数（称为同相和正交分量），您可以获得任意相移。

h(t) = Acos(wt) + iB*sin(wt)

这里的关键是在线性系统中：如果 f(t) 和 g(t) 求解方程，则 h (t) 也将求解相同的方程。所以，现在我们有了方程 h(t) 的通用解。

h(t) 的好处在于，

它可以紧凑地写为h(t) = Cexp(wt+theta)

利用 exp(iw) = cos(w)+i*sin(w) 的事实，

。这些确实没有什么特别深奥的地方。它只是利用数学恒等式来简洁地表示各种方程的通用解。

回复收藏 0 原文

呆头 2024-07-21 19:01:31

好吧，对于程序员来说：

class complex {
public:
  double real;
  double imaginary;

  complex(double a_real) : real(a_real), imaginary(0.0) { }
  complex(double a_real, double a_imaginary) : real(a_real), imaginary(a_imaginary) { }

  complex operator+(const complex &other) {
    return complex(
        real + other.real,
        imaginary + other.imaginary);
  }
  complex operator*(const complex &other) {
    return complex(
        real*other.real - imaginary*other.imaginary,
        real*other.imaginary + imaginary*other.real);
  }

  bool operator==(const complex &other) {
    return (real == other.real) && (imaginary == other.imaginary);
  }
};

这基本上就是全部了。复数只是实数对，为此定义了 +、* 和 == 的特殊重载。这些操作实际上就是这样定义的。然后事实证明，这些具有这些运算的数字对与数学的其余部分非常吻合，因此它们得到了一个特殊的名称。

它们不像“计数”中的数字，而更像“可以用 +、-、*、... 进行操作，并且与‘常规’数字混合时不会引起问题”。它们很重要，因为它们填补了实数留下的漏洞，就像没有数字的平方为 -1 一样。现在您有了 complex(0, 1) *complex(0, 1) == -1.0 这是一个有用的符号，因为在这些情况下您不必再专门处理负数。（而且，事实证明，当您使用复数时，基本上不再需要所有其他特殊情况）

Well, for the programmer:

class complex {
public:
  double real;
  double imaginary;

  complex(double a_real) : real(a_real), imaginary(0.0) { }
  complex(double a_real, double a_imaginary) : real(a_real), imaginary(a_imaginary) { }

  complex operator+(const complex &other) {
    return complex(
        real + other.real,
        imaginary + other.imaginary);
  }
  complex operator*(const complex &other) {
    return complex(
        real*other.real - imaginary*other.imaginary,
        real*other.imaginary + imaginary*other.real);
  }

  bool operator==(const complex &other) {
    return (real == other.real) && (imaginary == other.imaginary);
  }
};

That's basically all there is. Complex numbers are just pairs of real numbers, for which special overloads of +, * and == get defined. And these operations really just get defined like this. Then it turns out that these pairs of numbers with these operations fit in nicely with the rest of mathematics, so they get a special name.

They are not so much numbers like in "counting", but more like in "can be manipulated with +, -, *, ... and don't cause problems when mixed with 'conventional' numbers". They are important because they fill the holes left by real numbers, like that there's no number that has a square of -1. Now you have complex(0, 1) * complex(0, 1) == -1.0 which is a helpful notation, since you don't have to treat negative numbers specially anymore in these cases. (And, as it turns out, basically all other special cases are not needed anymore, when you use complex numbers)

回复收藏 0 原文

能怎样 2024-07-21 19:01:31

如果问题是“虚数存在吗？” 或“虚数是如何存在的？” 那么这就不是程序员的问题了。这甚至可能不是数学家的问题，而是形而上学家或数学哲学家的问题，尽管数学家可能觉得有必要证明他们在该领域的存在。从讨论数字到底是如何存在的开始是很有用的（仅供参考，很多研究这个问题的数学家都是柏拉图主义者）。有些人坚持认为虚数（正如早期怀特海所做的那样）是一种实际的便利。但是，如果虚数仅仅是一种实际的便利，那么这对数学来说又意味着什么呢？你不能仅仅将虚数解释为纯粹的实用工具或一对实数，而不必考虑这两对以及它们“实用”的一般后果。其他人则坚持虚数的存在，认为虚数的不存在会破坏大量使用虚数的物理理论（量子力学深陷复杂的希尔伯特空间）。我相信这个问题超出了本网站的范围。

如果您的问题更加实际，例如如何在软件中表达虚数，那么上面的答案（一对实数，以及它们的定义操作）就是它。

回复收藏 0 原文

清风挽心 2024-07-21 19:01:31

我不想把这个网站变成数学溢出，但对于那些感兴趣的人：查看 Paul J. Nahin 的“An Imaginary Tale: The Story of sqrt(-1)”。它以有趣和令人兴奋的方式讲述了虚数的所有历史和各种应用。七年前，当我读到这本书时，我决定攻读数学学位（当时我正在考虑艺术）。读得好！！

回复收藏 0 原文

失去的东西太少 2024-07-21 19:01:31

要点是添加您定义的数字作为二次方程的解，例如 x²= -1。说出该方程 i 的一个解，然后根据该方程得出 i 的计算规则。

这类似于当您只知道正数时将负数定义为 2 + x = 1 等方程的解，或者当您只知道整数时将分数定义为 2x = 1 等方程的解。

回复收藏 0 原文

白日梦 2024-07-21 19:01:31

最简单的方法可能是停止尝试理解数字如何成为负数的平方根，而继续假设它是负数。

因此（使用i作为-1的平方根）：

(3+5i)*(2-i)
= (3+5i)*2 + (3+5i)*(-i)
= 6 + 10i -3i - 5i * i
= 6 + (10 -3)*i - 5 * (-1)
= 6 + 7i + 5
= 11 + 7i

根据数学标准规则进行计算（记住第四行的i平方等于-1）。

It might be easiest to stop trying to understand how a number can be a square root of a negative number, and just carry on with the assumption that it is.

So (using the i as the square root of -1):

(3+5i)*(2-i)
= (3+5i)*2 + (3+5i)*(-i)
= 6 + 10i -3i - 5i * i
= 6 + (10 -3)*i - 5 * (-1)
= 6 + 7i + 5
= 11 + 7i

works according to the standard rules of maths (remembering that i squared equals -1 on line four).

回复收藏 0 原文

野鹿林 2024-07-21 19:01:31

虚数是实数乘以虚数单位i。 i 定义为：

i == sqrt(-1)

因此：

i * i == -1

使用此定义，您可以获得负数的平方根，如下所示：

   sqrt(-3)
== sqrt(3 * -1)
== sqrt(3 * i * i) // Replace '-1' with 'i squared'
== sqrt(3) * i     // Square root of 'i squared' is 'i' so move it out of sqrt()

最终答案是实数 sqrt(3) 乘以由虚数单位i。

An imaginary number is a real number multiplied by the imaginary unit i. i is defined as:

i == sqrt(-1)

So:

i * i == -1

Using this definition you can obtain the square root of a negative number like this:

   sqrt(-3)
== sqrt(3 * -1)
== sqrt(3 * i * i) // Replace '-1' with 'i squared'
== sqrt(3) * i     // Square root of 'i squared' is 'i' so move it out of sqrt()

And your final answer is the real number sqrt(3) multiplied by the imaginary unit i.

回复收藏 0 原文