C# 格式化单个&；SimpleDB的双值字符串？

Amazon的SimpleDB将值存储为字符串，我需要存储数值，以便它们仍能正确比较，例如：

“0001”<“0002”

我认为字节、整数和小数将相当简单，但我有点不确定处理单精度和双精度的最佳方法，因为它们可以非常小或非常大，并且希望比我聪明的人提供任何建议

（我使用的是C#）

一个选项（如果您不要求它们是人类可读的）是先存储指数（零填充），然后存储尾数。类似于“（07:4.5）的内容通常被写成4.5e7

*

smile

*

您要处理的是有符号值还是小于1的正浮点数？如果是这样，您还需要做类似的操作，但要在括号中（例如，[]表示正，（）表示负）以及尾数

如果你想将整数与单数等一起排序，你可能只需要在输入的过程中将所有的整数规格化为最大的类型（例如，你的双数），而不是试图变得太复杂

因此：

• 7-->[100,17.0]
• 0.1-->[099,11.0]
• -2-->（100,08.0）

依此类推。

一个选项（如果您不要求它们是人类可读的）将是首先存储指数（零填充），然后存储尾数。类似于“（07:4.5）的内容通常会写入4.5e7

*

smile

*

您要处理的是有符号值还是小于1的正浮点值？如果是这样的话，你也需要做一些类似的事情，但是在括号中（例如，[]代表正，（）代表负）以及尾数

如果你想将整数与单数等一起排序，你可能只需要在输入的过程中将所有的整数规格化为最大的类型（例如，你的双数），而不是试图变得太复杂

因此：

• 7-->[100,17.0]
• 0.1-->[099,11.0]
• -2-->（100,08.0）

---

依此类推。

如果你已经有了一种表示符号大小数字的方法（比如你说的不太难的

整数），那么你已经有了；-]

从

IEEE浮点和双精度格式
设计为使数字
“按字典顺序排列”，其中-
用IEEE架构师威廉的话来说
Kahan的意思是“如果两个浮点
相同格式的数字按顺序排列
（假设x它们被排序
同样的方式，当他们的位被
重新解释为符号大小
整数。“

静态公共字符串DoubleToSortableString（双dbl）
{
Int64解释长度=
BitConverter.ToInt64（BitConverter.GetBytes（dbl），0）；
返回LongToSortableString（解释为long）；
}
静态公共双DoubleFromSortableString（字符串str）
{
Int64解释长度=
LongFromSortableString（str）；
返回BitConverter.ToDouble（BitConverter.GetBytes（interpretataslong），0）；
}
静态公共字符串LongToSortableString（长lng）
{
如果（液化天然气<0）
返回“-”+（~lng）.ToString（“X16”）；
其他的
返回“0”+lng.ToString（“X16”）；
}
静态公共LongFromSortableString（字符串str）
{
if（str.StartsWith（“-”）
return~long.Parse（str.Substring（1,16），NumberStyles.HexNumber）；
其他的
返回long.Parse（str.Substring（1,16），NumberStyles.HexNumber）；
}

-0010000000000000=>-1.79769313486232E+308
-3F0795FFFFFFFF=>-100000
-3F3C77FFFFFFFF=>-10000
-3F70BFFFFFFFFFFF=>-1000
-3FA6FFFFFFFFFF=>-100
-3FDBFFFFFFFFFFFF=>-10
-400FFFFFFFFFFFFF=>-1
00000000000000000 => 0
03FF0000000000000=>1
04024000000000000 => 10
04059000000000000 => 100
0408F400000000=>1000
040C388000000000=>10000
040F86A0000000000=>100000
07FEFFFFFFFFFFF=>1.79769313486232E+308
如果您已经有了表示符号大小数字的方法（如您所说的不太难的
整数），那么您已经有了；-]

从

IEEE浮点和双精度格式
设计为使数字
“按字典顺序排列”，其中-
用IEEE架构师威廉的话来说
Kahan的意思是“如果两个浮点
相同格式的数字按顺序排列
（假设x它们被排序
同样的方式，当他们的位被
重新解释为符号大小
整数。“

静态公共字符串DoubleToSortableString（双dbl）
{
Int64解释长度=
BitConverter.ToInt64（BitConverter.GetBytes（dbl），0）；
返回LongToSortableString（解释为long）；
}
静态公共双DoubleFromSortableString（字符串str）
{
Int64解释长度=
LongFromSortableString（str）；
返回BitConverter.ToDouble（BitConverter.GetBytes（interpretataslong），0）；
}
静态公共字符串LongToSortableString（长lng）
{
如果（液化天然气<0）
返回“-”+（~lng）.ToString（“X16”）；
其他的
返回“0”+lng.ToString（“X16”）；
}
静态公共LongFromSortableString（字符串str）
{
if（str.StartsWith（“-”）
return~long.Parse（str.Substring（1,16），NumberStyles.HexNumber）；
其他的
返回long.Parse（str.Substring（1,16），NumberStyles.HexNumber）；
}

-0010000000000000=>-1.79769313486232E+308
-3F0795FFFFFFFF=>-100000
-3F3C77FFFFFFFF=>-10000
-3F70BFFFFFFFFFFF=>-1000
-3FA6FFFFFFFFFF=>-100
-3FDBFFFFFFFFFFFF=>-10
-400FFFFFFFFFFFFF=>-1
00000000000000000 => 0
03FF0000000000000=>1
04024000000000000 => 10
04059000000000000 => 100
0408F400000000=>1000
040C388000000000=>10000
040F86A0000000000=>100000
07FEFFFFFFFFFFF=>1.79769313486232E+308
而且，单打将无法与双打相媲美，也无法通过此方案与ints相媲美。哎呀！这是一项要求（混合类型）？我想他可以把所有东西都当作替身（就像你建议的那样）
static public string DoubleToSortableString(double dbl)
{
    Int64 interpretAsLong =
        BitConverter.ToInt64(BitConverter.GetBytes(dbl), 0);
    return LongToSortableString(interpretAsLong);
}

static public double DoubleFromSortableString(string str)
{
    Int64 interpretAsLong =
        LongFromSortableString(str);
    return BitConverter.ToDouble(BitConverter.GetBytes(interpretAsLong), 0);
}

static public string LongToSortableString(long lng)
{
    if (lng < 0)
        return "-" + (~lng).ToString("X16");
    else
        return "0" + lng.ToString("X16");
}

static public long LongFromSortableString(string str)
{
    if (str.StartsWith("-"))
        return ~long.Parse(str.Substring(1, 16), NumberStyles.HexNumber); 
    else
        return long.Parse(str.Substring(1, 16), NumberStyles.HexNumber);
}

-0010000000000000 => -1.79769313486232E+308
-3F0795FFFFFFFFFF => -100000
-3F3C77FFFFFFFFFF => -10000
-3F70BFFFFFFFFFFF => -1000
-3FA6FFFFFFFFFFFF => -100
-3FDBFFFFFFFFFFFF => -10
-400FFFFFFFFFFFFF => -1
00000000000000000 => 0
03FF0000000000000 => 1
04024000000000000 => 10
04059000000000000 => 100
0408F400000000000 => 1000
040C3880000000000 => 10000
040F86A0000000000 => 100000
07FEFFFFFFFFFFFFF => 1.79769313486232E+308