Improved Perlin Noise Implementation in C#

Perlin.cs

public class Perlin {

	public static double OctavePerlin(double x, double y, double z, int octaves, double persistence) {
		double total = 0;
		double frequency = 1;
		double amplitude = 1;
		for(int i=0;i<octaves;i++) {
			total += perlin(x * frequency, y * frequency, z * frequency) * amplitude;
			
			amplitude *= persistence;
			frequency *= 2;
		}
		
		return total;
	}
	
	private static readonly int[] permutation = { 151,160,137,91,90,15,					// Hash lookup table as defined by Ken Perlin.  This is a randomly
		131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,	// arranged array of all numbers from 0-255 inclusive.
		190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
		88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
		77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
		102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
		135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
		5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
		223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
		129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
		251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
		49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
		138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
	};
	
	private static readonly int[] p; 													// Doubled permutation to avoid overflow
	
	static Perlin() {
		p = new int[512];
		for(int x=0;x<512;x++) {
			p[x] = permutation[x%256];
		}
	}
	
	public static double perlin(double x, double y, double z) {
		if(repeat > 0) {									// If we have any repeat on, change the coordinates to their "local" repetitions
			x = x%repeat;
			y = y%repeat;
			z = z%repeat;
		}
		
		int xi = (int)x & 255;								// Calculate the "unit cube" that the point asked will be located in
		int yi = (int)y & 255;								// The left bound is ( |_x_|,|_y_|,|_z_| ) and the right bound is that
		int zi = (int)z & 255;								// plus 1.  Next we calculate the location (from 0.0 to 1.0) in that cube.
		double xf = x-(int)x;								// We also fade the location to smooth the result.
		double yf = y-(int)y;
		double zf = z-(int)z;
		double u = fade(xf);
		double v = fade(yf);
		double w = fade(zf);
		
		int a  = p[xi]  +yi;								// This here is Perlin's hash function.  We take our x value (remember,
		int aa = p[a]   +zi;								// between 0 and 255) and get a random value (from our p[] array above) between
		int ab = p[a+1] +zi;								// 0 and 255.  We then add y to it and plug that into p[], and add z to that.
		int b  = p[xi+1]+yi;								// Then, we get another random value by adding 1 to that and putting it into p[]
		int ba = p[b]   +zi;								// and add z to it.  We do the whole thing over again starting with x+1.  Later
		int bb = p[b+1] +zi;								// we plug aa, ab, ba, and bb back into p[] along with their +1's to get another set.
															// in the end we have 8 values between 0 and 255 - one for each vertex on the unit cube.
															// These are all interpolated together using u, v, and w below.
		
		double x1, x2, y1, y2;
		x1 = lerp(	grad (p[aa  ], xf  , yf  , zf),			// This is where the "magic" happens.  We calculate a new set of p[] values and use that to get
					grad (p[ba  ], xf-1, yf  , zf),			// our final gradient values.  Then, we interpolate between those gradients with the u value to get
					u);										// 4 x-values.  Next, we interpolate between the 4 x-values with v to get 2 y-values.  Finally,
		x2 = lerp(	grad (p[ab  ], xf  , yf-1, zf),			// we interpolate between the y-values to get a z-value.
					grad (p[bb  ], xf-1, yf-1, zf),
					u);										// When calculating the p[] values, remember that above, p[a+1] expands to p[xi]+yi+1 -- so you are
		y1 = lerp(x1, x2, v);								// essentially adding 1 to yi.  Likewise, p[ab+1] expands to p[p[xi]+yi+1]+zi+1] -- so you are adding
															// to zi.  The other 3 parameters are your possible return values (see grad()), which are actually
		x1 = lerp(	grad (p[aa+1], xf  , yf  , zf-1),		// the vectors from the edges of the unit cube to the point in the unit cube itself.
					grad (p[ba+1], xf-1, yf  , zf-1),
					u);
		x2 = lerp(	grad (p[ab+1], xf  , yf-1, zf-1),
		          	grad (p[bb+1], xf-1, yf-1, zf-1),
		          	u);
		y2 = lerp (x1, x2, v);
		
		return (lerp (y1, y2, w)+1)/2;						// For convenience we bound it to 0 - 1 (theoretical min/max before is -1 - 1)
	}
	
