ruby-fann 1.2.5 → 1.3.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NjMyNmI4NDY5MjgwMDgzYjkxMDFjOTNkMGE5ZmI4ZWI2Mjc0MjQ0Zg==
-  data.tar.gz: !binary |-
-    MGU3NjUxNmEyZTFhOTRkMzI2OWU0Zjk5YzQzYjA1MTMxMjlkZGEwYQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MGU5YmI0MWI3NDI2NDE4NGU1Y2FhYjcwMTgzOGJkZDM3MDUyNmE3NTA0OGEz
-    MmU4NzU3Y2UyMDIwNmNhMjE5MDNiYTMwNjRmY2I4NGQwNzhlZWUzMjM5YWMx
-    YWYzOWZlY2Q3NmNiN2I5OGVkNTgzOWRiODY1ZWUzMmU1MTk0YWM=
-  data.tar.gz: !binary |-
-    ZjQyOTI0NjU0NDQ5YWE0MmQ3ZDE0ZTMwMDgyMmM0YTkyZWQ5MTFkODVmM2Ji
-    YmE3YTU1YWEyZmI1ZjkyNDNmZDE0N2MyNzVjOTc2NGFjZmViM2EyZTI2N2Iy
-    ZDZlYjg0ZjI4NGRiNDUzMTJhZjFkNTllOGM5OWE2ZGQ5ZTUyMzQ=
+SHA256:
+  metadata.gz: 00c8b18955c60b5065c9a7651e0ec29025875b40d08c7243ae33729def2744d8
+  data.tar.gz: bfaa2fc0c5365e990341b8671cb10bed9305fcedde3a2bc210b62fbcc40cc32d
+SHA512:
+  metadata.gz: 7032504c501bf7ef8b25a68b38f80c8af1717188a7d10660fe33cbf48ede29a7751abfe2083d048dcc66506ec6fff7893b8b90eda2d9873167a3e95d0d10f41b
+  data.tar.gz: 22c57fa3b15ab68babaa531baa7cee54023a0bb65c423d25dba1a1bae237f9e40b3e6515c2648ff8fdeeee68b3375eee4ac4759bb7d7c1974e2123df119e7908

data/README.md

@@ -1,6 +1,17 @@
 # RubyFann
+_Fast_ **AI**
 
