ruby-fann 1.0.1 → 1.0.2

data/History.txt

@@ -1,3 +1,8 @@
+== 1.0.2 2009-12-02
+
+* 1 minor enhancement:
+  * Added missing file to manifest
+
 == 1.0.1 2009-12-02
 
 * 1 minor enhancement:

data/Manifest.txt

@@ -18,6 +18,7 @@ ext/ruby_fann/fann_internal.h
 ext/ruby_fann/fann_train.h
 ext/ruby_fann/fann_cascade.h
 ext/ruby_fann/fann_io.h
+ext/ruby_fann/fann.h
 ext/ruby_fann/fann.c
 ext/ruby_fann/doublefann.c
 ext/ruby_fann/fann_io.c

data/ext/ruby_fann/fann.h

@@ -0,0 +1,603 @@
+/*
+Fast Artificial Neural Network Library (fann)
+Copyright (C) 2003 Steffen Nissen (lukesky@diku.dk)
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/  
+	
+/* This file defines the user interface to the fann library.
+   It is included from fixedfann.h, floatfann.h and doublefann.h and should
+   NOT be included directly. If included directly it will react as if
+   floatfann.h was included.
+*/ 
+
+/* Section: FANN Creation/Execution
+   
+   The FANN library is designed to be very easy to use. 
+   A feedforward ann can be created by a simple <fann_create_standard> function, while
+   other ANNs can be created just as easily. The ANNs can be trained by <fann_train_on_file>
+   and executed by <fann_run>.
+   
+   All of this can be done without much knowledge of the internals of ANNs, although the ANNs created will
+   still be powerfull and effective. If you have more knowledge about ANNs, and desire more control, almost
+   every part of the ANNs can be parametized to create specialized and highly optimal ANNs.
+ */
+/* Group: Creation, Destruction & Execution */
+	
+#ifndef FANN_INCLUDE
+/* just to allow for inclusion of fann.h in normal stuations where only floats are needed */ 
+#ifdef FIXEDFANN
+#include "fixedfann.h"
+#else
+#include "floatfann.h"
+#endif	/* FIXEDFANN  */
+	
+#else
+	
+/* COMPAT_TIME REPLACEMENT */ 
+#ifndef _WIN32
+#include <sys/time.h>
+#else	/* _WIN32 */
+#if !defined(_MSC_EXTENSIONS) && !defined(_INC_WINDOWS)  
+extern unsigned long __stdcall GetTickCount(void);
+
+#else	/* _MSC_EXTENSIONS */
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif	/* _MSC_EXTENSIONS */
+#endif	/* _WIN32 */
+		
+#ifndef __fann_h__
+#define __fann_h__
+	
+#ifdef __cplusplus
+extern "C"
+{
+	
+#ifndef __cplusplus
+} /* to fool automatic indention engines */ 
+#endif
+#endif	/* __cplusplus */
+ 
+#ifndef NULL
+#define NULL 0
+#endif	/* NULL */
+ 
+/* ----- Macros used to define DLL external entrypoints ----- */ 
+/*
+ DLL Export, import and calling convention for Windows.
+ Only defined for Microsoft VC++ FANN_EXTERNAL indicates
+ that a function will be exported/imported from a dll
+ FANN_API ensures that the DLL calling convention
+ will be used for  a function regardless of the calling convention
+ used when compiling.
+
+ For a function to be exported from a DLL its prototype and
+ declaration must be like this:
+    FANN_EXTERNAL void FANN_API function(char *argument)
+
+ The following ifdef block is a way of creating macros which
+ make exporting from a DLL simple. All files within a DLL are
+ compiled with the FANN_DLL_EXPORTS symbol defined on the
+ command line. This symbol should not be defined on any project
+ that uses this DLL. This way any other project whose source
+ files include this file see FANN_EXTERNAL functions as being imported
+ from a DLL, whereas a DLL sees symbols defined with this
+ macro as being exported which makes calls more efficient.
+ The __stdcall calling convention is used for functions in a
+ windows DLL.
+
+ The callback functions for fann_set_callback must be declared as FANN_API
+ so the DLL and the application program both use the same
+ calling convention.
+*/ 
+ 
+/*
+ The following sets the default for MSVC++ 2003 or later to use
+ the fann dll's. To use a lib or fixedfann.c, floatfann.c or doublefann.c
+ with those compilers FANN_NO_DLL has to be defined before
+ including the fann headers.
+ The default for previous MSVC compilers such as VC++ 6 is not
+ to use dll's. To use dll's FANN_USE_DLL has to be defined before
+ including the fann headers.
+*/ 
+#if (_MSC_VER > 1300)
+#ifndef FANN_NO_DLL
+#define FANN_USE_DLL
+#endif	/* FANN_USE_LIB */
+#endif	/* _MSC_VER */
+#if defined(_MSC_VER) && (defined(FANN_USE_DLL) || defined(FANN_DLL_EXPORTS))
+#ifdef FANN_DLL_EXPORTS
+#define FANN_EXTERNAL __declspec(dllexport)
+#else							/*  */
+#define FANN_EXTERNAL __declspec(dllimport)
+#endif	/* FANN_DLL_EXPORTS*/
+#define FANN_API __stdcall
+#else							/*  */
+#define FANN_EXTERNAL
+#define FANN_API
+#endif	/* _MSC_VER */
+/* ----- End of macros used to define DLL external entrypoints ----- */ 
+
+#include "fann_error.h"
+#include "fann_activation.h"
+#include "fann_data.h"
+#include "fann_internal.h"
+#include "fann_train.h"
+#include "fann_cascade.h"
+#include "fann_io.h"
+
+/* Function: fann_create_standard
+	
+	Creates a standard fully connected backpropagation neural network.
+
+	There will be a bias neuron in each layer (except the output layer),
+	and this bias neuron will be connected to all neurons in the next layer.
+	When running the network, the bias nodes always emits 1.
+	
+	To destroy a <struct fann> use the <fann_destroy> function.
+
+	Parameters:
+		num_layers - The total number of layers including the input and the output layer.
+		... - Integer values determining the number of neurons in each layer starting with the 
+			input layer and ending with the output layer.
+			
+	Returns:
+		A pointer to the newly created <struct fann>.
+			
+	Example:
+		> // Creating an ANN with 2 input neurons, 1 output neuron, 
+		> // and two hidden neurons with 8 and 9 neurons
+		> struct fann *ann = fann_create_standard(4, 2, 8, 9, 1);
+		
+	See also:
+		<fann_create_standard_array>, <fann_create_sparse>, <fann_create_shortcut>		
+		
+	This function appears in FANN >= 2.0.0.
+*/ 
+FANN_EXTERNAL struct fann *FANN_API fann_create_standard(unsigned int num_layers, ...);
+
+/* Function: fann_create_standard_array
+   Just like <fann_create_standard>, but with an array of layer sizes
+   instead of individual parameters.
+
+	Example:
+		> // Creating an ANN with 2 input neurons, 1 output neuron, 
+		> // and two hidden neurons with 8 and 9 neurons
+		> unsigned int layers[4] = {2, 8, 9, 1};
+		> struct fann *ann = fann_create_standard_array(4, layers);
+
+	See also:
+		<fann_create_standard>, <fann_create_sparse>, <fann_create_shortcut>
+
+	This function appears in FANN >= 2.0.0.
+*/ 
+FANN_EXTERNAL struct fann *FANN_API fann_create_standard_array(unsigned int num_layers,
+													           const unsigned int *layers);
+
+/* Function: fann_create_sparse
+
+	Creates a standard backpropagation neural network, which is not fully connected.
+
+	Parameters:
+		connection_rate - The connection rate controls how many connections there will be in the
+   			network. If the connection rate is set to 1, the network will be fully
+   			connected, but if it is set to 0.5 only half of the connections will be set.
+			A connection rate of 1 will yield the same result as <fann_create_standard>
+		num_layers - The total number of layers including the input and the output layer.
+		... - Integer values determining the number of neurons in each layer starting with the 
+			input layer and ending with the output layer.
+			
+	Returns:
+		A pointer to the newly created <struct fann>.
+
+	See also:
+		<fann_create_sparse_array>, <fann_create_standard>, <fann_create_shortcut>
+
+	This function appears in FANN >= 2.0.0.
+*/
+FANN_EXTERNAL struct fann *FANN_API fann_create_sparse(float connection_rate, 
+	                                                   unsigned int num_layers, ...);
+
+
+/* Function: fann_create_sparse_array
+   Just like <fann_create_sparse>, but with an array of layer sizes
+   instead of individual parameters.
+
+	See <fann_create_standard_array> for a description of the parameters.
+
+	See also:
+		<fann_create_sparse>, <fann_create_standard>, <fann_create_shortcut>
+
+	This function appears in FANN >= 2.0.0.
+*/
+FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(float connection_rate, 
+	                                                         unsigned int num_layers, 
+															 const unsigned int *layers);
+
+/* Function: fann_create_shortcut
+
+	Creates a standard backpropagation neural network, which is not fully connected and which
+	also has shortcut connections.
+
+ 	Shortcut connections are connections that skip layers. A fully connected network with shortcut 
+	connections, is a network where all neurons are connected to all neurons in later layers. 
+	Including direct connections from the input layer to the output layer.
+
+	See <fann_create_standard> for a description of the parameters.
+
+	See also:
+		<fann_create_shortcut_array>, <fann_create_standard>, <fann_create_sparse>, 
+
+	This function appears in FANN >= 2.0.0.
+*/ 
+FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut(unsigned int num_layers, ...);
+
+/* Function: fann_create_shortcut_array
+   Just like <fann_create_shortcut>, but with an array of layer sizes
+   instead of individual parameters.
+
+	See <fann_create_standard_array> for a description of the parameters.
+
+	See also:
+		<fann_create_shortcut>, <fann_create_standard>, <fann_create_sparse>
+
+	This function appears in FANN >= 2.0.0.
+*/
+FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(unsigned int num_layers,
+															   const unsigned int *layers);
+/* Function: fann_destroy
+   Destroys the entire network and properly freeing all the associated memmory.
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL void FANN_API fann_destroy(struct fann *ann);
+
+
+/* Function: fann_run
+	Will run input through the neural network, returning an array of outputs, the number of which being 
+	equal to the number of neurons in the output layer.
+
+	See also:
+		<fann_test>
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL fann_type * FANN_API fann_run(struct fann *ann, fann_type * input);
+
+/* Function: fann_randomize_weights
+	Give each connection a random weight between *min_weight* and *max_weight*
+   
+	From the beginning the weights are random between -0.1 and 0.1.
+
+	See also:
+		<fann_init_weights>
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL void FANN_API fann_randomize_weights(struct fann *ann, fann_type min_weight,
+												   fann_type max_weight);
+
+/* Function: fann_init_weights
+  	Initialize the weights using Widrow + Nguyen's algorithm.
+	
+ 	This function behaves similarly to fann_randomize_weights. It will use the algorithm developed 
+	by Derrick Nguyen and Bernard Widrow to set the weights in such a way 
+	as to speed up training. This technique is not always successful, and in some cases can be less 
+	efficient than a purely random initialization.
+
+	The algorithm requires access to the range of the input data (ie, largest and smallest input), 
+	and therefore accepts a second argument, data, which is the training data that will be used to 
+	train the network.
+
+	See also:
+		<fann_randomize_weights>, <fann_read_train_from_file>
+
+	This function appears in FANN >= 1.1.0.
+*/ 
+FANN_EXTERNAL void FANN_API fann_init_weights(struct fann *ann, struct fann_train_data *train_data);
+
+/* Function: fann_print_connections
+	Will print the connections of the ann in a compact matrix, for easy viewing of the internals 
+	of the ann.
+
+	The output from fann_print_connections on a small (2 2 1) network trained on the xor problem
+	>Layer / Neuron 012345
+	>L   1 / N    3 BBa...
+	>L   1 / N    4 BBA...
+	>L   1 / N    5 ......
+	>L   2 / N    6 ...BBA
+	>L   2 / N    7 ......
+		  
+	This network have five real neurons and two bias neurons. This gives a total of seven neurons 
+	named from 0 to 6. The connections between these neurons can be seen in the matrix. "." is a 
+	place where there is no connection, while a character tells how strong the connection is on a 
+	scale from a-z. The two real neurons in the hidden layer (neuron 3 and 4 in layer 1) has 
+	connection from the three neurons in the previous layer as is visible in the first two lines. 
+	The output neuron (6) has connections form the three neurons in the hidden layer 3 - 5 as is 
+	visible in the fourth line.
+
+	To simplify the matrix output neurons is not visible as neurons that connections can come from, 
+	and input and bias neurons are not visible as neurons that connections can go to.
+
+	This function appears in FANN >= 1.2.0.
+*/ 
+FANN_EXTERNAL void FANN_API fann_print_connections(struct fann *ann);
+
+/* Group: Parameters */
+/* Function: fann_print_parameters
+
+  	Prints all of the parameters and options of the ANN 
+
+	This function appears in FANN >= 1.2.0.
+*/ 
+FANN_EXTERNAL void FANN_API fann_print_parameters(struct fann *ann);
+
+
+/* Function: fann_get_num_input
+
+   Get the number of input neurons.
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL unsigned int FANN_API fann_get_num_input(struct fann *ann);
+
+
+/* Function: fann_get_num_output
+
+   Get the number of output neurons.
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL unsigned int FANN_API fann_get_num_output(struct fann *ann);
+
+
+/* Function: fann_get_total_neurons
+
+   Get the total number of neurons in the entire network. This number does also include the 
+	bias neurons, so a 2-4-2 network has 2+4+2 +2(bias) = 10 neurons.
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL unsigned int FANN_API fann_get_total_neurons(struct fann *ann);
+
+
+/* Function: fann_get_total_connections
+
+   Get the total number of connections in the entire network.
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL unsigned int FANN_API fann_get_total_connections(struct fann *ann);
+
+/* Function: fann_get_network_type
+
+    Get the type of neural network it was created as.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+	Returns:
+        The neural network type from enum <fann_network_type_enum>
+
+    See Also:
+        <fann_network_type_enum>
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL enum fann_nettype_enum FANN_API fann_get_network_type(struct fann *ann);
+
+/* Function: fann_get_connection_rate
+
+    Get the connection rate used when the network was created
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+	Returns:
+        The connection rate
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL float FANN_API fann_get_connection_rate(struct fann *ann);
+
+/* Function: fann_get_num_layers
+
+    Get the number of layers in the network
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+			
+	Returns:
+		The number of layers in the neural network
+			
+	Example:
+		> // Obtain the number of layers in a neural network
+		> struct fann *ann = fann_create_standard(4, 2, 8, 9, 1);
+        > unsigned int num_layers = fann_get_num_layers(ann);
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL unsigned int FANN_API fann_get_num_layers(struct fann *ann);
+
+/*Function: fann_get_layer_array
+
+    Get the number of neurons in each layer in the network.
+
+    Bias is not included so the layers match the fann_create functions.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+    The layers array must be preallocated to at least
+    sizeof(unsigned int) * fann_num_layers() long.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void FANN_API fann_get_layer_array(struct fann *ann, unsigned int *layers);
+
+/* Function: fann_get_bias_array
+
+    Get the number of bias in each layer in the network.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+    The bias array must be preallocated to at least
+    sizeof(unsigned int) * fann_num_layers() long.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void FANN_API fann_get_bias_array(struct fann *ann, unsigned int *bias);
+
+/* Function: fann_get_connection_array
+
+    Get the connections in the network.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+    The connections array must be preallocated to at least
+    sizeof(struct fann_connection) * fann_get_total_connections() long.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void FANN_API fann_get_connection_array(struct fann *ann,
+    struct fann_connection *connections);
+
+/* Function: fann_set_weight_array
+
+    Set connections in the network.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+    Only the weights can be changed, connections and weights are ignored
+    if they do not already exist in the network.
+
+    The array must have sizeof(struct fann_connection) * num_connections size.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void FANN_API fann_set_weight_array(struct fann *ann,
+    struct fann_connection *connections, unsigned int num_connections);
+
+/* Function: fann_set_weight
+
+    Set a connection in the network.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+    Only the weights can be changed. The connection/weight is
+    ignored if it does not already exist in the network.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void FANN_API fann_set_weight(struct fann *ann,
+    unsigned int from_neuron, unsigned int to_neuron, fann_type weight);
+
+/* Function: fann_set_user_data
+
+    Store a pointer to user defined data. The pointer can be
+    retrieved with <fann_get_user_data> for example in a
+    callback. It is the user's responsibility to allocate and
+    deallocate any data that the pointer might point to.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+		user_data - A void pointer to user defined data.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void FANN_API fann_set_user_data(struct fann *ann, void *user_data);
+
+/* Function: fann_get_user_data
+
+    Get a pointer to user defined data that was previously set
+    with <fann_set_user_data>. It is the user's responsibility to
+    allocate and deallocate any data that the pointer might point to.
+
+    Parameters:
+		ann - A previously created neural network structure of
+            type <struct fann> pointer.
+
+    Returns:
+        A void pointer to user defined data.
+
+   This function appears in FANN >= 2.1.0
+*/
+FANN_EXTERNAL void * FANN_API fann_get_user_data(struct fann *ann);
+
+#ifdef FIXEDFANN
+	
+/* Function: fann_get_decimal_point
+
+	Returns the position of the decimal point in the ann.
+
+	This function is only available when the ANN is in fixed point mode.
+
+	The decimal point is described in greater detail in the tutorial <Fixed Point Usage>.
+
+	See also:
+		<Fixed Point Usage>, <fann_get_multiplier>, <fann_save_to_fixed>, <fann_save_train_to_fixed>
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL unsigned int FANN_API fann_get_decimal_point(struct fann *ann);
+
+
+/* Function: fann_get_multiplier
+
+    returns the multiplier that fix point data is multiplied with.
+
+	This function is only available when the ANN is in fixed point mode.
+
+	The multiplier is the used to convert between floating point and fixed point notation. 
+	A floating point number is multiplied with the multiplier in order to get the fixed point
+	number and visa versa.
+
+	The multiplier is described in greater detail in the tutorial <Fixed Point Usage>.
+
+	See also:
+		<Fixed Point Usage>, <fann_get_decimal_point>, <fann_save_to_fixed>, <fann_save_train_to_fixed>
+
+	This function appears in FANN >= 1.0.0.
+*/ 
+FANN_EXTERNAL unsigned int FANN_API fann_get_multiplier(struct fann *ann);
+
+#endif	/* FIXEDFANN */
+
+#ifdef __cplusplus
+#ifndef __cplusplus
+/* to fool automatic indention engines */ 
+{
+	
+#endif
+} 
+#endif	/* __cplusplus */
+	
+#endif	/* __fann_h__ */
+	
+#endif /* NOT FANN_INCLUDE */

