perlin_noise 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.swp
+*.swo
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in perlin.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,485 @@
+# perlin
+Ruby-implementation of N-dimension Perlin noise.
+
+## Installation
+
+```
+gem install perlin_noise
+```
+
+```ruby
+require 'perlin_noise'
+```
+
+## Basic
+### One-dimension
+```ruby
+n1d = Perlin::Noise.new 1
+0.step(100, 0.01) do |x|
+  puts n1d[x]
+end
+```
+
+### Two-dimension, three-dimension, or even more dimensions
+```ruby
+n2d = Perlin::Noise.new 2
+0.step(100, 0.01) do |x|
+  0.step(100, 0.01) do |y|
+    puts n2d[x, y]
+  end
+end
+
+n3d = Perlin::Noise.new 3
+n3d[rand, rand, rand]
+
+n5d = Perlin::Noise.new 5
+n5d[rand, rand, rand, rand, rand]
+```
+
+## Options
+### :interval
+A gradient noise repeats itself at certain interval. (Default interval is 256)
+You can change the interval of the noise generator but keep in mind that
+longer interval requires more pseudo-random gradient vectors to be maintained in memory.
+
+```ruby
+n3d = Perlin::Noise.new 3, :interval => 100
+n3d[0.1, 0.2, 0.3]
+n3d[0.1, 0.2, 100.3]
+```
+
+## Range of noise function
+While the original algorithm outputs a number between -1.0 and 1.0, 
+Perlin::Noise#[] manipulates this output and returns a number between 0.0 and 1.0 for ease of use.
+Thus, noise values at all of the integer lattice points should be 0.5, not 0.
+
+## Increasing the contrast
+Even though the range of the noise function is from 0 to 1, 
+you'll rarely see a noise value close to either end, 
+as most of the values are distributed around the center.
+You might want to apply S-shaped curve functions defined in Perlin::Curve module 
+one or more times to push away those numbers to either end.
+
+```ruby
+noise = Perlin::Noise.new 1
+
+n = noise[0.1]
+
+3.times do
+  n = Perlin::Curve::CUBIC.call n
+end
+```
+
+There's a shortcut for this process.
+```ruby
+contrast = Perlin::Curve.contrast(Perlin::Curve::CUBIC, 3)
+n = contrast.call n
+```
+
+## Noise gallery
+
+### 1D noise
+
+```ruby
+noise = Perlin::Noise.new 1, :interval => 200
+0.step(300, 0.1).each do |x|
+  n = noise[x]
+  len = (n * 60).to_i
+  puts '#' * len
+end
+```
+
+```
+##############################
+################################
+##################################
+##################################
+################################
+##############################
+###########################
+#########################
+#########################
+###########################
+##############################
+#################################
+#####################################
+########################################
+###########################################
+#############################################
+###########################################
+########################################
+#####################################
+#################################
+##############################
+###########################
+#########################
+#########################
+###########################
+##############################
+################################
+##################################
+##################################
+################################
+##############################
+##########################
+######################
+###################
+################
+###############
+################
+###################
+######################
+##########################
+##############################
+#################################
+#####################################
+########################################
+###########################################
+#############################################
+###########################################
+########################################
+#####################################
+#################################
+##############################
+##########################
+######################
+###################
+################
+###############
+################
+###################
+######################
+##########################
+##############################
+#################################
+#####################################
+########################################
+###########################################
+#############################################
+###########################################
+########################################
+#####################################
+#################################
+##############################
+##########################
+######################
+###################
+################
+###############
+################
+###################
+######################
+##########################
+##############################
+################################
+##################################
+##################################
+################################
+##############################
+###########################
+#########################
+#########################
+###########################
+##############################
+#################################
+#####################################
+########################################
+###########################################
+#############################################
+###########################################
+########################################
+#####################################
+#################################
+##############################
+###########################
+#########################
+#########################
+###########################
+##############################
+################################
+##################################
+##################################
+################################
+##############################
+##########################
+######################
+###################
+################
+###############
+################
+###################
+######################
+##########################
+##############################
+#################################
+#####################################
+########################################
+###########################################
+#############################################
+###########################################
+########################################
+#####################################
+#################################
+##############################
+##########################
+######################
+###################
+################
+```
+
+### 2D noise
+```ruby
+noises = Perlin::Noise.new(2)
+contrast = Perlin::Curve.contrast(Perlin::Curve::CUBIC, 2)
+
+bars = " ▁▂▃▄▅▆▇█".each_char.to_a
+bar = lambda { |n| 
+  bars[ (bars.length * n).floor ]
+}
+
+0.upto(100) do |i|
+  70.times do |y|
+    n = noises[i * 0.1, y * 0.1]
+    n = contrast.call n
+
+    print bar.call(n)
+  end
+  puts
+end
+```
+
+```
+▃▃▂▂▁▁▁▁▂▃▃▄▅▅▆▆▆▅▅▅▅▅▅▄▄▃▃▂▂▃▃▄▄▄▄▄▄▄▄▄▅▅▆▇▇▇▇▇▆▅▄▃▂▁   ▁▂▃▄▅▆▆▇▇▆▆▅▅
+▂▂▁▁▁▁▁▁▂▂▃▄▄▅▆▆▆▆▆▆▆▆▆▅▅▄▃▂▂▂▃▃▄▄▄▄▄▅▅▅▆▆▇▇██▇▇▆▅▄▃▂▁   ▁▂▃▄▅▆▆▇▇▇▇▆▆
+▁▁▁▁▁▁▁▁▂▃▃▄▄▅▅▆▆▆▇▇▇▇▇▆▆▅▄▃▃▃▃▃▄▄▄▅▅▆▆▆▇▇▇███▇▇▆▅▄▃▂▁   ▁▁▂▃▄▅▆▇▇▇▇▇▇
+▁  ▁▁▁▂▂▃▃▃▄▄▅▅▆▆▇▇▇▇▇▇▇▇▆▅▄▃▃▃▄▄▄▅▆▆▇▇▇▇▇████▇▇▆▆▅▄▃▂▁  ▁▁▂▂▃▄▅▆▇████
+  ▁▁▁▂▃▃▄▄▄▄▄▄▅▅▆▆▇▇▇███▇▇▆▅▄▄▄▄▄▅▅▆▇▇▇▇▇▇████▇▇▇▆▅▅▄▂▁▁▁▁▁▁▂▃▄▅▆▇████
+▁▁▁▂▃▄▄▅▅▅▅▄▄▄▄▄▅▅▆▇▇▇███▇▇▆▅▅▅▅▅▅▆▆▇▇▇▇▇▇▇▇▇▇▇▇▇▆▆▅▄▃▂▁▁▁▁▁▂▂▃▄▆▇▇███
+▁▁▂▃▄▅▆▆▆▅▅▅▄▃▃▃▃▄▅▆▇▇▇███▇▇▆▆▅▅▅▅▆▆▇▇▇▇▇▆▆▆▆▆▇▇▆▆▆▅▅▄▃▂▁▁▁▁▂▂▃▄▅▆▇▇▇▇
+▂▃▃▄▅▆▇▆▆▆▅▄▄▃▂▂▂▃▄▅▆▆▇▇██▇▇▆▆▅▅▅▅▅▆▆▆▇▆▆▅▅▅▅▅▆▆▆▆▆▅▄▄▃▂▂▂▂▂▂▃▃▄▅▆▆▇▇▆
+▃▄▅▅▆▇▇▇▆▅▅▄▃▂▁▁▁▂▃▄▅▅▆▇▇▇▇▇▆▅▅▄▄▄▅▅▆▆▆▅▅▄▄▄▄▄▅▅▅▅▅▄▄▃▃▂▂▂▂▃▃▃▄▅▅▆▆▆▆▅
+▄▅▅▆▇▇▇▆▆▅▄▃▂▂▁▁▁▁▂▃▄▅▆▆▇▇▇▆▅▅▄▄▃▄▄▄▅▅▅▅▄▃▃▃▃▃▄▄▄▄▄▄▃▃▂▂▂▃▃▄▄▄▅▅▅▆▅▅▅▄
+▅▅▆▇▇▇▆▆▅▄▃▃▂▁▁ ▁▁▂▃▃▄▅▆▆▆▆▅▄▄▃▃▂▃▃▃▄▄▄▄▃▃▂▂▂▃▃▃▃▃▃▃▂▂▂▂▃▃▄▅▅▅▆▆▆▆▅▅▄▃
+▅▆▆▇▇▇▆▅▄▃▂▂▁▁   ▁▂▂▃▄▅▅▆▆▅▄▃▂▂▂▂▂▂▃▃▄▄▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▃▄▅▅▆▆▆▆▆▆▅▄▄▃
+▅▆▆▆▆▆▅▄▃▂▁▁▁    ▁▂▃▃▄▅▅▅▅▄▃▂▁▁▁▁▁▂▂▃▄▄▃▃▂▂▂▁▁▁▁▁▁▁▁▁▁▂▃▄▅▆▆▆▆▆▆▆▅▅▄▄▃
+▅▅▆▆▆▅▄▃▂▁▁▁    ▁▁▂▃▄▄▅▅▅▄▃▂▁▁   ▁▁▂▃▄▄▄▃▃▂▂▁▁▁▁▁▁  ▁▁▂▃▄▅▆▆▆▆▆▆▆▅▅▄▄▄
+▄▅▅▅▅▄▃▂▁▁▁▁▁ ▁▁▁▂▃▄▄▅▅▅▅▄▃▁▁    ▁▂▃▄▅▅▅▄▄▃▂▁▁      ▁▁▂▄▅▆▆▆▆▆▅▅▅▅▅▅▅▄
+▄▄▄▄▄▃▂▁▁▁▁▁▁▁▁▁▂▃▃▄▅▆▆▆▅▄▃▁▁   ▁▁▂▄▅▅▅▅▅▄▃▂▂▁     ▁▁▂▃▅▆▆▆▆▅▅▄▄▄▄▅▅▅▅
+▃▄▄▄▃▃▂▁▁▁▁▂▂▂▂▂▃▃▄▅▅▆▆▆▅▄▃▂▁▁▁▁▁▂▃▅▅▆▆▆▅▅▄▃▂▁▁▁▁▁▁▁▂▃▄▅▆▆▆▆▅▄▃▃▃▄▄▅▅▆
+▃▄▄▄▄▃▂▂▂▂▂▃▃▃▃▃▃▄▄▅▅▆▆▆▅▅▄▃▂▂▂▂▃▃▄▅▆▆▆▆▅▅▄▃▂▁▁▁▁▂▂▂▃▄▅▆▇▆▆▅▄▃▃▂▃▃▄▅▅▆
+▃▄▄▄▄▃▃▃▂▃▃▄▄▄▄▄▃▃▄▄▅▅▆▆▅▅▄▃▃▃▃▃▄▄▅▆▆▆▆▅▅▄▃▃▂▂▂▂▂▃▃▄▄▅▆▇▇▇▆▅▄▃▂▂▂▃▄▄▅▅
+▄▅▅▅▅▄▄▃▃▃▄▅▅▅▄▄▃▃▃▃▄▅▅▅▅▅▅▄▄▄▄▄▅▅▆▆▆▆▅▅▄▃▃▂▂▂▂▂▃▄▄▅▅▆▇▇▇▇▆▅▄▃▂▂▂▂▃▄▄▄
+▅▅▆▆▅▅▅▄▄▄▅▅▅▅▅▄▃▂▂▃▃▄▄▅▅▅▅▅▅▅▅▅▆▆▆▆▆▅▄▄▃▃▂▂▂▂▂▃▄▄▅▅▆▇▇▇▇▇▆▅▄▃▂▂▂▂▂▃▃▃
+▆▆▆▆▆▆▅▅▅▅▆▆▆▆▅▄▃▂▂▂▂▃▃▄▅▅▆▆▆▆▆▆▆▇▆▆▅▄▃▃▂▂▁▁▁▂▂▃▄▅▅▆▆▇▇██▇▇▆▅▄▃▂▂▂▂▂▃▃
+▆▇▇▇▇▆▆▆▆▆▆▇▇▆▅▄▃▂▁▁▁▂▂▃▄▅▆▆▇▇▇▇▇▇▇▆▅▄▃▂▁▁▁▁▁▁▂▃▄▅▅▆▆▇▇██▇▇▆▅▄▄▃▂▂▂▂▂▂
+▆▇▇▇▇▇▆▆▆▆▇▇▇▇▆▄▃▁▁▁▁▁▁▂▄▅▆▇▇████▇▇▆▅▃▂▁▁▁  ▁▁▂▃▄▅▅▅▆▆▇▇▇▇▇▇▆▅▄▃▃▂▂▂▂▂
+▆▇▇▇▇▇▆▆▆▆▇▇▇▇▆▅▃▁▁  ▁▁▂▃▅▆▇█████▇▇▆▅▃▂▁▁   ▁▁▂▃▄▄▄▄▅▅▆▇▇▇▇▇▆▆▅▄▃▂▂▂▂▃
+▆▇▇▇▇▆▆▅▅▆▆▇▇▇▇▅▄▂▁▁▁▁▁▂▃▅▆▇███▇▇▇▆▆▅▄▃▂▁▁  ▁▁▂▃▄▄▄▃▄▄▅▆▇▇▇▇▇▆▅▄▃▃▂▂▃▃
+▅▆▇▇▆▆▅▅▅▅▆▇▇▇▇▆▄▃▂▁▁▁▁▂▃▅▆▇▇▇▇▇▇▆▆▆▅▄▃▂▂▁▁▁▁▂▃▃▄▄▃▃▃▃▄▅▆▆▇▇▆▆▅▄▃▂▂▂▃▃
+▅▆▆▆▆▅▄▄▄▄▅▆▇▇▇▆▅▄▃▂▂▂▂▂▃▄▅▆▆▆▆▆▅▅▅▅▅▅▄▃▃▂▁▁▂▂▃▄▄▄▃▂▂▂▃▄▅▆▆▆▆▅▅▄▃▂▂▂▃▄
+▄▅▆▆▅▄▄▃▃▄▄▅▆▇▇▇▆▅▄▃▃▃▃▃▄▄▅▅▆▅▅▅▄▅▅▅▅▅▅▄▃▃▂▂▂▃▄▄▄▄▃▃▂▂▃▃▄▅▅▅▅▄▄▃▂▂▂▂▃▄
+▄▅▅▅▅▄▃▃▃▃▄▅▆▇▇▇▆▆▅▄▄▄▄▄▄▄▅▅▅▄▄▄▄▄▄▅▅▆▅▅▄▃▃▃▃▄▄▅▅▅▄▃▃▃▃▃▄▄▄▄▄▄▃▂▁▁▁▂▂▃
+▄▅▅▅▅▄▃▃▂▃▄▅▆▆▇▇▇▆▆▅▅▅▄▄▄▄▄▄▄▄▃▃▃▃▄▅▆▆▆▅▅▄▃▃▄▄▅▅▆▅▅▄▄▃▃▃▃▃▄▃▃▃▂▁▁▁▁▁▂▃
+▃▄▅▅▄▄▃▃▃▃▄▅▆▆▇▇▇▇▆▆▅▅▅▅▅▄▄▄▄▃▃▂▂▃▄▅▆▆▆▆▅▄▄▄▄▅▆▆▆▆▆▅▅▄▃▃▃▃▂▂▂▂▁▁▁ ▁▁▂▃
+▃▃▄▄▄▄▃▃▃▄▄▅▆▇▇▇▇▇▆▆▆▅▅▅▅▄▄▄▄▃▃▃▃▃▄▅▆▇▇▆▆▅▅▄▅▅▆▇▇▇▆▆▆▅▄▃▂▂▁▁▁▁▁   ▁▁▂▃
+▂▃▃▄▄▄▄▄▄▄▅▆▆▇▇▇▇▇▆▆▅▅▅▄▄▄▄▄▄▄▃▃▃▄▅▆▇▇▇▇▆▅▅▅▅▅▆▇▇▇▇▇▆▆▄▃▂▁▁▁▁    ▁▁▂▃▃
+▁▂▃▃▄▄▄▄▅▅▆▆▇▇▇▇▇▇▆▅▅▄▄▄▄▄▄▅▅▅▄▄▄▅▆▇▇▇▇▇▆▆▅▄▄▅▅▆▇▇▇▇▇▆▅▃▂▁▁    ▁▁▁▂▂▃▄
+▁▂▃▃▄▄▅▅▅▆▆▆▇▇▇▇▇▆▅▅▄▃▃▃▃▄▄▅▅▅▅▅▅▅▆▇▇▇▇▇▆▅▄▄▄▄▄▅▆▇▇▇▇▆▅▄▂▁▁ ▁▁▁▁▁▂▂▃▄▅
+▂▂▃▃▄▅▅▅▆▆▆▆▆▇▇▇▆▆▅▄▃▃▂▂▃▃▄▅▅▆▅▅▅▆▆▇▇▇▇▆▆▅▄▃▃▃▃▄▅▆▆▇▇▆▅▄▃▂▁▁▁▁▂▂▂▃▃▄▄▅
+▂▃▃▄▅▅▅▅▆▆▆▆▆▆▆▆▆▅▅▄▃▃▂▂▂▃▄▅▅▆▅▅▅▆▆▇▇▇▆▆▅▄▃▂▂▂▂▃▄▅▆▆▆▆▅▄▃▂▂▂▂▃▃▃▃▄▄▄▄▅
+▃▄▄▅▅▅▅▅▅▅▅▅▅▆▆▆▆▆▅▄▃▃▂▂▂▃▄▄▅▅▅▅▅▅▆▆▇▆▆▅▄▃▂▂▁▁▁▂▃▄▅▅▆▆▅▄▃▃▃▃▃▄▄▄▄▄▄▄▄▄
+▄▄▅▅▅▅▅▄▄▄▄▄▄▅▅▆▆▆▅▅▄▃▃▂▂▃▃▄▄▄▄▄▄▅▅▆▆▆▆▅▄▃▂▁▁▁▁▁▂▃▄▅▅▅▅▄▄▃▃▃▄▅▅▅▅▄▄▃▃▄
+▅▅▆▆▅▅▄▄▃▃▃▃▄▄▅▆▆▆▆▅▅▄▃▃▃▃▃▃▃▃▃▃▃▄▄▅▆▆▅▅▄▃▂▁   ▁▂▂▃▄▄▅▅▄▄▄▄▄▅▅▅▅▅▄▃▃▃▃
+▆▆▆▆▆▅▄▃▃▂▂▃▃▄▅▆▆▆▆▆▅▅▄▃▃▂▂▂▂▂▂▂▂▂▃▄▅▅▅▄▃▃▂▁   ▁▁▂▂▃▃▄▄▄▄▄▄▅▅▆▆▆▅▄▃▃▂▂
+▆▇▇▇▆▅▄▃▂▂▂▂▃▄▅▅▆▆▆▆▆▅▅▄▃▃▂▂▁▁▁▁▁▁▂▃▄▄▄▄▃▃▂▁▁   ▁▁▁▂▂▃▃▃▃▄▄▅▅▆▆▆▅▅▄▃▃▃
+▇▇▇▇▆▅▄▃▂▂▂▃▃▄▅▅▆▆▆▆▆▆▅▅▄▃▂▁▁▁   ▁▁▂▃▄▄▄▄▃▃▂▁▁▁  ▁▁▁▁▂▂▂▂▃▄▄▅▅▆▆▆▅▄▄▃▃
+▇▇▇▇▇▆▄▃▃▂▃▃▄▄▅▅▅▅▆▆▆▆▆▅▅▄▃▂▁     ▁▁▂▃▄▄▄▄▄▃▃▂▁▁▁▁▁▁▁▁▁▁▂▂▃▄▄▅▅▆▆▆▅▅▄▄
+▇▇▇▇▇▆▄▃▃▃▄▄▅▅▅▅▅▅▅▅▅▆▆▆▆▅▃▂▁▁     ▁▁▂▃▄▄▅▅▅▄▃▃▂▁▁▁▁▁  ▁▁▁▂▃▄▄▅▅▆▆▆▆▅▅
+▆▇▇▇▆▅▄▄▃▄▄▅▅▅▅▅▄▄▄▄▅▆▆▆▆▆▅▃▂▁▁▁   ▁▁▂▃▄▄▅▆▆▆▅▄▃▂▂▁▁▁▁  ▁▁▂▂▃▄▅▅▆▆▆▆▆▆
+▅▆▆▆▆▅▄▄▃▄▅▅▆▅▅▄▄▃▃▄▄▅▆▇▇▆▆▄▃▂▂▂▁▁▁▁▁▂▃▄▄▅▆▆▇▆▆▄▃▃▂▂▁▁▁ ▁▁▂▂▃▄▄▅▆▇▇▆▆▆
+▄▅▆▆▅▅▄▃▃▄▄▅▆▅▅▄▃▃▃▃▄▅▆▇▇▇▆▅▄▄▃▃▂▁▁▁▁▁▂▃▄▅▆▇▇▇▆▆▅▄▃▃▂▁▁▁▁▁▂▃▃▄▅▆▆▇▇▆▆▅
+▄▅▅▅▅▄▃▃▃▃▄▅▅▅▄▄▃▂▃▃▄▅▆▇▇▇▇▆▅▅▄▃▃▂▁▁▁▁▂▃▄▅▆▇▇▇▇▆▅▅▄▃▃▂▂▁▁▂▃▃▄▅▅▆▆▇▆▆▅▅
+▄▄▅▅▅▄▃▃▂▃▄▄▅▅▄▃▃▂▃▃▄▅▆▇▇▇▇▇▆▅▅▄▄▃▂▁▁▁▂▃▄▅▆▇▇▇▇▇▆▅▅▄▄▃▂▂▂▃▃▄▅▅▆▆▇▆▆▅▄▄
+▃▄▄▅▄▄▃▂▂▃▃▄▄▄▄▃▃▂▃▃▄▅▆▇███▇▇▆▆▆▅▄▃▂▁▂▂▃▄▄▅▆▇▇▇▇▆▆▅▅▄▃▃▃▃▃▄▅▆▆▇▇▇▆▅▄▃▂
+▂▃▄▄▄▄▃▃▃▃▃▄▄▄▃▃▃▃▃▄▅▆▇▇█████▇▇▇▆▅▄▃▃▂▃▃▄▄▅▆▇▇▇▆▆▅▅▅▄▃▃▃▃▄▅▅▆▇▇▇▇▆▅▃▂▁
+▂▃▃▄▄▄▄▃▃▃▃▄▄▃▃▃▃▃▄▄▅▆▇████████▇▇▆▆▅▄▄▄▄▄▅▅▅▆▆▆▆▅▅▄▄▄▃▃▃▃▄▅▆▆▇▇▇▇▆▄▂▁▁
+▂▂▃▄▅▅▅▄▄▄▄▄▃▃▃▃▃▃▄▅▆▆▇██████████▇▇▆▆▅▅▅▅▅▅▅▅▅▅▄▄▄▄▃▃▃▃▃▃▄▅▆▆▇▇▇▆▅▃▂▁ 
+▂▂▃▅▅▆▆▆▅▅▄▄▃▃▂▂▃▃▄▅▆▇▇▇██████████▇▇▇▆▆▅▅▅▄▄▄▃▃▃▃▃▃▃▃▂▂▂▃▃▄▅▆▇▇▇▆▅▃▂▁ 
+▂▃▄▅▆▇▇▆▆▅▅▄▃▂▂▂▂▃▄▅▆▆▇▇▇▇▇▇▇▇▇▇▇██▇▇▇▆▆▅▅▄▃▃▂▂▂▂▂▃▃▂▂▂▂▂▃▃▄▅▆▇▇▆▅▃▂▁▁
+▃▄▅▆▇▇▇▇▆▅▅▄▃▂▁▁▂▃▄▅▅▆▆▇▇▇▆▆▆▆▆▆▇▇▇▇▇▇▆▆▅▄▃▃▂▂▂▂▂▂▃▃▂▂▂▂▂▂▃▄▅▆▆▆▆▅▄▃▂▂
+▃▄▅▆▇▇▇▇▆▅▄▃▂▂▁▁▁▂▃▄▅▅▆▆▆▆▅▅▅▅▅▅▆▇▇▇▇▇▆▅▅▄▃▂▂▂▂▂▃▃▃▃▃▃▂▂▂▂▂▃▄▅▆▆▆▅▅▄▃▃
+▄▅▆▇▇█▇▇▆▅▄▃▂▁▁▁▁▁▂▃▄▅▅▅▅▅▄▄▄▄▄▄▅▆▆▇▇▆▆▅▄▃▂▂▂▂▂▃▃▄▄▄▄▃▃▂▂▂▂▃▄▅▆▆▆▆▅▅▄▄
+▅▅▆▇██▇▇▆▅▄▃▂▁   ▁▂▃▃▄▄▅▅▄▄▃▃▃▃▄▄▅▆▆▆▆▅▄▃▃▂▂▁▂▂▃▄▅▅▅▅▄▃▂▂▂▂▃▄▅▆▆▆▆▆▅▅▅
+▅▆▇▇██▇▆▅▄▃▂▁▁   ▁▁▂▃▄▄▄▄▄▃▃▂▂▃▃▄▄▅▅▅▅▄▃▃▂▁▁▁▂▃▄▅▅▅▅▅▄▃▂▂▂▂▂▃▄▅▆▆▆▆▆▆▆
+▆▇▇███▇▆▅▃▂▂▁    ▁▁▂▃▄▄▄▄▄▃▃▃▂▃▃▃▄▄▄▄▄▃▂▂▁▁▁▁▁▂▃▅▅▅▅▅▄▃▂▁▁▁▂▃▃▄▅▆▇▇▇▇▇
+▇▇████▇▆▄▃▂▁▁    ▁▂▃▃▄▅▅▅▅▄▄▃▃▃▃▃▄▄▄▃▃▂▂▁▁  ▁▁▂▃▄▅▅▅▄▄▃▂▁▁▁▁▂▃▄▅▆▇▇███
+▇▇████▇▆▄▃▂▁▁    ▁▂▃▄▅▅▆▆▆▅▅▄▄▄▄▄▄▃▃▃▂▂▁▁    ▁▂▂▃▄▄▄▄▃▂▁▁▁▁▁▁▂▃▄▆▇▇███
+▇▇████▇▆▄▃▂▁▁   ▁▂▃▄▅▅▆▆▇▇▆▆▅▅▄▄▄▄▃▃▃▂▂▁▁▁   ▁▁▂▃▃▃▃▃▂▂▁▁▁▁▁▁▂▃▄▆▇▇███
+▆▇▇███▇▆▅▃▂▂▁   ▁▂▃▄▅▆▆▇▇▇▇▇▆▅▅▄▄▄▃▃▃▃▂▂▁▁▁▁▁▁▁▂▂▃▃▃▂▂▁▁▁▁▁▁▂▂▃▄▆▆▇▇▇▇
+▅▆▇▇██▇▆▅▄▃▂▁▁ ▁▁▂▃▄▅▆▆▇▇█▇▇▆▆▅▅▄▄▄▃▃▃▃▃▂▂▁▁▁▁▂▂▂▃▃▃▂▂▂▁▁▁▁▂▂▃▄▅▆▆▇▇▇▆
+▅▅▆▇██▇▇▆▅▄▃▂▁▁▁▁▂▃▄▅▅▆▇▇▇▇▇▆▅▅▄▄▃▃▄▄▄▄▄▃▃▂▂▂▂▂▃▃▃▃▃▃▃▂▂▂▂▂▃▃▄▄▅▆▆▆▆▆▅
+▄▅▆▇▇█▇▇▆▅▄▃▂▁▁▁▁▁▂▃▄▅▆▆▇▇▇▆▅▅▄▃▃▃▃▄▄▄▅▄▄▄▃▃▃▃▃▄▄▄▄▄▄▃▃▃▃▃▃▄▄▄▅▆▆▆▆▆▅▄
+▃▄▅▆▇▇▇▇▆▅▄▃▂▁▁▁▁▁▂▃▃▄▅▆▆▆▆▆▅▄▃▃▂▃▃▄▅▅▅▅▅▄▄▄▄▄▄▅▅▅▅▅▅▄▄▄▄▄▄▄▅▅▆▆▆▆▆▅▄▄
+▃▄▅▆▇▇▇▇▇▆▅▄▃▂▁▁▁▁▂▂▃▄▄▅▆▆▅▅▄▃▃▂▂▂▃▄▅▆▆▆▆▆▅▅▅▅▅▆▆▆▆▆▆▆▅▅▅▅▅▅▆▆▇▇▇▆▆▅▄▃
+▃▄▄▆▇▇▇▇▇▆▅▄▃▂▁▁▁▁▂▃▃▄▄▅▅▅▄▄▃▃▂▂▂▃▄▅▆▇▇▇▇▇▆▆▆▆▇▇▇▇▇▇▇▇▆▆▅▅▆▆▆▇▇▇▇▇▆▅▄▃
+▃▃▄▅▆▇▇▇▇▆▅▄▃▂▂▁▂▂▃▃▃▄▄▄▄▄▄▃▃▃▂▂▃▄▅▆▇████▇▇▇▇▇▇██████▇▇▆▆▆▆▆▇▇███▇▇▆▅▄
+▃▄▄▅▆▆▇▇▆▆▅▄▃▂▂▂▃▃▄▄▄▄▄▄▃▃▃▃▃▃▃▃▄▅▆▇▇█████▇▇▇▇███████▇▇▆▆▆▆▆▇▇████▇▆▅▅
+▄▄▄▄▅▆▆▆▆▆▅▄▃▂▂▃▃▄▅▅▅▄▄▃▃▂▂▂▂▃▃▄▅▆▇▇█████▇▇▇▇▇▇█████▇▇▆▆▅▅▅▆▇▇████▇▇▆▅
+▄▄▄▄▄▅▆▆▆▅▄▃▃▃▃▃▄▅▅▅▅▅▄▃▂▂▂▂▂▃▄▅▆▆▇███▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▆▅▄▄▄▄▅▆▇▇███▇▇▆▆
+▄▄▃▄▄▅▅▆▆▅▄▃▃▂▃▄▄▅▆▆▅▄▃▂▂▁▁▂▂▃▄▅▆▇▇▇▇▇▇▆▆▆▆▆▆▆▆▆▆▆▆▆▆▅▄▃▃▃▃▄▅▆▇▇▇▇▇▇▆▆
+▄▄▃▃▄▄▅▅▅▅▄▃▂▂▃▃▄▅▅▅▅▄▃▂▁▁▁▁▂▃▄▅▆▇▇▇▇▇▆▅▅▅▅▄▄▅▅▅▅▅▅▅▄▄▃▂▂▂▃▃▄▅▆▇▇▇▇▆▆▅
+▄▃▃▃▃▄▅▅▅▅▄▃▂▂▃▃▄▅▅▅▄▃▂▁▁▁▁▁▂▃▄▅▆▇▇▇▆▆▅▄▄▄▃▃▃▃▄▄▄▄▄▄▃▃▂▂▁▂▂▃▄▅▆▆▇▇▆▆▅▄
+▄▃▂▃▃▄▅▅▆▅▄▃▃▂▂▃▃▄▄▄▃▂▂▁   ▁▂▃▄▅▆▆▆▆▆▅▄▃▃▃▃▂▂▂▃▃▃▃▃▃▂▂▁▁▁▁▂▃▄▅▅▆▆▆▅▅▄▃
+▃▃▂▃▃▄▅▆▆▅▅▄▃▃▃▃▃▃▃▃▂▂▁    ▁▂▃▃▄▅▆▆▆▅▄▄▃▃▂▂▂▂▂▂▂▂▂▂▂▂▁▁▁▁▁▁▂▃▄▅▅▆▅▄▄▃▂
+▄▃▂▃▃▄▅▆▆▆▅▄▄▃▃▃▃▃▂▂▁▁     ▁▂▃▃▄▅▅▅▅▅▄▃▃▃▂▂▂▁▁▁▁▁▁▁▁▁▁   ▁▁▂▂▃▄▅▅▄▃▂▂▁
+▄▃▃▃▄▅▆▆▇▇▆▅▅▄▄▃▃▂▂▁▁▁    ▁▁▂▃▃▄▄▅▅▅▅▄▄▃▃▃▂▁▁▁   ▁▁▁▁▁    ▁▁▂▃▃▄▄▄▃▂▁▁
+▄▄▃▃▄▅▆▇▇▇▆▆▅▅▄▄▃▂▂▁▁    ▁▁▂▃▃▄▄▄▄▄▅▅▅▄▄▄▃▃▂▁▁    ▁▁▁▁▁   ▁▁▂▂▃▄▄▃▃▂▁ 
+▅▄▄▄▄▅▆▆▇▇▇▆▆▅▅▄▃▃▂▁▁▁  ▁▂▂▃▄▄▄▃▃▃▄▄▅▅▅▅▄▄▃▂▁▁   ▁▁▁▁▁▁▁▁▁▁▁▂▂▃▄▄▄▃▂▁▁
+▅▄▄▄▄▄▅▆▇▇▆▆▆▆▅▅▄▃▃▂▁▁▁▁▂▃▄▄▅▅▄▃▃▃▃▄▅▅▆▅▅▄▄▂▁▁  ▁▁▂▂▂▂▂▂▁▁▁▁▂▃▄▄▅▄▄▃▂▁
+▅▄▄▃▃▄▅▅▆▆▆▆▆▅▅▅▅▄▄▃▂▂▂▂▃▄▅▅▅▅▄▃▃▃▃▄▅▅▆▆▅▅▄▂▂▁▁▁▁▂▂▃▃▃▃▂▂▂▂▂▃▃▄▅▅▅▅▄▃▂
+▅▄▃▃▃▃▄▄▅▅▅▅▅▅▅▅▅▅▄▄▃▃▂▃▄▄▅▆▆▅▄▃▃▂▃▃▄▅▅▅▅▄▃▂▁▁▁▁▂▃▃▄▄▄▄▃▃▂▂▃▃▄▅▆▆▆▆▅▄▄
+▄▃▃▂▂▂▃▄▄▄▄▄▄▄▅▅▅▅▅▅▄▃▃▄▄▅▅▆▆▅▄▃▂▂▂▃▄▄▅▄▄▃▃▂▁▁▁▂▂▃▄▅▅▅▅▄▃▃▃▃▄▅▆▆▇▇▇▆▅▅
+▃▃▂▂▂▂▂▃▃▃▃▃▃▄▄▅▆▆▆▅▅▄▄▄▅▅▆▆▆▅▄▃▂▂▂▂▃▄▄▄▃▃▂▁▁▁▁▂▃▄▅▅▆▆▅▅▄▄▄▄▅▅▆▇▇▇▇▇▆▅
+▃▂▂▁▁▁▁▂▂▂▂▂▂▃▄▅▆▆▇▆▆▅▅▅▅▆▆▆▅▅▄▃▂▂▂▂▃▃▃▃▃▂▂▁▁▁▂▂▃▄▅▆▆▆▆▅▅▄▄▅▅▆▇▇███▇▇▆
+▃▂▂▁▁▁▁▁▁▁▁▁▁▂▃▅▆▇▇▇▇▆▆▆▆▆▆▆▅▅▄▃▂▂▂▂▃▃▃▃▃▂▂▁▁▂▂▃▄▅▆▆▆▆▆▅▅▅▅▆▆▇▇██████▇
+▃▂▂▁▁▁▁▁▁    ▁▂▄▆▇██▇▇▇▇▇▇▇▆▅▄▃▃▂▂▂▂▃▄▄▄▃▃▂▂▂▃▃▄▅▆▆▆▆▆▅▅▅▅▅▆▇▇████████
+▄▃▂▁▁▁▁      ▁▂▄▆▇████▇▇▇▇▇▆▅▄▃▂▂▂▂▃▃▄▅▄▄▃▃▃▃▄▄▅▆▆▆▆▅▅▅▄▄▅▅▆▇▇████████
+▄▃▂▂▁▁▁▁▁▁   ▁▂▃▅▇▇██▇▇██▇▇▆▆▄▃▃▂▂▂▃▄▅▅▅▅▄▄▄▄▅▅▆▆▆▆▅▅▄▃▃▄▄▅▆▇▇████████
+▄▄▃▂▂▁▁▁▁▁▁▁▁▁▂▃▅▆▇▇▇▇▇▇▇▇▇▆▆▅▄▃▂▂▂▃▄▅▆▆▅▅▄▄▅▅▆▆▆▆▅▄▄▃▂▂▂▃▄▅▆▇▇███▇▇▇▇
+▅▄▃▂▂▂▂▂▂▂▂▂▁▂▂▃▄▅▆▆▆▆▆▇▇▇▇▆▆▅▄▃▂▂▃▃▄▅▆▆▅▅▄▅▅▆▆▆▆▅▅▄▃▂▁▁▂▂▄▅▅▆▇▇▇▇▆▆▆▆
+▄▄▃▂▂▃▃▃▄▃▃▃▂▂▂▃▃▄▅▅▅▅▆▆▇▇▇▆▆▅▄▃▂▂▃▃▄▅▅▅▅▄▄▄▅▅▆▆▆▅▄▃▂▁▁▁▁▂▃▄▅▅▆▆▆▆▅▅▅▅
+▄▃▃▂▂▃▃▄▄▄▄▄▃▃▃▃▃▃▄▄▄▄▅▅▆▇▇▆▆▅▄▃▂▂▂▃▄▄▅▅▄▃▃▄▄▅▆▆▆▅▄▃▂▁  ▁▁▂▃▄▅▅▆▅▅▅▄▄▄
+```
+
+### Noise synthesis
+
+Noise looks much more interesting when combined.
+
+```ruby
+noises = Perlin::Noise.new(2)
+contrast = Perlin::Curve.contrast(Perlin::Curve::QUINTIC, 3)
+
+(0..100).each do |x|
+  n = 0
+  [[0.02, 10], [0.04, 10], [0.1, 20], [0.2, 15]].each_with_index do |step_scale, idx|
+    step, scale = step_scale
+    n += contrast.call( noises[idx, x * step] ) * scale
+  end
+  puts '=' * n.floor
+end
+```
+
+```
+================================
+=========================================
+===============================================
+===============================================
+========================================
+===========================
+===================
+=====================
+========================
+===========================
+============================
+=============================
+==============================
+==============================
+==============================
+===========================
+=======================
+======================
+======================
+========================
+==========================
+============================
+===============================
+=================================
+==================================
+=================================
+================================
+=================================
+==================================
+=====================================
+======================================
+=========================================
+================================================
+=========================================================
+===========================================================
+=====================================================
+==============================================
+===============================================
+=====================================================
+=================================================
+=================================
+==================
+=============
+=============
+====================
+============================
+=====================================
+==============================================
+================================================
+=============================================
+================================
+==================
+============
+===========
+===========
+==================
+=========================
+==========================
+===========================
+================================
+================================
+==================================
+=========================================
+==================================================
+====================================================
+===============================================
+=========================================
+==========================================
+==============================================
+============================================
+===============================
+================
+==========
+========
+==========
+=============
+===================
+==========================
+===============================
+================================
+=========================
+================
+===========
+=======
+======
+=============
+====================
+======================
+========================
+=============================
+===============================
+==================================
+=======================================
+========================================
+=========================================
+================================================
+======================================================
+======================================================
+===============================================
+======================================
+================================
+```
+
+
+## References
+- Texturing & modeling: a procedural approach by David S. Ebert et al.
+- Improving Noise by Ken Perlin (http://mrl.nyu.edu/~perlin/paper445.pdf)
+- http://webstaff.itn.liu.se/~stegu/TNM022-2005/perlinnoiselinks/perlin-noise-math-faq.html#algorithm
+- http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+- http://burtleburtle.net/bob/rand/unitvec.html
+- http://briansharpe.wordpress.com/2011/11/14/two-useful-interpolation-functions-for-noise-development/
+- http://http.developer.nvidia.com/GPUGems/gpugems_ch05.html
+- http://www.java-gaming.org/index.php?topic=22796.0

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+

data/lib/perlin/curve.rb

@@ -0,0 +1,21 @@
+module Perlin
+  module Curve
+    LINEAR  = proc { |t| t }
+    CUBIC   = proc { |t| 3 * (t ** 2) - 2 * (t ** 3) }
+    QUINTIC = proc { |t| 6 * (t ** 5) - 15 * (t ** 4) + 10 * (t ** 3) }
+
+    # Returns a Proc object which applies S-curve function to
+    # a given number between 0 and 1.
+    # @param[Proc] curve
+    # @param[Fixnum] times
+    # @return[Proc]
+    def self.contrast curve, times
+      lambda { |n|
+        times.times do
+          n = curve.call n
+        end
+        n
+      }
+    end
+  end
+end

data/lib/perlin/gradient_table.rb

@@ -0,0 +1,41 @@
+module Perlin
+  class GradientTable
+    # Bit-wise AND operation is not any faster than MOD in Ruby
+    # MOD operation returns positive number for negative input
+    def initialize dim, interval = 256
+      @dim = dim
+      @interval = interval
+
+      @table   = Array.new(interval) { rand @interval }
+      @vectors = Array.new(interval) { random_unit_vector }
+    end
+
+    def [] *coords
+      @vectors[index *coords]
+    end
+
+  private
+    # A simple hashing
+    def index *coords
+      s = coords.last
+      coords.reverse[1..-1].each do |c|
+        s = perm(s) + c
+      end
+      perm(s)
+    end
+
+    def perm s
+      @table[s % @interval]
+    end
+
+    def random_unit_vector
+      while true
+        v = Vector[*Array.new(@dim) { rand * 2 - 1 }]
+        # Discards vectors whose length greater than 1 to avoid bias in distribution
+        break if v.r > 0 && v.r <= 1
+      end
+      r = v.r
+      v.map { |e| e / v.r }
+    end
+  end
+end

data/lib/perlin/noise.rb

@@ -0,0 +1,81 @@
+module Perlin
+  class Noise
+    DEFAULT_OPTIONS = {
+      :interval => 256,
+      :curve => Perlin::Curve::QUINTIC,
+      :contrast => proc { }
+    }
+
+    def initialize dim, options = {}
+      options = DEFAULT_OPTIONS.merge options
+
+      @dim = dim
+      @interval = options.fetch(:interval)
+      @curve = options.fetch(:curve)
+
+      raise ArgumentError.new("Invalid dimension: must be a positive integer")  unless @dim.is_a?(Fixnum) && @dim > 0
+      raise ArgumentError.new("Invalid interval: must be a positive integer")   unless @interval.is_a?(Fixnum) && @interval > 0
+      raise ArgumentError.new("Invalid curve specified: must be a Proc object") unless @curve.is_a?(Proc)
+
+      # Generate pseudo-random gradient vector for each grid point
+      @gradient_table = Perlin::GradientTable.new @dim, @interval
+    end
+
+    # @param [*coords] Coordinates
+    # @return [Float] Noise value between (-1..1)
+    def [] *coords
+      raise ArgumentError.new("Invalid coordinates") unless coords.length == @dim
+
+      coords = Vector[*coords]
+      cell = Vector[*coords.map(&:to_i)]
+      diff = coords - cell
+
+  		# Calculate noise factor at each surrouning vertex
+      nf = {}
+      iterate @dim, 2 do |idx|
+        idx = Vector[*idx]
+
+        # "The value of each gradient ramp is computed by means of a scalar
+        # product (dot product) between the gradient vectors of each grid point
+        # and the vectors from the grid points."
+        gv = @gradient_table[ * (cell + idx).to_a ]
+			  nf[idx.to_a] = gv.inner_product(diff - idx) 
+      end
+
+      dim = @dim
+      diff.to_a.each do |u|
+        bu = @curve.call u
+
+        # Pair-wise interpolation, trimming down dimensions
+        iterate dim, 2 do |idx1|
+          next if idx1.first == 1
+
+          idx2 = idx1.dup
+          idx2[0] = 1
+          idx3 = idx1[1..-1]
+
+          nf[idx3] = nf[idx1] + bu * (nf[idx2] - nf[idx1])
+        end
+        dim -= 1
+      end
+      (nf[[]] + 1) * 0.5
+    end
+
+  private
+    def iterate dim, length, &block
+      iterate_recursive dim, length, Array.new(dim, 0), &block
+    end
+
+    def iterate_recursive dim, length, idx, &block
+      length.times do |i|
+        idx[dim - 1] = i
+        if dim == 1
+          yield idx
+        else
+          iterate_recursive dim - 1, length, idx, &block
+        end
+      end
+    end
+  end#Noise
+end#Perlin
+

data/lib/perlin/version.rb

@@ -0,0 +1,3 @@
+module Perlin
+  VERSION = "0.1.0"
+end

data/lib/perlin_noise.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'matrix'
+require 'perlin/version'
+require 'perlin/curve'
+require 'perlin/gradient_table'
+require 'perlin/noise'
+

data/perlin_noise.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "perlin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "perlin_noise"
+  s.version     = Perlin::VERSION
+  s.authors     = ["Junegunn Choi"]
+  s.email       = ["junegunn.c@gmail.com"]
+  s.homepage    = "https://github.com/junegunn/perlin_noise"
+  s.summary     = %q{Perlin noise generator}
+  s.description = %q{Perlin noise implemented in Ruby}
+
+  s.rubyforge_project = "perlin"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/test/test_perlin.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'perlin_noise'
+require 'benchmark'
+
+# TODO
+class PerlinTest < Test::Unit::TestCase
+  def test_gradient_table
+    [10, 100, 1000].each do |interval|
+
+      gt = Perlin::GradientTable.new 1, interval
+
+      interval.times do |i|
+        assert (0.99..1.01).include?(gt[interval + i].r)
+      end
+
+      assert_equal gt[1], gt[1 + interval]
+      assert_equal gt[1], gt[1 + interval * 2]
+
+      gt = Perlin::GradientTable.new 2, interval
+      assert_equal gt[1, 1], gt[1, 1 + interval]
+      assert_equal gt[1, 1], gt[1, 1 + interval * 2]
+
+      gt = Perlin::GradientTable.new 4, interval
+      assert_equal gt[1, 2, 3, 4], gt[1, 2, 3 + interval, 4]
+      assert_equal gt[1, 2, 3, 4], gt[1, 2, 3 + interval * 2, 4]
+
+      interval.times do |i|
+        # FIXME: rand
+        assert (0.99..1.01).include?(gt[rand(interval), rand(interval), rand(interval), interval + i].r)
+      end
+    end
+
+    # FIXME: Just checking. Two-fold slower than default Ruby hash 
+    gt = Perlin::GradientTable.new 3
+    puts Benchmark.measure {
+      300000.times do |i|
+        gt[i * 0.01, i * 0.02, i * 0.03]
+      end
+    }
+  end
+
+  def test_curve
+    curves = [ Perlin::Curve::LINEAR, Perlin::Curve::CUBIC, Perlin::Curve::QUINTIC ]
+
+    curves.each_with_index do |c, idx|
+      0.step(1, 0.01).each do |x|
+        case idx
+        when 0
+          assert_equal x, c.call(x)
+        else
+          if x == 1 || x == 0
+            assert_equal x, c.call(x)
+          elsif x > 0.5
+            assert c.call(x) > x
+          elsif x == 0.5
+            assert_equal x, c.call(x)
+          else
+            assert c.call(x) < x
+          end
+        end
+      end
+    end
+  end
+
+  def test_noise_invalid_params
+    # Dimension
+    assert_raise(ArgumentError) { Perlin::Noise.new 0 }
+    assert_raise(ArgumentError) { Perlin::Noise.new 0.1 }
+    assert_raise(ArgumentError) { Perlin::Noise.new -1 }
+    assert_raise(ArgumentError) { Perlin::Noise.new -0.1 }
+
+    # Interval
+    Perlin::Noise.new 1
+    Perlin::Noise.new 1, :inteval => 100
+    assert_raise(ArgumentError) { Perlin::Noise.new 1, :interval => 0.5 }
+    assert_raise(ArgumentError) { Perlin::Noise.new 1, :interval => -1 }
+
+    # Curve
+    Perlin::Noise.new 2, :curve => Perlin::Curve::CUBIC
+    assert_raise(ArgumentError) { Perlin::Noise.new 2, :curve => nil }
+  end
+
+  def test_noise_1d
+    width = 60
+
+    noise = Perlin::Noise.new 1, :interval => 200
+    0.step(300, 0.1).each do |x|
+      n = noise[x]
+      len = (n * width).to_i
+      puts '#' * len
+      assert (0..width).include?(len)
+
+      if x.to_i == x
+        assert_equal 0.5, noise[x]
+      end
+    end
+  end
+
+  def test_noise_range
+    (1..7).each do |dim|
+      noise = Perlin::Noise.new dim
+      max = -999
+      min =  999
+
+      (0..100).each do |i|
+        coords = Array.new(dim) { |j| i * (j + 1) * 0.001 }
+        n = noise[*coords]
+
+        assert (0..1).include?(n)
+
+        max = n if n > max
+        min = n if n < min
+      end
+    end
+  end
+
+
+  def test_noise_2d
+    noises = Perlin::Noise.new(2)
+    contrast = Perlin::Curve.contrast(Perlin::Curve::CUBIC, 2)
+
+    bars = " ▁▂▃▄▅▆▇█".each_char.to_a
+    bar = lambda { |n| 
+      bars[ (bars.length * n).floor ]
+    }
+
+    0.upto(100) do |i|
+      70.times do |y|
+        n = noises[i * 0.1, y * 0.1]
+        n = contrast.call n
+
+        print bar.call(n)
+      end
+      puts
+    end
+  end
+
+  def test_synthesis
+    noises = Perlin::Noise.new(2)
+    contrast = Perlin::Curve.contrast(Perlin::Curve::QUINTIC, 3)
+
+    (0..100).each do |x|
+      n = 0
+      [[0.02, 10], [0.04, 10], [0.1, 30], [0.2, 15]].each_with_index do |step_scale, idx|
+        step, scale = step_scale
+        n += contrast.call( noises[idx, x * step] ) * scale
+      end
+      puts '=' * n.floor
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: perlin_noise
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-16 00:00:00.000000000 Z
+dependencies: []
+description: Perlin noise implemented in Ruby
+email:
+- junegunn.c@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- lib/perlin/curve.rb
+- lib/perlin/gradient_table.rb
+- lib/perlin/noise.rb
+- lib/perlin/version.rb
+- lib/perlin_noise.rb
+- perlin_noise.gemspec
+- test/test_perlin.rb
+homepage: https://github.com/junegunn/perlin_noise
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: perlin
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Perlin noise generator
+test_files:
+- test/test_perlin.rb
+has_rdoc: