ruby-fann 0.7.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2007-12-18
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2007 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+ext/ruby_fann/extconf.rb
+ext/ruby_fann/fann_augment.h
+ext/ruby_fann/neural_network.c
+lib/ruby_fann.rb
+lib/ruby_fann/version.rb
+lib/ruby_fann/neurotica.rb
+log/debug.log
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_helper.rb
+test/test_ruby_fann.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1 @@
+README

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,71 @@
+require 'ruby_fann/version'
+
+AUTHOR = 'Steven Miers'  # can also be an array of Authors
+EMAIL = "steven@7bpeople.com"
+DESCRIPTION = "Bindings to use FANN from within ruby/rails environment."
+GEM_NAME = 'ruby-fann' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'ruby-fann' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = RubyFann::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'ruby_fann documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'ruby_fann'

data/ext/ruby_fann/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+dir_config("ruby_fann")
+find_library("doublefann", "fann_create_standard", "/usr/local/lib")
+#create_makefile("ruby-fann")
+create_makefile("neural_network")

data/ext/ruby_fann/fann_augment.h

@@ -0,0 +1,110 @@
+
+FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train_from_rb_ary2(
+	unsigned int num_data,
+	unsigned int num_input,
+  unsigned int num_output)
+{
+	return 0;
+}
+
+/*
+ * Copied from fann_create_train_from_callback/file & modified to ease 
+ * allocating from ruby arrays:
+ */
+FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train_from_rb_ary(
+	VALUE inputs, 
+	VALUE outputs 
+)
+{
+    unsigned int i, j;
+    fann_type *data_input, *data_output;
+    struct fann_train_data *data = (struct fann_train_data *)malloc(sizeof(struct fann_train_data));
+    unsigned int num_input = RARRAY(RARRAY(inputs)->ptr[0])->len;
+    unsigned int num_output =RARRAY(RARRAY(outputs)->ptr[0])->len;
+		unsigned int num_data = RARRAY(inputs)->len;
+		
+    if(data == NULL) {
+        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
+        return NULL;
+    }
+
+    fann_init_error_data((struct fann_error *) data);
+
+    data->num_data     = num_data;
+    data->num_input    = num_input;
+    data->num_output = num_output;
+
+    data->input = (fann_type **) calloc(num_data, sizeof(fann_type *));
+    if(data->input == NULL)
+    {
+        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
+        fann_destroy_train(data);
+        return NULL;
+    }
+
+    data->output = (fann_type **) calloc(num_data, sizeof(fann_type *));
+    if(data->output == NULL)
+    {
+        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
+        fann_destroy_train(data);
+        return NULL;
+    }
+
+    data_input = (fann_type *) calloc(num_input * num_data, sizeof(fann_type));
+    if(data_input == NULL)
+    {
+        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
+        fann_destroy_train(data);
+        return NULL;
+    }
+
+    data_output = (fann_type *) calloc(num_output * num_data, sizeof(fann_type));
+    if(data_output == NULL)
+    {
+        fann_error(NULL, FANN_E_CANT_ALLOCATE_MEM);
+        fann_destroy_train(data);
+        return NULL;
+    }
+
+		VALUE inputs_i, outputs_i;
+		for(i = 0; i != num_data; i++)
+		{
+			data->input[i] = data_input;
+			data_input += num_input;
+
+			inputs_i = RARRAY(inputs)->ptr[i];
+			outputs_i = RARRAY(outputs)->ptr[i];
+			
+			if(RARRAY(inputs_i)->len != num_input) 
+			{
+				rb_raise (
+					rb_eRuntimeError, 
+					"Number of inputs at [%d] is inconsistent: (%d != %d)", 
+					i, RARRAY(inputs_i)->len, num_input);
+			}
+			
+			if(RARRAY(outputs_i)->len != num_output) 
+			{
+				rb_raise (
+					rb_eRuntimeError, 
+					"Number of outputs at [%d] is inconsistent: (%d != %d)", 
+					i, RARRAY(outputs_i)->len, num_output);
+			}
+			
+			
+			for(j = 0; j != num_input; j++)
+			{
+				data->input[i][j]=NUM2DBL(RARRAY(inputs_i)->ptr[j]);
+			}
+
+			data->output[i] = data_output;
+			data_output += num_output;
+			
+			for(j = 0; j != num_output; j++)
+			{
+				data->output[i][j]=NUM2DBL(RARRAY(outputs_i)->ptr[j]);
+			}
+		}
+		
+    return data;
+}

data/ext/ruby_fann/neural_network.c

