Generate a deterministic random number from a timestamp - random

Question

I’m generating IDs with a timestamp part (48 bits) and a random part (80 bits) so that the IDs are ordered but don’t clash. When serializing the IDs to a human readable format I want the IDs to appear random. The serialization will need to be reversible since I need to deserialize an ID back into its ordered timestamp/random form.
I don’t need the serialization to be secure, it’s ok if it’s easily reverse-engineered, I just want the appearance of a randomly generated ID.
Example of some IDs in hexadecimal that I want to encode:
16CF304F7B3D5CBED3977C90DD6F5
16CF30578DCBCF35A0585A4FF6DE0
16CF30599F53BB7E61791824D6345
Because of the ID format, I need an approach that will work on 128 bit values.

Answer 1

Since the lowest bits are random, here's a very fast solution:
fn mix (x: u128) -> u128 {
(x << 64) ^ x
}
playground
The function is its own reverse, so mix (mix (x)) == x.

Answer 2

Well, you could construct 128bit LCG. With proper constants (see here for details) it would map one 128bit value into another. Also, LCG support bijective mapping, so from result you could recover previous value.
Some (untested) C code, GCC or Clang
const unsigned __int128 a = 52583122484843402430317208685168068605;
const unsigned __int128 c = 1;
unsigned __int128 next(unsigned __int128 xprev) {
return a*xprev + c;
}
Mapping guaranteed to be unique and bijective. If this is what you want, I'll dig out and post my reversal code.
In Javascript, 128bit LCG as direct mapper would look like
const WIDTH = 2n ** 128n;
const MASK = WIDTH - 1n; // to keep things as 128bit values
const a = 52583122484843402430317208685168068605n; // see L'Ecuyer paper
const c = 1n; // see L'Ecuyer paper
function direct(xprev) { // takes BigInt argument
return (a*xprev + c) & MASK; // same as % WIDTH
}
console.log(direct(BigInt('0x16CF304F7B3D5CBED3977C90DD6F5')))
console.log(direct(BigInt('0x16CF30578DCBCF35A0585A4FF6DE0')))
console.log(direct(BigInt('0x16CF30599F53BB7E61791824D6345')))
which produced the output (Win 10 x64, Node 12.7)
128874473614597675792465454982924903202n
316384656665826187699254518510547678817n
104036942349128451345253863137794883122n
UPDATE
Digged out my skip code and converted it to Javascript
const WIDTH = 2n ** 128n;
const MASK = WIDTH - 1n; // to keep things as 128bit values
const a = 52583122484843402430317208685168068605n; // see L'Ecuyer paper
const c = 1n; // see L'Ecuyer paper
function direct(xprev) { // takes BigInt argument
return (a*xprev + c) & MASK; // same as % WIDTH
}
// Signed argument - skip forward as well as backward
// The algorithm here to determine the parameters used to skip ahead is
// described in the paper F. Brown, "Random Number Generation with Arbitrary Stride,"
// Trans. Am. Nucl. Soc. (Nov. 1994). This algorithm is able to skip ahead in
// O(log2(N)) operations instead of O(N). It computes parameters
// A and C which can then be used to find x_N = A*x_0 + C mod 2^M.
function skip(x, ns) { // takes BigInt argument
let nskip = BigInt(ns);
let aa = a;
let cc = c;
let a_next = 1n;
let c_next = 0n;
while (nskip > 0n)
{
if ((nskip & 1n) != 0n) {
a_next = (a_next * aa) & MASK;
c_next = (c_next * aa + cc) & MASK;
}
cc = ((aa + 1n) * cc) & MASK;
aa = (aa * aa) & MASK;
nskip = nskip >> 1n;
}
return (a_next * BigInt(x) + c_next) & MASK;
}
function inverse(x) {
return skip(x, MASK);
}
console.log(direct(BigInt('0x16CF304F7B3D5CBED3977C90DD6F5')));
console.log(direct(BigInt('0x16CF30578DCBCF35A0585A4FF6DE0')));
console.log(direct(BigInt('0x16CF30599F53BB7E61791824D6345')));
console.log('\n');
q = BigInt('0x16CF304F7B3D5CBED3977C90DD6F5');
console.log(q);
r = direct(q);
console.log(r);
t = inverse(r);
console.log(t);
Last three prints produced
7402051076614138449931424144152309n
128874473614597675792465454982924903202n
7402051076614138449931424144152309n