void cascadetrain_on_data( const  training_data  & data, unsigned  int  max_neurons, unsigned  int  neurons_between_reports, float  desired_error )

Trains on an entire dataset, for a period of time using the Cascade2 training algorithm.

void cascadetrain_on_file( const std:: string  & filename, unsigned  int  max_neurons, unsigned  int  neurons_between_reports, float  desired_error )

Does the same as cascadetrain_on_data, but reads the training data directly from a file.

bool clear_scaling_params()

Clears scaling parameters.

void copy_from_struct_fann( struct  fann  * other )

Set the internal fann struct to a copy of other

bool create_from_file( const std:: string  & configuration_file )

Constructs a backpropagation neural network from a configuration file, which have been saved by save.

bool create_shortcut( unsigned  int  num_layers,   ... )

Creates a standard backpropagation neural network, which is not fully connected and which also has shortcut connections.

bool create_shortcut_array( unsigned  int  num_layers, const unsigned  int  * layers )

Just like create_shortcut, but with an array of layer sizes instead of individual parameters.

bool create_sparse( float  connection_rate, unsigned  int  num_layers,   ... )

Creates a standard backpropagation neural network, which is not fully connected.

bool create_sparse_array( float  connection_rate, unsigned  int  num_layers, const unsigned  int  * layers )

Just like create_sparse, but with an array of layer sizes instead of individual parameters.

bool create_standard( unsigned  int  num_layers,   ... )

Creates a standard fully connected backpropagation neural network.

bool create_standard_array( unsigned  int  num_layers, const unsigned  int  * layers )

Just like create_standard, but with an array of layer sizes instead of individual parameters.

void create_train_from_callback(     unsigned  int  num_data,     unsigned  int  num_input,     unsigned  int  num_output,     void  (FANN_API *user_function)( unsigned int, unsigned int, unsigned int, fann_type * , fann_type * ) )

Creates the training data struct from a user supplied function.

void descale_input( fann_type  * input_vector )

Scale data in input vector after get it from ann based on previously calculated parameters.

void descale_output( fann_type  * output_vector )

Scale data in output vector after get it from ann based on previously calculated parameters.

void descale_train( training_data  & data )

Descale input and output data based on previously calculated parameters.

void destroy()

Destructs the entire network.

void destroy_train()

Destructs the training data.

FANN_EXTERNAL void FANN_API fann_cascadetrain_on_data(     struct  fann  * ann,     struct  fann_train_data  * data,     unsigned  int  max_neurons,     unsigned  int  neurons_between_reports,     float  desired_error )

Trains on an entire dataset, for a period of time using the Cascade2 training algorithm.

FANN_EXTERNAL void FANN_API fann_cascadetrain_on_file(     struct  fann  * ann,     const  char  * filename,     unsigned  int  max_neurons,     unsigned  int  neurons_between_reports,     float  desired_error )

Does the same as fann_cascadetrain_on_data, but reads the training data directly from a file.

FANN_EXTERNAL int FANN_API fann_clear_scaling_params( struct  fann  * ann )

Clears scaling parameters.

FANN_EXTERNAL struct fann * FANN_API fann_copy( struct  fann  * ann )

Creates a copy of a fann structure.

FANN_EXTERNAL struct fann *FANN_API fann_create_from_file(     const  char  * configuration_file )

Constructs a backpropagation neural network from a configuration file, which have been saved by fann_save.

FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut(     unsigned  int  num_layers,       ... )

Creates a standard backpropagation neural network, which is not fully connected and which also has shortcut connections.

FANN_EXTERNAL struct fann *FANN_API fann_create_shortcut_array(     unsigned  int  num_layers,     const unsigned  int  * layers )

Just like fann_create_shortcut, but with an array of layer sizes instead of individual parameters.

FANN_EXTERNAL struct fann *FANN_API fann_create_sparse(     float  connection_rate,     unsigned  int  num_layers,       ... )

Creates a standard backpropagation neural network, which is not fully connected.

FANN_EXTERNAL struct fann *FANN_API fann_create_sparse_array(     float  connection_rate,     unsigned  int  num_layers,     const unsigned  int  * layers )

Just like fann_create_sparse, but with an array of layer sizes instead of individual parameters.

FANN_EXTERNAL struct fann *FANN_API fann_create_standard(     unsigned  int  num_layers,       ... )

Creates a standard fully connected backpropagation neural network.

FANN_EXTERNAL struct fann *FANN_API fann_create_standard_array(     unsigned  int  num_layers,     const unsigned  int  * layers )

Just like fann_create_standard, but with an array of layer sizes instead of individual parameters.

FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train(     unsigned  int  num_data,     unsigned  int  num_input,     unsigned  int  num_output )

Creates an empty training data struct.

FANN_EXTERNAL struct fann_train_data * FANN_API fann_create_train_from_callback(     unsigned  int  num_data,     unsigned  int  num_input,     unsigned  int  num_output,     void  (FANN_API *user_function)( unsigned int, unsigned int, unsigned int, fann_type * , fann_type * ) )

Creates the training data struct from a user supplied function.

FANN_EXTERNAL void FANN_API fann_descale_input( struct  fann  * ann, fann_type  * input_vector )

Scale data in input vector after get it from ann based on previously calculated parameters.

FANN_EXTERNAL void FANN_API fann_descale_output( struct  fann  * ann, fann_type  * output_vector )

Scale data in output vector after get it from ann based on previously calculated parameters.

FANN_EXTERNAL void FANN_API fann_descale_train( struct  fann  * ann, struct  fann_train_data  * data )

Descale input and output data based on previously calculated parameters.

FANN_EXTERNAL void FANN_API fann_destroy( struct  fann  * ann )

Destroys the entire network and properly freeing all the associated memmory.

FANN_EXTERNAL void FANN_API fann_destroy_train(     struct  fann_train_data  * train_data )

Destructs the training data and properly deallocates all of the associated data.

FANN_EXTERNAL struct fann_train_data *FANN_API fann_duplicate_train_data(     struct  fann_train_data  * data )

Returns an exact copy of a struct fann_train_data.

FANN_EXTERNAL enum fann_activationfunc_enum FANN_API fann_get_activation_function(     struct  fann  * ann,     int  layer,     int  neuron )

Get the activation function for neuron number neuron in layer number layer, counting the input layer as layer 0.

FANN_EXTERNAL fann_type FANN_API fann_get_activation_steepness(     struct  fann  * ann,     int  layer,     int  neuron )

Get the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0.

FANN_EXTERNAL void FANN_API fann_get_bias_array( struct  fann  * ann, unsigned  int  * bias )

Get the number of bias in each layer in the network.

FANN_EXTERNAL unsigned int FANN_API fann_get_bit_fail( struct  fann  * ann )

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).

FANN_EXTERNAL fann_type FANN_API fann_get_bit_fail_limit( struct  fann  * ann )

Returns the bit fail limit used during training.

FANN_EXTERNAL enum fann_activationfunc_enum * FANN_API fann_get_cascade_activation_functions(     struct  fann  * ann )

The cascade activation functions array is an array of the different activation functions used by the candidates.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_activation_functions_count(     struct  fann  * ann )

The number of activation functions in the fann_get_cascade_activation_functions array.

FANN_EXTERNAL fann_type * FANN_API fann_get_cascade_activation_steepnesses(     struct  fann  * ann )

The cascade activation steepnesses array is an array of the different activation functions used by the candidates.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_activation_steepnesses_count(     struct  fann  * ann )

The number of activation steepnesses in the fann_get_cascade_activation_functions array.

FANN_EXTERNAL float FANN_API fann_get_cascade_candidate_change_fraction(     struct  fann  * ann )

The cascade candidate change fraction is a number between 0 and 1 determining how large a fraction the fann_get_MSE value should change within fann_get_cascade_candidate_stagnation_epochs during training of the candidate neurons, in order for the training not to stagnate.

FANN_EXTERNAL fann_type FANN_API fann_get_cascade_candidate_limit(     struct  fann  * ann )

The candidate limit is a limit for how much the candidate neuron may be trained.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_candidate_stagnation_epochs(     struct  fann  * ann )

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 fann_get_cascade_candidate_change_fraction.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_max_cand_epochs(     struct  fann  * ann )

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.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_max_out_epochs(     struct  fann  * ann )

The maximum out epochs determines the maximum number of epochs the output connections may be trained after adding a new candidate neuron.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_min_cand_epochs(     struct  fann  * ann )

The minimum candidate epochs determines the minimum number of epochs the input connections to the candidates may be trained before adding a new candidate neuron.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_min_out_epochs(     struct  fann  * ann )

The minimum out epochs determines the minimum number of epochs the output connections must be trained after adding a new candidate neuron.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_num_candidate_groups(     struct  fann  * ann )

The number of candidate groups is the number of groups of identical candidates which will be used during training.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_num_candidates(     struct  fann  * ann )

The number of candidates used during training (calculated by multiplying fann_get_cascade_activation_functions_count, fann_get_cascade_activation_steepnesses_count and fann_get_cascade_num_candidate_groups).

FANN_EXTERNAL float FANN_API fann_get_cascade_output_change_fraction(     struct  fann  * ann )

The cascade output change fraction is a number between 0 and 1 determining how large a fraction the fann_get_MSE value should change within fann_get_cascade_output_stagnation_epochs during training of the output connections, in order for the training not to stagnate.

FANN_EXTERNAL unsigned int FANN_API fann_get_cascade_output_stagnation_epochs(     struct  fann  * ann )

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 fann_get_cascade_output_change_fraction.

FANN_EXTERNAL fann_type FANN_API fann_get_cascade_weight_multiplier(     struct  fann  * ann )

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.

FANN_EXTERNAL void FANN_API fann_get_connection_array(     struct  fann  * ann,     struct  fann_connection  * connections )

Get the connections in the network.

FANN_EXTERNAL float FANN_API fann_get_connection_rate( struct  fann  * ann )

Get the connection rate used when the network was created

FANN_EXTERNAL unsigned int FANN_API fann_get_decimal_point( struct  fann  * ann )

Returns the position of the decimal point in the ann.

FANN_EXTERNAL enum fann_errno_enum FANN_API fann_get_errno(     struct  fann_error  * errdat )

Returns the last error number.

FANN_EXTERNAL char *FANN_API fann_get_errstr( struct  fann_error  * errdat )

Returns the last errstr.

FANN_EXTERNAL void FANN_API fann_get_layer_array( struct  fann  * ann, unsigned  int  * layers )

Get the number of neurons in each layer in the network.

FANN_EXTERNAL float FANN_API fann_get_learning_momentum( struct  fann  * ann )

Get the learning momentum.

FANN_EXTERNAL float FANN_API fann_get_learning_rate( struct  fann  * ann )

Return the learning rate.

FANN_EXTERNAL float FANN_API fann_get_MSE( struct  fann  * ann )

Reads the mean square error from the network.

FANN_EXTERNAL unsigned int FANN_API fann_get_multiplier( struct  fann  * ann )

returns the multiplier that fix point data is multiplied with.

FANN_EXTERNAL enum fann_nettype_enum FANN_API fann_get_network_type(     struct  fann  * ann )

Get the type of neural network it was created as.

FANN_EXTERNAL unsigned int FANN_API fann_get_num_input( struct  fann  * ann )

Get the number of input neurons.

FANN_EXTERNAL unsigned int FANN_API fann_get_num_layers( struct  fann  * ann )

Get the number of layers in the network

FANN_EXTERNAL unsigned int FANN_API fann_get_num_output( struct  fann  * ann )

Get the number of output neurons.

FANN_EXTERNAL float FANN_API fann_get_quickprop_decay( struct  fann  * ann )

The decay is a small negative valued number which is the factor that the weights should become smaller in each iteration during quickprop training.

FANN_EXTERNAL float FANN_API fann_get_quickprop_mu( struct  fann  * ann )

The mu factor is used to increase and decrease the step-size during quickprop training.

FANN_EXTERNAL float FANN_API fann_get_rprop_decrease_factor( struct  fann  * ann )

The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training.

FANN_EXTERNAL float FANN_API fann_get_rprop_delta_max( struct  fann  * ann )

The maximum step-size is a positive number determining how large the maximum step-size may be.

FANN_EXTERNAL float FANN_API fann_get_rprop_delta_min( struct  fann  * ann )

The minimum step-size is a small positive number determining how small the minimum step-size may be.

FANN_EXTERNAL float FANN_API fann_get_rprop_delta_zero( struct  fann  * ann )

The initial step-size is a positive number determining the initial step size.

FANN_EXTERNAL float FANN_API fann_get_rprop_increase_factor( struct  fann  * ann )

The increase factor is a value larger than 1, which is used to increase the step-size during RPROP training.

FANN_EXTERNAL float FANN_API fann_get_sarprop_step_error_shift(     struct  fann  * ann )

The get sarprop step error shift.

FANN_EXTERNAL float FANN_API fann_get_sarprop_step_error_threshold_factor(     struct  fann  * ann )

The sarprop step error threshold factor.

FANN_EXTERNAL float FANN_API fann_get_sarprop_temperature( struct  fann  * ann )

The sarprop weight decay shift.

FANN_EXTERNAL float FANN_API fann_get_sarprop_weight_decay_shift(     struct  fann  * ann )

The sarprop weight decay shift.

FANN_EXTERNAL unsigned int FANN_API fann_get_total_connections(     struct  fann  * ann )

Get the total number of connections in the entire network.

FANN_EXTERNAL unsigned int FANN_API fann_get_total_neurons( struct  fann  * ann )

Get the total number of neurons in the entire network.

FANN_EXTERNAL enum fann_errorfunc_enum FANN_API fann_get_train_error_function(     struct  fann  * ann )

Returns the error function used during training.

FANN_EXTERNAL enum fann_stopfunc_enum FANN_API fann_get_train_stop_function(     struct  fann  * ann )

Returns the the stop function used during training.

FANN_EXTERNAL enum fann_train_enum FANN_API fann_get_training_algorithm(     struct  fann  * ann )

Return the training algorithm as described by fann_train_enum.

FANN_EXTERNAL void * FANN_API fann_get_user_data( struct  fann  * ann )

Get a pointer to user defined data that was previously set with fann_set_user_data.

FANN_EXTERNAL void FANN_API fann_init_weights(     struct  fann  * ann,     struct  fann_train_data  * train_data )

Initialize the weights using Widrow + Nguyen’s algorithm.

FANN_EXTERNAL unsigned int FANN_API fann_length_train_data(     struct  fann_train_data  * data )

Returns the number of training patterns in the struct fann_train_data.

FANN_EXTERNAL struct fann_train_data *FANN_API fann_merge_train_data(     struct  fann_train_data  * data1,     struct  fann_train_data  * data2 )

Merges the data from data1 and data2 into a new struct fann_train_data.

FANN_EXTERNAL unsigned int FANN_API fann_num_input_train_data(     struct  fann_train_data  * data )

Returns the number of inputs in each of the training patterns in the struct fann_train_data.

FANN_EXTERNAL unsigned int FANN_API fann_num_output_train_data(     struct  fann_train_data  * data )

Returns the number of outputs in each of the training patterns in the struct fann_train_data.

FANN_EXTERNAL void FANN_API fann_print_connections( struct  fann  * ann )

Will print the connections of the ann in a compact matrix, for easy viewing of the internals of the ann.

FANN_EXTERNAL void FANN_API fann_print_error( struct  fann_error  * errdat )

Prints the last error to stderr.

FANN_EXTERNAL void FANN_API fann_print_parameters( struct  fann  * ann )

Prints all of the parameters and options of the ANN

FANN_EXTERNAL void FANN_API fann_randomize_weights( struct  fann  * ann, fann_type  min_weight, fann_type  max_weight )

Give each connection a random weight between min_weight and max_weight

FANN_EXTERNAL struct fann_train_data *FANN_API fann_read_train_from_file(     const  char  * filename )

Reads a file that stores training data.

FANN_EXTERNAL void FANN_API fann_reset_errno( struct  fann_error  * errdat )

Resets the last error number.

FANN_EXTERNAL void FANN_API fann_reset_errstr( struct  fann_error  * errdat )

Resets the last error string.

FANN_EXTERNAL void FANN_API fann_reset_MSE( struct  fann  * ann )

Resets the mean square error from the network.

FANN_EXTERNAL fann_type * FANN_API fann_run( struct  fann  * ann, fann_type  * input )

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.

FANN_EXTERNAL int FANN_API fann_save( struct  fann  * ann, const  char  * configuration_file )

Save the entire network to a configuration file.

FANN_EXTERNAL int FANN_API fann_save_to_fixed( struct  fann  * ann, const  char  * configuration_file )

Saves the entire network to a configuration file.

FANN_EXTERNAL int FANN_API fann_save_train( struct  fann_train_data  * data, const  char  * filename )

Save the training structure to a file, with the format as specified in fann_read_train_from_file

FANN_EXTERNAL int FANN_API fann_save_train_to_fixed(     struct  fann_train_data  * data,     const  char  * filename,     unsigned  int  decimal_point )

Saves the training structure to a fixed point data file.

FANN_EXTERNAL void FANN_API fann_scale_input( struct  fann  * ann, fann_type  * input_vector )

Scale data in input vector before feed it to ann based on previously calculated parameters.

FANN_EXTERNAL void FANN_API fann_scale_input_train_data(     struct  fann_train_data  * train_data,     fann_type  new_min,     fann_type  new_max )

Scales the inputs in the training data to the specified range.

FANN_EXTERNAL void FANN_API fann_scale_output( struct  fann  * ann, fann_type  * output_vector )

Scale data in output vector before feed it to ann based on previously calculated parameters.

FANN_EXTERNAL void FANN_API fann_scale_output_train_data(     struct  fann_train_data  * train_data,     fann_type  new_min,     fann_type  new_max )

Scales the outputs in the training data to the specified range.

FANN_EXTERNAL void FANN_API fann_scale_train( struct  fann  * ann, struct  fann_train_data  * data )

Scale input and output data based on previously calculated parameters.

FANN_EXTERNAL void FANN_API fann_scale_train_data(     struct  fann_train_data  * train_data,     fann_type  new_min,     fann_type  new_max )

Scales the inputs and outputs in the training data to the specified range.

FANN_EXTERNAL void FANN_API fann_set_activation_function(     struct  fann  * ann,     enum  fann_activationfunc_enum  activation_function,     int  layer,     int  neuron )

Set the activation function for neuron number neuron in layer number layer, counting the input layer as layer 0.

FANN_EXTERNAL void FANN_API fann_set_activation_function_hidden(     struct  fann  * ann,     enum  fann_activationfunc_enum  activation_function )

Set the activation function for all of the hidden layers.

FANN_EXTERNAL void FANN_API fann_set_activation_function_layer(     struct  fann  * ann,     enum  fann_activationfunc_enum  activation_function,     int  layer )

Set the activation function for all the neurons in the layer number layer, counting the input layer as layer 0.

FANN_EXTERNAL void FANN_API fann_set_activation_function_output(     struct  fann  * ann,     enum  fann_activationfunc_enum  activation_function )

Set the activation function for the output layer.

FANN_EXTERNAL void FANN_API fann_set_activation_steepness( struct  fann  * ann, fann_type  steepness, int  layer, int  neuron )

Set the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0.

FANN_EXTERNAL void FANN_API fann_set_activation_steepness_hidden(     struct  fann  * ann,     fann_type  steepness )

Set the steepness of the activation steepness in all of the hidden layers.

FANN_EXTERNAL void FANN_API fann_set_activation_steepness_layer(     struct  fann  * ann,     fann_type  steepness,     int  layer )

Set the activation steepness all of the neurons in layer number layer, counting the input layer as layer 0.

FANN_EXTERNAL void FANN_API fann_set_activation_steepness_output(     struct  fann  * ann,     fann_type  steepness )

Set the steepness of the activation steepness in the output layer.

FANN_EXTERNAL void FANN_API fann_set_bit_fail_limit( struct  fann  * ann, fann_type  bit_fail_limit )

Set the bit fail limit used during training.

FANN_EXTERNAL void FANN_API fann_set_callback( struct  fann  * ann, fann_callback_type  callback )

Sets the callback function for use during training.

FANN_EXTERNAL void FANN_API fann_set_cascade_activation_functions(     struct  fann  * ann,     enum  fann_activationfunc_enum  * cascade_activation_functions,     unsigned  int  cascade_activation_functions_count )

Sets the array of cascade candidate activation functions.

FANN_EXTERNAL void FANN_API fann_set_cascade_activation_steepnesses(     struct  fann  * ann,     fann_type  * cascade_activation_steepnesses,     unsigned  int  cascade_activation_steepnesses_count )

