ruby-fann 0.7.4 → 0.7.5

data/History.txt

@@ -17,3 +17,9 @@
 
   * 1 minor enhancement
     * Nicer message if FANN not installed
+
+== 0.7.5 2007-12-21
+  * 2 minor enhancements 
+    * Fixed rdoc to use actual parameter names
+    * Minor code cleanup & symbol fixage
+    * Nicer message for windows users

data/ext/ruby_fann/Makefile

@@ -43,7 +43,7 @@ LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
 RUBY_EXTCONF_H = 
 CFLAGS   =  -fno-common -g -O2  -fno-common -pipe -fno-common 
 INCFLAGS = -I. -I. -I/usr/local/lib/ruby/1.8/i686-darwin8.11.1 -I.
-CPPFLAGS =  -I/usr/funk/include 
+CPPFLAGS =  -I/usr/local/include 
 CXXFLAGS = $(CFLAGS) 
 DLDFLAGS = -L.   
 LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
@@ -68,8 +68,8 @@ COPY = cp
 
 preload = 
 
-libpath = . $(libdir) /usr/funk/lib
-LIBPATH =  -L"." -L"$(libdir)" -L"/usr/funk/lib"
+libpath = . $(libdir) /usr/local/lib
+LIBPATH =  -L"." -L"$(libdir)" -L"/usr/local/lib"
 DEFFILE = 
 
 CLEANFILES = mkmf.log

data/ext/ruby_fann/extconf.rb

@@ -1,7 +1,7 @@
 require 'mkmf'
 lib = dir_config('fann', '/usr/local')
 if !have_library("doublefann", "fann_create_standard")
-  puts "FANN must be installed and available in /usr/local or passed in with --with-fann-dir "
+  puts "FANN must be installed and available in /usr/local or passed in with --with-fann-dir.  Windows users should use ruby compiled in Cygwin or an equivalent, such as MingW."
   exit 1
 end
 #find_library("doublefann", "fann_create_standard", "/usr/local/lib")

data/ext/ruby_fann/neural_network.c

@@ -181,15 +181,22 @@ static VALUE fann_training_data_allocate (VALUE klass)
 }
 
 
-/** 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)
+/** call-seq: new(hash) -> new ruby-fann neural network object 
+
+    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)    
+    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') */
+    File Initialization
+      RubyFann::Standard.new(:filename=>'xor_float.net') 
+      
+      
+      
+*/
 static VALUE fann_initialize(VALUE self, VALUE hash)
 {
 	// Get args:
@@ -244,24 +251,25 @@ static VALUE fann_initialize(VALUE self, VALUE hash)
 	}	
 	
 	DATA_PTR(self) = ann;
-	return (VALUE)ann;
-	
-DATA_PTR(self) = ann;
-	return (VALUE)ann;
+	return (VALUE)ann;	
 }
 
-/** 
-  Initialize in one of the following forms:
+/** call-seq: new(hash) -> new ruby-fann training data object (RubyFann::TrainData)
+   
+    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]])    
+  
+    
   
-  # 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)
 {
@@ -306,7 +314,10 @@ static VALUE fann_train_data_initialize(VALUE self, VALUE hash)
 }
 
 
-/** Save to given filename */
+/** call-seq: save(filename)
+
+    Save to given filename 
+*/
 static VALUE training_save(VALUE self, VALUE filename)
 {
 	Check_Type(filename, T_STRING);	
@@ -316,7 +327,7 @@ static VALUE training_save(VALUE self, VALUE filename)
 }
 
 /** Shuffles training data, randomizing the order. 
-    This is recommended for incremental training, while it will have no influence during batch training. */
+    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; 
@@ -324,7 +335,7 @@ static VALUE shuffle(VALUE self)
 	fann_shuffle_train_data(t);
 }
 
-/** Length of training data */
+/** Length of training data*/
 static VALUE length_train_data(VALUE self)
 {
 	struct fann_train_data* t; 
@@ -332,13 +343,14 @@ static VALUE length_train_data(VALUE self)
 	return(UINT2NUM(fann_length_train_data(t)));
 }
 
