精华内容
下载资源
问答
  • I would like to convert a file that contained few DNA sequences into binary values which is as follow:A=1000C=0100G=0010T=0001FileA.txtCCGATGCTTADesired output0100010000101000000100100100000100011000I...

    I would like to convert a file that contained few DNA sequences into binary values which is as follow:

    A=1000

    C=0100

    G=0010

    T=0001

    FileA.txt

    CCGAT

    GCTTA

    Desired output

    01000100001010000001

    00100100000100011000

    I have tried using this code to solve my problem but the bin output file seem failed to output my desired answer. Can anyone help me?

    Code

    import sys

    if len(sys.argv) != 2 :

    sys.stderr.write('Usage: {} \n'.format(sys.argv[0]))

    sys.exit()

    # assumes the file only contains dna and newlines

    sequence = ''

    for line in open(sys.argv[1]) :

    sequence += line.strip().upper()

    sequence = sequence.replace('A', chr(0b1000))

    sequence = sequence.replace('C', chr(0b0100))

    sequence = sequence.replace('G', chr(0b0010))

    sequence = sequence.replace('T', chr(0b0001))

    outfile = open(sys.argv[1] + '.bin', 'wb')

    outfile.write(bytearray(sequence, encoding = 'utf-8'))

    解决方案

    Do you want ascii output or binary? The below will give you what you show in your post (though on a single line. Code needs to be modified to keep newlines).

    import sys

    if len(sys.argv) != 2 :

    sys.stderr.write('Usage: {} \n'.format(sys.argv[0]))

    sys.exit()

    # assumes the file only contains dna and newlines

    sequence = ''

    for line in open(sys.argv[1]) :

    sequence += line.strip().upper()

    sequence = sequence.replace('A', '1000')

    sequence = sequence.replace('C', '0100')

    sequence = sequence.replace('G', '0010')

    sequence = sequence.replace('T', '0001')

    outfile = open(sys.argv[1] + '.bin', 'wb')

    outfile.write(sequence)

    EDIT This creates a binary file where each nucleotide is a byte and the newlines are preserved in binary format.

    import sys

    if len(sys.argv) != 2 :

    sys.stderr.write('Usage: {} \n'.format(sys.argv[0]))

    sys.exit()

    # assumes the file only contains dna and newlines

    newbytearray=bytearray(b'',encoding='utf-8')

    dict={'A':0b1000,'C':0b0100,'G':0b0010,'T':0b0001,'\n':0b1010}

    with open(sys.argv[1]) as file:

    while True:

    char=file.read(1)

    if not char:

    file.close()

    break

    newbytearray.append(dict[char])

    outfile = open(sys.argv[1] + '.bin', 'wb')

    outfile.write(newbytearray)

    outfile.close()

    #Converts the binary file to unicode and prints the result sequence.

    testBin = open('fileA.txt.bin','rb')

    sequence=''

    for line in testBin:

    line = line.replace(chr(0b1000),'1000')

    line = line.replace(chr(0b0100),'0100')

    line = line.replace(chr(0b0010),'0010')

    line = line.replace(chr(0b0001),'0001')

    line = line.replace(chr(0b1010),'\n')

    sequence += line

    #outputVerify = open('outputVerify.txt','wb')

    #outputVerify.write(sequence)

    #outputVerify.close()

    print sequence

    testBin.close()

    #Shows the data of the binary file. Note that byte 6 is the newline character 0b1010.

    testBin = open('fileA.txt.bin','rb')

    list = ''

    i=0

    while True:

    b = testBin.read(1)

    i += 1

    if not b:

    break #due to eof

    list += b

    print 'byte: ' + str(i) + ' is '+ '{0:04b}'.format(ord(b)) +' and has decimal representation: ' + str(ord(b))

    testBin.close()

    展开全文
  • 字节数组转为二进制数 c# 低延迟系统需要高性能的消息处理和传递。 由于在大多数情况下,数据必须通过有线传输或序列化才能保持持久性,因此编码和解码消息已成为处理管道的重要组成部分。 高性能数据编码的最佳...

    字节数组转为二进制数 c#

    低延迟系统需要高性能的消息处理和传递。 由于在大多数情况下,数据必须通过有线传输或序列化才能保持持久性,因此编码和解码消息已成为处理管道的重要组成部分。 高性能数据编码的最佳结果通常涉及应用程序数据细节的知识。 本文介绍的技术是一个很好的示例,说明了如何利用数据的某些方面在延迟和空间复杂度方面都有利于编码。

    通常,高频交易系统周围传递的最大消息以订单簿摘录的形式表示某种交换状态。 即,典型的市场数据(报价)消息包含标识工具的信息和代表订单簿顶部的一组值。 数据集的强制性成员是以实数表示的价格/汇率信息(用于买卖双方)。

    从优化的角度来看,使该数据集非常有趣的原因是:

    1. 单调的
    2. 低方差
    3. 非负*

    因此,在实践中,我们处理的是浮点数集,这些浮点数不仅经过排序(升序出价和降价要求),而且相邻值彼此相对“接近”。 请记住,消息处理延迟对于大多数交易系统而言至关重要,因此市场行情波动,因为关键实体之一需要尽可能高效地传递。

    让我演示如何利用所有这些功能将数字数据编码为非常紧凑的二进制形式。 首先,两个前导图说明了不同序列化方法之间的差异:

    图片1

    到目前为止,我们可以看到,与基于标准ByteBuffer的序列化相比,增量编码在编码时间上可获得更好的结果,但是一旦数组长度超过40,它就会比Kryo (最流行的高性能序列化库之一)更差。不过,在这里重要的是一个典型的用例场景,对于高频交易,市场消息恰好适合阵列长度的10-40

    当我们检查生成的消息大小(作为数组长度的函数)时,它会变得更加有趣:

    image2

    此时,应用增量编码的好处将变得显而易见(蓝色曲线同样适用于字节缓冲区和Kryo​​序列化)。 这里发生的是,在掌握了一些有关要处理的数据的特定知识之后,可以安全地进行假设,从而导致序列化占用更多的CPU资源,但是在空间方面却要荒唐得多。 增量压缩背后的想法非常简单。 让我们从一个整数数组开始:

    • [85103、85111、85122、85129、85142、85144、85150、85165、85177]

    如果这些是整数,则不进行任何压缩就必须使用4 * 9 = 36字节来存储数据。 在这组数字中,特别有趣的是,它们彼此相对紧密地聚集在一起。 我们可以通过引用第一个值轻松地减少存储数据所需的字节数,然后生成一个对应的增量数组:

    • 参考:85103,[8、19、26、39、41、47、62、74]

    哇! 现在我们可以缩小为字节数组。 让我们再次进行计算。 我们需要4个字节作为参考值(仍为int),每个增量= 8 * 1个字节= 12个字节。

    与原始的36个字节相比,这是一个很大的改进,但仍有一些优化的余地。 与其从参考值计算增量,不如依次存储每个前任的差异:

    • 参考:85103,[8、11、7、13、2、6、15、12]

    结果是一组具有低方差和标准偏差的非单调数字。 我希望事情已经明确了。 尽管如此,还是值得详细说明。

    至此,我们最终得到的是一组二进制编码的理想选择。 对于我们的示例,这仅意味着可以在单个字节中容纳2个增量。 我们只需要一个半字节(4位)即可容纳0-15范围内的值,因此我们可以轻松地最终将原始数组压缩为4(供参考)+ 8 * 1/2 = 8个字节。

    由于价格是用十进制数字表示的,因此应用带有二进制编码的增量压缩将涉及建立最大支持的精度并将小数作为整数(将它们乘以10 ^精度),从而使精度为6的1.12345678成为1123456整数。 到目前为止,所有这些都是纯粹的理论推测,本文开头有一些预告片。 我想这是演示如何使用2个非常简单的类在Java中实现这些想法的恰当时机。

    我们将从编码方面开始:

    package eu.codearte.encoder;
    
    import java.nio.ByteBuffer;
    
    import static eu.codearte.encoder.Constants.*;
    
    public class BinaryDeltaEncoder {
    
        public static final int MAX_LENGTH_MASK = ~(1 << (LENGTH_BITS - 1));
    
        public ByteBuffer buffer;
        public double[] doubles;
        public int[] deltas;
        public int deltaSize, multiplier, idx;
    
        public void encode(final double[] values, final int[] temp, final int precision, final ByteBuffer buf) {
            if (precision >= 1 << PRECISION_BITS) throw new IllegalArgumentException();
            if ((values.length & MAX_LENGTH_MASK) != values.length) throw new IllegalArgumentException();
            doubles = values; deltas = temp; buffer = buf;
            multiplier =  Utils.pow(10, precision);
    
            calculateDeltaVector();
            if (deltaSize > DELTA_SIZE_BITS) throw new IllegalArgumentException();
            buffer.putLong((long) precision << (LENGTH_BITS + DELTA_SIZE_BITS) | (long) deltaSize << LENGTH_BITS | values.length);
            buffer.putLong(roundAndPromote(values[0]));
            idx = 1;
            encodeDeltas();
        }
    
        private void calculateDeltaVector() {
            long maxDelta = 0, currentValue = roundAndPromote(doubles[0]);
            for (int i = 1; i < doubles.length; i++) {
                deltas[i] = (int) (-currentValue + (currentValue = roundAndPromote(doubles[i])));
                if (deltas[i] > maxDelta) maxDelta = deltas[i];
            }
            deltaSize = Long.SIZE - Long.numberOfLeadingZeros(maxDelta);
        }
    
        private void encodeDeltas() {
            if (idx >= doubles.length) return;
            final int remainingBits = (doubles.length - idx) * deltaSize;
    
            if (remainingBits >= Long.SIZE || deltaSize > Integer.SIZE) buffer.putLong(encodeBits(Long.SIZE));
            else if (remainingBits >= Integer.SIZE || deltaSize > Short.SIZE) buffer.putInt((int) encodeBits(Integer.SIZE));
            else if (remainingBits >= Short.SIZE || deltaSize > Byte.SIZE) buffer.putShort((short) encodeBits(Short.SIZE));
            else buffer.put((byte) encodeBits(Byte.SIZE));
            encodeDeltas();
        }
    
        private long encodeBits(final int typeSize) {
            long bits = 0L;
            for (int pos = typeSize - deltaSize; pos >= 0 && idx < deltas.length; pos -= deltaSize)
                bits |= (long) deltas[idx++] << pos;
            return bits;
        }
    
        private long roundAndPromote(final double value) {
            return (long) (value * multiplier + .5d);
        }
    }

    在详细介绍之前,请先介绍几句话。 该代码不是完整的,成熟的解决方案。 它的唯一目的是演示提高应用程序序列化协议的某些位的难易程度。 由于它受到了微基准测试,因此它也不会引起gc压力,因为即使是最快的次要gc的影响也会严重扭曲最终结果,从而使api变得丑陋。 该实现也是次优的,尤其是在CPU方面,但是证明微优化不是本文的目标。 话虽如此,让我们看看它的作用(大括号中的行号)。

    编码方法首先进行一些基本的健全性检查{17,18},计算将十进制转换为整数{20}所使用的乘数,并计算calculateDeltaVector()。 这又有两个作用。

    1. 通过将小数转换为整数,从前任减去,最后将结果存储在临时数组{33}中,计算整个集合的滚动增量
    2. 作为副作用,得出表示增量{34,36}所需的最大位数

    然后,encode()方法存储正确反序列化所需的一些元数据。 它以位为单位打包精度,增量大小,并以前64位{24}打包数组长度。 然后,它存储参考值{25}并启动二进制编码{27}。

    编码增量执行以下操作:

    1. 检查它是否已经处理了所有数组条目,如果已​​退出则退出{40}
    2. 计算要编码的剩余位数{41}
    3. 选择最合适的类型(给定大小,以位为单位),对剩余的位进行编码,然后将这些位写入缓冲区{43-46}
    4. 递归{47}

    最后一点可能需要详细说明是encodeBits()方法本身。 根据在参数中传递的类型大小(以位为单位),它循环一个临时long,其唯一目的是充当位集,并写入代表从long值的最高有效部分到最低有效部分的连续增量的位(范围为字号)。

    正如预期的那样,解码与编码完全相反,并且主要是关于使用元数据来重建原始double数组,直至达到指定的精度:

    package eu.codearte.encoder;
    
    import java.nio.ByteBuffer;
    
    import static eu.codearte.encoder.Constants.DELTA_SIZE_BITS;
    import static eu.codearte.encoder.Constants.LENGTH_BITS;
    
    public class BinaryDeltaDecoder {
    
        private ByteBuffer buffer;
        private double[] doubles;
        private long current;
        private double divisor;
        private int deltaSize, length, mask;
    
        public void decode(final ByteBuffer buffer, final double[] doubles) {
            this.buffer = buffer; this.doubles = doubles;
            final long bits = this.buffer.getLong();
            divisor = Math.pow(10, bits >>> (LENGTH_BITS + DELTA_SIZE_BITS));
            deltaSize = (int) (bits >>> LENGTH_BITS) & 0x3FFFFFF;
            length = (int) (bits & 0xFFFFFFFF);
            doubles[0] = (current = this.buffer.getLong()) / divisor;
            mask = (1 << deltaSize) - 1;
            decodeDeltas(1);
        }
    
        private void decodeDeltas(final int idx) {
            if (idx == length) return;
            final int remainingBits = (length - idx) * deltaSize;
    
            if (remainingBits >= Long.SIZE) decodeBits(idx, buffer.getLong(), Long.SIZE);
            else if (remainingBits >= Integer.SIZE) decodeBits(idx, buffer.getInt(), Integer.SIZE);
            else if (remainingBits >= Short.SIZE) decodeBits(idx, buffer.getShort(), Short.SIZE);
            else decodeBits(idx, buffer.get(), Byte.SIZE);
        }
    
        private void decodeBits(int idx, final long bits, final int typeSize) {
            for (int offset = typeSize - deltaSize; offset >= 0 && idx < length; offset -= deltaSize)
                doubles[idx++] = (current += ((bits >>> offset) & mask)) / divisor;
            decodeDeltas(idx);
        }
    
    }

    带有一些测试类的源代码可以在这里找到。 请记住,即使事实证明该代码可以正常工作,也不适合生产。 您绝对可以使它工作而无需临时数组,用聪明的方法代替最大数组大小时替换全数组扫描,或者通过进行倒数近似除以重量级除法就可以摆脱困境。 随意选择这些提示或应用不同的微优化,并构建自己的专有增量编码协议。 对于对延迟敏感的交易应用程序而言,它具有很大的区别,可将液体工具的市场数据消息大小减小20-30倍。 当然,如果切换到增量压缩二进制编码会对您的应用程序生态系统带来任何价值,那么您必须弄清楚自己。 随便发表评论与您的​​发现!


    翻译自: https://www.javacodegeeks.com/2014/01/how-to-serialize-an-array-of-doubles-with-a-byte-binary-delta-encoding-for-low-varianced-monotonic-sets-of-floating-point-data.html

    字节数组转为二进制数 c#

    展开全文
  • 遗传算法的编码方法各种各样,但二进制编码方式是最经典的一种,那么它的编码和解码该如何进行呢?或许本博客能给你一个具有参考价值的答案。 编码 经典遗传算法中使用“染色体”来代指个体,它由二进制串组成,...

    前言

    遗传算法的编码方法各种各样,但二进制串编码方式是最经典的一种,那么它的编码和解码该如何进行呢?或许本博客能给你一个具有参考价值的答案。


    编码

    经典遗传算法中使用“染色体”来代指个体,它由二进制串组成,如下图所示:

    它的每一维称为一个基因,取值为0或1。



    下面用一个具体的优化问题来解释个体(染色体)的编码和解码:

    maxmize f(x) = x2+10cos(2πx)+30, 5x5maxmize \ f(x)\ =\ -x^2+10\cos{(2\pi x)}+30,\ -5\le x \le 5

    对于上述待优化函数,我们的编码应该设置多长的二进制串呢?

    我们首先明确,编码长度取决于自变量的范围(更准确点应该是决策变量的范围)搜索精度,所以围绕它们来考虑如何编码。

    在本例,我们假设精度是0.01,记清楚了,是 0.01

    首先,我们可以确定自变量的范围(更准确点应该是决策变量的范围)是5-(-5)= 10.

    另外,我们需要的精度是0.01,也就是说我们要能用我们的编码把自变量范围1010.00表示,但二进制串只能表示整数没法表示小数(其实可以表示小数的,但我们不讨论这种情况),所以我们换个思路,我们用1000来表示10.00,但请注意,二进制串转化为十进制时不能刚好得到1000,而是得到 2n2^n,所以我们得找到一个最大值大于1000的二进制串。
    在这里插入图片描述
    根据上图,我们发现可以用长度为10的二进制串来“容纳”上述的1000,为什么我用“容纳”来表述呢?因为长度为10的二进制串可以表示 0(2101)0 \thicksim (2^{10}-1),也就是 010230 \thicksim 1023,有 1023>10001023>1000;而 0(291)0 \thicksim (2^{9}-1)05110 \thicksim 511, 有 511<1000511<1000 ,所以用1023来表示10.00,编码时二进制串长度为10,而不是9

    由上图公式,我们把初始群体的每个个体用一个长度为10的二进制串来表示,记为:
    A10A9A8...A3A2A1A_{10}A_{9}A_{8}...A_{3}A_{2}A_{1}

    解码

    在上一小节我们用1023来表示10.00,那解码的时候表示1023的二进制串如何表示回10.00呢?

    想想,我们编码时把10.00放大成1023,那么解码时缩小1023倍就行了!

    这样,我们解码的时候做如下处理:
    在这里插入图片描述
    10.00 /10230.009775,我们把解码出来的十进制数都乘以0.009775,就得到了最终结果。

    于是有:

    其中 Lx=5L_x = -5

    xx 就是解码所得十进制数。

    补充

    这里要稍微注意下,实际搜索精度与期望搜索精度之间是存在误差的:

    我们本想用1000来表示10.00的,但由于二进制串只能表示 2n2^n,所以只好用1023来表示10.00,之后在

    这里没法除尽产生了误差。







    参考资料:
    《人工智能及其应用第五版》- 蔡自兴

    展开全文
  • 低延迟系统需要高性能的... 本文介绍的技术是一个很好的例子,说明了如何利用数据的某些方面在延迟和空间复杂度方面使编码受益。 通常,高频交易系统周围传递的最大消息以订单簿摘录的形式表示某种交换状态。 即,...

    低延迟系统需要高性能的消息处理和传递。 由于在大多数情况下,数据必须通过有线传输或进行序列化才能保持持久性,因此编码和解码消息已成为处理管道的重要组成部分。 高性能数据编码的最佳结果通常涉及应用程序数据细节的知识。 本文介绍的技术是一个很好的例子,说明了如何利用数据的某些方面在延迟和空间复杂度方面使编码受益。

    通常,高频交易系统周围传递的最大消息以订单簿摘录的形式表示某种交换状态。 即,典型的市场数据(报价)消息包含标识工具的信息和代表订单簿顶部的一组值。 数据集的强制性成员是以实数表示的价格/汇率信息(用于买卖双方)。

    从优化的角度来看,使该数据集非常有趣的原因是:

    1. 单调的
    2. 低方差
    3. 非负*

    因此,在实践中,我们处理的是浮点数集,这些浮点数不仅经过排序(升序出价和降价要求),而且相邻值彼此相对“接近”。 请记住,消息处理延迟对于大多数交易系统而言至关重要,因此市场行情波动,因为关键实体之一需要尽可能高效地传递。

    让我演示如何利用所有这些功能将数字数据编码为非常紧凑的二进制形式。 首先,两个预告情节说明了不同序列化方法之间的区别:

    图片1

    到目前为止,我们可以看到,与基于标准ByteBuffer的序列化相比,增量编码在编码时间上可获得更好的结果,但是一旦数组长度超过40,它就会比Kryo (最流行的高性能序列化库之一)更差。不过,在这里重要的是一个典型的用例场景,对于高频交易,市场消息恰好适合阵列长度的10-40

    当我们检查生成的消息大小(作为数组长度的函数)时,它会变得更加有趣:

    image2

    此时,应用增量编码的好处将变得显而易见(蓝色曲线同样适用于字节缓冲区和Kryo​​序列化)。 这里发生的是,在掌握了一些有关要处理的数据的特定知识之后,可以安全地做出一些假设,从而导致序列化占用更多的CPU资源,但是在空间方面却效率高得多。 增量压缩背后的想法非常简单。 让我们从一个整数数组开始:

    • [85103、85111、85122、85129、85142、85144、85150、85165、85177]

    如果这些是整数,则不进行任何压缩就必须使用4 * 9 = 36字节来存储数据。 在这组数字中,特别有趣的是它们彼此相对紧密地聚集在一起。 我们可以通过引用第一个值轻松地减少存储数据所需的字节数,然后生成一个对应的增量数组:

    • 参考:85103,[8、19、26、39、41、47、62、74]

    哇! 现在我们可以缩小为字节数组。 让我们再次进行计算。 我们需要4个字节作为参考值(仍为int),每个增量= 8 * 1个字节= 12个字节。

    与原始的36个字节相比,这是一个很大的改进,但仍有一些优化的余地。 与其从参考值计算增量,不如依次存储每个前任的差异:

    • 参考:85103,[8、11、7、13、2、6、15、12]

    结果是一组具有低方差和标准偏差的非单调数字。 我希望事情已经明确了。 尽管如此,还是值得详细说明。

    至此,我们基本上得出的是一个非常适合二进制编码的集合。 对于我们的示例,这仅意味着可以在单个字节中容纳2个增量。 我们只需要一个半字节(4位)即可容纳0-15范围内的值,因此我们可以轻松地最终将原始数组压缩为4(供参考)+ 8 * 1/2 = 8个字节。

    由于价格是用十进制数表示的,因此应用带有二进制编码的增量压缩将涉及建立最大支持的精度并将小数视为整数(将它们乘以10 ^精度),从而使精度为6的1.12345678成为1123456整数。 到目前为止,所有这些都是纯粹的理论推测,本文开头有一些预告片。 我想这是演示如何使用2个非常简单的类在Java中实现这些想法的恰当时机。

    我们将从编码方面开始:

    package eu.codearte.encoder;
    
    import java.nio.ByteBuffer;
    
    import static eu.codearte.encoder.Constants.*;
    
    public class BinaryDeltaEncoder {
    
        public static final int MAX_LENGTH_MASK = ~(1 << (LENGTH_BITS - 1));
    
        public ByteBuffer buffer;
        public double[] doubles;
        public int[] deltas;
        public int deltaSize, multiplier, idx;
    
        public void encode(final double[] values, final int[] temp, final int precision, final ByteBuffer buf) {
            if (precision >= 1 << PRECISION_BITS) throw new IllegalArgumentException();
            if ((values.length & MAX_LENGTH_MASK) != values.length) throw new IllegalArgumentException();
            doubles = values; deltas = temp; buffer = buf;
            multiplier =  Utils.pow(10, precision);
    
            calculateDeltaVector();
            if (deltaSize > DELTA_SIZE_BITS) throw new IllegalArgumentException();
            buffer.putLong((long) precision << (LENGTH_BITS + DELTA_SIZE_BITS) | (long) deltaSize << LENGTH_BITS | values.length);
            buffer.putLong(roundAndPromote(values[0]));
            idx = 1;
            encodeDeltas();
        }
    
        private void calculateDeltaVector() {
            long maxDelta = 0, currentValue = roundAndPromote(doubles[0]);
            for (int i = 1; i < doubles.length; i++) {
                deltas[i] = (int) (-currentValue + (currentValue = roundAndPromote(doubles[i])));
                if (deltas[i] > maxDelta) maxDelta = deltas[i];
            }
            deltaSize = Long.SIZE - Long.numberOfLeadingZeros(maxDelta);
        }
    
        private void encodeDeltas() {
            if (idx >= doubles.length) return;
            final int remainingBits = (doubles.length - idx) * deltaSize;
    
            if (remainingBits >= Long.SIZE || deltaSize > Integer.SIZE) buffer.putLong(encodeBits(Long.SIZE));
            else if (remainingBits >= Integer.SIZE || deltaSize > Short.SIZE) buffer.putInt((int) encodeBits(Integer.SIZE));
            else if (remainingBits >= Short.SIZE || deltaSize > Byte.SIZE) buffer.putShort((short) encodeBits(Short.SIZE));
            else buffer.put((byte) encodeBits(Byte.SIZE));
            encodeDeltas();
        }
    
        private long encodeBits(final int typeSize) {
            long bits = 0L;
            for (int pos = typeSize - deltaSize; pos >= 0 && idx < deltas.length; pos -= deltaSize)
                bits |= (long) deltas[idx++] << pos;
            return bits;
        }
    
        private long roundAndPromote(final double value) {
            return (long) (value * multiplier + .5d);
        }
    }
    

    在详细介绍之前,请先介绍几句话。 该代码不是完整的,成熟的解决方案。 它的唯一目的是演示提高应用程序序列化协议的某些位的难易程度。 由于它受到了微基准测试,它也不会引起gc压力,因为即使是最快的次要gc的影响也会严重扭曲最终结果,从而使api变得丑陋。 该实现也是次优的,尤其是在CPU方面,但是证明微优化不是本文的目标。 话虽如此,让我们看看它的作用(大括号中的行号)。

    编码方法首先进行一些基本的健全性检查{17,18},计算将十进制转换为整数{20}所用的乘数,并计算calculateDeltaVector()。 这又有两个影响。

    1. 通过将小数转换为整数,从前任减去,最后将结果存储在临时数组{33}中,计算整个集合的滚动增量
    2. 作为副作用,得出表示增量{34,36}所需的最大位数

    然后,encode()方法存储正确反序列化所需的一些元数据。 它以位为单位打包精度,增量大小,并以前64位{24}打包数组长度。 然后,它存储参考值{25}并启动二进制编码{27}。

    编码增量执行以下操作:

    1. 检查它是否已经处理了所有数组条目,如果已​​退出则退出{40}
    2. 计算要编码的剩余位数{41}
    3. 选择最合适的类型(给定大小,以位为单位),对剩余的位进行编码,然后将这些位写入缓冲区{43-46}
    4. 递归{47}

    可能需要详细说明的最后一点是encodeBits()方法本身。 根据在参数中传递的类型大小(以位为单位),它会循环一个临时long,其唯一目的是用作位集,并写入代表从long值的最高有效部分到最低有效部分的连续增量的位(范围为字号)。

    正如预期的那样,解码与编码完全相反,并且主要是关于使用元数据来重建原始double数组,直至达到指定的精度:

    package eu.codearte.encoder;
    
    import java.nio.ByteBuffer;
    
    import static eu.codearte.encoder.Constants.DELTA_SIZE_BITS;
    import static eu.codearte.encoder.Constants.LENGTH_BITS;
    
    public class BinaryDeltaDecoder {
    
        private ByteBuffer buffer;
        private double[] doubles;
        private long current;
        private double divisor;
        private int deltaSize, length, mask;
    
        public void decode(final ByteBuffer buffer, final double[] doubles) {
            this.buffer = buffer; this.doubles = doubles;
            final long bits = this.buffer.getLong();
            divisor = Math.pow(10, bits >>> (LENGTH_BITS + DELTA_SIZE_BITS));
            deltaSize = (int) (bits >>> LENGTH_BITS) & 0x3FFFFFF;
            length = (int) (bits & 0xFFFFFFFF);
            doubles[0] = (current = this.buffer.getLong()) / divisor;
            mask = (1 << deltaSize) - 1;
            decodeDeltas(1);
        }
    
        private void decodeDeltas(final int idx) {
            if (idx == length) return;
            final int remainingBits = (length - idx) * deltaSize;
    
            if (remainingBits >= Long.SIZE) decodeBits(idx, buffer.getLong(), Long.SIZE);
            else if (remainingBits >= Integer.SIZE) decodeBits(idx, buffer.getInt(), Integer.SIZE);
            else if (remainingBits >= Short.SIZE) decodeBits(idx, buffer.getShort(), Short.SIZE);
            else decodeBits(idx, buffer.get(), Byte.SIZE);
        }
    
        private void decodeBits(int idx, final long bits, final int typeSize) {
            for (int offset = typeSize - deltaSize; offset >= 0 && idx < length; offset -= deltaSize)
                doubles[idx++] = (current += ((bits >>> offset) & mask)) / divisor;
            decodeDeltas(idx);
        }
    
    }

    带有一些测试类的源代码可以在这里找到。 请记住,即使事实证明该代码可以正常工作,也不适合生产。 您绝对可以使它工作而无需临时阵列,用聪明的方法代替最大阵列大小时,可以代替全阵列扫描,也可以通过采用倒数近似除法而无需进行重量级除法。 随意选择这些提示或进行不同的微优化,并构建自己的专有增量编码协议。 对于对延迟敏感的交易应用程序而言,它具有很大的区别,可将液体工具的市场数据消息大小减小20-30倍。 当然,如果切换到增量压缩二进制编码会对您的应用程序生态系统带来任何价值,那么您必须弄清楚自己。 随便发表您的发现与评论!

    翻译自: https://www.javacodegeeks.com/2014/01/how-to-serialize-an-array-of-doubles-with-a-byte-binary-delta-encoding-for-low-varianced-monotonic-sets-of-floating-point-data.html

    展开全文
  • Python如何读写二进制数组数据,代码,如果你,二进制数,字节,结构Python如何读写二进制数组数据易采站长站,站长之家为您整理了Python如何读写二进制数组数据的相关内容。问题你想读写一个二进制数组的结构化数据到...
  • 一:表示法: 1、正数5的表示法 假设有一个 int 类型的数,值为5,那么,我们知道它在计算机中表示为: 00000000 00000000 00000000...一个负数按照绝对值大小转换成的二进制数,然后最高位补1,称为原码。 比如 000000
  • day2 进制编码

    2019-05-28 18:47:02
    二进制的来源, 之前上初中的时候觉得编程很酷,把自己的YY频道都改成了0101111 即使那时候的自己根本不明白那些0101代表着什么, 学了二进制才知道,0,1这两个数字其实表示的就是电路的两种状态, 开和关, 但...
  • 字节跳动 低延迟系统... 本文中介绍的技术是一个很好的例子,说明了如何利用数据的某些方面在延迟和空间复杂度方面使编码受益。 通常,围绕高频交易系统传递的最大消息以摘录的形式代表某种交易状态。 即,典型的...
  • 二进制数的编码表示

    千次阅读 2017-08-02 14:50:37
    二进制数的编码表示  需要解决的问题:负数如何表示?  最容易想到的方案: 0:表示“+”号; 1:表示“-”号。  原码  "符号──绝对值"表示的编码 例如:  原码的缺点:  零的表示不惟一  进行四则...
  • 遗传算法求三元函数极值(python)-采用二进制编码 ...这里,我们仍然使用二进制编码,但是如何与我们的问题对应起来呢? 我们知道二进制很容易转十进制,再区间压缩以下,这样一个DNA和一个解一一映射。 def translat...
  • 经常要与多种进制打交道,例如配置个子网啥子的,就需要将10进制进转换,但对于在GNU Linux的命令行模式下的操作来说,就不是如可视界面下的科学计算器那么安逸了,那么如何在shell下进行多种进制间的转换呢?...
  • BaseXX的主要目标是对basenc进行改进,并了解不同的二进制到文本编码方案如何在basenc 。 安装 使用标准协议./configure , make和sudo make install应该够这个包安装到您的计算机。 否则,请参阅提供的文件以获取...
  • 采石场与二进制石燕岩是古南海县重要的采石场,数百年来,人们通过种种方式开采石燕岩里的石头,用来建设南海县的城市乡村。石燕岩的采石遗址,是本文的线索数百年之后,...但是这个假想,其实就是一种二进制编码的...
  • 不管是在内存中,还是文件中,还是网络传输中,计算机运算和存储的都只能是二进制。 内码是程序内部使用的字符编码,特别是某种语言实现其char或String类型在内存里用的内部编码;外码是程序与外部交互时外部使用...
  • 下面是一段示例代码将一个Python元组列表写入一个二进制文件,并使用 struct 将每个元组编码为一个结构体。from struct import Structdef write_records(records, format, f):'''Write a sequence of ...
  • 初学Python写二进制文件把一个图片的16进制数据保存到一个txt文本,从这个txt文本读出并保存为二进制文件jpg图片文件。说明:图片读出的0xff粘贴ff到文本中,读出时是字符串的”ff”。我主要是用C语言,python为初学...
  • 二进制转换二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一”,借位规则是“借一当二”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机...
  • 因为二进制编码的数据我要得到的也是byte[]就不用二次转了,重点就是如何判断指针的初始位置。 //对于一行一行的 public void parseHead(string path) { StreamReader sr = new StreamReader(path); int i = 0; ...
  • 转换入参字符串waitForSignString 为二进制数组,编码采用UTF-8(Java代码如:waitForSignString.getByte(“utf-8”)),得到签名入参的二进制格式数据(waitForSignBytes)。使用MD5,Sha1或Sha256算法对waitForSignBytes...
  • 如果一定要处理的话,只能使用charCodeAt()方法,一个个字节地从文字编码转成二进制数据,还有一种办法是将二进制数据转成Base64编码,再进行处理。这两种方法不仅速度慢,而且容易出错。ECMAScript5引入了Blob对象...
  • 在本地用Typora写好的。传图片比较麻烦,就直接截图上传了。
  • 从最基础的莫尔斯编码二进制,基础电路和布尔逻辑运算的神奇结合。产生了目前人类最伟大的发明-计算机。二进制(binary)二进制的提出者是德国数学家莱布尼茨,他和牛顿发现了高等数学中的微积分。用二进制记数只...
  • 下面是一段示例代码将一个Python元组列表写入一个二进制文件,并使用 struct 将每个元组编码为一个结构体。 from struct import Struct def write_records(records, format, f): ''' Write a sequence of tuples...
  • 众所周知,计算机上的的数据都是以二进制方式存储,哪二进制如何以字符显示在显示器上呢?如下图所示: 例如:a在ascii码中用二进制编码01100001表示 16进制61h表示,我们用键盘输入一个a,计算机把a放入...
  • 如何用vim编辑二进制文件

    千次阅读 2019-05-05 16:45:28
    1、"vim -b <FileName>" 打开二进制文件(这种方式可防止vim擅自在文件尾部加上0x0a) ...xxd”,将二进制编码转成十六进制进行编辑。 3、“:%!xxd -r”,将十六进制转回二进制编码并保存即可完成编辑。 ...
  • <p>I have a PHP script encoded with Zend Guard, when I view it with sublime text or notepad++ it ... ... <p>I think this shouldn't be how it looks, What should I change to view in binary format? </div>
  • 二进制核心思想: 冯诺依曼 + 图灵机电如何表示状态,才能稳定? 计算机开始设计的时候并不是考虑简单,而是考虑能自动完成任务与结果的可靠性, 简单始终是建立再稳定、可靠基础上 经过尝试10进制,但很难检查...
  • 需求是这样的:我要把一个图片用webservice发布出去,流程 图片---》二进制---》字符串---》调用webserivce接口---》字符串---》二进制---》图片。不能直接发布二进制接口,因为客户端不支持。 现在遇到的问题是...
  • Java对文本I/O提供自动编码与解码在文本文件中存储的数据是以人能读懂的方式表示的,而在二进制文件中存储的数据是用二进制形式来表示的。人读不懂二进制文件,它们是为程序读取而设计的。例如,Java源程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,643
精华内容 657
关键字:

二进制如何编码