Sets the array of cascade candidate activation steepnesses.

FANN_EXTERNAL void FANN_API fann_set_cascade_candidate_change_fraction(     struct  fann  * ann,     float  cascade_candidate_change_fraction )

Sets the cascade candidate change fraction.

FANN_EXTERNAL void FANN_API fann_set_cascade_candidate_limit(     struct  fann  * ann,     fann_type  cascade_candidate_limit )

Sets the candidate limit.

FANN_EXTERNAL void FANN_API fann_set_cascade_candidate_stagnation_epochs(     struct  fann  * ann,     unsigned  int  cascade_candidate_stagnation_epochs )

Sets the number of cascade candidate stagnation epochs.

FANN_EXTERNAL void FANN_API fann_set_cascade_max_cand_epochs(     struct  fann  * ann,     unsigned  int  cascade_max_cand_epochs )

Sets the max candidate epochs.

FANN_EXTERNAL void FANN_API fann_set_cascade_max_out_epochs(     struct  fann  * ann,     unsigned  int  cascade_max_out_epochs )

Sets the maximum out epochs.

FANN_EXTERNAL void FANN_API fann_set_cascade_min_cand_epochs(     struct  fann  * ann,     unsigned  int  cascade_min_cand_epochs )

Sets the min candidate epochs.

FANN_EXTERNAL void FANN_API fann_set_cascade_min_out_epochs(     struct  fann  * ann,     unsigned  int  cascade_min_out_epochs )

Sets the minimum out epochs.

FANN_EXTERNAL void FANN_API fann_set_cascade_num_candidate_groups(     struct  fann  * ann,     unsigned  int  cascade_num_candidate_groups )

Sets the number of candidate groups.

FANN_EXTERNAL void FANN_API fann_set_cascade_output_change_fraction(     struct  fann  * ann,     float  cascade_output_change_fraction )

Sets the cascade output change fraction.

FANN_EXTERNAL void FANN_API fann_set_cascade_output_stagnation_epochs(     struct  fann  * ann,     unsigned  int  cascade_output_stagnation_epochs )

Sets the number of cascade output stagnation epochs.

FANN_EXTERNAL void FANN_API fann_set_cascade_weight_multiplier(     struct  fann  * ann,     fann_type  cascade_weight_multiplier )

Sets the weight multiplier.

FANN_EXTERNAL void FANN_API fann_set_error_log( struct  fann_error  * errdat, FILE  * log_file )

Change where errors are logged to.

FANN_EXTERNAL int FANN_API fann_set_input_scaling_params(     struct  fann  * ann,     const struct  fann_train_data  * data,     float  new_input_min,     float  new_input_max )

Calculate input scaling parameters for future use based on training data.

FANN_EXTERNAL void FANN_API fann_set_learning_momentum( struct  fann  * ann, float  learning_momentum )

Set the learning momentum.

FANN_EXTERNAL void FANN_API fann_set_learning_rate( struct  fann  * ann, float  learning_rate )

Set the learning rate.

FANN_EXTERNAL int FANN_API fann_set_output_scaling_params(     struct  fann  * ann,     const struct  fann_train_data  * data,     float  new_output_min,     float  new_output_max )

Calculate output scaling parameters for future use based on training data.

FANN_EXTERNAL void FANN_API fann_set_quickprop_decay( struct  fann  * ann, float  quickprop_decay )

Sets the quickprop decay factor.

FANN_EXTERNAL void FANN_API fann_set_quickprop_mu( struct  fann  * ann, float  quickprop_mu )

Sets the quickprop mu factor.

FANN_EXTERNAL void FANN_API fann_set_rprop_decrease_factor(     struct  fann  * ann,     float  rprop_decrease_factor )

The decrease factor is a value smaller than 1, which is used to decrease the step-size during RPROP training.

FANN_EXTERNAL void FANN_API fann_set_rprop_delta_max( struct  fann  * ann, float  rprop_delta_max )

The maximum step-size is a positive number determining how large the maximum step-size may be.

FANN_EXTERNAL void FANN_API fann_set_rprop_delta_min( struct  fann  * ann, float  rprop_delta_min )

The minimum step-size is a small positive number determining how small the minimum step-size may be.

