algorithm - 将小数转换为负十进制的算法？

Question

我想知道，如何将分数（比如，-.06）转换成负整数或负基数我知道-.06在negadecimal中是.14，因为我可以用另一种方法来做，但是用于将分数转换成其他碱基的常规算法不适用于负碱基。不要给出代码示例，只需解释所需的步骤。
常规算法的工作原理如下：
你乘以你要转换成的基数。记录整数，然后继续使用剩余的分数部分，直到没有分数为止：
0.337二进制：
0.337*2=0.674“0”
0.674*2=1.348“1”
0.348*2=0.696“0”
0.696*2=1.392“1”
0.392*2=0.784“0”
0.784*2=1.568“1”
0.568*2=1.136“1”
大约0101011

Answer 1

我有一个两步的转换算法。我不确定这是否是最佳算法，但它工作得很好。
其基本思想是从得到数字的十进制表示开始，然后通过分别处理偶数幂和奇数幂将该十进制表示转换为负十进制表示。
下面是一个激发算法背后想法的例子。这将涉及很多细节，但最终将得出算法，同时显示它的来源。
假设我们要将0.523598734转换为negadecimal（注意，我假设您可以转换为decimal）请注意

0.523598734 =   5 * 10^-1
              + 2 * 10^-2
              + 3 * 10^-3
              + 5 * 10^-4
              + 9 * 10^-5
              + 8 * 10^-6
              + 7 * 10^-7
              + 3 * 10^-8
              + 4 * 10^-9

当n为偶数时，由于10^-n=（-10）^-n，我们可以将其重写为

0.523598734 =   5 * 10^-1
              + 2 * (-10)^-2
              + 3 * 10^-3
              + 5 * (-10)^-4
              + 9 * 10^-5
              + 8 * (-10)^-6
              + 7 * 10^-7
              + 3 * (-10)^-8
              + 4 * 10^-9

重新排列和重新组合术语为我们提供了：

0.523598734 =   2 * (-10)^-2
              + 5 * (-10)^-4
              + 8 * (-10)^-6
              + 3 * (-10)^-8
              + 5 * 10^-1
              + 3 * 10^-3
              + 9 * 10^-5
              + 7 * 10^-7
              + 4 * 10^-9

如果我们能把那些否定的词改写成-10的幂，而不是10的幂，我们就完了幸运的是，我们可以做一个很好的观察：如果d是一个非零数字（1，2，…，或9），那么

  d * 10^-n + (10 - d) * 10^-n
= 10^-n (d + 10 - d)
= 10^-n (10)
= 10^{-n+1}

以不同的方式重申：

  d * 10^-n + (10 - d) * 10^-n = 10^{-n+1}

因此，我们得到一个有用的事实：

  d * 10^-n = 10^{-n+1} - (10 - d) * 10^-n

如果假设n是奇数，那么-10^-n=（-10）^-n和10^{-n+1}=（-10）^{-n+1}因此，对于奇数n，我们看到

  d * 10^-n = 10^{-n+1}    - (10 - d) * 10^-n
            = (-10)^{-n+1} + (10 - d) * (-10)^-n

想想这在谈判中意味着什么我们把十的幂变成了两个负十的幂。
把这个应用到我们的总结中可以得到：

0.523598734 =   2 * (-10)^-2
              + 5 * (-10)^-4
              + 8 * (-10)^-6
              + 3 * (-10)^-8
              + 5 * 10^-1
              + 3 * 10^-3
              + 9 * 10^-5
              + 7 * 10^-7
              + 4 * 10^-9
            =   2 * (-10)^-2
              + 5 * (-10)^-4
              + 8 * (-10)^-6
              + 3 * (-10)^-8
              + (-10)^0  + 5 * (-10)^-1
              + (-10)^-2 + 7 * (-10)^-3
              + (-10)^-4 + 1 * (-10)^-5
              + (-10)^-6 + 3 * (-10)^-7
              + (-10)^-8 + 6 * (-10)^-9

