Oauth requires a random 64-bit, unsigned number encoded as an ASCII string in decimal format. Can you guys help me achieve this with php? Thanks

## Answers

SymPy can calculate arbitrary precision:

```
from sympy import exp, N, S
from sympy.matrices import Matrix
data = [[S("-800.21"),S("-600.00")],[S("-600.00"),S("-1000.48")]]
m = Matrix(data)
ex = m.applyfunc(exp).applyfunc(lambda x:N(x, 100))
vecs = ex.eigenvects()
print vecs[0][0] # eigen value
print vecs[1][0] # eigen value
print vecs[0][2] # eigen vect
print vecs[1][2] # eigen vect
```

output:

```
-2.650396553004310816338679447269582701529092549943247237903254759946483528035516341807463648841185335e-261
2.650396553004310816338679447269582701529092549943247237903254759946483528035516341807466621962539464e-261
[[-0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999994391176386872]
[ 1]]
[[1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000560882361313]
[ 1]]
```

you can change 100 in N(x, 100) to other precision, but, as I tried 1000, the calculation of eigen vect failed.

The warning from your compiler is telling you that your format specifier doesn't match the data type you're passing to it.

Try using `%lx`

or `%llx`

. For more portability, include `inttypes.h`

and use the `PRIx64`

macro.

For example: `printf("val = 0x%" PRIx64 "n", val);`

(note that it's string concatenation)

This could be a solution, without multiplication:

```
r30 = RAND_MAX*rand()+rand()
s30 = RAND_MAX*rand()+rand()
t4 = rand() & 0xf
res = (r30 << 34) + (s30 << 4) + t4
```

*what exactly is arbitrary-precision math?*

Arbitrary precision arithmetic aka "bignum math", introduces a way of performing arithmetic operations on numbers which number of digits are only limited by the amount of memory available. This is in departure with the *fixed precision arithmetic* which is afforded by the CPUs/ALUs of the host systems and where the maximum size/precision of the number represented is a factor of the number of bits of the registers of these hardware processors.

Fixed precision arithmetic is fast, efficient with regards to storage and it is built-in/universally available. It is however applicable to limited (if only sometimes "big enough") numerical ranges. Arbitrary precision arithmetic is slower, somewhat wasteful of the storage and requires specialized libraries such as GMP or BCMath.

*what are the differences between the BCMath and GMP libraries*

The most salient difference is that GMP works on [arbitrary precision] *integer* values, whereby BCMath allows [arbitrary precision] *decimal* / float-like values.

Neither API is hard to learn, but BCMath may be a bit more intuitive (in addition to support float-like values)

One's selection of a particular library over another one is typically driven by the intended use (or by the availability on a given platform). Until you get heavily into MP applications, most library will fit the bill and be generally equivalent (within its class of course, i.e. avoid integer-only library if you need floating point numbers).

*what type of numbers BCMath/GMP takes?*

As with most arbitrary precision math packages, these two libraries use strings for their API, i.e. to represent their input and output numeric values.

Internally... Some packages like GMP have their own representation for the numbers. The specific of such structures is typically a compromise between minimizing storage requirements and allowing fast computations (including that of "serializing/deserializing" such structures to/from text files.)

The example `"x12x23x45x67"`

in the question is known as **BCD** i.e. Binary Coded Decimal. It allows storing 2 decimal digits per byte and is sometimes used by Arbitrary Precision Arithmetic libraries.

You could use two 32-bit numbers, four 16-bit numbers, etc.

PHP has rand() and and mt_rand() but how many random bits they supply isn't specified by the standard (though they can be queried with the help of getrandmax() and mt_getrandmax(), respectively.)

So your

~~safest~~simplest bet would be generating 64 random bits and setting them one by one.As for working with 64-bit integers, I'd recommend using the GMP library as it has a good range of functions to help you out.

You could create a number, call 64 gmp_setbit()s on it with successive positions then convert it to a string using gmp_strval().