Perlin noise: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
| (24 intermediate revisions by 12 users not shown) | |||
Line 1:
{{task}}
The
The Perlin noise is basically a
Either by using a dedicated library or by implementing the algorithm, show that the Perlin noise (as defined in 2002 in the Java implementation below) of the point in 3D-space with coordinates 3.14, 42, 7 is 0.13691995878400012.
''Note: this result assumes 64 bit IEEE-754 floating point calculations. If your language uses a different floating point representation, make a note of it and calculate the value accurate to 15 decimal places, or your languages accuracy threshold if it is less. Trailing zeros need not be displayed.''
Line 14 ⟶ 13:
{{trans|Python}}
<
V permutation = [151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
Line 68 ⟶ 67:
grad(:p[BB + 1], x - 1, y - 1, z - 1))))
print(‘#.17’.format(perlin_noise(3.14, 42, 7)))</
{{out}}
Line 74 ⟶ 73:
0.13691995878400011
</pre>
=={{header|Arturo}}==
{{trans|Java}}
<syntaxhighlight lang="arturo">
p: [
151 160 137 91 90 15 131 13 201 95 96 53 194 233 7 225 140
36 103 30 69 142 8 99 37 240 21 10 23 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
]
'p ++ p
fade: function [t] -> t * t * t * 10 + t * (t * 6) - 15
lerp: function [t a b] -> a + t * b - a
grad: function [hsh x y z][
h: and hsh 15
u: (h < 8)? -> x -> y
v: (h < 4)? -> y [(or? 12=h 14=h)? -> x -> z]
((0 = and h 1)? -> u -> neg u) + (0 = and h 2)? -> v -> neg v
]
noise: function [x y z][
X: and floor x 255
Y: and floor y 255
Z: and floor z 255
x: x - floor x
y: y - floor y
z: z - floor z
u: fade x
v: fade y
w: fade z
A: p\[X ] + Y
AA: p\[A ] + Z
AB: p\[A+1] + Z
B: p\[X+1] + Y
BA: p\[B ] + Z
BB: p\[B+1] + Z
lerp w lerp v lerp u grad p\[AA ] x y z
grad p\[BA ] x-1 y z
lerp u grad p\[AB ] x y-1 z
grad p\[BB ] x-1 y-1 z
lerp v lerp u grad p\[AA+1] x y z-1
grad p\[BA+1] x-1 y z-1
lerp u grad p\[AB+1] x y-1 z-1
grad p\[BB+1] x-1 y-1 z-1
]
print noise 3.14 42 7
</syntaxhighlight>
{{out}}
<pre>0.1369199587840001</pre>
=={{header|C}}==
A sign of how close C and Java are is this implementation which differs very little from Perlin's Java implementation. I only removed the static, public and final keywords and the Math class name from the floor calls, and it compiled without errors. Interestingly, in the paper, Perlin says that the benchmark implementation which was used to gauge the algorithm's performance was in C. One important improvement here is that the permutation data is externalized and read from a file. This way different textures and effects can be generated without having to change the source code.
<syntaxhighlight lang="c">
#include<stdlib.h>
#include<stdio.h>
Line 139 ⟶ 204:
return 0;
}
</syntaxhighlight>
Permutation file, it should have 256 integers in the range [0,255]:
<pre>
Line 148 ⟶ 213:
C:\rosettaCode>perlin.exe perlinData.txt 3.14 42 7
Perlin Noise for (3.14,42,7) is 0.13691995878400012
</pre>
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <cmath>
#include <cstdint>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
std::vector<int32_t> p(512, 0);
double fade(const double& t) {
return t * t * t * ( t * ( t * 6 - 15 ) + 10 );
}
double lerp(const double& t, const double& a, const double& b) {
return a + t * ( b - a );
}
double grad(const int32_t& hash, const double& x, const double& y, const double& z) {
const int32_t h = hash & 15; // CONVERT LOW 4 BITS OF HASH CODE
const double u = h < 8 ? x : y; // INTO 12 GRADIENT DIRECTIONS.
const double v = h < 4 ? y : ( h == 12 || h == 14 ) ? x : z;
return ( ( h & 1 ) == 0 ? u : -u ) + ( ( h & 2 ) == 0 ? v : -v );
}
double perlin_noise(double x, double y, double z) {
int32_t X = static_cast<int32_t>(floor(x)) & 0xff; // FIND UNIT CUBE THAT
int32_t Y = static_cast<int32_t>(floor(y)) & 0xff; // CONTAINS POINT.
int32_t Z = static_cast<int32_t>(floor(z)) & 0xff;
x -= floor(x); // FIND RELATIVE X,Y,Z
y -= floor(y); // OF POINT IN CUBE.
z -= floor(z);
const double u = fade(x); // COMPUTE FADE CURVES
const double v = fade(y); // FOR EACH OF X,Y,Z.
const double w = fade(z);
const int32_t A = p[X ] + Y;
const int32_t AA = p[A ] + Z;
const int32_t AB = p[A + 1] + Z; // HASH COORDINATES OF
const int32_t B = p[X + 1] + Y;
const int32_t BA = p[B ] + Z;
const int32_t BB = p[B + 1] + Z; // THE 8 CUBE CORNERS,
return lerp(w, lerp(v, lerp(u, grad(p[AA ], x , y , z ), // AND ADD
grad(p[BA ], x - 1, y , z )), // BLENDED
lerp(u, grad(p[AB ], x , y - 1, z ), // RESULTS
grad(p[BB ], x - 1, y - 1, z ))), // FROM 8
lerp(v, lerp(u, grad(p[AA + 1], x , y , z - 1), // CORNERS
grad(p[BA + 1], x - 1, y , z - 1)), // OF CUBE
lerp(u, grad(p[AB + 1], x , y - 1, z - 1),
grad(p[BB + 1], x - 1, y - 1, z - 1))));
}
void read_file(const std::string& file_name) {
std::ifstream file("../" + file_name);
if ( file.is_open() ) {
int32_t index = 0;
std::string line;
while( std::getline(file, line) ) {
std::istringstream stream(line);
std::string word;
while ( std::getline(stream, word, ',') ) {
const int32_t number = std::stoi(word);
p[index] = number;
p[256 + index] = number;
index++;
}
}
} else {
std::cout << "Cannot open file" << std::endl;
}
}
int main() {
read_file("permutation.txt");
std::cout << "Perlin noise applied to (3.14, 42.0, 7.0) gives " << std::setprecision(16)
<<perlin_noise(3.14, 42.0, 7.0) << std::endl;
}
</syntaxhighlight>
{{ out }}
<pre>
Perlin noise applied to (3.14, 42.0, 7.0) gives 0.1369199587840001
</pre>
=={{header|Common Lisp}}==
<
(declaim (optimize (speed 3) (debug 0)))
Line 239 ⟶ 392:
(print (noise 3.14d0 42d0 7d0))
</syntaxhighlight>
{{out}}
<pre>0.13691995878400012d0</pre>
=={{header|D}}==
<
struct PerlinNoise {
Line 344 ⟶ 497:
im.savePGM("perlin_noise.pgm");
*/
}</
{{out}}
<pre>0.13691995878400012</pre>
=={{header|Delphi}}==
See [https://rosettacode.org/wiki/Perlin_noise#Pascal Pascal].
=={{header|EasyLang}}==
{{trans|Lua}}
{{trans|D}}
[https://easylang.dev/show/#cod=bZbdctpIEIXveYqu2qot2C0TzYxmJF3kSVK+AGxiyjZQBBykp893hBBIxLHRzOnuM6d/NGT/49m+2w9z0ZlLmblQWOWsYhXZAAbzGUC0KlkM5qrcfAhWmPd45JmFZC4LFjJLFYC30qrK4PEYPQx8Kg475hK4MOcF5lZEYwFeFZa8iTt6gioOJcYVFjjEWfAWiSrYByvhgN7llcVkpXDiUCxBUlMol9L4dRyA0SUeyoVlqEwiiErJCtEQEUXprNSZjsxIxHtL0q8wakB6XmdkFMJb7ixGI9LnPDDlMGcesmAxN45DS4ItEQ4JMjMrVMrKCs4jH4dwn5VWchZCk1KGv5JVebAmzJGsi5WVLJPOkAQiKuUGP3gwDG3V1BMkRZUCX6qODlQFnFV0ndM6RCtpE0ZHWCYd9BYBVEV+bEQPu2SCl0ZbvbqoChUqiyqFJZc8bKYCRFWa0VCpyFvTkulJOglmhdJjNOgooxG+HShTMlTCMSkFZo2c15RxegFcagRYZ2BO85OsUqosmVp66lHnKjUJCBInMYI4XIRMlqdjJU0DoWOeCvtc08qSByXQrlIRc9PU4+sqWTQcqkRupYYMYvVPLwcpUulcK8JxI21VQCKYQq9JUSYIgZQCKG1GXmJIG0GOFBxvFkkyix5SjUtU1zN7nqx3B9vYcQdtmpjZnnf13+88Ns+T+WR92q5svXh5taPNZT68Hk+HLbv/+r9p/5HsCeaZ/U9Ks2v0x+thj9/ClgOGBV5t4JKgRe/987B4sbfFrzc7W23NJeSN26PFPncvFFrQZt2imSFfC+eF3ujP0NeCXj86V9e75kPXGgHngesD19OIKwwdnh498kc5zcAhDh2aBxHpUcSQofiLiKFHOU50LKLqaxIe5YzKlz1WrSW7b+rTBe16ud1tfr3e93EBz/pjx5nntpXdyC17uL6HVz3c3MPnM/gl3mlf1+zr275p2De3/Uk0muBzW9+v67Zu8/t93TZtMovMNPsaTvfMx7IF3QXMruiqRf0N9T26vBH4nmB5IVgOCZb+ht4I3uXbvgWwuEsAKZPlReG7v9mXnX16Vu/d7M4r3LH4nmVa1xfHziu/4/IjrrFvHOnyV13TpmkdW680UueH6ga+xUijH2oc+JYjpf5vSu8juolsb5/fNm2fX93zpCq/+9ltG6jFbPboFsnozq1AyEx31fb0uf486usrm+wPm+2xG/Yw5xbmi6KY/GPt1arhzHS9ctFL1rod/iHGzx7owjA92zf+m6OsukU2d53X5+5L79M3vgllvF5Tq93H7hDg4F//kq6OBCb9XV7S+eQP Run it]
<syntaxhighlight>
p[] = [ 151 160 137 91 90 15 131 13 201 95 96 53 194 233 7 225 140 36 103 30 69 142 8 99 37 240 21 10 23 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 ]
for i to 256
p[] &= p[i]
.
func fade t .
return t * t * t * (t * (t * 6 - 15) + 10)
.
func lerp t a b .
return a + t * (b - a)
.
func grad hash x y z .
h = hash mod 16
if h = 0 or h = 12
return x + y
elif h = 1 or h = 14
return y - x
elif h = 2
return x - y
elif h = 3
return -x - y
elif h = 4
return x + z
elif h = 5
return z - x
elif h = 6
return x - z
elif h = 7
return -x - z
elif h = 8
return y + z
elif h = 9 or h = 13
return z - y
elif h = 10
return y - z
.
return -y - z
.
func noise x y z .
a = floor x mod 256
b = floor y mod 256
c = floor z mod 256
xx = x mod 1
yy = y mod 1
zz = z mod 1
u = fade xx
v = fade yy
w = fade zz
a0 = p[a + 1] + b
a1 = p[a0 + 1] + c
a2 = p[a0 + 2] + c
b0 = p[a + 2] + b
b1 = p[b0 + 1] + c
b2 = p[b0 + 2] + c
k1 = grad p[a1 + 1] xx yy zz
k2 = grad p[b1 + 1] (xx - 1) yy zz
k3 = grad p[a2 + 1] xx (yy - 1) zz
k4 = grad p[b2 + 1] (xx - 1) (yy - 1) zz
k5 = grad p[a1 + 2] xx yy (zz - 1)
k6 = grad p[b1 + 2] (xx - 1) yy (zz - 1)
k7 = grad p[a2 + 2] xx (yy - 1) (zz - 1)
k8 = grad p[b2 + 2] (xx - 1) (yy - 1) (zz - 1)
return lerp w (lerp v (lerp u k1 k2) (lerp u k3 k4)) (lerp v (lerp u k5 k6) (lerp u k7 k8))
.
numfmt 17 0
print noise 3.14 42 7
#
# demo
for y = 0 to 199
for x = 0 to 199
p = noise (x / 30) (y / 30) 0.1
move x / 2 y / 2
color3 p p p
rect 0.6 0.6
.
.
</syntaxhighlight>
=={{header|Evaldraw}}==
{{trans|C}}
This is a translation of the C version, with the gradient function borrowed from the Go version.
This evaldraw version computes the correct output. The array doesnt have to be 512 elements, we can rely on the wrap around when
accessing indices out of bounds since power of 2 arrays are anded with their size on access. Evaldraw has a built-in noise(x,y,z) function
that behaves like perlin noise, but does not give the exact same result as the original implementation in Java by Ken Perlin. There
is a comparison, so we can see the similarity in output visually.
[[File:Evaldrawperlinnoise.png|thumb|alt=builtin noise function is faster|Perlin noise function vs builtin noise]]
<syntaxhighlight lang="c">
static p[256] = {
151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,
99,37,240,21,10,23,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
};
()
{
cls(0);
x=3.14; y=42; z=7;
val = perlin_noise(x,y,z);
// expect val=0.13691995878400012
moveto(0,256);
setcol(255,255,255);
printf("Perlin Noise for (%g,%g,%g) is %.17lf\n",x,y,z,val);
val = noise(x,y,z);
printf("Evaldraw builtin noise for (%g,%g,%g) is %.17lf",x,y,z,val);
t = 2*klock(0);
freq = 8;
scale = freq/255;
for(y=0; y<256; y++)
for(x=0; x<256; x++)
{
val = 128+128 * perlin_noise(x * scale,y * scale,t);
setcol(48+.25*val,64+1*val,200+1.5*val);
setpix(x,y);
val = 128+128 * noise(x * scale,y * scale,t);
setcol(48+.25*val,64+1*val,200+1.5*val);
setpix(x+256,y);
}
}
fade(t) { t * t * t * (t * (t * 6 - 15) + 10); }
lerp(t,a,b) { a + t * (b - a); }
grad(hash, double x, double y, double z) {
// convert 4 bits of hash into 12 gradient vectors
h = int(hash % 15);
// Evaldraw rscript compiler doesnt handle
// chained terniary statements gracefully, use if-else instead.
if (h==0 || h==12)
return x + y;
else if (h==1 || h==14)
return y - x;
else if (h==2)
return x - y;
else if (h==3)
return -x - y;
else if (h==4)
return x + z;
else if (h==5)
return z - x;
else if (h==6)
return x - z;
else if (h==7)
return -x - z;
else if (h==8)
return y + z;
else if (h==9 || h==13)
return z - y;
else if (h==10)
return y - z;
// case 11, 16:
return -y - z;
}
perlin_noise(x,y,z) {
// Find cube corner from xyz
cubx = floor(x);
cuby = floor(y);
cubz = floor(z);
x -= floor(x);
y -= floor(y);
z -= floor(z);
// Curves for x,y,z
u = fade(x);
v = fade(y);
w = fade(z);
// Hash coords of 8 cube corners
A = p[cubx]+cuby; AA = p[A]+cubz; AB = p[A+1]+cubz,
B = p[cubx+1]+cuby; BA = p[B]+cubz; BB = p[B+1]+cubz;
// Blended results from 8 corners in cube
return lerp(w, lerp(v, lerp(u, grad(p[AA ], x , y , z ),
grad(p[BA ], x-1, y , z )),
lerp(u, grad(p[AB ], x , y-1, z ),
grad(p[BB ], x-1, y-1, z ))),
lerp(v, lerp(u, grad(p[AA+1], x , y , z-1 ),
grad(p[BA+1], x-1, y , z-1 )),
lerp(u, grad(p[AB+1], x , y-1, z-1 ),
grad(p[BB+1], x-1, y-1, z-1 ))));
}
</syntaxhighlight>
=={{header|Factor}}==
Line 354 ⟶ 713:
As this is a strict translation of applicative code that makes heavy use of local variables, it is highly non-idiomatic. In idiomatic code, we would never write a word as long as <code>noise</code> or name so many throwaway values. We would also abstract out repetitive patterns such as
<syntaxhighlight lang="text">x floor >integer 255 bitand :> X
y floor >integer 255 bitand :> Y
z floor >integer 255 bitand :> Z</
with dataflow combinators:
<syntaxhighlight lang="text">[ floor >integer 255 bitand ] tri@</
<
sequences ;
IN: rosetta-code.perlin-noise
Line 420 ⟶ 779:
: main ( -- ) 3.14 42 7 noise . ;
MAIN: main</
{{out}}
<pre>
Line 430 ⟶ 789:
{{trans|Java}}
<
PROGRAM PERLIN
IMPLICIT NONE
Line 529 ⟶ 888:
END PROGRAM
</syntaxhighlight>
{{out}}
Line 540 ⟶ 899:
{{trans|PureBasic}}
{{trans|Phix}}
<
#define floor(x) ((x*2.0-0.5) Shr 1)
Dim Shared As Byte p(256) => { _
Line 608 ⟶ 967:
Print Using "El Ruido Perlin para (3.14, 42, 7) es #.################"; noise(3.14, 42, 7)
Sleep
</syntaxhighlight>
{{out}}
<pre>
Line 616 ⟶ 975:
=={{header|GLSL}}==
From https://gist.github.com/patriciogonzalezvivo/670c22f3966e662d2f83 :
<
float rand(vec2 c){
return fract(sin(dot(c.xy ,vec2(12.9898,78.233))) * 43758.5453);
Line 654 ⟶ 1,013:
return nf*nf*nf*nf;
}
</syntaxhighlight>
=={{header|Go}}==
<
import (
Line 745 ⟶ 1,104:
222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180,
}
var p = append(permutation, permutation...)</
{{out}}
<pre>
Line 755 ⟶ 1,114:
We can trivially copy the java implementation:
<
ImprovedNoise=:3 :0
'x y z'=. y
Line 821 ⟶ 1,180:
(lerp w,(lerp v,(lerp u,(grad(p{~AA),x, y, z), t7),t6),t4)
)
</syntaxhighlight>
And this gives us our desired result:
<
0.13692</
Or, asking to see 20 digits after the decimal point:
<syntaxhighlight lang="j">
22j20": ImprovedNoise 3.14 42 7
0.13691995878400012000</
=== Simplified Expression ===
Line 838 ⟶ 1,197:
It's tempting, though, to express this more concisely. We are limited, there, by some of the arbitrary choices in the algorithm, but we can still exploit regularities in its structure:
<
fade=: 0 0 0 10 _15 6&p.
Line 860 ⟶ 1,219:
v=. (1{uvw) lerp"1 u
w=. (2{uvw) lerp"1 v
)</
And we can see that there's no difference in this result:
<
0</
It's probably possible to simplify this further.
=={{header|Java}}==
The original code from Perlin was
<
public final class ImprovedNoise {
Line 919 ⟶ 1,278:
};
static { for (int i=0; i < 256 ; i++) p[256+i] = p[i] = permutation[i]; }
}</
=={{header|Julia}}==
<
151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233,
7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
Line 972 ⟶ 1,331:
println("Perlin noise applied to (3.14, 42.0, 7.0) gives ", perlinsnoise(3.14, 42.0, 7.0))
</
<pre>
Perlin noise applied to (3.14, 42.0, 7.0) gives 0.13691995878400012
Line 979 ⟶ 1,338:
=={{header|Kotlin}}==
{{trans|Java}}
<
object Perlin {
Line 1,058 ⟶ 1,417:
fun main(args: Array<String>) {
println(Perlin.noise(3.14, 42.0, 7.0))
}</
{{out}}
<pre>
0.13691995878400012
</pre>
=={{header|M2000 Interpreter}}==
{{trans|Java}}
<syntaxhighlight lang="m2000 interpreter">
Group Perlin {
private:
permutation =(151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 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)
Public:
function noise(x, y, z) {
p=lambda a=.permutation (it)-> {
if it < 256 then =a#val(it) else =a#val(it - 256)
}
def fade(t)= t * t * t * (t * (t * 6 - 15) + 10)
def lerp(t, a, b) = a + t * (b - a)
function grad(hash, x, y, z) {
// Convert low 4 bits of hash code into 12 gradient directions
h = binary.and(hash, 15)
u = if(h < 8-> x, y)
v = if(h < 4-> y, if(h == 12 or h == 14->x, z))
=if(binary.and(h,1) = 0-> u, -u) + if(binary.and(h, 2) = 0-> v, -v)
}
// Find unit cube that contains point
xi = binary.and(floor(x), 255)
yi = binary.and(floor(y), 255)
zi = binary.and(floor(z), 255)
// Find relative x, y, z of point in cube
xx = x - floor(x)
yy = y - floor(y)
zz = z - floor(z)
// Compute fade curves for each of xx, yy, zz
u = fade(xx)
v = fade(yy)
w = fade(zz)
// Hash co-ordinates of the 8 cube corners
// and add blended results from 8 corners of cube
a = p(xi) + yi
aa = p(a) + zi
ab = p(a + 1) + zi
b = p(xi + 1) + yi
ba = p(b) + zi
bb = p(b + 1) + zi
=lerp(w, lerp(v, lerp(u, grad(p(aa), xx, yy, zz), grad(p(ba), xx - 1, yy, zz)), lerp(u, grad(p(ab), xx, yy - 1, zz), grad(p(bb), xx - 1, yy - 1, zz))), lerp(v, lerp(u, grad(p(aa + 1), xx, yy, zz - 1), grad(p(ba + 1), xx - 1, yy, zz - 1)), lerp(u, grad(p(ab + 1), xx, yy - 1, zz - 1), grad(p(bb + 1), xx - 1, yy - 1, zz - 1))))
}
}
print Perlin.noise(3.14, 42.0, 7.0)
</syntaxhighlight>
{{out}}
<pre>
0.136919958784
</pre>
=={{header|Lua}}==
<
}
Line 1,147 ⟶ 1,561:
print (noise(3.14, 42, 7)) -- 0.136919958784
print (noise(1.4142, 1.2589, 2.718)) -- -0.17245663814988</
=={{header|Nim}}==
{{trans|Kotlin}}
<
const Permutation = [
Line 1,232 ⟶ 1,646:
when isMainModule:
echo noise(3.14, 42, 7)</
{{out}}
Line 1,239 ⟶ 1,653:
=={{header|OCaml}}==
<
131;13;201;95;96;53;194;233;7;225;140;36;103;30;69;142;8;99;37;240;21;10;23;
190; 6;148;247;120;234;75;0;26;197;62;94;252;219;203;117;35;11;32;57;177;33;
Line 1,296 ⟶ 1,710:
let p = perlin_init permutation in
print_string ((Printf.sprintf "%0.17f" (perlin_noise p 3.14 42.0 7.0)) ^ "\n")</
{{out}}
<pre>0.13691995878400012</pre>
Line 1,303 ⟶ 1,717:
{{works with|Free Pascal}}
dumb copy of [http://rosettacode.org/mw/index.php?title=Perlin_noise#Go Go] minimal adjustments.
<
//Perlin Noise
//http://rosettacode.org/mw/index.php?title=Perlin_noise#Go
Line 1,411 ⟶ 1,825:
writeln(noise(3.14, 42, 7):20:17);
end.
</syntaxhighlight>
{{out}}
<pre> 0.13691995878400012</pre>
Line 1,417 ⟶ 1,831:
=={{header|Perl}}==
{{trans|Java}}
<
use warnings;
use experimental 'signatures';
Line 1,467 ⟶ 1,881:
}
print noise 3.14, 42, 7;</
{{out}}
<pre>0.136919958784</pre>
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">ph</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">x"97 A0 89 5B 5A 0F 83 0D C9 5F 60 35 C2 E9 07 E1"</span><span style="color: #0000FF;">&</span>
Line 1,526 ⟶ 1,940:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Perlin Noise for (3.14,42,7) is %.17f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">noise</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3.14</span><span style="color: #0000FF;">,</span><span style="color: #000000;">42</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">)})</span>
<!--</
{{out}}
<pre>
Line 1,534 ⟶ 1,948:
=={{header|PureBasic}}==
{{trans|Pascal}}
<
; http://www.rosettacode.org
Line 1,625 ⟶ 2,039:
Input()
EndIf
</syntaxhighlight>
{{out}}
<pre>noise(3.14,42,7) => 0.13691995878400012</pre>
Line 1,633 ⟶ 2,047:
{{trans|Java}}
<syntaxhighlight lang
def perlin_noise(x, y, z):
Z = math.floor(z) & 255
x -= math.floor(x) # FIND RELATIVE X,Y,Z
y -= math.floor(y) # OF POINT IN CUBE.
z -= math.floor(z)
u = fade(x) # COMPUTE FADE CURVES
v = fade(y) # FOR EACH OF X,Y,Z.
Line 1,685 ⟶ 2,101:
if __name__ == '__main__':
print("%1.17f" % perlin_noise(3.14, 42, 7))</
{{out}}
Line 1,693 ⟶ 2,109:
{{trans|Java}} -- because we were asked to
<
(define (floor-to-255 x)
(bitwise-and (exact-floor x) #xFF))
Line 1,765 ⟶ 2,181:
(module+ test
(noise 3.14 42 7))</
{{out}}
<pre>0.13691995878400012</pre>
Line 1,772 ⟶ 2,188:
(formerly Perl 6)
{{trans|Java}}
<syntaxhighlight lang="raku"
😅😎📸👑👐✌ 💻✊😻💀💁🍃😲🤦☺🤙🔵🌕💎🌎🎶🖕⚠💆🌖🤭❣⚽➡😮☹😂
🥰💣🤧🐷▶🌈😵🎁👼🦋🤐🙂💟🌔✅🌑🍒😟🌒👎🤪😃🍑👍😜❓💩📣😙😖🎵😝
🐶😓🏃📌🔴🌺🌊😔🐾😀😌🤣👉💙🤠💦🍻🙋💿🤢🤑💓👶🌞🍎🌸🥀🌚🤷💍🖤🍊
🎉⭐🎂😏☀🚩👆🐉🙈🐸💾😫🙇👏❄😗😹😴📍💸💞😬😍👌😒💋💗😶😛😪☎🎈
🍀🚶🤝🥵💨💧☝ 🙁🌗😁💡💪🪐👈👋🙌🙆🙅🍺🤞🌹✔🍓✨😤😭🌌🌟🤗😥😘🙏
💢🥳😆☄🌴😈😑🎼🤓😇💌😉😕🌱😚⚡💰❤🌘🧐❌💅💖💘👅💛🤘🤤😠😩💚💐
🛰 🥂💃🤟🥺🌓🤯😱🤫🙊🖥 ✈😯😡😐🤮👇🌿🗣 🤨🥴✋🤬💕🌻😰🚀🌏😣😷💔😋
😨👊🙃😞💝💥🌼🌷💫☕😄🧡🔥🤩🙄👻🤔💜🎤🌍⬇🏆🤲🕺💯😳👀🎊🚨🎀😊😢
>.join.comb) xx 2;
sub fade($_) { $_ * $_ * $_ * ($_ * ($_ * 6 - 15) + 10) }
Line 1,794 ⟶ 2,208:
}
sub noise($x is copy, $y is copy, $z is copy)
my ($u, $v, $w) = map &fade, ($x, $y, $z) »-=«
my ($X, $Y, $Z) = ($x, $y, $z)».floor »+&» 255;
my ($AA, $AB) = @p[$_] + $Z, @p[$_ + 1] + $Z given @p[$X] + $Y;
my ($BA, $BB) = @p[$_] + $Z, @p[$_ + 1] + $Z given @p[$X + 1] + $Y;
lerp($w, lerp($v, lerp($u, grad(@p[$AA ], $x , $y , $z ),
grad(@p[$BA ], $x - 1, $y , $z )),
lerp($u, grad(@p[$AB ], $x , $y - 1, $z ),
grad(@p[$BB ], $x - 1, $y - 1, $z ))),
lerp($v, lerp($u, grad(@p[$AA + 1], $x , $y , $z - 1 ),
grad(@p[$BA + 1], $x - 1, $y , $z - 1 )),
lerp($u, grad(@p[$AB + 1], $x , $y - 1, $z - 1 ),
grad(@p[$BB + 1], $x - 1, $y - 1, $z - 1 ))));
}
say noise 3.14, 42, 7;</
{{out}}
<pre>0.13691995878</pre>
Line 1,815 ⟶ 2,229:
=={{header|REXX}}==
{{trans|Go}}
Programming note:
<br>remainder is used for this task.
The original decimal (data) table was compressed into a single hexadecimal value (without spaces).
<
_= 97a0895b5a0f830dc95f6035c2e907e18c24671e458e086325f0150a17be0694f778ea4b001ac53e5efcdbcb75230b2039b12158ed953857ae147d88aba844af,
||4aa547868b301ba64d929ee7536fe57a3cd385e6dc695c29372ef528f4668f3641193fa101d85049d14c84bbd05912a9c8c4878274bc9f56a4646dc6adba0340,
Line 1,864 ⟶ 2,278:
grad( pick(ba+1), xm, y , zm )), ,
lerp(u, grad( pick(ab+1), x , ym, zm ), ,
grad( pick(bb+1), xm, ym, zm )))) /1</
{{out|output|text=
(Output note:
(Note that REXX uses
<pre>
Perlin noise for the 3D point [3.14 42 7] ───► 0.136919958784
Line 1,876 ⟶ 2,290:
=={{header|Rust}}==
{{trans|Java}}
<
println!("{}", noise(3.14, 42.0, 7.0));
}
Line 1,952 ⟶ 2,366:
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];</
'''Output:'''
<pre>
Line 1,960 ⟶ 2,374:
=={{header|Sidef}}==
{{trans|Raku}}
<
2R 11 6O L A N 5A 6 44 6V 3C 6I 23 0 Q 5H 1Q 2M 70 63 5N 39 Z B W 1L 4X X 2G
6L 45 1K 2F 4U K 3H 3S 4R 4O 1W 4V 22 4L 1Z 3Q 3V 1C R 4M 25 42 4E 6F 2B 33 6D
Line 1,996 ⟶ 2,410:
}
say noise(3.14, 42, 7)</
{{out}}
<pre>
Line 2,004 ⟶ 2,418:
=={{header|Swift}}==
<
struct Perlin {
Line 2,077 ⟶ 2,491:
}
print(Perlin.noise(x: 3.14, y: 42, z: 7))</
{{out}}
Line 2,085 ⟶ 2,499:
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<
proc noise {x y z} {
# Find unit cube that contains point.
Line 2,152 ⟶ 2,566:
}
puts [perlin::noise 3.14 42 7]</
{{out}}
0.13691995878400012
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import math
// vlang doesn't have globals
Line 2,279 ⟶ 2,693:
}
}
}</
{{out}}
<pre>
Line 2,287 ⟶ 2,701:
=={{header|Wren}}==
{{trans|Kotlin}}
<
151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225,
140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148,
Line 2,353 ⟶ 2,767:
}
System.print(noise.call(3.14, 42, 7))</
{{out}}
Line 2,362 ⟶ 2,776:
=={{header|XPL0}}==
{{trans|Java}}
<
real U, V, W;
int IX, IY, IZ, P(512), A, AA, AB, B, BA, BB;
Line 2,431 ⟶ 2,845:
[Format(1, 17);
RlOut(0, Noise(3.14, 42., 7.));
]</
{{out}}
<pre>
0.13691995878400000
</pre>
=={{header|Zig}}==
{{trans|Go}}
<syntaxhighlight lang="zig">// Made for Zig 0.10.0
// This implementation works with generic float types
const std = @import("std");
const expect = std.testing.expect;
pub fn main() void {
std.debug.print("{d}\n", .{noise3D(f64, 3.14, 42, 7)});
}
pub fn noise3D(comptime T: type, x: T, y: T, z: T) T {
// Disable runtime safety to allow the permutation table values to wrap
@setRuntimeSafety(false);
// Truncate float to u8 (256 possible values)
const x_i = @intCast(u8, @floatToInt(isize, @floor(x)) & 255);
const y_i = @intCast(u8, @floatToInt(isize, @floor(y)) & 255);
const z_i = @intCast(u8, @floatToInt(isize, @floor(z)) & 255);
// Float remainder of coords (eg: 5.34 -> 0.34)
const x_r = x - @floor(x);
const y_r = y - @floor(y);
const z_r = z - @floor(z);
const u = fade(x_r);
const v = fade(y_r);
const w = fade(z_r);
const a = permutation[ x_i ] +% y_i;
const aa = permutation[ a ] +% z_i;
const ab = permutation[ a + 1 ] +% z_i;
const b = permutation[x_i + 1] +% y_i;
const ba = permutation[ b ] +% z_i;
const bb = permutation[ b + 1 ] +% z_i;
// Add blended results from all 8 corners of the cube
// Use `1.0` instead of `1` to let Zig know it must always be a float value
return lerp(w, lerp(v, lerp(u, grad3D(T, permutation[ aa ], x_r, y_r, z_r),
grad3D(T, permutation[ ba ], x_r - 1.0, y_r, z_r)),
lerp(u, grad3D(T, permutation[ ab ], x_r, y_r - 1.0, z_r),
grad3D(T, permutation[ bb ], x_r - 1.0, y_r - 1.0, z_r))),
lerp(v, lerp(u, grad3D(T, permutation[aa + 1], x_r, y_r, z_r - 1.0),
grad3D(T, permutation[ba + 1], x_r - 1.0, y_r, z_r - 1.0)),
lerp(u, grad3D(T, permutation[ab + 1], x_r, y_r - 1.0, z_r - 1.0),
grad3D(T, permutation[bb + 1], x_r - 1.0, y_r - 1.0, z_r - 1.0))));
}
fn grad3D(comptime T: type, h: u8, x: T, y: T, z: T) T {
return switch (h & 15) {
0, 12 => x + y,
1, 14 => y - x,
2 => x - y,
3 => -x - y,
4 => x + z,
5 => z - x,
6 => x - z,
7 => -x - z,
8 => y + z,
9, 13 => z - y,
10 => y - z,
else => -y - z, // 11, 15
};
}
fn lerp(t: anytype, a: anytype, b: anytype) @TypeOf(t, a, b) {
return a + t * (b - a);
}
fn fade(t: anytype) @TypeOf(t) {
return t * t * t * (t * (6.0 * t - 15.0) + 10.0);
}
const permutation = [256]u8{
151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225,
140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 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,
};
test "3D noise" {
try expect(noise3D(f64, 3.14, 42, 7) == 0.13691995878400012);
try expect(noise3D(f64, -4.20, 10, 6) == 0.14208000000000043);
}</syntaxhighlight>
{{out}}
<pre>
0.13691995878400012
</pre>
=={{header|zkl}}==
{{trans|Java}}
<
fcn noise(xyz){ xyz=vm.arglist.apply("toFloat");
X,Y,Z:= // FIND UNIT CUBE THAT CONTAINS POINT.
Line 2,481 ⟶ 2,997:
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180),
p=Data(Void,permutation,permutation);
}</
<
{{out}}
<pre>0.13692</pre>
| |||