-RubyFann, or "ruby-fann" is a ruby gem that binds to FANN (Fast Artificial Neural Network) from within a ruby/rails environment.  FANN is a is a free open source neural network library, which implements multilayer artificial neural networks with support for both fully connected and sparsely connected networks.  It is easy to use, versatile, well documented, and fast.  RubyFann makes working with neural networks a breeze using ruby, with the added benefit that most of the heavy lifting is done natively.
+
+![NN eye candy](nn1.png)
+
+---
+Neural Networks in `ruby`
+
+[![Gem Version](https://badge.fury.io/rb/ruby-fann.png)](http://badge.fury.io/rb/ruby-fann)
+
+RubyFann, or "ruby-fann" is a ruby gem that binds to FANN (Fast Artificial Neural Network) from within a ruby/rails environment.  FANN is a is a free (native) open source neural network library, which implements multilayer artificial neural networks, supporting both fully-connected and sparsely-connected networks.  It is easy to use, versatile, well documented, and fast.  `RubyFann` makes working with neural networks a breeze using `ruby`, with the added benefit that most of the heavy lifting is done natively.
+
+A talk given by our friend Ethan from Big-Oh Studios at Lone Star Ruby 2013: http://confreaks.com/videos/2609-lonestarruby2013-neural-networks-with-rubyfann
 
 ## Installation
 
@@ -21,17 +32,20 @@ Or install it yourself as:
 First, Go here & read about FANN. You don't need to install it before using the gem, but understanding FANN will help you understand what you can do with the ruby-fann gem:
 http://leenissen.dk/fann/
 
-ruby-fann RDocs:
-http://ruby-fann.rubyforge.org/
+## Documentation:
+*ruby-fann documentation:*
+http://tangledpath.github.io/ruby-fann/index.html
+
+
 
 ### Example training & subsequent execution:
-  
+
 ```ruby
   require 'ruby-fann'
   train = RubyFann::TrainData.new(:inputs=>[[0.3, 0.4, 0.5], [0.1, 0.2, 0.3]], :desired_outputs=>[[0.7], [0.8]])
   fann = RubyFann::Standard.new(:num_inputs=>3, :hidden_neurons=>[2, 8, 4, 3, 4], :num_outputs=>1)
   fann.train_on_data(train, 1000, 10, 0.1) # 1000 max_epochs, 10 errors between reports and 0.1 desired MSE (mean-squared-error)
-  outputs = fann.run([0.3, 0.2, 0.4])    
+  outputs = fann.run([0.3, 0.2, 0.4])
 ```
 
 ### Save training data to file and use it later (continued from above)
@@ -41,7 +55,7 @@ http://ruby-fann.rubyforge.org/
   train = RubyFann::TrainData.new(:filename=>'verify.train')
   # Train again with 10000 max_epochs, 20 errors between reports and 0.01 desired MSE (mean-squared-error)
   # This will take longer:
-  fann.train_on_data(train, 10000, 20, 0.01) 
+  fann.train_on_data(train, 10000, 20, 0.01)
 ```
 
 ### Save trained network to file and use it later (continued from above)
@@ -49,9 +63,9 @@ http://ruby-fann.rubyforge.org/
 ```ruby
   fann.save('foo.net')
   saved_nn = RubyFann::Standard.new(:filename=>"foo.net")
-  saved_nn.run([0.3, 0.2, 0.4])  
+  saved_nn.run([0.3, 0.2, 0.4])
 ```
-  
+
 ### Custom training using a callback method
 
 This callback function can be called during training when using train_on_data, train_on_file or cascadetrain_on_data.
@@ -66,7 +80,7 @@ The callback (training_callback) will be automatically called if it is implement
 class MyFann < RubyFann::Standard
   def training_callback(args)
     puts "ARGS: #{args.inspect}"
-    0  
+    0
   end
 end
 ```
@@ -77,7 +91,7 @@ https://github.com/bigohstudios/tictactoe
 1. Steven Miers
 2. Ole Krüger
 3. dignati
-4. Michal Pokorný
+4. Michal Pokorny
 5. Scott Li (locksley)
 
 ## Contributing

data/ext/ruby_fann/config.h

@@ -1,65 +1,8 @@
-/* src/include/config.h.  Generated by configure.  */
-/* config.in.  Generated from configure.in by autoheader.  */
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you have the `gettimeofday' function. */
-#define HAVE_GETTIMEOFDAY 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
 /* Name of package */
-#define PACKAGE "fann"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT ""
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME ""
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING ""
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION ""
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
-#define TIME_WITH_SYS_TIME 1
+/* #undef PACKAGE */
 
 /* Version number of package */
-#define VERSION "2.1.0"
+#define VERSION "2.2.0"
 
-/* Define to empty if `const' does not conform to ANSI C. */
-/* #undef const */
+/* Define for the x86_64 CPU famyly */
+/* #undef X86_64 */

data/ext/ruby_fann/doublefann.c

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public

data/ext/ruby_fann/doublefann.h

@@ -1,6 +1,6 @@
 /*
 Fast Artificial Neural Network Library (fann)
-Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public

data/ext/ruby_fann/fann.c

@@ -1,6 +1,6 @@
 /*
   Fast Artificial Neural Network Library (fann)
-  Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+  Copyright (C) 2003-2012 Steffen Nissen (sn@leenissen.dk)
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -27,6 +27,8 @@
 #include "config.h"
 #include "fann.h"
 
+/* #define FANN_NO_SEED */
+
 FANN_EXTERNAL struct fann *FANN_API fann_create_standard(unsigned int num_layers, ...)
 {
 	struct fann *ann;
@@ -104,7 +106,6 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(float connection_ra
 	unsigned int random_number, found_connection, tmp_con;
 
 #ifdef FIXEDFANN
-	unsigned int decimal_point;
 	unsigned int multiplier;
 #endif
 	if(connection_rate > 1)
@@ -127,7 +128,6 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(float connection_ra
 
 	ann->connection_rate = connection_rate;
 #ifdef FIXEDFANN
-	decimal_point = ann->decimal_point;
 	multiplier = ann->multiplier;
 	fann_update_stepwise(ann);
 #endif
@@ -158,7 +158,7 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(float connection_ra
 	printf("creating network with connection rate %f\n", connection_rate);
 	printf("input\n");
 	printf("  layer       : %d neurons, 1 bias\n",
-		   ann->first_layer->last_neuron - ann->first_layer->first_neuron - 1);
+		   (int)(ann->first_layer->last_neuron - ann->first_layer->first_neuron - 1));
 #endif
 
 	num_neurons_in = ann->num_input;
@@ -169,11 +169,11 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(float connection_ra
 		 * in the previous layer, and one neuron in the next layer.
 		 * and the bias node should be connected to the all neurons in the next layer.
 		 * Then this is the minimum amount of neurons */
-		min_connections = fann_max(num_neurons_in, num_neurons_out) + num_neurons_out;
-		max_connections = num_neurons_in * num_neurons_out;	/* not calculating bias */
+		min_connections = fann_max(num_neurons_in, num_neurons_out); /* not calculating bias */
+		max_connections = num_neurons_in * num_neurons_out;	     /* not calculating bias */
 		num_connections = fann_max(min_connections,
-								   (unsigned int) (0.5 + (connection_rate * max_connections)) +
-								   num_neurons_out);
+								   (unsigned int) (0.5 + (connection_rate * max_connections))) +
+								   num_neurons_out;
 
 		connections_per_neuron = num_connections / num_neurons_out;
 		allocated_connections = 0;
@@ -401,7 +401,6 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(unsigned int num_
 	unsigned int num_neurons_in, num_neurons_out;
 
 #ifdef FIXEDFANN
-	unsigned int decimal_point;
 	unsigned int multiplier;
 #endif
 	/* seed random */
@@ -420,7 +419,6 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(unsigned int num_
 	ann->connection_rate = 1;
 	ann->network_type = FANN_NETTYPE_SHORTCUT;
 #ifdef FIXEDFANN
-	decimal_point = ann->decimal_point;
 	multiplier = ann->multiplier;
 	fann_update_stepwise(ann);
 #endif
@@ -457,7 +455,7 @@ FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(unsigned int num_
 	printf("creating fully shortcut connected network.\n");
 	printf("input\n");
 	printf("  layer       : %d neurons, 1 bias\n",
-		   ann->first_layer->last_neuron - ann->first_layer->first_neuron - 1);
+		   (int)(ann->first_layer->last_neuron - ann->first_layer->first_neuron - 1));
 #endif
 
 	num_neurons_in = ann->num_input;
@@ -550,7 +548,7 @@ FANN_EXTERNAL fann_type *FANN_API fann_run(struct fann * ann, fann_type * input)
 	fann_type last_steepness = 0;
 	unsigned int last_activation_function = 0;
 #else
-	fann_type max_sum;	
+	fann_type max_sum = 0;	
 #endif
 
 	/* first set the input */
@@ -831,6 +829,241 @@ FANN_EXTERNAL void FANN_API fann_randomize_weights(struct fann *ann, fann_type m
 #endif
 }
 
+/* deep copy of the fann structure */
+FANN_EXTERNAL struct fann* FANN_API fann_copy(struct fann* orig)
+{
+    struct fann* copy;
+    unsigned int num_layers = orig->last_layer - orig->first_layer;
+    struct fann_layer *orig_layer_it, *copy_layer_it;
+    unsigned int layer_size;
+    struct fann_neuron *last_neuron,*orig_neuron_it,*copy_neuron_it;
+    unsigned int i;
+    struct fann_neuron *orig_first_neuron,*copy_first_neuron;
+    unsigned int input_neuron;
+
+    copy = fann_allocate_structure(num_layers);
+    if (copy==NULL) {
+        fann_error((struct fann_error*)orig, FANN_E_CANT_ALLOCATE_MEM);
+        return NULL;
+    }
+    copy->errno_f = orig->errno_f;
+    if (orig->errstr)
+    {
+        copy->errstr = (char *) malloc(FANN_ERRSTR_MAX);
+        if (copy->errstr == NULL)
+        {
+            fann_destroy(copy);
+            return NULL;
+        }
+        strcpy(copy->errstr,orig->errstr);
+    }
+    copy->error_log = orig->error_log;
+
+    copy->learning_rate = orig->learning_rate;
+    copy->learning_momentum = orig->learning_momentum;
+    copy->connection_rate = orig->connection_rate;
+    copy->network_type = orig->network_type;
+    copy->num_MSE = orig->num_MSE;
+    copy->MSE_value = orig->MSE_value;
+    copy->num_bit_fail = orig->num_bit_fail;
+    copy->bit_fail_limit = orig->bit_fail_limit;
+    copy->train_error_function = orig->train_error_function;
+    copy->train_stop_function = orig->train_stop_function;
+    copy->callback = orig->callback;
+    copy->cascade_output_change_fraction = orig->cascade_output_change_fraction;
+    copy->cascade_output_stagnation_epochs = orig->cascade_output_stagnation_epochs;
+    copy->cascade_candidate_change_fraction = orig->cascade_candidate_change_fraction;
+    copy->cascade_candidate_stagnation_epochs = orig->cascade_candidate_stagnation_epochs;
+    copy->cascade_best_candidate = orig->cascade_best_candidate;
+    copy->cascade_candidate_limit = orig->cascade_candidate_limit;
+    copy->cascade_weight_multiplier = orig->cascade_weight_multiplier;
+    copy->cascade_max_out_epochs = orig->cascade_max_out_epochs;
+    copy->cascade_max_cand_epochs = orig->cascade_max_cand_epochs;
+	copy->user_data = orig->user_data;
+
+   /* copy cascade activation functions */
+    copy->cascade_activation_functions_count = orig->cascade_activation_functions_count;
+    copy->cascade_activation_functions = (enum fann_activationfunc_enum *)realloc(copy->cascade_activation_functions,
+        copy->cascade_activation_functions_count * sizeof(enum fann_activationfunc_enum));
+    if(copy->cascade_activation_functions == NULL)
+    {
+        fann_error((struct fann_error*)orig, FANN_E_CANT_ALLOCATE_MEM);
+        fann_destroy(copy);
+        return NULL;
+    }
+    memcpy(copy->cascade_activation_functions,orig->cascade_activation_functions,
+            copy->cascade_activation_functions_count * sizeof(enum fann_activationfunc_enum));
+
+    /* copy cascade activation steepnesses */
+    copy->cascade_activation_steepnesses_count = orig->cascade_activation_steepnesses_count;
+    copy->cascade_activation_steepnesses = (fann_type *)realloc(copy->cascade_activation_steepnesses, copy->cascade_activation_steepnesses_count * sizeof(fann_type));
+    if(copy->cascade_activation_steepnesses == NULL)
+    {
+        fann_error((struct fann_error*)orig, FANN_E_CANT_ALLOCATE_MEM);
+        fann_destroy(copy);
+        return NULL;
+    }
+    memcpy(copy->cascade_activation_steepnesses,orig->cascade_activation_steepnesses,copy->cascade_activation_steepnesses_count * sizeof(fann_type));
+
+    copy->cascade_num_candidate_groups = orig->cascade_num_candidate_groups;
+
+    /* copy candidate scores, if used */
+    if (orig->cascade_candidate_scores == NULL)
+    {
+        copy->cascade_candidate_scores = NULL;
+    }
+    else
+    {
+        copy->cascade_candidate_scores =
+            (fann_type *) malloc(fann_get_cascade_num_candidates(copy) * sizeof(fann_type));
+        if(copy->cascade_candidate_scores == NULL)
+        {
+            fann_error((struct fann_error *) orig, FANN_E_CANT_ALLOCATE_MEM);
+            fann_destroy(copy);
+            return NULL;
+        }
+        memcpy(copy->cascade_candidate_scores,orig->cascade_candidate_scores,fann_get_cascade_num_candidates(copy) * sizeof(fann_type));
+    }
+
+    copy->quickprop_decay = orig->quickprop_decay;
+    copy->quickprop_mu = orig->quickprop_mu;
+    copy->rprop_increase_factor = orig->rprop_increase_factor;
+    copy->rprop_decrease_factor = orig->rprop_decrease_factor;
+    copy->rprop_delta_min = orig->rprop_delta_min;
+    copy->rprop_delta_max = orig->rprop_delta_max;
+    copy->rprop_delta_zero = orig->rprop_delta_zero;
+
+    /* user_data is not deep copied.  user should use fann_copy_with_user_data() for that */
+    copy->user_data = orig->user_data;
+
+#ifdef FIXEDFANN
+    copy->decimal_point = orig->decimal_point;
+    copy->multiplier = orig->multiplier;
+    memcpy(copy->sigmoid_results,orig->sigmoid_results,6*sizeof(fann_type));
+    memcpy(copy->sigmoid_values,orig->sigmoid_values,6*sizeof(fann_type));
+    memcpy(copy->sigmoid_symmetric_results,orig->sigmoid_symmetric_results,6*sizeof(fann_type));
+    memcpy(copy->sigmoid_symmetric_values,orig->sigmoid_symmetric_values,6*sizeof(fann_type));
+#endif
+
+
+    /* copy layer sizes, prepare for fann_allocate_neurons */
+    for (orig_layer_it = orig->first_layer, copy_layer_it = copy->first_layer;
+            orig_layer_it != orig->last_layer; orig_layer_it++, copy_layer_it++)
+    {
+        layer_size = orig_layer_it->last_neuron - orig_layer_it->first_neuron;
+        copy_layer_it->first_neuron = NULL;
+        copy_layer_it->last_neuron = copy_layer_it->first_neuron + layer_size;
+        copy->total_neurons += layer_size;
+    }
+    copy->num_input = orig->num_input;
+    copy->num_output = orig->num_output;
+
+
+    /* copy scale parameters, when used */
+#ifndef FIXEDFANN
+    if (orig->scale_mean_in != NULL)
+    {
+        fann_allocate_scale(copy);
+        for (i=0; i < orig->num_input ; i++) {
+            copy->scale_mean_in[i] = orig->scale_mean_in[i];
+            copy->scale_deviation_in[i] = orig->scale_deviation_in[i];
+            copy->scale_new_min_in[i] = orig->scale_new_min_in[i];
+            copy->scale_factor_in[i] = orig->scale_factor_in[i];
+        }
+        for (i=0; i < orig->num_output ; i++) {
+            copy->scale_mean_out[i] = orig->scale_mean_out[i];
+            copy->scale_deviation_out[i] = orig->scale_deviation_out[i];
+            copy->scale_new_min_out[i] = orig->scale_new_min_out[i];
+            copy->scale_factor_out[i] = orig->scale_factor_out[i];
+        }
+    }
+#endif
+
+    /* copy the neurons */
+    fann_allocate_neurons(copy);
+    if (copy->errno_f == FANN_E_CANT_ALLOCATE_MEM)
+    {
+        fann_destroy(copy);
+        return NULL;
+    }
+    layer_size = (orig->last_layer-1)->last_neuron - (orig->last_layer-1)->first_neuron;
+    memcpy(copy->output,orig->output, layer_size * sizeof(fann_type));
+
+    last_neuron = (orig->last_layer - 1)->last_neuron;
+    for (orig_neuron_it = orig->first_layer->first_neuron, copy_neuron_it = copy->first_layer->first_neuron;
+            orig_neuron_it != last_neuron; orig_neuron_it++, copy_neuron_it++)
+    {
+        memcpy(copy_neuron_it,orig_neuron_it,sizeof(struct fann_neuron));
+    }
+ /* copy the connections */
+    copy->total_connections = orig->total_connections;
+    fann_allocate_connections(copy);
+    if (copy->errno_f == FANN_E_CANT_ALLOCATE_MEM)
+    {
+        fann_destroy(copy);
+        return NULL;
+    }
+
+    orig_first_neuron = orig->first_layer->first_neuron;
+    copy_first_neuron = copy->first_layer->first_neuron;
+    for (i=0; i < orig->total_connections; i++)
+    {
+        copy->weights[i] = orig->weights[i];
+        input_neuron = orig->connections[i] - orig_first_neuron;
+        copy->connections[i] = copy_first_neuron + input_neuron;
+    }
+
+    if (orig->train_slopes)
+    {
+        copy->train_slopes = (fann_type *) malloc(copy->total_connections_allocated * sizeof(fann_type));
+        if (copy->train_slopes == NULL)
+        {
+            fann_error((struct fann_error *) orig, FANN_E_CANT_ALLOCATE_MEM);
+            fann_destroy(copy);
+            return NULL;
+        }
+        memcpy(copy->train_slopes,orig->train_slopes,copy->total_connections_allocated * sizeof(fann_type));
+    }
+
+    if (orig->prev_steps)
+    {
+        copy->prev_steps = (fann_type *) malloc(copy->total_connections_allocated * sizeof(fann_type));
+        if (copy->prev_steps == NULL)
+        {
+            fann_error((struct fann_error *) orig, FANN_E_CANT_ALLOCATE_MEM);
+            fann_destroy(copy);
+            return NULL;
+        }
+        memcpy(copy->prev_steps, orig->prev_steps, copy->total_connections_allocated * sizeof(fann_type));
+    }
+
+    if (orig->prev_train_slopes)
+    {
+        copy->prev_train_slopes = (fann_type *) malloc(copy->total_connections_allocated * sizeof(fann_type));
+        if (copy->prev_train_slopes == NULL)
+        {
+            fann_error((struct fann_error *) orig, FANN_E_CANT_ALLOCATE_MEM);
+            fann_destroy(copy);
+            return NULL;
+        }
+        memcpy(copy->prev_train_slopes,orig->prev_train_slopes, copy->total_connections_allocated * sizeof(fann_type));
+    }
+
+    if (orig->prev_weights_deltas)
+    {
+        copy->prev_weights_deltas = (fann_type *) malloc(copy->total_connections_allocated * sizeof(fann_type));
+        if(copy->prev_weights_deltas == NULL)
+        {
+            fann_error((struct fann_error *) orig, FANN_E_CANT_ALLOCATE_MEM);
+            fann_destroy(copy);
+            return NULL;
+        }
+        memcpy(copy->prev_weights_deltas, orig->prev_weights_deltas,copy->total_connections_allocated * sizeof(fann_type));
+    }
+
+    return copy;
+}
+
 FANN_EXTERNAL void FANN_API fann_print_connections(struct fann *ann)
 {
 	struct fann_layer *layer_it;
@@ -886,8 +1119,8 @@ FANN_EXTERNAL void FANN_API fann_print_connections(struct fann *ann)
 					neurons[ann->connections[i] - ann->first_layer->first_neuron] = (char)('A' + value);
 				}
 			}
-			printf("L %3d / N %4d %s\n", layer_it - ann->first_layer,
-				   neuron_it - ann->first_layer->first_neuron, neurons);
+			printf("L %3d / N %4d %s\n", (int)(layer_it - ann->first_layer),
+				   (int)(neuron_it - ann->first_layer->first_neuron), neurons);
 		}
 	}
 
@@ -988,12 +1221,12 @@ FANN_EXTERNAL void FANN_API fann_print_parameters(struct fann *ann)
 		if(ann->network_type == FANN_NETTYPE_SHORTCUT)
 		{
 			printf("  Hidden layer                       :%4d neurons, 0 bias\n",
-				   layer_it->last_neuron - layer_it->first_neuron);
+				   (int)(layer_it->last_neuron - layer_it->first_neuron));
 		}
 		else
 		{
 			printf("  Hidden layer                       :%4d neurons, 1 bias\n",
-				   layer_it->last_neuron - layer_it->first_neuron - 1);
+				   (int)(layer_it->last_neuron - layer_it->first_neuron - 1));
 		}
 	}
 	printf("Output layer                         :%4d neurons\n", ann->num_output);
@@ -1026,7 +1259,9 @@ FANN_EXTERNAL void FANN_API fann_print_parameters(struct fann *ann)
 	printf("Cascade output stagnation epochs     :%4d\n", ann->cascade_output_stagnation_epochs);
 	printf("Cascade candidate stagnation epochs  :%4d\n", ann->cascade_candidate_stagnation_epochs);
 	printf("Cascade max output epochs            :%4d\n", ann->cascade_max_out_epochs);
+	printf("Cascade min output epochs            :%4d\n", ann->cascade_min_out_epochs);
 	printf("Cascade max candidate epochs         :%4d\n", ann->cascade_max_cand_epochs);
+	printf("Cascade min candidate epochs         :%4d\n", ann->cascade_min_cand_epochs);
 	printf("Cascade weight multiplier            :%8.3f\n", ann->cascade_weight_multiplier);
 	printf("Cascade candidate limit              :%8.3f\n", ann->cascade_candidate_limit);
 	for(i = 0; i < ann->cascade_activation_functions_count; i++)
@@ -1141,7 +1376,7 @@ FANN_EXTERNAL void FANN_API fann_get_connection_array(struct fann *ann, struct f
     struct fann_neuron *first_neuron;
     struct fann_layer *layer_it;
     struct fann_neuron *neuron_it;
-    unsigned int index;
+    unsigned int idx;
     unsigned int source_index;
     unsigned int destination_index;
 
@@ -1157,7 +1392,7 @@ FANN_EXTERNAL void FANN_API fann_get_connection_array(struct fann *ann, struct f
         /* for each neuron */
         for(neuron_it = layer_it->first_neuron; neuron_it != layer_it->last_neuron; neuron_it++){
             /* for each connection */
-            for (index = neuron_it->first_con; index < neuron_it->last_con; index++){
+            for (idx = neuron_it->first_con; idx < neuron_it->last_con; idx++){
                 /* Assign the source, destination and weight */
                 connections->from_neuron = ann->connections[source_index] - first_neuron;
                 connections->to_neuron = destination_index;
@@ -1174,11 +1409,11 @@ FANN_EXTERNAL void FANN_API fann_get_connection_array(struct fann *ann, struct f
 FANN_EXTERNAL void FANN_API fann_set_weight_array(struct fann *ann,
     struct fann_connection *connections, unsigned int num_connections)
 {
-    unsigned int index;
+    unsigned int idx;
 
-    for (index = 0; index < num_connections; index++) {
-        fann_set_weight(ann, connections[index].from_neuron,
-            connections[index].to_neuron, connections[index].weight);
+    for (idx = 0; idx < num_connections; idx++) {
+        fann_set_weight(ann, connections[idx].from_neuron,
+            connections[idx].to_neuron, connections[idx].weight);
     }
 }
 
@@ -1188,7 +1423,7 @@ FANN_EXTERNAL void FANN_API fann_set_weight(struct fann *ann,
     struct fann_neuron *first_neuron;
     struct fann_layer *layer_it;
     struct fann_neuron *neuron_it;
-    unsigned int index;
+    unsigned int idx;
     unsigned int source_index;
     unsigned int destination_index;
 
@@ -1206,7 +1441,7 @@ FANN_EXTERNAL void FANN_API fann_set_weight(struct fann *ann,
         /* for each neuron */
         for(neuron_it = layer_it->first_neuron; neuron_it != layer_it->last_neuron; neuron_it++){
             /* for each connection */
-            for (index = neuron_it->first_con; index < neuron_it->last_con; index++){
+            for (idx = neuron_it->first_con; idx < neuron_it->last_con; idx++){
                 /* If the source and destination neurons match, assign the weight */
                 if (((int)from_neuron == ann->connections[source_index] - first_neuron) &&
                     (to_neuron == destination_index))
@@ -1347,6 +1582,8 @@ struct fann *fann_allocate_structure(unsigned int num_layers)
 	ann->cascade_candidate_limit = (fann_type)1000.0;
 	ann->cascade_max_out_epochs = 150;
 	ann->cascade_max_cand_epochs = 150;
+	ann->cascade_min_out_epochs = 50;
+	ann->cascade_min_cand_epochs = 50;
 	ann->cascade_candidate_scores = NULL;
 	ann->cascade_activation_functions_count = 10;
 	ann->cascade_activation_functions = 
@@ -1388,16 +1625,23 @@ struct fann *fann_allocate_structure(unsigned int num_layers)
 	ann->cascade_activation_steepnesses[3] = (fann_type)1.0;
 
 	/* Variables for use with with Quickprop training (reasonable defaults) */
-	ann->quickprop_decay = (float) -0.0001;
+	ann->quickprop_decay = -0.0001f;
 	ann->quickprop_mu = 1.75;
 
 	/* Variables for use with with RPROP training (reasonable defaults) */
-	ann->rprop_increase_factor = (float) 1.2;
+	ann->rprop_increase_factor = 1.2f;
 	ann->rprop_decrease_factor = 0.5;
 	ann->rprop_delta_min = 0.0;
 	ann->rprop_delta_max = 50.0;
-	ann->rprop_delta_zero = 0.1;
+	ann->rprop_delta_zero = 0.1f;
 	
+ 	/* Variables for use with SARPROP training (reasonable defaults) */
+ 	ann->sarprop_weight_decay_shift = -6.644f;
+ 	ann->sarprop_step_error_threshold_factor = 0.1f;
+ 	ann->sarprop_step_error_shift = 1.385f;
+ 	ann->sarprop_temperature = 0.015f;
+ 	ann->sarprop_epoch = 0;
+ 
 	fann_init_error_data((struct fann_error *) ann);
 
 #ifdef FIXEDFANN
@@ -1540,7 +1784,14 @@ void fann_seed_rand()
 	}
 	else
 	{
-		fread(&foo, sizeof(foo), 1, fp);
+	        if(fread(&foo, sizeof(foo), 1, fp) != 1) 
+	        {
+  		       gettimeofday(&t, NULL);
+		       foo = t.tv_usec;
+#ifdef DEBUG
+		       printf("unable to read from /dev/urandom\n");
+#endif		      
+		}
 		fclose(fp);
 	}
 	srand(foo);