data/lib/ruby_fann/version.rb

@@ -2,7 +2,7 @@ module RubyFann #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     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 2160579600
+# node 2148098720
 Transform {
-  translation 6.000 46.000 66.000
+  translation 6.000 46.000 83.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -24,9 +24,9 @@ Transform {
     }
   ]
 }
-# node 2160577360
+# node 2148093340
 Transform {
-  translation 50.000 6.000 80.000
+  translation 50.000 6.000 93.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -44,7 +44,7 @@ Transform {
     }
   ]
 }
-# edge 2160579600 -> 2160577360
+# edge 2148098720 -> 2148093340
  Group { children [
 Transform {
   children [
@@ -79,9 +79,9 @@ Transform {
       translation 24.000 17.000 0.000
     }
 ] }
-# node 2160577760
+# node 2148098020
 Transform {
-  translation 28.000 46.000 74.000
+  translation 28.000 46.000 31.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -99,7 +99,7 @@ Transform {
     }
   ]
 }
-# edge 2160577760 -> 2160577360
+# edge 2148098020 -> 2148093340
  Group { children [
 Transform {
   children [
@@ -134,9 +134,9 @@ Transform {
       translation 35.000 17.000 0.000
     }
 ] }
-# node 2160577660
+# node 2148097880
 Transform {
-  translation 50.000 46.000 92.000
+  translation 50.000 46.000 20.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -154,7 +154,7 @@ Transform {
     }
   ]
 }
-# edge 2160577660 -> 2160577360
+# edge 2148097880 -> 2148093340
  Group { children [
 Transform {
   children [
@@ -189,9 +189,9 @@ Transform {
       translation 46.000 17.000 0.000
     }
 ] }
-# node 2160577560
+# node 2148096860
 Transform {
-  translation 72.000 46.000 73.000
+  translation 72.000 46.000 38.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -209,7 +209,7 @@ Transform {
     }
   ]
 }
-# edge 2160577560 -> 2160577360
+# edge 2148096860 -> 2148093340
  Group { children [
 Transform {
   children [
@@ -244,9 +244,9 @@ Transform {
       translation 57.000 17.000 0.000
     }
 ] }
-# node 2160577460
+# node 2148095220
 Transform {
-  translation 94.000 46.000 29.000
+  translation 94.000 46.000 41.000
   scale 2.000 2.000 2.000
   children [
     Transform {
@@ -264,7 +264,7 @@ Transform {
     }
   ]
 }
-# edge 2160577460 -> 2160577360
+# edge 2148095220 -> 2148093340
  Group { children [
 Transform {
   children [
@@ -300,5 +300,5 @@ Transform {
     }
 ] }
   ] }
-  Viewpoint {position 1.852 0.963 7.035}
+  Viewpoint {position 1.852 0.963 6.702}
 ] }

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">1.0.0</a>
+      <a href="http://rubyforge.org/projects/ruby-fann" class="numbers">1.0.2</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>
 <h2>Documentation</h2>

data/xor_cascade.net

@@ -30,5 +30,5 @@ 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 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, 2.50000000000000000000e-01) (4, 3, 5.00000000000000000000e-01) (5, 5, 5.00000000000000000000e-01) 
-connections (connected_to_neuron, weight)=(0, 6.03121553472700799858e+00) (1, 5.92105744890394891655e+00) (2, 8.14956251680783866354e-02) (0, 6.94100315065092517142e-03) (1, 3.52612781717012192806e-03) (2, -8.15146231147867013078e+01) (3, -4.67572273234011584475e-03) (0, 2.85375829917018764004e-01) (1, 2.88068426443957192884e-01) (2, 4.27497417431277615396e-02) (3, 3.96005150696007106603e+01) (4, 2.44562686549522956270e-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, 5.00000000000000000000e-01) (4, 3, 7.50000000000000000000e-01) (5, 5, 5.00000000000000000000e-01) 
+connections (connected_to_neuron, weight)=(0, 1.93441716139228003790e+00) (1, 1.70890924020654355608e+00) (2, 1.23564954660518554197e-02) (0, -8.14182709333025056431e-02) (1, -7.15250401659676127153e-02) (2, -2.38748796481204799136e+01) (3, -4.16798582203117828904e-01) (0, 4.46139384612332989821e-01) (1, 3.91859924128322711923e-01) (2, -9.99655042040694441496e-01) (3, 4.06572980026871846349e+01) (4, -5.10086273232595699412e-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.80850670860991669109e-01) (1, 5.31853923495240299424e-01) (2, 1.94246314046218548910e+00) (0, -2.41994141449592392590e+00) (1, 2.40561692453033115768e+00) (2, -1.38967102463236291676e+00) (0, 2.02945595642753762178e+00) (1, -2.11680476314898902146e+00) (2, -1.63136454713236567216e+00) (3, 1.38258366722087866485e+00) (4, 4.93982711345169622774e+00) (5, 4.87308662094168720813e+00) (6, 3.15280014713231304668e+00) 
+connections (connected_to_neuron, weight)=(0, 2.23371764591571020375e+00) (1, 1.58521562208138422356e+00) (2, 1.43955559831288093520e+00) (0, 1.63051204219772549742e+00) (1, -1.49354703398461952091e+00) (2, 2.37087930182826900349e+00) (0, 1.61957436211062755227e+00) (1, 2.28195297973940336433e+00) (2, -1.40962767164018121235e+00) (3, 4.58246629418312600990e+00) (4, -2.31578449129627728098e+00) (5, -4.54905458104575011191e+00) (6, -1.79180653141054779809e+00) 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-fann
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Steven Miers
@@ -55,6 +55,7 @@ files:
 - ext/ruby_fann/fann_train.h
 - ext/ruby_fann/fann_cascade.h
 - ext/ruby_fann/fann_io.h
+- ext/ruby_fann/fann.h
 - ext/ruby_fann/fann.c
 - ext/ruby_fann/doublefann.c
 - ext/ruby_fann/fann_io.c