Java Perlin noise implementation I've decided to code Perlin noise generator in Java. It works pretty well, I just want to know If I am doing everything right and if it is a valid implementation!

PS : The metaVector2f and metaVector2i are just 2D vector classes

public float[][] generate(long seed, metaVector2i size, metaVector2i gridSize) {
    Random rand = new Random(seed);
    metaVector2f[][] gvectors = new metaVector2f[gridSize.x][gridSize.y];

    for (int y = 0; y &lt; gridSize.y; y++)
        for (int x = 0; x &lt; gridSize.x; x++)
            gvectors[x][y] = new metaVector2f(rand.nextFloat(),rand.nextFloat());

    float[][] data = new float[size.x][size.y];

    for (int y = 0; y &lt; size.y; y++)
        for (int x = 0; x &lt; size.x; x++) {
            data[x][y] = perlinPoint(new metaVector2f(x/(float)(size.x/gridSize.x),y/(float)(size.y/gridSize.y)), gvectors);
        }

    return data;
}

private float perlinPoint(metaVector2f position, metaVector2f[][] gvectors) {

    int x0 = (int)position.x;
    int y0 = (int)position.y;
    int x1 = (int)position.x+1;
    int y1 = (int)position.y+1;

    float dx0 = position.x-x0;
    float dy0 = position.y-y0;

    float dx1 = position.x-x1;
    float dy1 = position.y-y1;

    float h1 = dotProduct(new metaVector2f(dx0, dy0), gvectors[x0%gvectors.length][y0%gvectors[0].length]);
    float h2 = dotProduct(new metaVector2f(dx1, dy0), gvectors[x1%gvectors.length][y0%gvectors[0].length]);
    float fin1 = lerp(h1, h2, dx0);

    float v1 = dotProduct(new metaVector2f(dx0, dy1), gvectors[x0%gvectors.length][y1%gvectors[0].length]);
    float v2 = dotProduct(new metaVector2f(dx1, dy1), gvectors[x1%gvectors.length][y1%gvectors[0].length]);
    float fin2 = lerp(v1, v2, dx0);

    return lerp(fin1,fin2,dy0);

}

private float lerp(float x, float y, float t) {
    return (1.0f - t)*x + t*y;
}

private float dotProduct(metaVector2f vec, metaVector2f grad) {
    return vec.x*grad.x+vec.y*grad.y;
}


Here is the output (value/2+0.5f) :
Consider warmwaffle's code at GitHub (re: https://github.com/warmwaffles/Noise).  The one difference I see between the two solutions is how the 'metaVector2f's are created.  Your code is using non-repeatable random numbers; whereas, the other uses a mathematical calculation which includes prime numbers and bit shifting operations.  The latter would produce a repeatable solution with the same seed versus yours.  This may be worth something if you're testing or troubleshooting elsewhere.