重新组合可以得到：

0.523598734 = (-10)^0
              + 5 * (-10)^-1
              + 2 * (-10)^-2 + (-10)^-2
              + 7 * (-10)^-3
              + 5 * (-10)^-4 + (-10)^-4
              + 1 * (-10)^-5
              + 8 * (-10)^-6 + (-10)^-6
              + 3 * (-10)^-7
              + 3 * (-10)^-8 + (-10)^-8
              + 6 * (-10)^-9

总的来说，这给出了1.537619346的负向表示。
现在，让我们在negadigit级别考虑这个问题。请注意
偶数位置的数字大多被保留。
奇数位置的数字被翻转：任何非零的奇数数字被10减去该数字所代替。
每次翻转奇数数字时，前面的数字都会递增。
让我们看看0.523598734并直接应用这个算法。我们首先翻转所有奇数位数，给出其10的补码：

0.523598734 --> 0.527518336

接下来，我们在所有翻转的奇数位数之前递增偶数位数：

0.523598734 --> 0.527518336 --> 1.537619346ND

这与我们之前的数字相匹配，所以看起来我们有一个算法的构成！
不幸的是，当我们开始处理涉及数字9的十进制值时，事情变得有点棘手例如，我们取0.999应用我们的算法，我们首先翻转所有奇数位数：

0.999 --> 0.191

现在，我们将值翻转的列前面的所有偶数数字递增：

0.999 --> 0.191 --> 1.1(10)1

这里，（10）表示包含9的列溢出到10。很明显这是不允许的，所以我们必须修复它。
为了找出解决这个问题的方法，看看如何用负数来计算是很有启发性的以下是从0到110的计数方法：

000
001
002
003
...
008
009
190
191
192
193
194
...
198
199
180
181
...
188
189
170
...
118
119
100
101
102
...
108
109
290

幸运的是，这里有一个非常好的模式基本机制的工作原理类似于普通的base-10递增：递增最后一个数字，如果它溢出，则在下一列中携带1，继续携带，直到一切稳定。这里的区别是奇数列的工作方式相反例如，如果您将-10s数字递增，您实际上是减去一个而不是加一个，因为将该列中的值增加10相当于在您的总和中少包含一个-10。如果该数字低于0，则将其重置回9（减去90），然后增加下一列（加100）换言之，递增负整数的一般算法如下：
从1的列开始。
如果当前列位于偶数位置：
加一个。
如果该值达到10，则将其设置为零，然后将此过程应用于前面的列。
如果当前列位于奇数位置：
减去一。
如果值达到-1，则将其设置为9，然后将此过程应用于前面的列。
你可以通过将上述关于-10s数字和100s数字的推理归纳出来，并意识到溢出一个对应于10k的偶数列意味着你需要加入10k+1，这意味着你需要将前一列减去一，奇数列的下溢是减去9.10k，再加上10k+1。
让我们回到我们手头的例子。我们试图将0.999转换为Negadecimal

0.999 --> 0.191 --> 1.1(10)1

要解决这个问题，我们将10的列重置为0，然后将1带入前一列。这是一个奇数列，所以我们将其减量这给出了最终结果：

0.999 --> 0.191 --> 1.1(10)1 --> 1.001ND

总的来说，对于正数，我们有以下转换算法：
从左到右处理数字：
如果您所处的奇数位数不是零：
将数字d替换为数字10-d。
使用标准的negadecimal加法算法，增加前一列中的值。
当然，负数是另一回事对于负数，奇数列是正确的，偶数列需要翻转，因为求和中的（-10）k项的奇偶性翻转。因此，对于负数，应用上述算法，但保留奇数列并翻转偶数列。类似地，在进行翻转时，不是递增前一个数字，而是递减前一个数字。
例如，假设我们要将-0.523598734转换为negadecimal应用该算法可以得到：

-0.523598734 --> 0.583592774 --> 0.6845(10)2874 --> 0.684402874ND

这确实是正确的表述。
希望这有帮助！