@@ -0,0 +1,1499 @@
+#include "ruby.h"
+// #include "fann.h"
+#include "doublefann.h"
+#include "fann_data.h"
+#include "fann_augment.h"
+
+static VALUE m_rb_fann_module;
+static VALUE m_rb_fann_standard_class;
+static VALUE m_rb_fann_shortcut_class;
+static VALUE m_rb_fann_train_data_class;
+
+#define RETURN_FANN_INT(fn) \
+struct fann* f; \
+Data_Get_Struct (self, struct fann, f); \
+return INT2NUM(fn(f)); 
+
+#define SET_FANN_INT(attr_name, fann_fn) \
+Check_Type(attr_name, T_FIXNUM); \
+struct fann* f; \
+Data_Get_Struct(self, struct fann, f); \
+fann_fn(f, NUM2INT(attr_name)); \
+
+#define RETURN_FANN_UINT(fn) \
+struct fann* f; \
+Data_Get_Struct (self, struct fann, f); \
+return UINT2NUM(fn(f)); 
+
+#define SET_FANN_UINT(attr_name, fann_fn) \
+Check_Type(attr_name, T_FIXNUM); \
+struct fann* f; \
+Data_Get_Struct(self, struct fann, f); \
+fann_fn(f, NUM2UINT(attr_name)); \
+
+// Converts float return values to a double with same precision, avoids floating point errors.
+#define RETURN_FANN_FLT(fn) \
+struct fann* f; \
+Data_Get_Struct (self, struct fann, f); \
+char buffy[20]; \
+sprintf(buffy, "%0.6g", fn(f)); \
+return rb_float_new(atof(buffy)); 
+
+#define SET_FANN_FLT(attr_name, fann_fn) \
+Check_Type(attr_name, T_FLOAT); \
+struct fann* f; \
+Data_Get_Struct(self, struct fann, f); \
+fann_fn(f, NUM2DBL(attr_name)); \
+
+#define RETURN_FANN_DBL(fn) \
+struct fann* f; \
+Data_Get_Struct (self, struct fann, f); \
+return rb_float_new(fn(f)); 
+
+#define SET_FANN_DBL SET_FANN_FLT
+
+// Convert ruby symbol to corresponding FANN enum type for activation function:
+enum fann_activationfunc_enum sym_to_activation_function(VALUE activation_func)
+{
+	ID id=SYM2ID(activation_func);
+	enum fann_activationfunc_enum activation_function;
+	if(id==rb_intern("linear")) {
+		activation_function = FANN_LINEAR;	
+	}	else if(id==rb_intern("threshold")) {
+		activation_function = FANN_THRESHOLD;	
+	}	else if(id==rb_intern("threshold_symmetric")) {
+		activation_function = FANN_THRESHOLD_SYMMETRIC;	
+	}	else if(id==rb_intern("sigmoid")) {
+		activation_function = FANN_SIGMOID;	
+	}	else if(id==rb_intern("sigmoid_stepwise")) {
+		activation_function = FANN_SIGMOID_STEPWISE;	
+	}	else if(id==rb_intern("sigmoid_symmetric")) {
+		activation_function = FANN_SIGMOID_SYMMETRIC;	
+	}	else if(id==rb_intern("sigmoid_symmetric_stepwise")) {
+		activation_function = FANN_SIGMOID_SYMMETRIC_STEPWISE;	
+	}	else if(id==rb_intern("gaussian")) {
+		activation_function = FANN_GAUSSIAN;	
+	}	else if(id==rb_intern("gaussian_symmetric")) {
+		activation_function = FANN_GAUSSIAN_SYMMETRIC;	
+	}	else if(id==rb_intern("gaussian_stepwise")) {
+		activation_function = FANN_GAUSSIAN_STEPWISE;	
+	}	else if(id==rb_intern("elliot")) {
+		activation_function = FANN_ELLIOT;	
+	}	else if(id==rb_intern("elliot_symmetric")) {
+		activation_function = FANN_ELLIOT_SYMMETRIC;	
+	}	else if(id==rb_intern("linear_piece")) {
+		activation_function = FANN_LINEAR_PIECE;	
+	}	else if(id==rb_intern("linear_piece_symmetric")) {
+		activation_function = FANN_LINEAR_PIECE_SYMMETRIC;	
+	}	else if(id==rb_intern("sin_symmetric")) {
+		activation_function = FANN_SIN_SYMMETRIC;	
+	}	else if(id==rb_intern("cos_symmetric")) {
+		activation_function = FANN_COS_SYMMETRIC;	
+	}	else if(id==rb_intern("sin")) {
+		activation_function = FANN_SIN;	
+	}	else if(id==rb_intern("cos")) {
+		activation_function = FANN_COS;	
+	}	else {
+		rb_raise(rb_eRuntimeError, "Unrecognized activation function: [%s]", rb_id2name(SYM2ID(activation_func)));
+	}	
+	return activation_function;
+}
+
+// Convert FANN enum type for activation function to corresponding ruby symbol:
+VALUE activation_function_to_sym(enum fann_activationfunc_enum fn)
+{
+	VALUE activation_function;
+	
+	if(fn==FANN_LINEAR) {
+		activation_function = ID2SYM(rb_intern("linear"));	
+	}	else if(fn==FANN_THRESHOLD) {
+		activation_function = ID2SYM(rb_intern("threshold"));	
+	}	else if(fn==FANN_THRESHOLD_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("threshold_symmetric"));	
+	}	else if(fn==FANN_SIGMOID) {
+		activation_function = ID2SYM(rb_intern("sigmoid"));	
+	}	else if(fn==FANN_SIGMOID_STEPWISE) {
+		activation_function = ID2SYM(rb_intern("sigmoid_stepwise"));	
+	}	else if(fn==FANN_SIGMOID_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("sigmoid_symmetric"));	
+	}	else if(fn==FANN_SIGMOID_SYMMETRIC_STEPWISE) {
+		activation_function = ID2SYM(rb_intern("sigmoid_symmetric_stepwise"));	
+	}	else if(fn==FANN_GAUSSIAN) {
+		activation_function = ID2SYM(rb_intern("gaussian"));	
+	}	else if(fn==FANN_GAUSSIAN_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("gaussian_symmetric"));	
+	}	else if(fn==FANN_GAUSSIAN_STEPWISE) {
+		activation_function = ID2SYM(rb_intern("gaussian_stepwise"));	
+	}	else if(fn==FANN_ELLIOT) {
+		activation_function = ID2SYM(rb_intern("elliot"));	
+	}	else if(fn==FANN_ELLIOT_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("elliot_symmetric"));	
+	}	else if(fn==FANN_LINEAR_PIECE) {
+		activation_function = ID2SYM(rb_intern("linear_piece"));	
+	}	else if(fn==FANN_LINEAR_PIECE_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("linear_piece_symmetric"));	
+	}	else if(fn==FANN_SIN_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("sin_symmetric"));	
+	}	else if(fn==FANN_COS_SYMMETRIC) {
+		activation_function = ID2SYM(rb_intern("cos_symmetric"));	
+	}	else if(fn==FANN_SIN) {
+		activation_function = ID2SYM(rb_intern("sin"));	
+	}	else if(fn==FANN_COS) {
+		activation_function = ID2SYM(rb_intern("cos"));	
+	}	else {
+		rb_raise(rb_eRuntimeError, "Unrecognized activation function: [%d]", fn);
+	}	
+	return activation_function;
+}
+
+
+// Unused for now:
+static void fann_mark (struct fann* ann){}
+
+// #define DEBUG 1
+
+// Free memory associated with FANN:
+static void fann_free (struct fann* ann)
+{
+  fann_destroy(ann);
+	printf("Destroyed FANN network [%d].\n", ann);
+}
+
+// Free memory associated with FANN Training data:
+static void fann_training_data_free (struct fann_train_data* train_data)
+{
+  fann_destroy_train(train_data);
+	printf("Destroyed Training data [%d].\n", train_data);
+}
+
+// Create wrapper, but don't allocate anything...do that in 
+// initialize, so we can construct with args:
+static VALUE fann_allocate (VALUE klass)
+{
+	return Data_Wrap_Struct (klass, fann_mark, fann_free, 0);
+}
+
+// Create wrapper, but don't allocate annything...do that in 
+// initialize, so we can construct with args:
+static VALUE fann_training_data_allocate (VALUE klass)
+{
+	return Data_Wrap_Struct (klass, fann_mark, fann_training_data_free, 0);
+}
+
+
+/** Initialization routine for both standard, shortcut & filename forms of FANN:
+Standard Initialization:
+			RubyFann::Standard.new(:num_inputs=>1, :hidden_neurons=>[3, 4, 3, 4], :num_outputs=>1)
+			
+Shortcut Initialization (e.g., for use in cascade training):
+			RubyFann::Shortcut.new(:num_inputs=>5, :num_outputs=>1)    
+			
+File Initialization:
+			RubyFann::Standard.new(:filename=>'xor_float.net') */
+static VALUE fann_initialize(VALUE self, VALUE hash)
+{
+	// Get args:
+	VALUE filename = rb_hash_aref(hash, ID2SYM(rb_intern("filename")));
+	VALUE num_inputs = rb_hash_aref(hash, ID2SYM(rb_intern("num_inputs")));
+	VALUE num_outputs = rb_hash_aref(hash, ID2SYM(rb_intern("num_outputs")));
+	VALUE hidden_neurons = rb_hash_aref(hash, ID2SYM(rb_intern("hidden_neurons")));
+	
+	struct fann* ann;
+	if (TYPE(filename)==T_STRING) 
+	{
+		// Initialize with file:
+		// train_data = fann_read_train_from_file(StringValuePtr(filename));
+		// DATA_PTR(self) = train_data;
+		ann = fann_create_from_file(StringValuePtr(filename));
+    printf("Created RubyFann::Standard [%d] from file [%s].\n", ann, StringValuePtr(filename));		
+	} 
+	else if(rb_obj_is_kind_of(self, m_rb_fann_shortcut_class))
+	{
+		// Initialize as shortcut, suitable for cascade training:
+		//ann = fann_create_shortcut_array(num_layers, layers);	
+		Check_Type(num_inputs, T_FIXNUM);
+		Check_Type(num_outputs, T_FIXNUM);
+		
+		ann = fann_create_shortcut(2, NUM2INT(num_inputs), NUM2INT(num_outputs));	
+		printf("Created RubyFann::Shortcut [%d].\n", ann);
+	}
+	else
+	{
+		// Initialize as standard:
+		Check_Type(num_inputs, T_FIXNUM);
+		Check_Type(hidden_neurons, T_ARRAY);
+		Check_Type(num_outputs, T_FIXNUM);
+		
+		// Initialize layers:
+		unsigned int num_layers=RARRAY(hidden_neurons)->len + 2; // NUM2INT(num_inputs) + NUM2INT(num_outputs) + RARRAY(hidden_neurons)->len;		
+		unsigned int layers[num_layers];
+
+		// Input:
+		layers[0]=NUM2INT(num_inputs); 
+		// Output:
+		layers[num_layers-1]=NUM2INT(num_outputs);  
+		// Hidden:
+		int i;
+		for (i=1; i<=num_layers-2; i++) {
+			layers[i]=NUM2UINT(RARRAY(hidden_neurons)->ptr[i-1]);
+			printf("Setting layer [%d] to [%d]\n", i, layers[i]);
+		}
+		
+		ann = fann_create_standard_array(num_layers, layers);	
+		printf("Created RubyFann::Standard [%d].\n", ann);
+	}	
+	
+	DATA_PTR(self) = ann;
+	return (VALUE)ann;
+	
+DATA_PTR(self) = ann;
+	return (VALUE)ann;
+}
+
+/** 
+  Initialize in one of the following forms:
+  
+  # This is a flat file with training data as described in FANN docs.
+  RubyFann::TrainData.new(:filename => 'path/to/training_file.train')
+OR
+  # Train with inputs (array of arrays) & desired_outputs (array of arrays)
+  # inputs & desired outputs should be of same length
+  # All sub-arrays on inputs should be of same length
+  # All sub-arrays on desired_outputs should be of same length
+  # Sub-arrays on inputs & desired_outputs can be different sizes from one another
+  RubyFann::TrainData.new(:inputs=>[[0.2, 0.3, 0.4], [0.8, 0.9, 0.7]], :desired_outputs=>[[3.14], [6.33]])    
+*/
+static VALUE fann_train_data_initialize(VALUE self, VALUE hash)
+{
+	struct fann_train_data* train_data;
+	Check_Type(hash, T_HASH);
+  
+	VALUE filename = rb_hash_aref(hash, ID2SYM(rb_intern("filename")));
+	VALUE inputs = rb_hash_aref(hash, ID2SYM(rb_intern("inputs")));
+	VALUE desired_outputs = rb_hash_aref(hash, ID2SYM(rb_intern("desired_outputs")));
+
+  if (TYPE(filename)==T_STRING) 
+	{
+		train_data = fann_read_train_from_file(StringValuePtr(filename));
+		DATA_PTR(self) = train_data;
+	} 
+	else if (TYPE(inputs)==T_ARRAY) 
+	{
+		if (TYPE(desired_outputs)!=T_ARRAY)
+		{
+			rb_raise (rb_eRuntimeError, "[desired_outputs] must be present when [inputs] used.");
+		}
+
+		// The data is here, start constructing:
+		if(RARRAY(inputs)->len != RARRAY(desired_outputs)->len) 
+		{
+			rb_raise (
+				rb_eRuntimeError, 
+				"Number of inputs must match number of outputs: (%d != %d)", 
+				RARRAY(inputs)->len, 
+				RARRAY(desired_outputs)->len);
+		}
+
+		train_data = fann_create_train_from_rb_ary(inputs, desired_outputs);		
+		DATA_PTR(self) = train_data;				
+	} 
+	else 
+	{
+		rb_raise (rb_eRuntimeError, "Must construct with a filename(string) or inputs/desired_outputs(arrays).  All args passed via hash with symbols as keys.");
+	}
+	
+	return (VALUE)train_data;
+}
+
+
+/** Save to given filename */
+static VALUE training_save(VALUE self, VALUE filename)
+{
+	Check_Type(filename, T_STRING);	
+	struct fann_train_data* t;
+	Data_Get_Struct (self, struct fann_train_data, t);	
+	fann_save_train(t, StringValuePtr(filename));
+}
+
+/** Shuffles training data, randomizing the order. 
+    This is recommended for incremental training, while it will have no influence during batch training. */
+static VALUE shuffle(VALUE self)
+{
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann_train_data, t);	
+	fann_shuffle_train_data(t);
+}
+
+/** Length of training data */
+static VALUE length_train_data(VALUE self)
+{
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann_train_data, t);	
+	return(UINT2NUM(fann_length_train_data(t)));
+}
+
+/** Set the activation function for neuron number *neuron* in layer number *layer*, 
+		counting the input layer as layer 0.  activation_func must be one of the following symbols:
+			:linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric, 
+			:sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot, 
+			:elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric, 
+			:sin, :cos
+*/
+static VALUE set_activation_function(VALUE self, VALUE activation_func, VALUE layer, VALUE neuron)
+{
+	Check_Type(activation_func, T_SYMBOL);
+	Check_Type(layer, T_FIXNUM);
+	Check_Type(neuron, T_FIXNUM);
+	
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_set_activation_function(f, sym_to_activation_function(activation_func), NUM2INT(layer), NUM2INT(neuron));
+}
+
+/** Set the activation function for all of the hidden layers.  activation_func must be one of the following symbols:
+			:linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric, 
+			:sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot, 
+			:elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric, 
+			:sin, :cos*/
+static VALUE set_activation_function_hidden(VALUE self, VALUE activation_func)
+{
+	Check_Type(activation_func, T_SYMBOL);
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_set_activation_function_hidden(f, sym_to_activation_function(activation_func));
+}
+
+/** Set the activation function for all the neurons in the layer number *layer*, 
+ 		counting the input layer as layer 0.  activation_func must be one of the following symbols:
+			:linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric, 
+			:sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot, 
+			:elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric, 
+			:sin, :cos */
+static VALUE set_activation_function_layer(VALUE self, VALUE activation_func, VALUE layer)
+{
+	Check_Type(activation_func, T_SYMBOL);
+	Check_Type(layer, T_FIXNUM);
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_set_activation_function_layer(f, sym_to_activation_function(activation_func), NUM2INT(layer));
+}
+
+/**	Set the activation function for the output layer.  activation_func must be one of the following symbols:
+			:linear, :threshold, :threshold_symmetric, :sigmoid, :sigmoid_stepwise, :sigmoid_symmetric, 
+			:sigmoid_symmetric_stepwise, :gaussian, :gaussian_symmetric, :gaussian_stepwise, :elliot, 
+			:elliot_symmetric, :linear_piece, :linear_piece_symmetric, :sin_symmetric, :cos_symmetric, 
+			:sin, :cos */
+static VALUE set_activation_function_output(VALUE self, VALUE activation_func)
+{
+	Check_Type(activation_func, T_SYMBOL);
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_set_activation_function_output(f, sym_to_activation_function(activation_func));
+}
+
+/** Get the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0. */
+static VALUE get_activation_steepness(self, layer, neuron)
+VALUE self; VALUE layer; VALUE neuron;
+{
+	Check_Type(layer, T_FIXNUM);
+	Check_Type(neuron, T_FIXNUM);
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_type val = fann_get_activation_steepness(f, NUM2INT(layer), NUM2INT(neuron));
+	return rb_float_new(val);
+}
+
+/** Set the activation steepness for neuron number {neuron} in layer number (({layer})), 
+counting the input layer as layer 0. */
+static VALUE set_activation_steepness(VALUE self, VALUE steepness, VALUE layer, VALUE neuron)
+{
+	Check_Type(steepness, T_FLOAT);
+	Check_Type(layer, T_FIXNUM);
+	Check_Type(neuron, T_FIXNUM);
+	
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_set_activation_steepness(f, NUM2DBL(steepness), NUM2INT(layer), NUM2INT(neuron));
+}
+
+/** Set the activation steepness in all of the hidden layers. */
+static VALUE set_activation_steepness_hidden(VALUE self, VALUE steepness)
+{
+	SET_FANN_FLT(steepness, fann_set_activation_steepness_hidden);
+}
+
+/** Set the activation steepness all of the neurons in layer number *layer*, 
+counting the input layer as layer 0. */
+static VALUE set_activation_steepness_layer(VALUE self, VALUE steepness, VALUE layer)
+{
+	Check_Type(steepness, T_FLOAT);
+	Check_Type(layer, T_FIXNUM);
+	
+	struct fann* f;
+	Data_Get_Struct(self, struct fann, f);
+	fann_set_activation_steepness_layer(f, NUM2DBL(steepness), NUM2INT(layer));
+}
+
+/** Set the activation steepness in the output layer. */
+static VALUE set_activation_steepness_output(VALUE self, VALUE steepness)
+{
+	SET_FANN_FLT(steepness, fann_set_activation_steepness_output);
+}
+
+/** Returns the bit fail limit used during training. */
+static VALUE get_bit_fail_limit(VALUE self)
+{
+	RETURN_FANN_DBL(fann_get_bit_fail_limit);
+}
+
+/** Sets the bit fail limit used during training. */
+static VALUE set_bit_fail_limit(VALUE self, VALUE bit_fail_limit)
+{
+	SET_FANN_FLT(bit_fail_limit, fann_set_bit_fail_limit);
+}
+
+/** The decay is a small negative valued number which is the factor that the weights 
+should become smaller in each iteration during quickprop training. This is used 
+to make sure that the weights do not become too high during training. */
+static VALUE get_quickprop_decay(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_quickprop_decay);
+}
+
+/** Sets the quickprop decay factor */
+static VALUE set_quickprop_decay(VALUE self, VALUE quickprop_decay)
+{
+	SET_FANN_FLT(quickprop_decay, fann_set_quickprop_decay);
+}
+
+/** The mu factor is used to increase and decrease the step-size during quickprop training. 
+The mu factor should always be above 1, since it would otherwise decrease the step-size 
+when it was suppose to increase it. */
+static VALUE get_quickprop_mu(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_quickprop_mu);
+}
+
+/** Sets the quickprop mu factor. */
+static VALUE set_quickprop_mu(VALUE self, VALUE quickprop_mu)
+{
+	SET_FANN_FLT(quickprop_mu, fann_set_quickprop_mu);
+}
+
+/** The increase factor is a value larger than 1, which is used to 
+increase the step-size during RPROP training. */
+static VALUE get_rprop_increase_factor(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_rprop_increase_factor);
+}
+
+/** The increase factor used during RPROP training. */
+static VALUE set_rprop_increase_factor(VALUE self, VALUE rprop_increase_factor)
+{
+	SET_FANN_FLT(rprop_increase_factor, fann_set_rprop_increase_factor);
+}
+
+/** The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training. */
+static VALUE get_rprop_decrease_factor(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_rprop_decrease_factor);
+}
+
+/** The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training. */
+static VALUE set_rprop_decrease_factor(VALUE self, VALUE rprop_decrease_factor)
+{
+	SET_FANN_FLT(rprop_decrease_factor, fann_set_rprop_decrease_factor);
+}
+
+/** The minimum step-size is a small positive number determining how small the minimum step-size may be. */
+static VALUE get_rprop_delta_min(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_rprop_delta_min);
+}
+
+/** The minimum step-size is a small positive number determining how small the minimum step-size may be. */
+static VALUE set_rprop_delta_min(VALUE self, VALUE rprop_delta_min)
+{
+	SET_FANN_FLT(rprop_delta_min, fann_set_rprop_delta_min);
+}
+
+/** The maximum step-size is a positive number determining how large the maximum step-size may be. */
+static VALUE get_rprop_delta_max(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_rprop_delta_max);
+}
+
+/** The maximum step-size is a positive number determining how large the maximum step-size may be. */
+static VALUE set_rprop_delta_max(VALUE self, VALUE rprop_delta_max)
+{
+	SET_FANN_FLT(rprop_delta_max, fann_set_rprop_delta_max);
+}
+
+/** The initial step-size is a positive number determining the initial step size. */
+static VALUE get_rprop_delta_zero(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_rprop_delta_zero);
+}
+
+/** The initial step-size is a positive number determining the initial step size. */
+static VALUE set_rprop_delta_zero(VALUE self, VALUE rprop_delta_zero)
+{
+	SET_FANN_FLT(rprop_delta_zero, fann_set_rprop_delta_zero);
+}
+
+/** Return array of bias(es) */
+static VALUE get_bias_array(VALUE self)
+{
+  struct fann* f;
+	unsigned int num_layers;
+  Data_Get_Struct (self, struct fann, f);
+	num_layers = fann_get_num_layers(f);
+	unsigned int layers[num_layers];
+	fann_get_bias_array(f, layers);	
+	
+	// Create ruby array & set outputs:
+	VALUE arr;
+	arr = rb_ary_new();
+	int i;
+	for (i=0; i<num_layers; i++)
+	{
+		rb_ary_push(arr, INT2NUM(layers[i]));
+	}
+	
+  return arr;
+}
+
+/** The number of fail bits; means the number of output neurons which differ more 
+than the bit fail limit (see <fann_get_bit_fail_limit>, <fann_set_bit_fail_limit>). 
+The bits are counted in all of the training data, so this number can be higher than
+the number of training data. */
+static VALUE get_bit_fail(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_bit_fail);
+}
+
+/** Get the connection rate used when the network was created. */
+static VALUE get_connection_rate(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_connection_rate);
+}
+
+/** Return array<hash> where each array element is a hash
+		representing a neuron.  It contains the following keys:
+		:activation_function, symbol -- the activation function
+		:activation_steepness=float -- The steepness of the activation function
+		:sum=float -- The sum of the inputs multiplied with the weights
+		:value=float -- The value of the activation fuction applied to the sum
+		:connections=array<int> -- indices of connected neurons(inputs)
+		
+		This could be done more elegantly (e.g., defining more ruby ext classes).
+		This method does not directly correlate to anything in FANN, and accesses
+		structs that are not guaranteed to not change.				
+*/		
+static VALUE get_neurons(VALUE self, VALUE layer)
+{
+  struct fann_layer *layer_it;
+	struct fann_neuron *neuron_it;
+	
+	struct fann* f;
+	unsigned int i;
+  Data_Get_Struct (self, struct fann, f);
+
+	VALUE neuron_array = rb_ary_new();
+	VALUE activation_function_sym = ID2SYM(rb_intern("activation_function"));
+	VALUE activation_steepness_sym = ID2SYM(rb_intern("activation_steepness"));
+	VALUE layer_sym = ID2SYM(rb_intern("layer"));
+	VALUE sum_sym = ID2SYM(rb_intern("sum"));
+	VALUE value_sym = ID2SYM(rb_intern("value"));
+	VALUE connections_sym = ID2SYM(rb_intern("connections"));
+	unsigned int layer_num = 0;
+	for(layer_it = f->first_layer; layer_it != f->last_layer; layer_it++)
+	{
+		for(neuron_it = layer_it->first_neuron; neuron_it != layer_it->last_neuron; neuron_it++)
+		{
+			// Create array of connection indicies:
+			VALUE connection_array = rb_ary_new();
+			for (i = neuron_it->first_con; i < neuron_it->last_con; i++) {				
+				rb_ary_push(connection_array, INT2NUM(f->connections[i] - f->first_layer->first_neuron));	
+      }
+
+			VALUE neuron = rb_hash_new();
+			
+			// Set attributes on hash & push on array:
+			rb_hash_aset(neuron, activation_function_sym, activation_function_to_sym(neuron_it->activation_function));
+			rb_hash_aset(neuron, activation_steepness_sym, rb_float_new(neuron_it->activation_steepness));
+			rb_hash_aset(neuron, layer_sym, INT2NUM(layer_num));
+			rb_hash_aset(neuron, sum_sym, rb_float_new(neuron_it->sum));
+			rb_hash_aset(neuron, value_sym, rb_float_new(neuron_it->value));
+			rb_hash_aset(neuron, connections_sym, connection_array);
+			
+			rb_ary_push(neuron_array, neuron);			
+		}
+		++layer_num;
+	}
+
+	return neuron_array;	
+}
+
+/** Get list of layers in array format where each element contains number of neurons in that layer */
+static VALUE get_layer_array(VALUE self)
+{
+  struct fann* f;
+	unsigned int num_layers;
+  Data_Get_Struct (self, struct fann, f);
+	num_layers = fann_get_num_layers(f);
+	unsigned int layers[num_layers];
+	fann_get_layer_array(f, layers);	
+	
+	// Create ruby array & set outputs:
+	VALUE arr;
+	arr = rb_ary_new();
+	int i;
+	for (i=0; i<num_layers; i++)
+	{
+		rb_ary_push(arr, INT2NUM(layers[i]));
+	}
+	
+  return arr;
+}
+
+/** Reads the mean square error from the network. */
+static VALUE get_MSE(VALUE self)
+{
+	RETURN_FANN_DBL(fann_get_MSE);
+}
+
+/** Resets the mean square error from the network.
+  	This function also resets the number of bits that fail. */
+static VALUE reset_MSE(VALUE self)
+{
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_reset_MSE(f);
+}
+
+/** Get the type of network.  Returns as ruby symbol (one of :fann_nettype_shortcut, :fann_nettype_layer) */
+static VALUE get_network_type(VALUE self)
+{
+	struct fann* f;
+	enum fann_nettype_enum net_type;
+	VALUE ret_val;
+	Data_Get_Struct (self, struct fann, f);
+
+	net_type = fann_get_network_type(f);
+	
+	if(net_type==FANN_NETTYPE_LAYER) 
+	{
+		ret_val = ID2SYM(rb_intern("fann_nettype_layer")); // (rb_str_new2("FANN_NETTYPE_LAYER"));
+	}
+	else if(net_type==FANN_NETTYPE_SHORTCUT)
+	{
+		ret_val = ID2SYM(rb_intern("fann_nettype_shortcut")); // (rb_str_new2("FANN_NETTYPE_SHORTCUT"));
+	}	
+	return ret_val;
+}
+
+/** Get the number of input neurons. */
+static VALUE get_num_input(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_num_input);
+}
+	
+/** Get the number of layers in the network. */
+static VALUE get_num_layers(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_num_layers);
+}
+
+/** Get the number of output neurons. */
+static VALUE get_num_output(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_num_output);
+}
+
+/** Get the total number of connections in the entire network. */
+static VALUE get_total_connections(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_total_connections);
+}
+
+/** Get the total number of neurons in the entire network. */
+static VALUE get_total_neurons(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_total_neurons);
+}
+
+/** Sets the error function used during training.  One of the following symbols:
+			:linear, :tanh */
+static VALUE set_train_error_function(VALUE self, VALUE train_error_function)
+{
+	Check_Type(train_error_function, T_SYMBOL);
+	
+	ID id=SYM2ID(train_error_function);
+	enum fann_errorfunc_enum fann_train_error_function;
+
+	if(id==rb_intern("linear")) {
+		fann_train_error_function = FANN_ERRORFUNC_LINEAR;	
+	}	else if(id==rb_intern("tanh")) {
+		fann_train_error_function = FANN_ERRORFUNC_TANH;	
+	}	else {
+		rb_raise(rb_eRuntimeError, "Unrecognized train error function: [%s]", rb_id2name(SYM2ID(train_error_function)));
+	}	
+
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_set_train_error_function(f, fann_train_error_function);
+}
+
+/** Returns the error function used during training.  One of the following symbols:
+			:linear, :tanh */
+static VALUE get_train_error_function(VALUE self)
+{
+	struct fann* f;
+	enum fann_errorfunc_enum train_error;
+	VALUE ret_val;
+	Data_Get_Struct (self, struct fann, f);
+
+	train_error = fann_get_train_error_function(f);
+	
+	if(train_error==FANN_ERRORFUNC_LINEAR) 
+	{
+		ret_val = ID2SYM(rb_intern("linear")); 
+	}
+	else if(train_error==FANN_ERRORFUNC_TANH)
+	{
+		ret_val = ID2SYM(rb_intern("tanh")); 
+	}	
+	return ret_val;
+}
+
+/** Set the training algorithm.  One of the following symbols:
+			:incremental, :batch, :rprop, :quickprop */
+static VALUE set_training_algorithm(VALUE self, VALUE train_error_function)
+{
+	Check_Type(train_error_function, T_SYMBOL);
+	
+	ID id=SYM2ID(train_error_function);
+	enum fann_train_enum fann_train_algorithm;
+
+	if(id==rb_intern("incremental")) {
+		fann_train_algorithm = FANN_TRAIN_INCREMENTAL;	
+	}	else if(id==rb_intern("batch")) {
+		fann_train_algorithm = FANN_TRAIN_BATCH;	
+	}	else if(id==rb_intern("rprop")) {
+		fann_train_algorithm = FANN_TRAIN_RPROP;	
+	}	else if(id==rb_intern("quickprop")) {
+		fann_train_algorithm = FANN_TRAIN_QUICKPROP;	
+	}	else {
+		rb_raise(rb_eRuntimeError, "Unrecognized training algorithm function: [%s]", rb_id2name(SYM2ID(train_error_function)));
+	}	
+
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_set_training_algorithm(f, fann_train_algorithm);
+}
+
+/** Returns the training algorithm.  One of the following symbols:
+			:incremental, :batch, :rprop, :quickprop */
+static VALUE get_training_algorithm(VALUE self)
+{
+	struct fann* f;
+	enum fann_train_enum fann_train_algorithm;
+	VALUE ret_val;
+	Data_Get_Struct (self, struct fann, f);
+
+	fann_train_algorithm = fann_get_training_algorithm(f);
+	
+	if(fann_train_algorithm==FANN_TRAIN_INCREMENTAL) {
+		ret_val = ID2SYM(rb_intern("incremental"));
+	} else if(fann_train_algorithm==FANN_TRAIN_BATCH) {
+		ret_val = ID2SYM(rb_intern("batch")); 
+	} else if(fann_train_algorithm==FANN_TRAIN_RPROP) {
+		ret_val = ID2SYM(rb_intern("rprop")); 
+	} else if(fann_train_algorithm==FANN_TRAIN_QUICKPROP) {
+		ret_val = ID2SYM(rb_intern("quickprop")); 
+	}	
+	return ret_val;
+}
+
+/** Set the training stop function.  One of the following symbols:
+			:mse, :bit */
+static VALUE set_train_stop_function(VALUE self, VALUE train_stop_function)
+{
+	Check_Type(train_stop_function, T_SYMBOL);
+	ID id=SYM2ID(train_stop_function);
+	enum fann_stopfunc_enum fann_train_stop_function;
+
+	if(id==rb_intern("mse")) {
+		fann_train_stop_function = FANN_STOPFUNC_MSE;	
+	}	else if(id==rb_intern("bit")) {
+		fann_train_stop_function = FANN_STOPFUNC_BIT;	
+	}	else {
+		rb_raise(rb_eRuntimeError, "Unrecognized stop function: [%s]", rb_id2name(SYM2ID(train_stop_function)));
+	}	
+
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_set_train_stop_function(f, fann_train_stop_function);
+}
+
+/** Returns the training stop function.  One of the following symbols:
+			:mse, :bit */
+static VALUE get_train_stop_function(VALUE self)
+{
+	struct fann* f;
+	enum fann_stopfunc_enum train_stop;
+	VALUE ret_val;
+	Data_Get_Struct (self, struct fann, f);
+
+	train_stop = fann_get_train_stop_function(f);
+	
+	if(train_stop==FANN_STOPFUNC_MSE) 
+	{
+		ret_val = ID2SYM(rb_intern("mse")); // (rb_str_new2("FANN_NETTYPE_LAYER"));
+	}
+	else if(train_stop==FANN_STOPFUNC_BIT)
+	{
+		ret_val = ID2SYM(rb_intern("bit")); // (rb_str_new2("FANN_NETTYPE_SHORTCUT"));
+	}	
+	return ret_val;
+}
+
+
+/** Will print the connections of the ann in a compact matrix, 
+		for easy viewing of the internals of the ann. */
+static VALUE print_connections(VALUE self)
+{
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_print_connections(f);
+}
+
+/** Print current NN parameters to stdout */
+static VALUE print_parameters(VALUE self)
+{
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_print_parameters(f);
+	return Qnil;
+}
+
+/** Give each connection a random weight between *min_weight* and *max_weight* */
+static VALUE randomize_weights(VALUE self, VALUE min_weight, VALUE max_weight)
+{
+	Check_Type(min_weight, T_FLOAT);
+	Check_Type(max_weight, T_FLOAT);
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);	
+	fann_randomize_weights(f, NUM2DBL(min_weight), NUM2DBL(max_weight));
+}
+
+/** Run neural net with current parameters */
+static VALUE run (VALUE self, VALUE inputs)
+{
+	Check_Type(inputs, T_ARRAY);
+
+  struct fann* f;
+	int i;
+	fann_type* outputs;
+		
+	// Convert inputs to type needed for NN:
+	unsigned int len = RARRAY(inputs)->len;
+	fann_type fann_inputs[len];
+	for (i=0; i<len; i++)
+	{
+		fann_inputs[i] = NUM2DBL(RARRAY(inputs)->ptr[i]);
+	}
+	
+	
+	// Obtain NN & run method:
+  Data_Get_Struct (self, struct fann, f);
+	outputs = fann_run(f, fann_inputs);
+
+	// Create ruby array & set outputs:
+	VALUE arr;
+	arr = rb_ary_new();
+	unsigned int output_len=fann_get_num_output(f);
+	for (i=0; i<output_len; i++)
+	{		
+		rb_ary_push(arr, rb_float_new(outputs[i]));
+	}
+	
+  return arr;
+}
+
+/** Initialize the weights using Widrow + Nguyen's algorithm. */
+static VALUE init_weights(VALUE self, VALUE train_data)
+{
+	
+	Check_Type(train_data, T_DATA);
+	
+	struct fann* f;
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann, f);	
+	Data_Get_Struct (train_data, struct fann_train_data, t);	
+
+	fann_init_weights(f, t);	
+}
+
+
+
+/** Train with training data created with RubyFann::TrainData.new
+		max_epochs - The maximum number of epochs the training should continue
+ 		epochs_between_reports - The number of epochs between printing a status report to stdout.
+ 		desired_error - The desired <get_MSE> or <get_bit_fail>, depending on which stop function
+ 		is chosen by <set_train_stop_function>.  */
+static VALUE train_on_data(VALUE self, VALUE train_data, VALUE max_epochs, VALUE epochs_between_reports, VALUE desired_error)
+{
+	Check_Type(train_data, T_DATA);
+	Check_Type(max_epochs, T_FIXNUM);
+	Check_Type(epochs_between_reports, T_FIXNUM);
+	Check_Type(desired_error, T_FLOAT);
+	
+	struct fann* f;
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann, f);	
+	Data_Get_Struct (train_data, struct fann_train_data, t);	
+
+	unsigned int fann_max_epochs = NUM2INT(max_epochs);
+	unsigned int fann_epochs_between_reports = NUM2INT(epochs_between_reports);
+	float fann_desired_error = NUM2DBL(desired_error);	
+	fann_train_on_data(f, t, fann_max_epochs, fann_epochs_between_reports, fann_desired_error);
+}
+
+/** Train one epoch with a set of training data, created with RubyFann::TrainData.new */
+static VALUE train_epoch(VALUE self, VALUE train_data)
+{
+	Check_Type(train_data, T_DATA);
+	struct fann* f;
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann, f);	
+	Data_Get_Struct (train_data, struct fann_train_data, t);	
+	return rb_float_new(fann_train_epoch(f, t));
+}
+
+/** Test a set of training data and calculates the MSE for the training data. */
+static VALUE test_data(VALUE self, VALUE train_data)
+{
+	Check_Type(train_data, T_DATA);
+	struct fann* f;
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann, f);	
+	Data_Get_Struct (train_data, struct fann_train_data, t);	
+	return rb_float_new(fann_test_data(f, t));
+}
+
+// Returns the position of the decimal point in the ann.
+// Only available in fixed-point mode, which we don't need:
+// static VALUE get_decimal_point(VALUE self)
+// {
+// 	struct fann* f;
+// 	Data_Get_Struct (self, struct fann, f);
+// 	return INT2NUM(fann_get_decimal_point(f));
+// }
+	
+// returns the multiplier that fix point data is multiplied with.
+
+// Only available in fixed-point mode, which we don't need:
+// static VALUE get_multiplier(VALUE self)
+// {
+// 	struct fann* f;
+// 	Data_Get_Struct (self, struct fann, f);
+// 	return INT2NUM(fann_get_multiplier(f));
+// }
+
+// Train with inputs (array of arrays) & desired_outputs (array of arrays)
+// inputs & desired outputs should be of same length
+// All sub-arrays on inputs should be of same length
+// All sub-arrays on desired outputs should be of same length
+// Sub-arrays on inputs & desired_outputs can be different sizes from one another
+static VALUE cascadetrain_on_data(VALUE self, VALUE train_data, VALUE max_neurons, VALUE neurons_between_reports, VALUE desired_error)
+{
+	Check_Type(train_data, T_DATA);
+	Check_Type(max_neurons, T_FIXNUM);
+	Check_Type(neurons_between_reports, T_FIXNUM);
+	Check_Type(desired_error, T_FLOAT);
+	
+	struct fann* f;
+	struct fann_train_data* t; 
+	Data_Get_Struct (self, struct fann, f);	
+	Data_Get_Struct (train_data, struct fann_train_data, t);	
+
+	unsigned int fann_max_neurons = NUM2INT(max_neurons);
+	unsigned int fann_neurons_between_reports = NUM2INT(neurons_between_reports);
+	float fann_desired_error = NUM2DBL(desired_error);
+	
+	fann_cascadetrain_on_data(f, t, fann_max_neurons, fann_neurons_between_reports, fann_desired_error);
+	
+}			
+
+/** The cascade output change fraction is a number between 0 and 1 */
+static VALUE get_cascade_output_change_fraction(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_cascade_output_change_fraction);
+}
+
+/** The cascade output change fraction is a number between 0 and 1 */
+static VALUE set_cascade_output_change_fraction(VALUE self, VALUE cascade_output_change_fraction)
+{
+	SET_FANN_FLT(cascade_output_change_fraction, fann_set_cascade_output_change_fraction);
+}
+
+/** The number of cascade output stagnation epochs determines the number of epochs training is allowed to 
+		continue without changing the MSE by a fraction of <get_cascade_output_change_fraction>. */
+static VALUE get_cascade_output_stagnation_epochs(VALUE self)
+{
+	RETURN_FANN_INT(fann_get_cascade_output_stagnation_epochs);
+}
+
+/** The number of cascade output stagnation epochs determines the number of epochs training is allowed to 
+		continue without changing the MSE by a fraction of <get_cascade_output_change_fraction>. */
+static VALUE set_cascade_output_stagnation_epochs(VALUE self, VALUE cascade_output_stagnation_epochs)
+{
+	SET_FANN_INT(cascade_output_stagnation_epochs, fann_set_cascade_output_stagnation_epochs);
+}
+
+/** The cascade candidate change fraction is a number between 0 and 1 */
+static VALUE get_cascade_candidate_change_fraction(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_cascade_candidate_change_fraction);
+}
+
+/** The cascade candidate change fraction is a number between 0 and 1 */
+static VALUE set_cascade_candidate_change_fraction(VALUE self, VALUE cascade_candidate_change_fraction)
+{
+	SET_FANN_FLT(cascade_candidate_change_fraction, fann_set_cascade_candidate_change_fraction);
+}
+
+/** The number of cascade candidate stagnation epochs determines the number of epochs training is allowed to
+		continue without changing the MSE by a fraction of <get_cascade_candidate_change_fraction>. */
+static VALUE get_cascade_candidate_stagnation_epochs(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_candidate_stagnation_epochs);
+}
+
+/** The number of cascade candidate stagnation epochs determines the number of epochs training is allowed to
+		continue without changing the MSE by a fraction of <get_cascade_candidate_change_fraction>. */
+static VALUE set_cascade_candidate_stagnation_epochs(VALUE self, VALUE cascade_candidate_stagnation_epochs)
+{
+	SET_FANN_UINT(cascade_candidate_stagnation_epochs, fann_set_cascade_candidate_stagnation_epochs);
+}						
+
+/** The weight multiplier is a parameter which is used to multiply the weights from the candidate neuron
+		before adding the neuron to the neural network. This parameter is usually between 0 and 1, and is used
+		to make the training a bit less aggressive. */
+static VALUE get_cascade_weight_multiplier(VALUE self)
+{
+	RETURN_FANN_DBL(fann_get_cascade_weight_multiplier);
+}
+
+/** The weight multiplier is a parameter which is used to multiply the weights from the candidate neuron
+		before adding the neuron to the neural network. This parameter is usually between 0 and 1, and is used
+		to make the training a bit less aggressive. */
+static VALUE set_cascade_weight_multiplier(VALUE self, VALUE cascade_weight_multiplier)
+{
+	SET_FANN_DBL(cascade_weight_multiplier, fann_set_cascade_weight_multiplier);
+}
+
+/** The candidate limit is a limit for how much the candidate neuron may be trained.
+		The limit is a limit on the proportion between the MSE and candidate score. */
+static VALUE get_cascade_candidate_limit(VALUE self)
+{
+	RETURN_FANN_DBL(fann_get_cascade_candidate_limit);
+}
+
+/** The candidate limit is a limit for how much the candidate neuron may be trained.
+		The limit is a limit on the proportion between the MSE and candidate score. */
+static VALUE set_cascade_candidate_limit(VALUE self, VALUE cascade_candidate_limit)
+{
+	SET_FANN_DBL(cascade_candidate_limit, fann_set_cascade_candidate_limit);
+}
+
+/** The maximum out epochs determines the maximum number of epochs the output connections
+		may be trained after adding a new candidate neuron. */
+static VALUE get_cascade_max_out_epochs(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_max_out_epochs);
+}
+
+/** The maximum out epochs determines the maximum number of epochs the output connections
+		may be trained after adding a new candidate neuron. */
+static VALUE set_cascade_max_out_epochs(VALUE self, VALUE cascade_max_out_epochs)
+{
+	SET_FANN_UINT(cascade_max_out_epochs, fann_set_cascade_max_out_epochs);
+}
+
+/** The maximum candidate epochs determines the maximum number of epochs the input 
+		connections to the candidates may be trained before adding a new candidate neuron. */
+static VALUE get_cascade_max_cand_epochs(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_max_cand_epochs);
+}
+
+/** The maximum candidate epochs determines the maximum number of epochs the input 
+		connections to the candidates may be trained before adding a new candidate neuron. */
+static VALUE set_cascade_max_cand_epochs(VALUE self, VALUE cascade_max_cand_epochs)
+{
+	SET_FANN_UINT(cascade_max_cand_epochs, fann_set_cascade_max_cand_epochs);
+}
+
+/** The number of candidates used during training (calculated by multiplying <get_cascade_activation_functions_count>,
+		<get_cascade_activation_steepnesses_count> and <get_cascade_num_candidate_groups>).  */
+static VALUE get_cascade_num_candidates(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_num_candidates);
+}
+
+/** The number of activation functions in the <get_cascade_activation_functions> array */
+static VALUE get_cascade_activation_functions_count(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_activation_functions_count);
+}
+
+/** The learning rate is used to determine how aggressive training should be for some of the
+		training algorithms (:incremental, :batch, :quickprop).
+		Do however note that it is not used in :rprop. 
+		The default learning rate is 0.7. */
+static VALUE get_learning_rate(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_learning_rate);
+}
+
+/** The learning rate is used to determine how aggressive training should be for some of the
+		training algorithms (:incremental, :batch, :quickprop).
+		Do however note that it is not used in :rprop. 
+		The default learning rate is 0.7. */
+static VALUE set_learning_rate(VALUE self, VALUE learning_rate)
+{
+	SET_FANN_FLT(learning_rate, fann_set_learning_rate);
+}
+
+/** Get the learning momentum. */
+static VALUE get_learning_momentum(VALUE self)
+{
+	RETURN_FANN_FLT(fann_get_learning_momentum);
+}
+
+/** Set the learning momentum. */
+static VALUE set_learning_momentum(VALUE self, VALUE learning_momentum)
+{
+	SET_FANN_FLT(learning_momentum, fann_set_learning_momentum);
+}
+
+/** The cascade activation functions is an array of the different activation functions used by
+ 		the candidates.  The default is [:sigmoid, :sigmoid_symmetric, :gaussian, :gaussian_symmetric, :elliot, :elliot_symmetric] */
+static VALUE set_cascade_activation_functions(VALUE self, VALUE cascade_activation_functions)
+{
+	Check_Type(cascade_activation_functions, T_ARRAY);
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);	
+	
+	unsigned int cnt = RARRAY(cascade_activation_functions)->len;
+	enum fann_activationfunc_enum fann_activation_functions[cnt];
+	int i;
+	for (i=0; i<cnt; i++)
+	{
+		fann_activation_functions[i] = sym_to_activation_function(RARRAY(cascade_activation_functions)->ptr[i]);
+	}
+	
+	fann_set_cascade_activation_functions(f, fann_activation_functions, cnt);
+}
+
+/** The cascade activation functions is an array of the different activation functions used by
+ 		the candidates.  The default is [:sigmoid, :sigmoid_symmetric, :gaussian, :gaussian_symmetric, :elliot, :elliot_symmetric] */
+static VALUE get_cascade_activation_functions(VALUE self)
+{
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	unsigned int cnt = fann_get_cascade_activation_functions_count(f);
+	enum fann_activationfunc_enum* fann_functions = fann_get_cascade_activation_functions(f);
+
+	// Create ruby array & set outputs:
+	VALUE arr;
+	arr = rb_ary_new();
+	int i;
+	for (i=0; i<cnt; i++)
+	{
+		rb_ary_push(arr, activation_function_to_sym(fann_functions[i]));
+	}
+
+	return arr;
+}
+
+/** The number of activation steepnesses in the <get_cascade_activation_functions> array. */
+static VALUE get_cascade_activation_steepnesses_count(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_activation_steepnesses_count);
+}
+
+/** The number of candidate groups is the number of groups of identical candidates which will be used
+		during training. */
+static VALUE get_cascade_num_candidate_groups(VALUE self)
+{
+	RETURN_FANN_UINT(fann_get_cascade_num_candidate_groups);
+}
+
+/** The number of candidate groups is the number of groups of identical candidates which will be used
+		during training. */
+static VALUE set_cascade_num_candidate_groups(VALUE self, VALUE cascade_num_candidate_groups)
+{
+	SET_FANN_UINT(cascade_num_candidate_groups, fann_set_cascade_num_candidate_groups);
+}
+
+/** The cascade activation steepnesses array is an array of the different activation functions used by
+		the candidates. */
+static VALUE set_cascade_activation_steepnesses(VALUE self, VALUE cascade_activation_steepnesses)
+{
+	Check_Type(cascade_activation_steepnesses, T_ARRAY);
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);	
+	
+	unsigned int cnt = RARRAY(cascade_activation_steepnesses)->len;
+	fann_type fann_activation_steepnesses[cnt];
+	int i;
+	for (i=0; i<cnt; i++)
+	{
+		fann_activation_steepnesses[i] = NUM2DBL(RARRAY(cascade_activation_steepnesses)->ptr[i]);
+	}
+	
+	fann_set_cascade_activation_steepnesses(f, fann_activation_steepnesses, cnt);
+}
+
+/** The cascade activation steepnesses array is an array of the different activation functions used by
+		the candidates. */
+static VALUE get_cascade_activation_steepnesses(VALUE self)
+{
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	fann_type* fann_steepnesses = fann_get_cascade_activation_steepnesses(f);
+	unsigned int cnt = fann_get_cascade_activation_steepnesses_count(f);
+
+	// Create ruby array & set outputs:
+	VALUE arr;
+	arr = rb_ary_new();
+	int i;
+	for (i=0; i<cnt; i++)
+	{
+		rb_ary_push(arr, rb_float_new(fann_steepnesses[i]));
+	}
+
+	return arr;
+}
+
+/** Save the entire network to configuration file with given name */
+static VALUE nn_save(VALUE self, VALUE filename)
+{
+	struct fann* f;
+	Data_Get_Struct (self, struct fann, f);
+	int status = fann_save(f, StringValuePtr(filename));
+	return INT2NUM(status);
+}
+
+/** Initializes classes under RubyFann module/namespace. */
+void Init_neural_network ()
+{
+	// RubyFann module/namespace:
+	m_rb_fann_module = rb_define_module ("RubyFann");
+
+	// Standard NN class:
+	m_rb_fann_standard_class = rb_define_class_under (m_rb_fann_module, "Standard", rb_cObject);
+	rb_define_alloc_func (m_rb_fann_standard_class, fann_allocate);
+	rb_define_method(m_rb_fann_standard_class, "initialize", fann_initialize, 1);
+	rb_define_method(m_rb_fann_standard_class, "init_weights", init_weights, 1);
+	rb_define_method(m_rb_fann_standard_class, "set_activation_function", set_activation_function, 3);	
+	rb_define_method(m_rb_fann_standard_class, "set_activation_function_hidden", set_activation_function_hidden, 1);	
+	rb_define_method(m_rb_fann_standard_class, "set_activation_function_layer", set_activation_function_layer, 1);	
+	rb_define_method(m_rb_fann_standard_class, "set_activation_function_output", set_activation_function_output, 1);	
+	rb_define_method(m_rb_fann_standard_class, "get_activation_steepness", get_activation_steepness, 2);
+	rb_define_method(m_rb_fann_standard_class, "set_activation_steepness", set_activation_steepness, 3);
+	rb_define_method(m_rb_fann_standard_class, "set_activation_steepness_hidden", set_activation_steepness_hidden, 1);
+	rb_define_method(m_rb_fann_standard_class, "set_activation_steepness_layer", set_activation_steepness_layer, 2);
+	rb_define_method(m_rb_fann_standard_class, "set_activation_steepness_output", set_activation_steepness_output, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_train_error_function", get_train_error_function, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_train_error_function", set_train_error_function, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_train_stop_function", get_train_stop_function, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_train_stop_function", set_train_stop_function, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_bit_fail_limit", get_bit_fail_limit, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_bit_fail_limit", set_bit_fail_limit, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_quickprop_decay", get_quickprop_decay, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_quickprop_decay", set_quickprop_decay, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_quickprop_mu", get_quickprop_mu, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_quickprop_mu", set_quickprop_mu, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_rprop_increase_factor", get_rprop_increase_factor, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_rprop_increase_factor", set_rprop_increase_factor, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_rprop_decrease_factor", get_rprop_decrease_factor, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_rprop_decrease_factor", set_rprop_decrease_factor, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_rprop_delta_max", get_rprop_delta_max, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_rprop_delta_max", set_rprop_delta_max, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_rprop_delta_min", get_rprop_delta_min, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_rprop_delta_min", set_rprop_delta_min, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_rprop_delta_zero", get_rprop_delta_zero, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_rprop_delta_zero", set_rprop_delta_zero, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_bias_array", get_bias_array, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_connection_rate", get_connection_rate, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_layer_array", get_layer_array, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_network_type", get_network_type, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_neurons", get_neurons, 0);	
+	rb_define_method(m_rb_fann_standard_class, "get_num_input", get_num_input, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_num_layers", get_num_layers, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_num_output", get_num_output, 0);	
+	rb_define_method(m_rb_fann_standard_class, "get_total_connections", get_total_connections, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_total_neurons", get_total_neurons, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_train_error_function", get_train_error_function, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_train_error_function", set_train_error_function, 1);	
+	rb_define_method(m_rb_fann_standard_class, "print_connections", print_connections, 0);
+	rb_define_method(m_rb_fann_standard_class, "print_parameters", print_parameters, 0);
+	rb_define_method(m_rb_fann_standard_class, "randomize_weights", randomize_weights, 2);
+	rb_define_method(m_rb_fann_standard_class, "run", run, 1);
+	rb_define_method(m_rb_fann_standard_class, "train_on_data", train_on_data, 4);
+	rb_define_method(m_rb_fann_standard_class, "train_epoch", train_epoch, 1);
+	rb_define_method(m_rb_fann_standard_class, "test_data", test_data, 1);	
+	rb_define_method(m_rb_fann_standard_class, "get_MSE", get_MSE, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_bit_fail", get_bit_fail, 0);
+	rb_define_method(m_rb_fann_standard_class, "reset_MSE", reset_MSE, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_learning_rate", get_learning_rate, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_learning_rate", set_learning_rate, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_learning_momentum", get_learning_momentum, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_learning_momentum", set_learning_momentum, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_training_algorithm", get_training_algorithm, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_training_algorithm", set_training_algorithm, 1);
+	
+	
+	// Cascade functions:
+	rb_define_method(m_rb_fann_standard_class, "cascadetrain_on_data", cascadetrain_on_data, 4);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_output_change_fraction", get_cascade_output_change_fraction, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_output_change_fraction", set_cascade_output_change_fraction, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_output_stagnation_epochs", get_cascade_output_stagnation_epochs, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_output_stagnation_epochs", set_cascade_output_stagnation_epochs, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_candidate_change_fraction", get_cascade_candidate_change_fraction, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_candidate_change_fraction", set_cascade_candidate_change_fraction, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_candidate_stagnation_epochs", get_cascade_candidate_stagnation_epochs, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_candidate_stagnation_epochs", set_cascade_candidate_stagnation_epochs, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_weight_multiplier", get_cascade_weight_multiplier, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_weight_multiplier", set_cascade_weight_multiplier, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_candidate_limit", get_cascade_candidate_limit, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_candidate_limit", set_cascade_candidate_limit, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_max_out_epochs", get_cascade_max_out_epochs, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_max_out_epochs", set_cascade_max_out_epochs, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_max_cand_epochs", get_cascade_max_cand_epochs, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_max_cand_epochs", set_cascade_max_cand_epochs, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_num_candidates", get_cascade_num_candidates, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_activation_functions_count", get_cascade_activation_functions_count, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_activation_functions", get_cascade_activation_functions, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_activation_functions", set_cascade_activation_functions, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_activation_steepnesses_count", get_cascade_activation_steepnesses_count, 0);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_activation_steepnesses", get_cascade_activation_steepnesses, 0);
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_activation_steepnesses", set_cascade_activation_steepnesses, 1);
+	rb_define_method(m_rb_fann_standard_class, "get_cascade_num_candidate_groups", get_cascade_num_candidate_groups, 0);	
+	rb_define_method(m_rb_fann_standard_class, "set_cascade_num_candidate_groups", set_cascade_num_candidate_groups, 1);	
+	rb_define_method(m_rb_fann_standard_class, "save", nn_save, 1);
+
+	
+	// Uncomment for fixed-point mode (also recompile fann).  Probably not going to be needed:
+	//rb_define_method(clazz, "get_decimal_point", get_decimal_point, 0);	
+	//rb_define_method(clazz, "get_multiplier", get_multiplier, 0);	
+	
+	// Shortcut NN class (duplicated from above so that rdoc generation tools can find the methods:):
+	m_rb_fann_shortcut_class = rb_define_class_under (m_rb_fann_module, "Shortcut", rb_cObject);	
+	rb_define_alloc_func (m_rb_fann_shortcut_class, fann_allocate);
+	rb_define_method(m_rb_fann_shortcut_class, "initialize", fann_initialize, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "init_weights", init_weights, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_function", set_activation_function, 3);	
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_function_hidden", set_activation_function_hidden, 1);	
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_function_layer", set_activation_function_layer, 1);	
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_function_output", set_activation_function_output, 1);	
+	rb_define_method(m_rb_fann_shortcut_class, "get_activation_steepness", get_activation_steepness, 2);
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_steepness", set_activation_steepness, 3);
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_steepness_hidden", set_activation_steepness_hidden, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_steepness_layer", set_activation_steepness_layer, 2);
+	rb_define_method(m_rb_fann_shortcut_class, "set_activation_steepness_output", set_activation_steepness_output, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_train_error_function", get_train_error_function, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_train_error_function", set_train_error_function, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_train_stop_function", get_train_stop_function, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_train_stop_function", set_train_stop_function, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_bit_fail_limit", get_bit_fail_limit, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_bit_fail_limit", set_bit_fail_limit, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_quickprop_decay", get_quickprop_decay, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_quickprop_decay", set_quickprop_decay, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_quickprop_mu", get_quickprop_mu, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_quickprop_mu", set_quickprop_mu, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_rprop_increase_factor", get_rprop_increase_factor, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_rprop_increase_factor", set_rprop_increase_factor, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_rprop_decrease_factor", get_rprop_decrease_factor, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_rprop_decrease_factor", set_rprop_decrease_factor, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_rprop_delta_max", get_rprop_delta_max, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_rprop_delta_max", set_rprop_delta_max, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_rprop_delta_min", get_rprop_delta_min, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_rprop_delta_min", set_rprop_delta_min, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_rprop_delta_zero", get_rprop_delta_zero, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_rprop_delta_zero", set_rprop_delta_zero, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_bias_array", get_bias_array, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_connection_rate", get_connection_rate, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_layer_array", get_layer_array, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_network_type", get_network_type, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_neurons", get_neurons, 0);	
+	rb_define_method(m_rb_fann_shortcut_class, "get_num_input", get_num_input, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_num_layers", get_num_layers, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_num_output", get_num_output, 0);	
+	rb_define_method(m_rb_fann_shortcut_class, "get_total_connections", get_total_connections, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_total_neurons", get_total_neurons, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_train_error_function", get_train_error_function, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_train_error_function", set_train_error_function, 1);	
+	rb_define_method(m_rb_fann_shortcut_class, "print_connections", print_connections, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "print_parameters", print_parameters, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "randomize_weights", randomize_weights, 2);
+	rb_define_method(m_rb_fann_shortcut_class, "run", run, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "train_on_data", train_on_data, 4);
+	rb_define_method(m_rb_fann_shortcut_class, "train_epoch", train_epoch, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "test_data", test_data, 1);	
+	rb_define_method(m_rb_fann_shortcut_class, "get_MSE", get_MSE, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_bit_fail", get_bit_fail, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "reset_MSE", reset_MSE, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_learning_rate", get_learning_rate, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_learning_rate", set_learning_rate, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_learning_momentum", get_learning_momentum, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_learning_momentum", set_learning_momentum, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_training_algorithm", get_training_algorithm, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_training_algorithm", set_training_algorithm, 1);
+	
+	// Cascade functions:
+	rb_define_method(m_rb_fann_shortcut_class, "cascadetrain_on_data", cascadetrain_on_data, 4);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_output_change_fraction", get_cascade_output_change_fraction, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_output_change_fraction", set_cascade_output_change_fraction, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_output_stagnation_epochs", get_cascade_output_stagnation_epochs, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_output_stagnation_epochs", set_cascade_output_stagnation_epochs, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_candidate_change_fraction", get_cascade_candidate_change_fraction, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_candidate_change_fraction", set_cascade_candidate_change_fraction, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_candidate_stagnation_epochs", get_cascade_candidate_stagnation_epochs, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_candidate_stagnation_epochs", set_cascade_candidate_stagnation_epochs, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_weight_multiplier", get_cascade_weight_multiplier, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_weight_multiplier", set_cascade_weight_multiplier, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_candidate_limit", get_cascade_candidate_limit, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_candidate_limit", set_cascade_candidate_limit, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_max_out_epochs", get_cascade_max_out_epochs, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_max_out_epochs", set_cascade_max_out_epochs, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_max_cand_epochs", get_cascade_max_cand_epochs, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_max_cand_epochs", set_cascade_max_cand_epochs, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_num_candidates", get_cascade_num_candidates, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_activation_functions_count", get_cascade_activation_functions_count, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_activation_functions", get_cascade_activation_functions, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_activation_functions", set_cascade_activation_functions, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_activation_steepnesses_count", get_cascade_activation_steepnesses_count, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_activation_steepnesses", get_cascade_activation_steepnesses, 0);
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_activation_steepnesses", set_cascade_activation_steepnesses, 1);
+	rb_define_method(m_rb_fann_shortcut_class, "get_cascade_num_candidate_groups", get_cascade_num_candidate_groups, 0);	
+	rb_define_method(m_rb_fann_shortcut_class, "set_cascade_num_candidate_groups", set_cascade_num_candidate_groups, 1);	
+	rb_define_method(m_rb_fann_shortcut_class, "save", nn_save, 1);
+	
+
+	// TrainData NN class:
+	m_rb_fann_train_data_class = rb_define_class_under (m_rb_fann_module, "TrainData", rb_cObject);	
+	rb_define_alloc_func (m_rb_fann_train_data_class, fann_training_data_allocate);		
+	rb_define_method(m_rb_fann_train_data_class, "initialize", fann_train_data_initialize, 1);
+	rb_define_method(m_rb_fann_train_data_class, "length", length_train_data, 0);
+	rb_define_method(m_rb_fann_train_data_class, "shuffle", shuffle, 0);	
+	rb_define_method(m_rb_fann_train_data_class, "save", training_save, 1);
+	
+	printf("Initialized Ruby Bindings for FANN.\n");
+}
+