	public static double grad(int hash, double x, double y, double z) {
		int h = hash & 15;									// Take the hashed value and take the first 4 bits of it (15 == 0b1111)
		double u = h < 8 /* 0b1000 */ ? x : y;				// If the most signifigant bit (MSB) of the hash is 0 then set u = x.  Otherwise y.
		
		double v;											// In Ken Perlin's original implementation this was another conditional operator (?:).  I
															// expanded it for readability.
		
		if(h < 4 /* 0b0100 */)								// If the first and second signifigant bits are 0 set v = y
			v = y;
		else if(h == 12 /* 0b1100 */ || h == 14 /* 0b1110*/)// If the first and second signifigant bits are 1 set v = x
			v = x;
		else 												// If the first and second signifigant bits are not equal (0/1, 1/0) set v = z
			v = z;
		
		return ((h&1) == 0 ? u : -u)+((h&2) == 0 ? v : -v); // Use the last 2 bits to decide if u and v are positive or negative.  Then return their addition.
	}
	
	public static double fade(double t) {
															// Fade function as defined by Ken Perlin.  This eases coordinate values
															// so that they will "ease" towards integral values.  This ends up smoothing
															// the final output.
		return t * t * t * (t * (t * 6 - 15) + 10);			// 6t^5 - 15t^4 + 10t^3
	}
	
	public static double lerp(double a, double b, double x) {
		return a + x * (b - a);
	}
}

This implementation have negative space issues.

Here is my solution for negative numbers issue: Map the block coordinates properly with floor function, then adjust fractional parts for negative numbers. Works perfectly, and doesn't mirror the positive regions but flows smoothly ahead:

        int xi = ((int)(Math.Floor(x) % 256) + 256) % 256;
        int yi = ((int)(Math.Floor(y) % 256) + 256) % 256;
        int zi = ((int)(Math.Floor(z) % 256) + 256) % 256;

        double xf = x - (int)x;                             // We also fade the location to smooth the result.
        if (x < 0)
            xf = 1 + xf;
        double yf = y - (int)y;
        if (y < 0)
            yf = 1 + yf;
        double zf = z - (int)z;
        if (z < 0)
            zf = 1 + zf;

Using your solution, I got some artefacts at regular intervals in the negative range.
I adapted your solution to this, and it seems to work:

int xi, yi, zi;
double xf, yf, zf;

if (pos.x < 0f)                                             // Added support for negative values
{
    xi = 255 - ((int)(-pos.x) & 255);
    xf = 1 + pos.x - (int) pos.x;
}
else
{
    xi = (int) pos.x & 255;
    xf = pos.x - (int) pos.x; 
}

if (pos.y < 0f)
{
    yi = 255 - ((int)(-pos.y) & 255);
    yf = 1 + pos.y - (int) pos.y;
}
else
{
    yi = (int) pos.y & 255;
    yf = pos.y - (int) pos.y;
}

if (pos.z < 0f)
{
    zi = 255 - ((int)(-pos.z) & 255);
    zf = 1 + pos.z - (int) pos.z;
}
else
{
    zi = (int) pos.z & 255;
    zf = pos.z - (int) pos.z;
}

@NerdIt:
In case it's still relevant...
Just replace the following code part with the code above:

int xi = (int) pos.x & 255;   
int yi = (int) pos.y & 255;   
int zi = (int) pos.z & 255;   
double xf = pos.x - (int) pos.x; 
double yf = pos.y - (int) pos.y;
double zf = pos.z - (int) pos.z;

For anyone looking for the missing "repeat" variable. Here's what to do:

1. Add a public variable and default constructor
   public int repeat; public Perlin(int repeat = -1) { this.repeat = repeat; }

2. Remove the words 'static' from the methods 'perlin' and 'OctavePerlin'

I trying used this code but I always get 0.5 as result from:

OctavePerlin(myX, myY, 0, 8, 1);

Im sure that my implementation is wrong... do you can show me a easy example about use this code?

For anyone having issues with this Perlin noise due to problems with negative numbers or w/e (in my case it was big width/height causing an issue), consider using another perlin noise generator. In Unity3D, it works right off the bat to use Sebastian Lague's perlin noise generator:

https://github.com/SebLague/Procedural-Landmass-Generation/blob/master/Proc%20Gen%20E03/Assets/Scripts/Noise.cs