NoiseGeneraton3 C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#define A_ASDF sqrt(3.00)

typedef struct {
    double b, c, d;
    int f[512];
} NoiseGenerator3Handler;
typedef struct {
    int b;
    NoiseGenerator3Handler a[];
} NoiseGenerator3;


void NG3Hinit (NoiseGenerator3Handler *ptr, int x),
     NG3init (NoiseGenerator3 *ptr, int i);
int NG3Hrand_interval (int max),
    NG3Ha0 (double d0);
double NG3Ha1 (int *aint, double d0, double d1),
       NG3Ha2 (NoiseGenerator3Handler *ptr, double d0, double d1);


int e[12][3] = { { 1, 1, 0}, { -1, 1, 0}, { 1, -1, 0}, { -1, -1, 0},
                        { 1, 0, 1}, { -1, 0, 1}, { 1, 0, -1}, { -1, 0, -1},
                        { 0, 1, 1}, { 0, -1, 1}, { 0, 1, -1}, { 0, -1, -1}
                      };
double g = 0.50 * (A_ASDF - 1.00),
       h = (3.00 - A_ASDF) / 6.00;


void NG3Hinit (NoiseGenerator3Handler *ptr, int x) {
    for(int y = 0; y < x; y++) {
        ptr->b = rand()/(RAND_MAX + 1.) * 256.00;
        ptr->c = rand()/(RAND_MAX + 1.) * 256.00;
        ptr->d = rand()/(RAND_MAX + 1.) * 256.00;

        int i;

        for (i = 0; i < 256; ++i) {
            int j = NG3Hrand_interval(256 - i) + i;
            int k = ptr->f[i];

            ptr->f[i] = ptr->f[j];
            ptr->f[j] = k;
            ptr->f[256 + i] = ptr->f[i];
        }
        ptr++;
    }
}

int NG3Hrand_interval(int max)
{
    int r;
    unsigned int y = max;
    const unsigned int range = 1 + y,
                       buckets = RAND_MAX / range,
                       limit = buckets * range;

    /* Create equal size buckets all in a row, then fire randomly towards
     * the buckets until you land in one of them. All buckets are equally
     * likely. If you land off the end of the line of buckets, try again. */
    do { r = rand(); } while (r >= limit);

    unsigned int z = (r / buckets);
    return (int)r;
}

int NG3Ha0 (double d0) {
    return d0 > 0.00 ? (int)d0 : (int)d0 - 1;
}

double NG3Ha1 (int *aint, double d0, double d1) {
    int x = aint[0], y = aint[1];
    return (double) (x * d0) + (y * d1);
}

double NG3Ha2 (NoiseGenerator3Handler *ptr, double d0, double d1) {
    double d2 = 0.50 * (A_ASDF - 1.00);
    double d3 = (d0 + d1) * d2;
    int i = NG3Ha0(d0 + d3);
    int j = NG3Ha0(d1 + d3);
    double d4 = (3.00 - A_ASDF) / 6.00;
    double d5 = (double) (i + j) * d4;
    double d6 = (double) i - d5;
    double d7 = (double) j - d5;
    double d8 = d0 - d6;
    double d9 = d1 - d7;
    unsigned char b0, b1;

    if (d8 > d9) {
        b0 = 1;
        b1 = 0;
    } else {
        b0 = 0;
        b1 = 1;
    }

    double d10 = d8 - (double) b0 + d4;
    double d11 = d9 - (double) b1 + d4;
    double d12 = d8 - 1.00 + 2.00 * d4;
    double d13 = d9 - 1.00 + 2.00 * d4;
    int k = i & 255;
    int l = j & 255;
    int i1 = ptr->f[k + ptr->f[1]] % 12;
    int j1 = ptr->f[k + b0 + ptr->f[l + b1]] % 12;
    int k1 = ptr->f[k + 1 + ptr->f[l + 1]] % 12;
    double d14 = 0.50 - d8 * d8 - d9 * d9;
    double d15;

    if (d14 < 0.00) {
        d15 = 0.00;
    } else {
        d14 *= d14;
        d15 = d14 * d14 * NG3Ha1(e[i1], d8, d9);
    }

    double d16 = 0.50 - d10 * d10 - d11 * d11;
    double d17;

    if (d16 < 0.00) {
        d17 = 0.00;
    } else {
        d16 *= d16;
        d17 = d16 * d16 * NG3Ha1(e[j1], d10, d11);
    }

    double d18 = 0.50 - d12 * d12 - d13 * d13;
    double d19;

    if (d18 < 0.00) {
        d19 = 0.00;
    } else {
        d18 *= d18;
        d19 = d18 * d18 * NG3Ha1(e[k1], d12, d13);
    }

    return 70.00 * (d15 + d17 + d19);
}

void NG3init (NoiseGenerator3 *ptr, int i) {
    srand((unsigned)time(NULL));
    NoiseGenerator3 *x = (NoiseGenerator3*) malloc(sizeof(NoiseGenerator3) + i * sizeof(NoiseGenerator3Handler));
    ptr->b = i;
    NG3Hinit(ptr->a, i);

    x = ptr;
}


int main()
{
    NoiseGenerator3 *test;
    NG3init(test, 3);

    return 0;
}