标签: numeric

我有一个函数，它接受两个参数，如果它们相等则返回 true，如果不相等则返回 false：

private bool isequal(object a, object b)
{
    if (a != null)
        return a.Equals(b);
    if (b != null)
        return b.Equals(a);
    //if (a == null && b == null)
        return true;
}

现在我想扩展这个功能。如果 a 和 b 是 2 个相同的数字但类型不同，它也应该返回 true。

例如：

int a = 15;
double b = 15;
if (isequal(a,b)) //should be true; right now it's false
{ //...
}

我已经找到了一个类似的问题（带有答案）比较 double 和 int 的最佳方法，但 a 和 b 可以是任何类型的数字或数字以外的其他数字。如何检查 a 和 b 是否是数字？我希望有一种比检查 .net 的所有现有数字类型（Int32、Int16、Int64、UInt32、Double、Decimal，...）更好的方法

// …

我尝试使用此命令创建一个生存对象。

Surv(date1, date2, event=status)

它导致错误“时间变量不是数字”。请注意，“date1”和“date2”的类别是 Date。

在创建生存对象之前，我是否需要将 Date 对象强制转换为数字？我认为这没有任何意义。

由于有人问我使用前缀“0x”表示十六进制数字背后的原因，我一直在深入研究 BCPL 的历史。

在我的搜索中，我偶然发现了这个代币背后历史的非常好的解释。（为什么十六进制数要加上0x前缀？）

然而，从这篇文章中，又引发了另一个问题：

对于八进制常量，BCPL 是否使用8 <digit>（根据规范：http://cm.bell-labs.com/cm/cs/who/dmr/bcpl.pdf）或是否使用#<digit>（根据http://rabbit.eng .miami.edu/info/bcpl_reference_manual.pdf）或者这两种语法在该语言的不同实现中都有效吗？

我还在这里找到了第二个答案，它使用了 # 语法，这进一步引起了我对这个主题的兴趣。（为什么用前导零来表示八进制数？）

任何历史见解都将受到高度赞赏。

如何优化数值积分例程（与 C 相比）？

目前已经做了什么：

1. 我用未装箱的向量替换了列表（显而易见）。
2. 我应用了“Read World Haskell”一书中描述的分析技术http://book.realworldhaskell.org/read/profiling-and-optimization.html。我内联了一些琐碎的函数，并在各处插入了很多刘海。这带来了大约 10 倍的加速。
3. 我重构了代码（即提取iterator函数）。这带来了 3 倍的加速。
4. 我尝试用 Floats 替换多态签名，如这个问题 Optimizing numeric array Performance in Haskell 的答案。这几乎提高了 2 倍的速度。
5. 我这样编译 cabal exec ghc -- Simul.hs -O2 -fforce-recomp -fllvm -Wall
6. 更新按照 cchalmers 的建议，type Sample = (F, F)被替换为 data Sample = Sample {-# UNPACK #-} !F {-# UNPACK #-} !F

现在的性能几乎和C代码一样好。我们可以做得更好吗？

{-# LANGUAGE BangPatterns #-}

module Main
  where

import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as UM …

在研究三角形点测试（2D 情况）的各种方法时，我发现使用重心坐标的方法是最常用的一种。这是 StackOverflow 的答案，对此进行了解释。

为什么这种方法是最优选的方法？这可能与计算量减少有关，但是数值稳定性呢？对于点特别靠近边界的情况，该算法是否比“同边”技术更适合？

在 Go 中如何使用二进制补码表示法将负整数表示为二进制？
例如：

n := int64(-1)
fmt.Printf("%b", n)
fmt.Println(strconv.FormatInt(n, 2))

两行都打印-1。结果应该是这样的ffffffffffffffff。

有人能指出为什么 Julia 在对某些类型的矩阵进行对角化时会失去对称性吗？（在下面我将忽略归一化常量。）我一直在尝试解决以下 Floquet 矩阵：

U[i,i] = exp(-i^2im/N),

与N基体和其它部件的尺寸是零。显然，这是哈密顿量的“时间演化”

H = p^2/2.

这H是在奇偶校验下对称的，因此U在站点基础上Us = Udft'U*Udft（Udft是离散傅立叶矩阵 stUdft[m,mp] = sqrt(N)^-1 exp(i*j*1im/N)见下文），也就是说，可以检查

Jp*Us - Us*Jp = 0,

在哪里

Jp[i,j] = \delta_{i,N-j+1}

是空间求逆矩阵。然而，本征态不满足奇偶性。如果vs是 的本征态Us，则

Jp*vs = \pm vs,

对于 julia 给出的数值结果，这不会发生。这有点奇怪，因为对于低维，说N=11没有问题，但如果我去，说N=1001然后麻烦开始出现。（在某些条件下，我想N成为奇数。原因是我有粒子被限制在单一圆上移动，并且我希望这些位置围绕零角对称。）为了对角化，我使用Julia 1.2.0和

 LinearAlgebra.eigen(Us).

附录：感谢 SGJ 指出 DFT 中的明显错误。构造矩阵我做

M = div(N,2)
m = 1
for ii in -M:M
    mp = …

我正在使用Data.Ratio（连分数的收敛）实现一个算法。但是，我遇到了两个障碍：

• 该算法从分数开始1%0- 但这会引发零分母异常。
• 我想模式匹配构造函数 a :% b

我正在探索hackage。一个特别是源似乎正在使用这些功能（例如定义infinity = 1 :% 0，或模式匹配numerator）。

作为初学者，我也很困惑在哪里确定(%)，numerator等暴露给我，但不是infinity和(:%)。

我已经使用整数元组做了一个肮脏的解决方法，但是为如此微不足道的事情重新发明轮子似乎很愚蠢。也很高兴了解如何阅读公开哪些功能的源代码。

我有一个关于 Julia 中矩阵乘法的计算问题。事实上我今天开始学习 Julia。以前我经常使用Python、numpy 等。

但是，我有一个 6x6 矩阵A ，我想将其与已有的初始向量x ₁相乘，然后将另一个向量a ₁添加到乘积中。然后我使用它的输出向量x ₂作为具有相同矩阵A的相同操作的输入，但不同的向量a ₂等等。

那是：

\n
0. 迭代：x ₁
\n
1. 迭代：x ₂ = A x ₁ + a ₁
\n
2. 迭代x ₃ = A x ₂ + a ₂
\n
3. 迭代...
\n

涉及的对象非常小，但问题是，我想多次执行此操作：大约 ~10 ¹¹到 ~10 ¹³次。此外，我需要非常高的数值精度，远远高于 Float64 给出的精度。

我能够编写一种直接的方法，它可以满足我的要求并达到我想要的精度。在良好/成熟的Python实践中，我已经预定义了我的数组，并在进行过程中用计算值填充它们。然而，我感觉我受到低效内存管理的瓶颈，正如分配数量可能表明的那样。

时不时地（比如每 1000 次迭代）我想将当前迭代的向量x _i保存到另一个数组m，这是函数的输出和我的结果。

我认为用第 i …

我有一个如下所示的文件：

1:line1
14:line2
135:line3
15:line4

我需要在每行前面添加前导零，使其看起来像这样：

00001:line1
00014:line2
00135:line3
00015:line4

在 Linux 中是否有一种简单的方法可以做到这一点？

我尝试过使用

awk '{printf "%05d:%s\n", FNR, $0}' file

但这输出：

00001:1:line1
00002:14:line2
00003:135:line3
00004:15:line4

我应该注意我没有写这个命令，我从谷歌那里得到它并且并不真正理解它是如何工作的