Variable-length quantity: Difference between revisions

Implement some operations on [[wp:Variable-length quantity|variable-length quantities]], at least including conversions from a normal number in the language to the binary representation of the variable-length quantity for that number, and ''vice versa''. Any variants are acceptable.

 

*convert these two numbers 0x200000 (2097152 in decimal) and 0x1fffff (2097151 in decimal) into sequences of octets (an eight-bit byte);

*display these sequences of octets;

*convert these sequences of octets back to numbers, and check that they are equal to original numbers.

 

=={{header|Ada}}==

 

with Ada.Text_IO;

with Ada.Unchecked_Conversion;

Nat_IO.Put (To_Int (Test), 10, 16); Ada.Text_IO.Put (" = ");

Print (Test);

 

Output:

16#1FFFFF# = :16#FF#:16#FF#:16#7F#

16#200000# = :16#81#:16#80#:16#80#: 16#0#</pre>

 

=={{header|C}}==

#include <stdint.h>

 

 

return 0;

seq from 4000: [ 81 80 00 ] back: 4000

seq from 0: [ 00 ] back: 0

seq from 1fffff: [ ff ff 7f ] back: 1fffff

seq from 200000: [ 81 80 80 00 ] back: 200000

 

 

This implements a Variable-length Quantity struct for an ulong integer.

 

 

while ((idx < limit) && ((v[idx] & 0x80) > 0))

else

}

}

}

}

 

 

 

<pre>a: 7f = (7F)

b: 4000 = (81:80:00)

c: 0 = (00)

a: 3ffffe = (81:FF:FF:7E)

b: 1fffff = (FF:FF:7F)

c: 200000 = (81:80:80:00)

1: 3ffffe = (81:FF:FF:7E)

2: 1fffff = (FF:FF:7F)

3: 200000 = (81:80:80:00)</pre>

 

=={{header|Euphoria}}==

sequence s

s = {}

s = vlq_encode(testNumbers[i])

printf(1, "#%02x -> %s -> #%02x\n", {testNumbers[i], svlg(s), vlq_decode(s)})

 

Output:

#80 -> #81:#00 -> #80

</pre>

=={{header|Go}}==

Go has an implementation of variable length quantities in the standard library.

 

import (

fmt.Println(x, "decoded")

}

Output required by task:

<pre>

=={{header|Groovy}}==

Solution:

final MASK = 2**RADIX - 1

(n << RADIX) + ((int)(octet) & MASK)

}

 

Test (samples borrowed from [[Java]] example):

testNumbers.each { a ->

def a1 = deoctetify(octets)

assert a1 == a

 

Output:

0x81 0x00

0x91 0x94 0xf2 0x84 0x9c 0x0a</pre>

 

=={{header|Icon}} and {{header|Unicon}}==

every i := 2097152 | 2097151 | 1 | 127 | 128 | 589723405834 | 165 | 256 do

write(image(i)," = ",string2hex(v := uint2vlq(i))," = ",vlq2uint(v))

h ||:= "0123456789abcdef"[i/16+1] || "0123456789abcdef"[i%16+1]

return h

 

Output:<pre>2097152 = 81808000 = 2097152

=={{header|J}}==

 

v2i=: (N&| N&#./.~ [: +/\ _1 |. N&>)@i.~&a.

i2v=: a. {~ [:;}.@(N+//.@,:N&#.inv)&.>

ifv=: v2i :. i2v

 

<code>ifv</code> is an invertible function which gets an (unsigned, arbitrary precision) integer sequence from a variable-length quantity sequence. <code>vfi</code> is an invertable function which gets a variable-length quantity sequence from an unsigned integer sequence. <code>av</code> displays character code numbers corresponding to the characters in its argument.

Example use:

 

av vlq=: vfi numbers

127 129 128 0 0 129 255 255 126 255 255 127 140 154 64

av (vfi 1 2 3 4 5 6) +&.ifv vlq

 

=={{header|Java}}==

 

{

public static byte[] encode(long n)

}

}

 

Output:

Original input=128, encoded = [81, 00], decoded=128, OK

Original input=589723405834, encoded = [91, 94, f2, 84, 9c, 0a], decoded=589723405834, OK</pre>

 

=={{header|OCaml}}==

let a, b = n lsr 7, n land 0x7F in

let rec aux n acc =

v_rep 0x200000;

v_rep 0x1FFFFF

 

Outputs:

2097152 -> 0x81 0x80 0x80 0x00 -> 2097152

2097151 -> 0xFF 0xFF 0x7F -> 2097151</pre>

 

=={{header|Perl}}==

The vlg_encode sub returns an array of octets in most -> least significant order. Simply reverse the array to reverse the order.

 

use warnings;

use strict;

return oct '0b' . $num;

}

 

Output:

2097152 81:80:80:00 2097152

</pre>

 

 

 

<pre>

</pre>

 

=={{header|PicoLisp}}==

(let Res (cons (& Num 127))

(while (gt0 (setq Num (>> 7 Num)))

(for Num (0 15 16 127 128 255 2097151 2097152)

(let Vlq (numToVlq Num)

Output:

<pre> 0 0 0

 

=={{header|PL/I}}==

test: procedure options(main);

declare s character (20) varying;

put skip list (hs);

end test;

OUTPUT:

<pre>

When transmitting the Vlq, octets are sent from the rightmost of the Vlq first.

 

'Express n as binary bits with separator'

bits = '{0:b}'.format(n)[::-1]

def vlqsend(vlq):

for i, byte in enumerate(vlq.split('_')[::-1]):

 

<br>'''Sample Output'''

The underscore separates groups of eight bits (octets), for readability

print('int: %7i bin: %26s vlq: %35s vlq->int: %7i' % (n, tobits(n,_pad=True), tovlq(n), toint(tovlq(n))))

 

Sent byte 1: 0xff

Sent byte 2: 0x7f

 

 

 

 

 

 

</pre>

 

Array#pack can encode the ''BER-compressed integer'', which is identical to the ''variable-length quantity'' from the [http://sander.vanzoest.com/talks/2002/audio_and_apache/midispec.html MIDI specification]. String#unpack can decode it.

 

# Encode i => BER

ber = [i].pack("w")

j = ber.unpack("w").first

i == j or fail "BER not preserve integer"

 

<pre>2097152 => 81:80:80:00

 

=={{header|Scala}}==

def encode(x:Long)={

val result=scala.collection.mutable.Stack[Byte]()

xs foreach test

}

Output:

<pre>0x0 => [00] => 0x0

The example below uses [http://seed7.sourceforge.net/libraries/bigint.htm bigInteger] numbers,

since variable-length quantities are able to represent integer numbers of unlimited size.

include "bigint.s7i";

write("sequence from " <& testValue <& ": [ ");

for element range sequence do

end for;

writeln("] back: " <& fromSequence(sequence));

end for;

 

Output:

sequence from 2097151: [ ff ff 7f ] back: 2097151

sequence from 2097152: [ 81 80 80 00 ] back: 2097152

</pre>

 

=={{header|Tcl}}==

 

proc vlqEncode number {

}

return $n

Demo code:

binary scan [string trimleft [binary format W $num] \0] H* hexEncoded

regsub -all "..(?=.)" $hexEncoded "&:"

[strtohex $encoded] ([string length $encoded] bytes) ==>\

$decoded"

Output:

<pre>

12345678901234566789 (ab:54:a9:8c:eb:1f:06:85) ==> 81:ab:aa:aa:b1:ce:d8:fc:8d:05 (10 bytes) ==> 12345678901234566789

</pre>