FANN_EXTERNAL void FANN_API fann_set_rprop_delta_zero( struct  fann  * ann, float  rprop_delta_max )

The initial step-size is a positive number determining the initial step size.

FANN_EXTERNAL void FANN_API fann_set_rprop_increase_factor(     struct  fann  * ann,     float  rprop_increase_factor )

The increase factor used during RPROP training.

FANN_EXTERNAL void FANN_API fann_set_sarprop_step_error_shift(     struct  fann  * ann,     float  sarprop_step_error_shift )

Set the sarprop step error shift.

FANN_EXTERNAL void FANN_API fann_set_sarprop_step_error_threshold_factor(     struct  fann  * ann,     float  sarprop_step_error_threshold_factor )

Set the sarprop step error threshold factor.

FANN_EXTERNAL void FANN_API fann_set_sarprop_temperature(     struct  fann  * ann,     float  sarprop_temperature )

Set the sarprop_temperature.

FANN_EXTERNAL void FANN_API fann_set_sarprop_weight_decay_shift(     struct  fann  * ann,     float  sarprop_weight_decay_shift )

Set the sarprop weight decay shift.

FANN_EXTERNAL int FANN_API fann_set_scaling_params(     struct  fann  * ann,     const struct  fann_train_data  * data,     float  new_input_min,     float  new_input_max,     float  new_output_min,     float  new_output_max )

Calculate input and output scaling parameters for future use based on training data.

FANN_EXTERNAL void FANN_API fann_set_train_error_function(     struct  fann  * ann,     enum  fann_errorfunc_enum  train_error_function )

Set the error function used during training.

FANN_EXTERNAL void FANN_API fann_set_train_stop_function(     struct  fann  * ann,     enum  fann_stopfunc_enum  train_stop_function )

Set the stop function used during training.

FANN_EXTERNAL void FANN_API fann_set_training_algorithm(     struct  fann  * ann,     enum  fann_train_enum  training_algorithm )

Set the training algorithm.

FANN_EXTERNAL void FANN_API fann_set_user_data( struct  fann  * ann, void  * user_data )

Store a pointer to user defined data.

FANN_EXTERNAL void FANN_API fann_set_weight( struct  fann  * ann, unsigned  int  from_neuron, unsigned  int  to_neuron, fann_type  weight )

Set a connection in the network.

FANN_EXTERNAL void FANN_API fann_set_weight_array(     struct  fann  * ann,     struct  fann_connection  * connections,     unsigned  int  num_connections )

Set connections in the network.

FANN_EXTERNAL void FANN_API fann_shuffle_train_data(     struct  fann_train_data  * train_data )

Shuffles training data, randomizing the order.

FANN_EXTERNAL struct fann_train_data *FANN_API fann_subset_train_data(     struct  fann_train_data  * data,     unsigned  int  pos,     unsigned  int  length )

Returns an copy of a subset of the struct fann_train_data, starting at position pos and length elements forward.

FANN_EXTERNAL fann_type * FANN_API fann_test( struct  fann  * ann, fann_type  * input, fann_type  * desired_output )

Test with a set of inputs, and a set of desired outputs.

FANN_EXTERNAL float FANN_API fann_test_data( struct  fann  * ann, struct  fann_train_data  * data )

Test a set of training data and calculates the MSE for the training data.

FANN_EXTERNAL void FANN_API fann_train( struct  fann  * ann, fann_type  * input, fann_type  * desired_output )

Train one iteration with a set of inputs, and a set of desired outputs.

FANN_EXTERNAL float FANN_API fann_train_epoch( struct  fann  * ann, struct  fann_train_data  * data )

Train one epoch with a set of training data.

FANN_EXTERNAL void FANN_API fann_train_on_data(     struct  fann  * ann,     struct  fann_train_data  * data,     unsigned  int  max_epochs,     unsigned  int  epochs_between_reports,     float  desired_error )

Trains on an entire dataset, for a period of time.

FANN_EXTERNAL void FANN_API fann_train_on_file(     struct  fann  * ann,     const  char  * filename,     unsigned  int  max_epochs,     unsigned  int  epochs_between_reports,     float  desired_error )

Does the same as fann_train_on_data, but reads the training data directly from a file.