Weird code

>>59074604

its gibberish

whoever made this should get shot

>>59074645
I know its not gibberish. It generates intelligible output.

>>59074604
Bump!

Someone must be able to understand at least a bit about it.

I know that rdrand64_step generates hardware random values.

I think eatPie takes a float and subtracts a portion of pi from it.

>>59074734
The first part of the main is calculating a histogram of random numbers, with the added wrinkle that for each step it generates two random numbers and only counts the larger of the two numbers in the histogram. I'm not sure why you would do this...maybe a test of the reliability of your random number generator?

I'm too lazy to walk through the eatPie function, but I'm pretty sure it has nothing to do with pi.

>>59075134
*smaller of the two numbers

File: giphy-37.gif (4MB, 480x270px) Image search: [Google]

4MB, 480x270px

>>59075134
Oh yeah I think I remember what I was doing with it.
I think it was meant to test probabilities. When you add two probability maps or something then you get a certain bias in the outcome and I wanted to see what that looked like with random data.

No idea why I wrote it in such a convoluted manner.

Thanks.

File: 1477589869039.gif (2MB, 500x500px) Image search: [Google]

2MB, 500x500px

>>59075455

>>59074645
This. Needlessly difficult-to-read code and an obvious amateur trying to look sophisticated.

>>59075824
>amateur trying to look sophisticated
wtf bro.

It was some private code I put together to test what probability outcomes would look like.

When I wrote it I was just testing something so I knew what it was doing and didn't put any effort into layout/comprehension. I stumbled upon it just now and couldn't figure what it was about.

>>59075824
Here's one for you. Try to figure out how this code works.

/******************************************************************************/

static int sprp (uint64_t n, uint64_t a)
{
    uint64_t m = n - 1, r, y;
    unsigned int s = 1, j;

    /* assert(n > 2 && (n & 0x1) != 0); */

    while ((m & (UINT64_C(1) << s)) == 0) s++;
    r = m >> s; /* r, s s.t. 2^s * r = n - 1, r in odd. */

    if ((a %= n) == 0) /* else (0 < a < n) */
        return (1);

    {
        unsigned __int128 u = 1, w = a;

        while (r != 0)
        {
            if ((r & 0x1) != 0)
                u = (u * w) % n; /* (mul-rdx) */

            if ((r >>= 1) != 0)
                w = (w * w) % n; /* (sqr-rdx) */
        }

        if ((y = (uint64_t) u) == 1)
            return (1);
    }

    for (j = 1; j < s && y != m; j++)
    {
        unsigned __int128 u = y;
        u = (u * u) % n; /* (sqr-rdx) */

        if ((y = (uint64_t) u) <= 1) /* (n) is composite: */
            return (0);
    }

    return (y == m);
}

/******************************************************************************/

static int is_prime (uint64_t n)
{
    const uint32_t sprp32_base[] = /* (Jaeschke) */ {
        2, 7, 61, 0};

    const uint32_t sprp64_base[] = /* (Sinclair) */ {
        2, 325, 9375, 28178, 450775, 9780504, 1795265022, 0};

    const uint32_t *sprp_base;

    /* assert(n > 1); */

    if ((n & 0x1) == 0) /* even: */
        return (n == 2);

    sprp_base = (n <= UINT32_MAX) ? sprp32_base : sprp64_base;

    for (; *sprp_base != 0; sprp_base++)
        if (!sprp(n, *sprp_base)) return (0);

    return (1); /* prime. */
}

/******************************************************************************/

>>59075963
>2^64
why even bother checking the primality of such tiny numbers? Go bigint or go home

>>59075455
>>59075912
Write comments next time fag. Especially if it is your code.

>>59074887
Wtf

Please, this is baby stuff.

Try to parse this, if you want to test your C comprehension:

http://pastebin.com/GQPnUi7d

What is the tripcode algorithm?

>>59079521

>>59079537

>>59079557

>>59078972
Is he okay