-/** Set the activation function for neuron number *neuron* in layer number *layer*, 
+/** call-seq: set_activation_function(activation_func, layer, neuron)
+
+    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
-*/
+			:sin, :cos*/
 static VALUE set_activation_function(VALUE self, VALUE activation_func, VALUE layer, VALUE neuron)
 {
 	Check_Type(activation_func, T_SYMBOL);
@@ -350,7 +362,9 @@ static VALUE set_activation_function(VALUE self, VALUE activation_func, VALUE la
 	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:
+/** call-seq: set_activation_function_hidden(activation_func)
+
+    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, 
@@ -363,12 +377,15 @@ static VALUE set_activation_function_hidden(VALUE self, VALUE activation_func)
 	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*, 
+/** call-seq: set_activation_function_layer(activation_func, layer)
+
+    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 */
+			:sin, :cos*/
+			
 static VALUE set_activation_function_layer(VALUE self, VALUE activation_func, VALUE layer)
 {
 	Check_Type(activation_func, T_SYMBOL);
@@ -378,11 +395,14 @@ static VALUE set_activation_function_layer(VALUE self, VALUE activation_func, VA
 	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:
+/** call-seq: set_activation_function_output(activation_func)
+
+	  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 */
+			:sin, :cos*/
+
 static VALUE set_activation_function_output(VALUE self, VALUE activation_func)
 {
 	Check_Type(activation_func, T_SYMBOL);
@@ -391,9 +411,11 @@ static VALUE set_activation_function_output(VALUE self, VALUE activation_func)
 	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;
+/** call-seq: get_activation_steepness(layer, neuron) -> return value 
+ 
+    Get the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0. 
+*/
+static VALUE get_activation_steepness(VALUE self, VALUE layer, VALUE neuron)
 {
 	Check_Type(layer, T_FIXNUM);
 	Check_Type(neuron, T_FIXNUM);
@@ -403,8 +425,10 @@ VALUE self; VALUE layer; VALUE 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. */
+/** call-seq: set_activation_steepness(steepness, layer, neuron)
+
+    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);
@@ -416,14 +440,18 @@ static VALUE set_activation_steepness(VALUE self, VALUE steepness, VALUE layer,
 	fann_set_activation_steepness(f, NUM2DBL(steepness), NUM2INT(layer), NUM2INT(neuron));
 }
 
-/** Set the activation steepness in all of the hidden layers. */
+/** call-seq: set_activation_steepness_hidden(arg) -> return value 
+
+    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. */
+/** call-seq: set_activation_steepness_layer(steepness, layer)
+
+    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);
@@ -434,114 +462,132 @@ static VALUE set_activation_steepness_layer(VALUE self, VALUE steepness, VALUE l
 	fann_set_activation_steepness_layer(f, NUM2DBL(steepness), NUM2INT(layer));
 }
 
-/** Set the activation steepness in the output layer. */
+/** call-seq: set_activation_steepness_output(steepness)
+
+    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. */
+/** 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. */
+/** call-seq: set_bit_fail_limit(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. */
+    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 */
+/** call-seq: set_quickprop_decay(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. */
+    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. */
+/** call-seq: set_quickprop_mu(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. */
+    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. */
+/** call-seq: set_rprop_increase_factor(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. */
+/** 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. */
+/** call-seq: set_rprop_decrease_factor(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. */
+/** 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. */
+/** call-seq: set_rprop_delta_min(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. */
+/** 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. */
+/** call-seq: set_rprop_delta_max(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. */
+/** 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. */
+/** call-seq: set_rprop_delta_zero(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) */
+/** Return array of bias(es)*/
 static VALUE get_bias_array(VALUE self)
 {
   struct fann* f;
@@ -566,30 +612,32 @@ static VALUE get_bias_array(VALUE self)
 /** 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. */
+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. */
+/** 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)
+/** call-seq: get_neurons(layer) -> return value 
+
+    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 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;
@@ -635,7 +683,7 @@ static VALUE get_neurons(VALUE self, VALUE layer)
 	return neuron_array;	
 }
 
-/** Get list of layers in array format where each element contains number of neurons in that layer */
+/** 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;
@@ -657,14 +705,14 @@ static VALUE get_layer_array(VALUE self)
   return arr;
 }
 
-/** Reads the mean square error from the network. */
+/** 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. */
+  	This function also resets the number of bits that fail.*/  	
 static VALUE reset_MSE(VALUE self)
 {
 	struct fann* f;
@@ -672,7 +720,7 @@ static VALUE reset_MSE(VALUE self)
 	fann_reset_MSE(f);
 }
 
-/** Get the type of network.  Returns as ruby symbol (one of :fann_nettype_shortcut, :fann_nettype_layer) */
+/** Get the type of network.  Returns as ruby symbol (one of :shortcut, :layer)*/
 static VALUE get_network_type(VALUE self)
 {
 	struct fann* f;
@@ -684,46 +732,48 @@ static VALUE get_network_type(VALUE self)
 	
 	if(net_type==FANN_NETTYPE_LAYER) 
 	{
-		ret_val = ID2SYM(rb_intern("fann_nettype_layer")); // (rb_str_new2("FANN_NETTYPE_LAYER"));
+		ret_val = ID2SYM(rb_intern("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"));
+		ret_val = ID2SYM(rb_intern("shortcut")); // (rb_str_new2("FANN_NETTYPE_SHORTCUT"));
 	}	
 	return ret_val;
 }
 
-/** Get the number of input neurons. */
+/** 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. */
+/** 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. */
+/** 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. */
+/** 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. */
+/** 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:
+/** call-seq: set_train_error_function(train_error_function)
+
+    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)
 {
@@ -746,7 +796,7 @@ static VALUE set_train_error_function(VALUE self, VALUE train_error_function)
 }
 
 /** Returns the error function used during training.  One of the following symbols:
-			:linear, :tanh */
+			:linear, :tanh*/      
 static VALUE get_train_error_function(VALUE self)
 {
 	struct fann* f;
@@ -767,7 +817,9 @@ static VALUE get_train_error_function(VALUE self)
 	return ret_val;
 }
 
-/** Set the training algorithm.  One of the following symbols:
+/** call-seq: set_training_algorithm(train_error_function)
+
+    Set the training algorithm.  One of the following symbols:
 			:incremental, :batch, :rprop, :quickprop */
 static VALUE set_training_algorithm(VALUE self, VALUE train_error_function)
 {
@@ -816,7 +868,9 @@ static VALUE get_training_algorithm(VALUE self)
 	return ret_val;
 }
 
-/** Set the training stop function.  One of the following symbols:
+/** call-seq: set_train_stop_function(train_stop_function) -> return value 
+
+    Set the training stop function.  One of the following symbols:
 			:mse, :bit */
 static VALUE set_train_stop_function(VALUE self, VALUE train_stop_function)
 {
@@ -878,7 +932,9 @@ static VALUE print_parameters(VALUE self)
 	return Qnil;
 }
 
-/** Give each connection a random weight between *min_weight* and *max_weight* */
+/** call-seq: randomize_weights(min_weight, max_weight)
+
+    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);
@@ -888,7 +944,10 @@ static VALUE randomize_weights(VALUE self, VALUE min_weight, VALUE max_weight)
 	fann_randomize_weights(f, NUM2DBL(min_weight), NUM2DBL(max_weight));
 }
 
-/** Run neural net with current parameters */
+/** call-seq: run(inputs) -> return value 
+
+    Run neural net on array<Float> of inputs with current parameters.  
+    Returns array<Float> as output  */
 static VALUE run (VALUE self, VALUE inputs)
 {
 	Check_Type(inputs, T_ARRAY);
@@ -922,7 +981,9 @@ static VALUE run (VALUE self, VALUE inputs)
   return arr;
 }
 
-/** Initialize the weights using Widrow + Nguyen's algorithm. */
+/** call-seq: init_weights(train_data) -> return value 
+
+    Initialize the weights using Widrow + Nguyen's algorithm. */
 static VALUE init_weights(VALUE self, VALUE train_data)
 {
 	
@@ -938,11 +999,13 @@ static VALUE init_weights(VALUE self, VALUE train_data)
 
 
 
-/** 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>.  */
+/** call-seq: train_on_data(train_data, max_epochs, epochs_between_reports, desired_error)
+
+    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);
@@ -961,7 +1024,9 @@ static VALUE train_on_data(VALUE self, VALUE train_data, VALUE max_epochs, VALUE
 	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 */
+/** call-seq: train_epoch(train_data) -> return value 
+
+    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);
@@ -972,7 +1037,9 @@ static VALUE train_epoch(VALUE self, VALUE train_data)
 	return rb_float_new(fann_train_epoch(f, t));
 }
 
-/** Test a set of training data and calculates the MSE for the training data. */
+/** call-seq: test_data(train_data) -> return value 
+
+    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);
@@ -1002,11 +1069,13 @@ static VALUE test_data(VALUE self, VALUE train_data)
 // 	return INT2NUM(fann_get_multiplier(f));
 // }
 
-/** Perform cascade training with training data created with RubyFann::TrainData.new
-		max_epochs - The maximum number of neurons in trained network
- 		neurons_between_reports - The number of neurons 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>.  */
+/** call-seq: cascadetrain_on_data(train_data, max_neurons, neurons_between_reports, desired_error)
+
+    Perform cascade training with training data created with RubyFann::TrainData.new
+  		max_epochs - The maximum number of neurons in trained network
+   		neurons_between_reports - The number of neurons 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 cascadetrain_on_data(VALUE self, VALUE train_data, VALUE max_neurons, VALUE neurons_between_reports, VALUE desired_error)
 {
 	Check_Type(train_data, T_DATA);
@@ -1033,7 +1102,9 @@ 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 */
+/** call-seq: set_cascade_output_change_fraction(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);
@@ -1046,7 +1117,9 @@ 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 
+/** call-seq: set_cascade_output_stagnation_epochs(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)
 {
@@ -1059,7 +1132,9 @@ 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 */
+/** call-seq: set_cascade_candidate_change_fraction(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);
@@ -1072,7 +1147,9 @@ 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
+/** call-seq: set_cascade_candidate_stagnation_epochs(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)
 {
@@ -1087,7 +1164,9 @@ 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
+/** call-seq: set_cascade_weight_multiplier(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)
@@ -1102,7 +1181,9 @@ 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.
+/** call-seq: set_cascade_candidate_limit(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)
 {
@@ -1116,7 +1197,9 @@ 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
+/** call-seq: set_cascade_max_out_epochs(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)
 {
@@ -1130,7 +1213,9 @@ 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 
+/** call-seq: set_cascade_max_cand_epochs(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)
 {
@@ -1159,7 +1244,9 @@ 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
+/** call-seq: set_learning_rate(learning_rate) -> return value 
+
+    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. */
@@ -1174,13 +1261,17 @@ static VALUE get_learning_momentum(VALUE self)
 	RETURN_FANN_FLT(fann_get_learning_momentum);
 }
 
-/** Set the learning momentum. */
+/** call-seq: set_learning_momentum(learning_momentum) -> return value 
+  
+    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
+/** call-seq: set_cascade_activation_functions(cascade_activation_functions)
+
+    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)
 {
@@ -1233,7 +1324,9 @@ 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
+/** call-seq: set_cascade_num_candidate_groups(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)
 {
@@ -1280,7 +1373,9 @@ static VALUE get_cascade_activation_steepnesses(VALUE self)
 	return arr;
 }
 
-/** Save the entire network to configuration file with given name */
+/** call-seq: save(filename) -> return status
+
+    Save the entire network to configuration file with given name */
 static VALUE nn_save(VALUE self, VALUE filename)
 {
 	struct fann* f;
@@ -1289,7 +1384,7 @@ static VALUE nn_save(VALUE self, VALUE filename)
 	return INT2NUM(status);
 }
 
-/** Initializes classes under RubyFann module/namespace. */
+/** Initializes class under RubyFann module/namespace. */
 void Init_neural_network ()
 {
 	// RubyFann module/namespace:

data/lib/ruby_fann/version.rb

@@ -2,7 +2,7 @@ module RubyFann #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 7
-    TINY  = 4
+    TINY  = 5
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/neurotica2.vrml

@@ -4,9 +4,9 @@ Group { children [
     scale 0.028 0.028 0.028
     children [
  Background { skyColor 1.000 1.000 1.000 }
-# node 8471040
+# node 8453280
 Transform {
-  translation 6.000 46.000 30.000
+  translation 6.000 46.000 97.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -24,9 +24,9 @@ Transform {
     }
   ]
 }
-# node 8470590
+# node 8452100
 Transform {
-  translation 50.000 6.000 71.000
+  translation 50.000 6.000 94.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -44,7 +44,7 @@ Transform {
     }
   ]
 }
-# edge 8471040 -> 8470590
+# edge 8453280 -> 8452100
  Group { children [
 Transform {
   children [
@@ -79,9 +79,9 @@ Transform {
       translation 24.000 17.000 0.000
     }
 ] }
-# node 8470810
+# node 8452650
 Transform {
-  translation 28.000 46.000 5.000
+  translation 28.000 46.000 47.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -99,7 +99,7 @@ Transform {
     }
   ]
 }
-# edge 8470810 -> 8470590
+# edge 8452650 -> 8452100
  Group { children [
 Transform {
   children [
@@ -134,9 +134,9 @@ Transform {
       translation 35.000 17.000 0.000
     }
 ] }
-# node 8470760
+# node 8452530
 Transform {
-  translation 50.000 46.000 21.000
+  translation 50.000 46.000 3.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -154,7 +154,7 @@ Transform {
     }
   ]
 }
-# edge 8470760 -> 8470590
+# edge 8452530 -> 8452100
  Group { children [
 Transform {
   children [
@@ -189,9 +189,9 @@ Transform {
       translation 46.000 17.000 0.000
     }
 ] }
-# node 8470710
+# node 8452390
 Transform {
-  translation 72.000 46.000 9.000
+  translation 72.000 46.000 25.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -209,7 +209,7 @@ Transform {
     }
   ]
 }
-# edge 8470710 -> 8470590
+# edge 8452390 -> 8452100
  Group { children [
 Transform {
   children [
@@ -244,9 +244,9 @@ Transform {
       translation 57.000 17.000 0.000
     }
 ] }
-# node 8470650
+# node 8452310
 Transform {
-  translation 94.000 46.000 90.000
+  translation 94.000 46.000 91.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -264,7 +264,7 @@ Transform {
     }
   ]
 }
-# edge 8470650 -> 8470590
+# edge 8452310 -> 8452100
  Group { children [
 Transform {
   children [
@@ -300,5 +300,5 @@ Transform {
     }
 ] }
   ] }
-  Viewpoint {position 1.852 0.963 6.147}
+  Viewpoint {position 1.852 0.963 6.072}
 ] }

data/test/test_ruby_fann.rb

@@ -28,7 +28,7 @@ class RubyFannTest < Test::Unit::TestCase
     assert_equal(2, fann2.get_num_layers)
     assert_equal(1, fann2.get_num_input)
     assert_equal(2, fann2.get_num_output)    
-    assert_equal(:fann_nettype_shortcut, fann.get_network_type)
+    assert_equal(:shortcut, fann.get_network_type)
         
     sc = MyShortcut.new
   end
@@ -103,7 +103,7 @@ class RubyFannTest < Test::Unit::TestCase
   
   def test_get_network_type
     fann = RubyFann::Standard.new(:num_inputs=>5, :hidden_neurons=>[2, 8, 4, 3, 4], :num_outputs=>1) 
-    assert_equal(:fann_nettype_layer, fann.get_network_type)
+    assert_equal(:layer, fann.get_network_type)
     puts "fann.get_network_type: #{fann.get_network_type}"
   end
 

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>ruby-fann</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/ruby-fann"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/ruby-fann" class="numbers">0.7.3</a>
+      <a href="http://rubyforge.org/projects/ruby-fann" class="numbers">0.7.4</a>
     </div>
     <p><em>Bindings to use <a href="http://leenissen.dk/fann/"><span class="caps">FANN</span></a> (Fast Artificial Neural Network) from within ruby/rails environment.</em></p>
 
@@ -58,29 +58,42 @@
 
 
 	<h2>Requirements:</h2>
-
-
 	<ul>
-	<li><span class="caps">FANN 2</span>.1 or greater (preferably in /usr/local/lib)</li>
-		<li>Ruby 1.8.6 or greater.</li>
-		<li>gnu make tools or equiv for native code in ext</li>
+	<li><span class="caps">FANN 2</span>.1 or greater (preferably in /usr/local/lib)
+  * Ruby 1.8.6 or greater.  Windows Ruby should be built natively in Cygwin/MingW.  I haven&#8217;t had much luck with any native extensions and the one click installer.</li>
+		<li>graphviz and ruby-graphviz is required for <a href="http://ruby-fann.rubyforge.org/rdoc/classes/RubyFann/Neurotica.html">Neurotica</a> (<em>experimental</em>) graphical output.</li>
+		<li>gnu make tools or equiv for native code in ext (tested on linux, mac os x, and windows with <a href="http://www.cygwin.com/">Cygwin</a>)</li>
 	</ul>
 
 
+	<h2>Unit Tests</h2>
+
+
+	<p>ruby-fann Gem has full complement of unit tests that are executed before the gem is deployed/redeployed to RubyForge.</p>
+
+
 	<h2>Demonstration of usage</h2>
 
 
 	<p><pre class='syntax'>
 <span class="ident">require</span> <span class="punct">'</span><span class="string">rubygems</span><span class="punct">'</span>
 <span class="ident">require</span> <span class="punct">'</span><span class="string">ruby_fann/neural_network</span><span class="punct">'</span>
+
+<span class="comment"># Create Training data with 2 each of inputs(array of 3) &amp; desired outputs(array of 1).</span>
 <span class="ident">training_data</span> <span class="punct">=</span> <span class="constant">RubyFann</span><span class="punct">::</span><span class="constant">TrainData</span><span class="punct">.</span><span class="ident">new</span><span class="punct">(</span>
   <span class="symbol">:inputs=</span><span class="punct">&gt;[[</span><span class="number">0.3</span><span class="punct">,</span> <span class="number">0.4</span><span class="punct">,</span> <span class="number">0.5</span><span class="punct">],</span> <span class="punct">[</span><span class="number">0.1</span><span class="punct">,</span> <span class="number">0.2</span><span class="punct">,</span> <span class="number">0.3</span><span class="punct">]],</span> 
   <span class="symbol">:desired_outputs=</span><span class="punct">&gt;[[</span><span class="number">0.7</span><span class="punct">],</span> <span class="punct">[</span><span class="number">0.8</span><span class="punct">]])</span>
+
+<span class="comment"># Create FANN Neural Network to match appropriate training data:</span>
 <span class="ident">fann</span> <span class="punct">=</span> <span class="constant">RubyFann</span><span class="punct">::</span><span class="constant">Standard</span><span class="punct">.</span><span class="ident">new</span><span class="punct">(</span>
   <span class="symbol">:num_inputs=</span><span class="punct">&gt;</span><span class="number">3</span><span class="punct">,</span> 
   <span class="symbol">:hidden_neurons=</span><span class="punct">&gt;[</span><span class="number">2</span><span class="punct">,</span> <span class="number">8</span><span class="punct">,</span> <span class="number">4</span><span class="punct">,</span> <span class="number">3</span><span class="punct">,</span> <span class="number">4</span><span class="punct">],</span> 
   <span class="symbol">:num_outputs=</span><span class="punct">&gt;</span><span class="number">1</span><span class="punct">)</span>
+
+<span class="comment"># Training using data created above:</span>
 <span class="ident">fann</span><span class="punct">.</span><span class="ident">train_on_data</span><span class="punct">(</span><span class="ident">training_data</span><span class="punct">,</span> <span class="number">1000</span><span class="punct">,</span> <span class="number">1</span><span class="punct">,</span> <span class="number">0.1</span><span class="punct">)</span>
+
+<span class="comment"># Run with different input data:</span>
 <span class="ident">outputs</span> <span class="punct">=</span> <span class="ident">fann</span><span class="punct">.</span><span class="ident">run</span><span class="punct">([</span><span class="number">0.7</span><span class="punct">,</span> <span class="number">0.9</span><span class="punct">,</span> <span class="number">0.2</span><span class="punct">])</span>    
 </pre></p>
 
@@ -111,7 +124,7 @@
 
 	<p>Comments are welcome. Send an email to <a href="mailto:steven@7bpeople.com">Steven Miers</a> email via the <a href="http://groups.google.com/group/ruby_fann">forum</a></p>
     <p class="coda">
-      <a href="steven@7bpeople.com">Steven Miers</a>, 19th December 2007<br>
+      <a href="steven@7bpeople.com">Steven Miers</a>, 21st December 2007<br>
     </p>
 </div>
 

data/website/index.txt

@@ -17,23 +17,35 @@ h2. Installing
 h2. Requirements:
 
 	* FANN 2.1 or greater (preferably in /usr/local/lib)
-	* Ruby 1.8.6 or greater.
-	* gnu make tools or equiv for native code in ext
+	* Ruby 1.8.6 or greater.  Windows Ruby should be built natively in Cygwin/MingW.  I haven't had much luck with any native extensions and the one click installer.
+  * graphviz and ruby-graphviz is required for "Neurotica":http://ruby-fann.rubyforge.org/rdoc/classes/RubyFann/Neurotica.html (_experimental_) graphical output.
+  * gnu make tools or equiv for native code in ext (tested on linux, mac os x, and windows with "Cygwin":http://www.cygwin.com/)
+  
+h2. Unit Tests
 
+ruby-fann Gem has full complement of unit tests that are executed before the gem is deployed/redeployed to RubyForge.
 
 h2. Demonstration of usage
 
 <pre syntax="ruby">
 require 'rubygems'
 require 'ruby_fann/neural_network'
+
+# Create Training data with 2 each of inputs(array of 3) & desired outputs(array of 1).
 training_data = RubyFann::TrainData.new(
   :inputs=>[[0.3, 0.4, 0.5], [0.1, 0.2, 0.3]], 
   :desired_outputs=>[[0.7], [0.8]])
+
+# Create FANN Neural Network to match appropriate training data:
 fann = RubyFann::Standard.new(
   :num_inputs=>3, 
   :hidden_neurons=>[2, 8, 4, 3, 4], 
   :num_outputs=>1)
+
+# Training using data created above:
 fann.train_on_data(training_data, 1000, 1, 0.1)
+
+# Run with different input data:
 outputs = fann.run([0.7, 0.9, 0.2])    
 </pre>
 

data/xor_cascade.net

@@ -1,5 +1,5 @@
 FANN_FLO_2.1
-num_layers=3
+num_layers=4
 learning_rate=0.700000
 connection_rate=1.000000
 network_type=1
@@ -28,7 +28,7 @@ cascade_activation_functions_count=10
 cascade_activation_functions=3 5 7 8 10 11 14 15 16 17 
 cascade_activation_steepnesses_count=4
 cascade_activation_steepnesses=2.50000000000000000000e-01 5.00000000000000000000e-01 7.50000000000000000000e-01 1.00000000000000000000e+00 
-layer_sizes=3 1 1 
+layer_sizes=3 1 1 1 
 scale_included=0
-neurons (num_inputs, activation_function, activation_steepness)=(0, 0, 0.00000000000000000000e+00) (0, 0, 0.00000000000000000000e+00) (0, 0, 0.00000000000000000000e+00) (3, 15, 7.50000000000000000000e-01) (4, 5, 5.00000000000000000000e-01) 
-connections (connected_to_neuron, weight)=(0, 2.11189032829451006634e+00) (1, 1.38897825390983808980e+00) (2, 1.15236450682683587432e-02) (0, 2.72835175674095875564e-01) (1, 1.20351296053197442948e-01) (2, 3.97426992279901469818e-01) (3, 5.69930004183144021113e+01) 
+neurons (num_inputs, activation_function, activation_steepness)=(0, 0, 0.00000000000000000000e+00) (0, 0, 0.00000000000000000000e+00) (0, 0, 0.00000000000000000000e+00) (3, 8, 7.50000000000000000000e-01) (4, 3, 5.00000000000000000000e-01) (5, 5, 5.00000000000000000000e-01) 
+connections (connected_to_neuron, weight)=(0, 1.52969231315914755420e+00) (1, 1.50824598276217747284e+00) (2, 2.41220387265133409671e-02) (0, 3.28340708551594306908e-01) (1, 1.04425133310434167799e-01) (2, -6.59535845645816038996e+01) (3, 1.39189639221561134441e-01) (0, 2.68759220062898429582e-01) (1, 2.33959475563315866253e-01) (2, 4.39841832051311443230e-02) (3, 3.95917491761458038013e+01) (4, 2.40432266113240394878e-01) 

data/xor_float.net

@@ -31,4 +31,4 @@ cascade_activation_steepnesses=2.50000000000000000000e-01 5.00000000000000000000
 layer_sizes=3 4 2 
 scale_included=0
 neurons (num_inputs, activation_function, activation_steepness)=(0, 0, 0.00000000000000000000e+00) (0, 0, 0.00000000000000000000e+00) (0, 0, 0.00000000000000000000e+00) (3, 5, 1.00000000000000000000e+00) (3, 5, 1.00000000000000000000e+00) (3, 5, 1.00000000000000000000e+00) (0, 5, 1.00000000000000000000e+00) (4, 5, 1.00000000000000000000e+00) (0, 5, 1.00000000000000000000e+00) 
-connections (connected_to_neuron, weight)=(0, -3.16705915187245290454e+00) (1, -4.14808474757160297486e+02) (2, -1.49899501759802666889e+00) (0, -1.37559342196213130194e+00) (1, 9.92224239227251642026e-02) (2, -1.38055639686059938853e+00) (0, 1.78027947081140469621e+00) (1, 9.49321928628780314918e-02) (2, 1.77664309963691202654e+00) (3, 3.99985246158351248624e+00) (4, 3.92276033365987188972e+01) (5, 3.86637639535680861513e+01) (6, 3.20449395370871137345e-01) 
+connections (connected_to_neuron, weight)=(0, 1.81901505141687613865e+00) (1, -1.01895817621591100455e+00) (2, 8.42863331351461964047e-01) (0, 1.57494091898020349696e+00) (1, 1.87383001014118844019e+00) (2, 2.72897195277334425612e+00) (0, 2.21361297535147816262e+00) (1, -2.18159107932092855009e+00) (2, -1.76727410199432211080e+00) (3, -4.44379486136706614019e+00) (4, 3.59005526479922210115e+00) (5, 4.23621265514612499459e+00) (6, 4.67484948162714408770e-01) 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: ruby-fann
 version: !ruby/object:Gem::Version 
-  version: 0.7.4
-date: 2007-12-19 00:00:00 -06:00
+  version: 0.7.5
+date: 2007-12-21 00:00:00 -06:00
 summary: Bindings to use FANN from within ruby/rails environment.
 require_paths: 
 - lib