Algorithm 将小数转换为负小数的算法？

我想知道，如何将分数值（比如，-.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

注意，它告诉您如何将整数转换为负数。因此，解决这个问题的一种方法是将分数乘以足够高的100次方，将其转换成整数，然后再除以：-0.06=-6/100=>14/100=0.14

另一种方法是认识到你正在尝试创建一个表-a/10+b/100-c/1000+d/10000的总和。。。为了接近目标数字，您希望在每个阶段尽可能减少错误，但需要在下一阶段可以纠正的方向上留下错误。请注意，这也意味着分数可能不以0开头。转换时。0.5=>1.5=1-5/10

因此，换算为-0.06。这是负数，小数点后的第一个数字在[0.0，-0.1..-0.9]范围内，因此我们从0开始。让我们-0.06转换。现在，如果小数点后的第一个数字是0，那么我还有-0.06，这是用0.0d转换的错误方向，因此我需要选择小数点后的第一个数字，以产生低于我的目标-0.06的近似值。所以我选择了0.1，它实际上是-0.1，给我留下了一个0.04的错误，我可以精确地转换，只留下0.14的转换

因此，在每一点上输出一个数字

1） 准确的结果，在这种情况下，您就完成了

2） 如果下一个数字为负数，则近似值略大于目标数

3） 如果下一个数字为正数，则近似值略小于目标数

---

如果你开始尝试在每一点上近似一个介于（-1.0，0.0）范围内的数字，你可以选择一个使剩余误差足够小且方向正确的数字，所以这总是有效的。

我有一个两步算法来进行转换。我不确定这是否是最佳算法，但它工作得很好

其基本思想是首先获得数字的十进制表示，然后通过分别处理偶数幂和奇数幂，将十进制表示转换为负整数表示

这是一个激发算法背后想法的例子。这将涉及很多细节，但最终将得出算法，同时说明它的来源

假设我们想要将数字0.523598734转换为负整数（注意，我假设您可以转换为十进制）

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+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

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

重新组合会产生以下结果：

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

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

总的来说，这给出了1.537619346的负整数表示

现在，让我们从negadigit级别来考虑这个问题。注意

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

• 偶数位置的数字大多保留
• 奇数位置的数字被翻转：任何非零的奇数数字都被10减去该数字替换
• 每次翻转奇数数字时，前面的数字都会递增

让我们看看0.523598734，并直接应用该算法。我们首先翻转所有奇数数字，给出它们的10的补码：

0.523598734 --> 0.527518336

接下来，我们增加所有翻转奇数数字之前的偶数数字：

0.523598734 --> 0.527518336 --> 1.537619346ND

0.999 --> 0.191

这与我们之前的数字相匹配，所以看起来我们具备了算法的素质

不幸的是，当我们开始处理涉及数字9的十进制值时，事情变得有点棘手。例如，让我们以数字0.999为例。应用我们的算法，我们首先翻转所有奇数数字：

0.523598734 --> 0.527518336 --> 1.537619346ND

0.999 --> 0.191

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

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

这里，（10）表示包含9的列溢出为10。显然这是不允许的，所以我们必须修复它

要了解如何解决此问题，请了解如何在negabinary中计数。以下是如何从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

幸运的是，这里有一个非常好的模式。基本机制的工作原理类似于正常的基数-10递增：递增最后一个数字，如果溢出，将1带入下一列，继续进位，直到一切稳定。这里的区别是奇数列的工作方式相反。如果递增-10s数字，例如举例来说，你实际上是减去一而不是加一，因为将该列中的值增加10对应于在你的总和中包含一个小于-10的值。如果该数字小于0，