fann.c

/*
  +----------------------------------------------------------------------+
  | PHP Version 5                                                        |
  +----------------------------------------------------------------------+
  | Copyright (c) 1997-2015 Jakub Zelenka                                |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.php.net/license/3_01.txt                                  |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author: Jakub Zelenka <bukka@php.net>                                |
  +----------------------------------------------------------------------+
*/

/* $Id$ */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "ext/standard/php_filestat.h"
#include "ext/standard/php_string.h"
#include "phpc/phpc.h"
#include "php_fann.h"

/* used fann type - default float */
#ifdef PHP_FANN_DOUBLE
#include "doublefann.h"
#else
#include "floatfann.h"
#endif

/* True global resources - no need for thread safety here */
static int le_fannbuf, le_fanntrainbuf;
#define le_fannbuf_name "FANN"
#define le_fanntrainbuf_name "FANN Train Data"

/* fann user data structure */
typedef struct _php_fann_user_data {
	phpc_val callback;
	zval *z_ann;
	zval *z_train_data;
} php_fann_user_data;

/* {{{ arginfo */
ZEND_BEGIN_ARG_INFO_EX(arginfo_fann_create_standard, 0, 0, 3)
ZEND_ARG_INFO(0, num_layers)
ZEND_ARG_INFO(0, num_neurons1)
ZEND_ARG_INFO(0, num_neurons2)
ZEND_ARG_INFO(0, ...)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_create_standard_array, 0)
ZEND_ARG_INFO(0, num_layers)
ZEND_ARG_INFO(0, layers)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_fann_create_sparse, 0, 0, 4)
ZEND_ARG_INFO(0, connection_rate)
ZEND_ARG_INFO(0, num_layers)
ZEND_ARG_INFO(0, num_neurons1)
ZEND_ARG_INFO(0, num_neurons2)
ZEND_ARG_INFO(0, ...)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_create_sparse_array, 0)
ZEND_ARG_INFO(0, connection_rate)
ZEND_ARG_INFO(0, num_layers)
ZEND_ARG_INFO(0, layers)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_fann_create_shortcut, 0, 0, 3)
ZEND_ARG_INFO(0, num_layers)
ZEND_ARG_INFO(0, num_neurons1)
ZEND_ARG_INFO(0, num_neurons2)
ZEND_ARG_INFO(0, ...)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_create_shortcut_array, 0)
ZEND_ARG_INFO(0, num_layers)
ZEND_ARG_INFO(0, layers)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_destroy, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
ZEND_BEGIN_ARG_INFO(arginfo_fann_copy, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()
#endif

ZEND_BEGIN_ARG_INFO(arginfo_fann_run, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, input)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_randomize_weights, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, min_weight)
ZEND_ARG_INFO(0, max_weight)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_init_weights, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, train_data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_num_input, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_num_output, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_total_neurons, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_total_connections, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_network_type, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_connection_rate, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_num_layers, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_layer_array, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_bias_array, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_connection_array, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_weight_array, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, connections)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_weight, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, from_neuron)
ZEND_ARG_INFO(0, to_neuron)
ZEND_ARG_INFO(0, weight)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_train, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, input)
ZEND_ARG_INFO(0, desired_output)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_test, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, input)
ZEND_ARG_INFO(0, desired_output)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_MSE, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_bit_fail, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_reset_MSE, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_train_on_data, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, data)
ZEND_ARG_INFO(0, max_epochs)
ZEND_ARG_INFO(0, epochs_between_reports)
ZEND_ARG_INFO(0, desired_error)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_train_on_file, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, filename)
ZEND_ARG_INFO(0, max_epochs)
ZEND_ARG_INFO(0, epochs_between_reports)
ZEND_ARG_INFO(0, desired_error)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_train_epoch, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_test_data, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_read_train_from_file, 0)
ZEND_ARG_INFO(0, filename)
ZEND_END_ARG_INFO()

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
ZEND_BEGIN_ARG_INFO(arginfo_fann_create_train, 0)
ZEND_ARG_INFO(0, num_data)
ZEND_ARG_INFO(0, num_input)
ZEND_ARG_INFO(0, num_output)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_create_train_from_callback, 0)
ZEND_ARG_INFO(0, num_data)
ZEND_ARG_INFO(0, num_input)
ZEND_ARG_INFO(0, num_output)
ZEND_ARG_INFO(0, user_function)
ZEND_END_ARG_INFO()
#endif

ZEND_BEGIN_ARG_INFO(arginfo_fann_destroy_train, 0)
ZEND_ARG_INFO(0, train_data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_shuffle_train_data, 0)
ZEND_ARG_INFO(0, train_data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_scale_train, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, train_data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_descale_train, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, train_data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_input_scaling_params, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, train_data)
ZEND_ARG_INFO(0, new_input_min)
ZEND_ARG_INFO(0, new_input_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_output_scaling_params, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, train_data)
ZEND_ARG_INFO(0, new_output_min)
ZEND_ARG_INFO(0, new_output_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_scaling_params, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, train_data)
ZEND_ARG_INFO(0, new_input_min)
ZEND_ARG_INFO(0, new_input_max)
ZEND_ARG_INFO(0, new_output_min)
ZEND_ARG_INFO(0, new_output_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_clear_scaling_params, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_scale_input, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, input_vector)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_scale_output, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, output_vector)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_descale_input, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, input_vector)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_descale_output, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, output_vector)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_scale_input_train_data, 0)
ZEND_ARG_INFO(0, train_data)
ZEND_ARG_INFO(0, new_min)
ZEND_ARG_INFO(0, new_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_scale_output_train_data, 0)
ZEND_ARG_INFO(0, train_data)
ZEND_ARG_INFO(0, new_min)
ZEND_ARG_INFO(0, new_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_scale_train_data, 0)
ZEND_ARG_INFO(0, train_data)
ZEND_ARG_INFO(0, new_min)
ZEND_ARG_INFO(0, new_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_merge_train_data, 0)
ZEND_ARG_INFO(0, data1)
ZEND_ARG_INFO(0, data2)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_duplicate_train_data, 0)
ZEND_ARG_INFO(0, data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_subset_train_data, 0)
ZEND_ARG_INFO(0, data)
ZEND_ARG_INFO(0, pos)
ZEND_ARG_INFO(0, length)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_length_train_data, 0)
ZEND_ARG_INFO(0, data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_num_input_train_data, 0)
ZEND_ARG_INFO(0, data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_num_output_train_data, 0)
ZEND_ARG_INFO(0, data)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_save_train, 0)
ZEND_ARG_INFO(0, data)
ZEND_ARG_INFO(0, file_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_training_algorithm, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_training_algorithm, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, training_algorithm)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_learning_rate, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_learning_rate, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, learning_rate)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_learning_momentum, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_learning_momentum, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, learning_momentum)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_train_error_function, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_train_error_function, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, error_function)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_train_stop_function, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_train_stop_function, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, stop_function)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_bit_fail_limit, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_bit_fail_limit, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, bit_fail_limit)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_callback, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, callback)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_quickprop_decay, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_quickprop_decay, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, quickprop_decay)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_quickprop_mu, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_quickprop_mu, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, quickprop_mu)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_rprop_increase_factor, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_rprop_increase_factor, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, rprop_increase_factor)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_rprop_decrease_factor, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_rprop_decrease_factor, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, rprop_decrease_factor)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_rprop_delta_min, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_rprop_delta_min, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, rprop_delta_min)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_rprop_delta_max, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_rprop_delta_max, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, rprop_delta_max)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_rprop_delta_zero, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_rprop_delta_zero, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0 , rprop_delta_zero)
ZEND_END_ARG_INFO()

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
ZEND_BEGIN_ARG_INFO(arginfo_fann_get_sarprop_weight_decay_shift, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_sarprop_weight_decay_shift, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, sarprop_weight_decay_shift)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_sarprop_step_error_threshold_factor, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_sarprop_step_error_threshold_factor, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, sarprop_step_error_threshold_factor)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_sarprop_step_error_shift, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_sarprop_step_error_shift, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, sarprop_step_error_shift)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_sarprop_temperature, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_sarprop_temperature, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, sarprop_temperature)
ZEND_END_ARG_INFO()
#endif

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_activation_function, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, layer)
ZEND_ARG_INFO(0, neuron)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_function, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_function)
ZEND_ARG_INFO(0, layer)
ZEND_ARG_INFO(0, neuron)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_function_layer, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_function)
ZEND_ARG_INFO(0, layer)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_function_hidden, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_function)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_function_output, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_function)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_activation_steepness, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, layer)
ZEND_ARG_INFO(0, neuron)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_steepness, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_steepness)
ZEND_ARG_INFO(0, layer)
ZEND_ARG_INFO(0, neuron)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_steepness_layer, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_steepness)
ZEND_ARG_INFO(0, layer)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_steepness_hidden, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_steepness)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_activation_steepness_output, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, activation_steepness)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_cascadetrain_on_data, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, data)
ZEND_ARG_INFO(0, max_neurons)
ZEND_ARG_INFO(0, neurons_between_reports)
ZEND_ARG_INFO(0, desired_error)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_cascadetrain_on_file, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, filename)
ZEND_ARG_INFO(0, max_neurons)
ZEND_ARG_INFO(0, neurons_between_reports)
ZEND_ARG_INFO(0, desired_error)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_output_change_fraction, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_output_change_fraction, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_output_change_fraction)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_output_stagnation_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_output_stagnation_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_output_stagnation_epochs)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_candidate_change_fraction, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_candidate_change_fraction, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_candidate_change_fraction)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_candidate_stagnation_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_candidate_stagnation_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_candidate_stagnation_epochs)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_weight_multiplier, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_weight_multiplier, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_weight_multiplier)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_candidate_limit, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_candidate_limit, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_candidate_limit)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_max_out_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_max_out_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_max_out_epochs)
ZEND_END_ARG_INFO()

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_min_out_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_min_out_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_min_out_epochs)
ZEND_END_ARG_INFO()
#endif

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_max_cand_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_max_cand_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_max_cand_epochs)
ZEND_END_ARG_INFO()

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_min_cand_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_min_cand_epochs, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_min_cand_epochs)
ZEND_END_ARG_INFO()
#endif

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_num_candidates, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_activation_functions_count, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_activation_functions, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_activation_functions, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_activation_functions)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_activation_steepnesses_count, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_activation_steepnesses, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_activation_steepnesses, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_activation_steepnesses_count)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_cascade_num_candidate_groups, 0)
ZEND_ARG_INFO(0, ann)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_cascade_num_candidate_groups, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, cascade_num_candidate_groups)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_create_from_file, 0)
ZEND_ARG_INFO(0, configuration_file)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_save, 0)
ZEND_ARG_INFO(0, ann)
ZEND_ARG_INFO(0, configuration_file)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_set_error_log, 0)
ZEND_ARG_INFO(0, errdat)
ZEND_ARG_INFO(0, log_file)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_errno, 0)
ZEND_ARG_INFO(0, errdat)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_reset_errno, 0)
ZEND_ARG_INFO(0, errdat)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_reset_errstr, 0)
ZEND_ARG_INFO(0, errdat)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_get_errstr, 0)
ZEND_ARG_INFO(0, errdat)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_fann_print_error, 0)
ZEND_ARG_INFO(0, errdat)
ZEND_END_ARG_INFO()
/* }}} */

/* {{{ fann_functions[] */
zend_function_entry fann_functions[] = {
	PHP_FE(fann_create_standard,                          arginfo_fann_create_standard)
	PHP_FE(fann_create_standard_array,                    arginfo_fann_create_standard_array)
	PHP_FE(fann_create_sparse,                            arginfo_fann_create_sparse)
	PHP_FE(fann_create_sparse_array,                      arginfo_fann_create_sparse_array)
	PHP_FE(fann_create_shortcut,                          arginfo_fann_create_shortcut)
	PHP_FE(fann_create_shortcut_array,                    arginfo_fann_create_shortcut_array)
	PHP_FE(fann_destroy,                                  arginfo_fann_destroy)
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	PHP_FE(fann_copy,                                     arginfo_fann_copy)
#endif
	PHP_FE(fann_run,                                      arginfo_fann_run)
	PHP_FE(fann_randomize_weights,                        arginfo_fann_randomize_weights)
	PHP_FE(fann_init_weights,                             arginfo_fann_init_weights)
	PHP_FE(fann_get_num_input,                            arginfo_fann_get_num_input)
	PHP_FE(fann_get_num_output,                           arginfo_fann_get_num_output)
	PHP_FE(fann_get_total_neurons,                        arginfo_fann_get_total_neurons)
	PHP_FE(fann_get_total_connections,                    arginfo_fann_get_total_connections)
	PHP_FE(fann_get_network_type,                         arginfo_fann_get_network_type)
	PHP_FE(fann_get_connection_rate,                      arginfo_fann_get_connection_rate)
	PHP_FE(fann_get_num_layers,                           arginfo_fann_get_num_layers)
	PHP_FE(fann_get_layer_array,                          arginfo_fann_get_layer_array)
	PHP_FE(fann_get_bias_array,                           arginfo_fann_get_bias_array)
	PHP_FE(fann_get_connection_array,                     arginfo_fann_get_connection_array)
	PHP_FE(fann_set_weight_array,                         arginfo_fann_set_weight_array)
	PHP_FE(fann_set_weight,                               arginfo_fann_set_weight)
	PHP_FE(fann_train,                                    arginfo_fann_train)
	PHP_FE(fann_test,                                     arginfo_fann_test)
	PHP_FE(fann_get_MSE,                                  arginfo_fann_get_MSE)
	PHP_FE(fann_get_bit_fail,                             arginfo_fann_get_bit_fail)
	PHP_FE(fann_reset_MSE,                                arginfo_fann_reset_MSE)
	PHP_FE(fann_train_on_data,                            arginfo_fann_train_on_data)
	PHP_FE(fann_train_on_file,                            arginfo_fann_train_on_file)
	PHP_FE(fann_train_epoch,                              arginfo_fann_train_epoch)
	PHP_FE(fann_test_data,                                arginfo_fann_test_data)
	PHP_FE(fann_read_train_from_file,                     arginfo_fann_read_train_from_file)
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	PHP_FE(fann_create_train,                             arginfo_fann_create_train)
	PHP_FE(fann_create_train_from_callback,               arginfo_fann_create_train_from_callback)
#endif
	PHP_FE(fann_destroy_train,                            arginfo_fann_destroy_train)
	PHP_FE(fann_shuffle_train_data,                       arginfo_fann_shuffle_train_data)
	PHP_FE(fann_scale_train,                              arginfo_fann_scale_train)
	PHP_FE(fann_descale_train,                            arginfo_fann_descale_train)
	PHP_FE(fann_set_input_scaling_params,                 arginfo_fann_set_input_scaling_params)
	PHP_FE(fann_set_output_scaling_params,                arginfo_fann_set_output_scaling_params)
	PHP_FE(fann_set_scaling_params,                       arginfo_fann_set_scaling_params)
	PHP_FE(fann_clear_scaling_params,                     arginfo_fann_clear_scaling_params)
	PHP_FE(fann_scale_input,                              arginfo_fann_scale_input)
	PHP_FE(fann_scale_output,                             arginfo_fann_scale_output)
	PHP_FE(fann_descale_input,                            arginfo_fann_descale_input)
	PHP_FE(fann_descale_output,                           arginfo_fann_descale_output)
	PHP_FE(fann_scale_input_train_data,                   arginfo_fann_scale_input_train_data)
	PHP_FE(fann_scale_output_train_data,                  arginfo_fann_scale_output_train_data)
	PHP_FE(fann_scale_train_data,                         arginfo_fann_scale_train_data)
	PHP_FE(fann_merge_train_data,                         arginfo_fann_merge_train_data)
	PHP_FE(fann_duplicate_train_data,                     arginfo_fann_duplicate_train_data)
	PHP_FE(fann_subset_train_data,                        arginfo_fann_subset_train_data)
	PHP_FE(fann_length_train_data,                        arginfo_fann_length_train_data)
	PHP_FE(fann_num_input_train_data,                     arginfo_fann_num_input_train_data)
	PHP_FE(fann_num_output_train_data,                    arginfo_fann_num_output_train_data)
	PHP_FE(fann_save_train,                               arginfo_fann_save_train)
	PHP_FE(fann_get_learning_rate,                        arginfo_fann_get_learning_rate)
	PHP_FE(fann_set_learning_rate,                        arginfo_fann_set_learning_rate)
	PHP_FE(fann_get_learning_momentum,                    arginfo_fann_get_learning_momentum)
	PHP_FE(fann_set_learning_momentum,                    arginfo_fann_set_learning_momentum)
	PHP_FE(fann_get_train_error_function,                 arginfo_fann_get_train_error_function)
	PHP_FE(fann_set_train_error_function,                 arginfo_fann_set_train_error_function)
	PHP_FE(fann_get_train_stop_function,                  arginfo_fann_get_train_stop_function)
	PHP_FE(fann_set_train_stop_function,                  arginfo_fann_set_train_stop_function)
	PHP_FE(fann_get_bit_fail_limit,                       arginfo_fann_get_bit_fail_limit)
	PHP_FE(fann_set_bit_fail_limit,                       arginfo_fann_set_bit_fail_limit)
	PHP_FE(fann_set_callback,                             arginfo_fann_set_callback)
	PHP_FE(fann_get_quickprop_decay,                      arginfo_fann_get_quickprop_decay)
	PHP_FE(fann_set_quickprop_decay,                      arginfo_fann_set_quickprop_decay)
	PHP_FE(fann_get_quickprop_mu,                         arginfo_fann_get_quickprop_mu)
	PHP_FE(fann_set_quickprop_mu,                         arginfo_fann_set_quickprop_mu)
	PHP_FE(fann_get_rprop_increase_factor,                arginfo_fann_get_rprop_increase_factor)
	PHP_FE(fann_set_rprop_increase_factor,                arginfo_fann_set_rprop_increase_factor)
	PHP_FE(fann_get_rprop_decrease_factor,                arginfo_fann_get_rprop_decrease_factor)
	PHP_FE(fann_set_rprop_decrease_factor,                arginfo_fann_set_rprop_decrease_factor)
	PHP_FE(fann_get_rprop_delta_min,                      arginfo_fann_get_rprop_delta_min)
	PHP_FE(fann_set_rprop_delta_min,                      arginfo_fann_set_rprop_delta_min)
	PHP_FE(fann_get_rprop_delta_max,                      arginfo_fann_get_rprop_delta_max)
	PHP_FE(fann_set_rprop_delta_max,                      arginfo_fann_set_rprop_delta_max)
	PHP_FE(fann_get_rprop_delta_zero,                     arginfo_fann_get_rprop_delta_zero)
	PHP_FE(fann_set_rprop_delta_zero,                     arginfo_fann_set_rprop_delta_zero)
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	PHP_FE(fann_get_sarprop_weight_decay_shift,           arginfo_fann_get_sarprop_weight_decay_shift)
	PHP_FE(fann_set_sarprop_weight_decay_shift,           arginfo_fann_set_sarprop_weight_decay_shift)
	PHP_FE(fann_get_sarprop_step_error_threshold_factor,  arginfo_fann_get_sarprop_step_error_threshold_factor)
	PHP_FE(fann_set_sarprop_step_error_threshold_factor,  arginfo_fann_set_sarprop_step_error_threshold_factor)
	PHP_FE(fann_get_sarprop_step_error_shift,             arginfo_fann_get_sarprop_step_error_shift)
	PHP_FE(fann_set_sarprop_step_error_shift,             arginfo_fann_set_sarprop_step_error_shift)
	PHP_FE(fann_get_sarprop_temperature,                  arginfo_fann_get_sarprop_temperature)
	PHP_FE(fann_set_sarprop_temperature,                  arginfo_fann_set_sarprop_temperature)
#endif
	PHP_FE(fann_get_training_algorithm,                   arginfo_fann_get_training_algorithm)
	PHP_FE(fann_set_training_algorithm,                   arginfo_fann_set_training_algorithm)
	PHP_FE(fann_get_activation_function,                  arginfo_fann_get_activation_function)
	PHP_FE(fann_set_activation_function,                  arginfo_fann_set_activation_function)
	PHP_FE(fann_set_activation_function_layer,            arginfo_fann_set_activation_function_layer)
	PHP_FE(fann_set_activation_function_hidden,           arginfo_fann_set_activation_function_hidden)
	PHP_FE(fann_set_activation_function_output,           arginfo_fann_set_activation_function_output)
	PHP_FE(fann_get_activation_steepness,                 arginfo_fann_get_activation_steepness)
	PHP_FE(fann_set_activation_steepness,                 arginfo_fann_set_activation_steepness)
	PHP_FE(fann_set_activation_steepness_layer,           arginfo_fann_set_activation_steepness_layer)
	PHP_FE(fann_set_activation_steepness_hidden,          arginfo_fann_set_activation_steepness_hidden)
	PHP_FE(fann_set_activation_steepness_output,          arginfo_fann_set_activation_steepness_output)
	PHP_FE(fann_cascadetrain_on_data,                     arginfo_fann_cascadetrain_on_data)
	PHP_FE(fann_cascadetrain_on_file,                     arginfo_fann_cascadetrain_on_file)
	PHP_FE(fann_get_cascade_output_change_fraction,       arginfo_fann_get_cascade_output_change_fraction)
	PHP_FE(fann_set_cascade_output_change_fraction,       arginfo_fann_set_cascade_output_change_fraction)
	PHP_FE(fann_get_cascade_output_stagnation_epochs,     arginfo_fann_get_cascade_output_stagnation_epochs)
	PHP_FE(fann_set_cascade_output_stagnation_epochs,     arginfo_fann_set_cascade_output_stagnation_epochs)
	PHP_FE(fann_get_cascade_candidate_change_fraction,    arginfo_fann_get_cascade_candidate_change_fraction)
	PHP_FE(fann_set_cascade_candidate_change_fraction,    arginfo_fann_set_cascade_candidate_change_fraction)
	PHP_FE(fann_get_cascade_candidate_stagnation_epochs,  arginfo_fann_get_cascade_candidate_stagnation_epochs)
	PHP_FE(fann_set_cascade_candidate_stagnation_epochs,  arginfo_fann_set_cascade_candidate_stagnation_epochs)
	PHP_FE(fann_get_cascade_weight_multiplier,            arginfo_fann_get_cascade_weight_multiplier)
	PHP_FE(fann_set_cascade_weight_multiplier,            arginfo_fann_set_cascade_weight_multiplier)
	PHP_FE(fann_get_cascade_candidate_limit,              arginfo_fann_get_cascade_candidate_limit)
	PHP_FE(fann_set_cascade_candidate_limit,              arginfo_fann_set_cascade_candidate_limit)
	PHP_FE(fann_get_cascade_max_out_epochs,               arginfo_fann_get_cascade_max_out_epochs)
	PHP_FE(fann_set_cascade_max_out_epochs,               arginfo_fann_set_cascade_max_out_epochs)
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	PHP_FE(fann_get_cascade_min_out_epochs,               arginfo_fann_get_cascade_min_out_epochs)
	PHP_FE(fann_set_cascade_min_out_epochs,               arginfo_fann_set_cascade_min_out_epochs)
#endif
	PHP_FE(fann_get_cascade_max_cand_epochs,              arginfo_fann_get_cascade_max_cand_epochs)
	PHP_FE(fann_set_cascade_max_cand_epochs,              arginfo_fann_set_cascade_max_cand_epochs)
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	PHP_FE(fann_get_cascade_min_cand_epochs,              arginfo_fann_get_cascade_min_cand_epochs)
	PHP_FE(fann_set_cascade_min_cand_epochs,              arginfo_fann_set_cascade_min_cand_epochs)
#endif
	PHP_FE(fann_get_cascade_num_candidates,               arginfo_fann_get_cascade_num_candidates)
	PHP_FE(fann_get_cascade_activation_functions_count,   arginfo_fann_get_cascade_activation_functions_count)
	PHP_FE(fann_get_cascade_activation_functions,         arginfo_fann_get_cascade_activation_functions)
	PHP_FE(fann_set_cascade_activation_functions,         arginfo_fann_set_cascade_activation_functions)
	PHP_FE(fann_get_cascade_activation_steepnesses_count, arginfo_fann_get_cascade_activation_steepnesses_count)
	PHP_FE(fann_get_cascade_activation_steepnesses,       arginfo_fann_get_cascade_activation_steepnesses)
	PHP_FE(fann_set_cascade_activation_steepnesses,       arginfo_fann_set_cascade_activation_steepnesses)
	PHP_FE(fann_get_cascade_num_candidate_groups,         arginfo_fann_get_cascade_num_candidate_groups)
	PHP_FE(fann_set_cascade_num_candidate_groups,         arginfo_fann_set_cascade_num_candidate_groups)
	PHP_FE(fann_create_from_file,                         arginfo_fann_create_from_file)
	PHP_FE(fann_save,                                     arginfo_fann_save)
	PHP_FE(fann_set_error_log,                            arginfo_fann_set_error_log)
	PHP_FE(fann_get_errno,                                arginfo_fann_get_errno)
	PHP_FE(fann_reset_errno,                              arginfo_fann_reset_errno)
	PHP_FE(fann_reset_errstr,                             arginfo_fann_reset_errstr)
	PHP_FE(fann_get_errstr,                               arginfo_fann_get_errstr)
	PHP_FE(fann_print_error,                              arginfo_fann_print_error)
	PHPC_FE_END
};
/* }}} */

/* {{{ fann_module_entry */
zend_module_entry fann_module_entry = {
	STANDARD_MODULE_HEADER,
	"fann",
	fann_functions,
	PHP_MINIT(fann),
	PHP_MSHUTDOWN(fann),
	NULL,
	NULL,
	PHP_MINFO(fann),
	PHP_FANN_VERSION,
	STANDARD_MODULE_PROPERTIES
};
/* }}} */

#ifdef COMPILE_DL_FANN
ZEND_GET_MODULE(fann)
#endif

/* macro for checking fann_error structs */
#define PHP_FANN_ERROR_CHECK_EX(_fann_struct, _error_msg) \
	if (!(_fann_struct)) { \
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", _error_msg); \
		RETURN_FALSE; \
	} \
	if (fann_get_errno((struct fann_error *) (_fann_struct)) != 0) { \
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", (_fann_struct)->errstr); \
		RETURN_FALSE; \
	}

/* macro for checking fann_error structs with default message */
#define PHP_FANN_ERROR_CHECK(_fann_struct) PHP_FANN_ERROR_CHECK_EX(_fann_struct, "Internal FANN error")

/* macro for checking ann errors */
#define PHP_FANN_ERROR_CHECK_ANN_EX(_error_msg) PHP_FANN_ERROR_CHECK_EX(ann, _error_msg)
#define PHP_FANN_ERROR_CHECK_ANN() PHP_FANN_ERROR_CHECK_ANN_EX("Neural network not created")

/* macro for checking ann errors */
#define PHP_FANN_ERROR_CHECK_TRAIN_DATA_EX(_error_msg) PHP_FANN_ERROR_CHECK_EX(train_data, _error_msg)
#define PHP_FANN_ERROR_CHECK_TRAIN_DATA() PHP_FANN_ERROR_CHECK_TRAIN_DATA_EX("Train data not created")

/* macro for returning ann resource */
#define PHP_FANN_RETURN_ANN() \
	if (!ann) { RETURN_FALSE; } \
	PHPC_RES_RETVAL(PHPC_RES_REGISTER(ann, le_fannbuf))

/* macro for returning train data resource */
#define PHP_FANN_RETURN_TRAIN_DATA() \
	if (!train_data) { RETURN_FALSE; } \
	PHPC_RES_RETVAL(PHPC_RES_REGISTER(train_data, le_fanntrainbuf))

/* macro for fetching ann resource */
#define PHP_FANN_FETCH_ANN() \
	ann = (struct fann *) PHPC_RES_FETCH(z_ann, le_fannbuf_name, le_fannbuf)

/* macro for fetching train data resource */
#define PHP_FANN_FETCH_TRAIN_DATA_EX(_train_data) \
	_train_data = (struct fann_train_data *) \
		PHPC_RES_FETCH(z_##_train_data, le_fanntrainbuf_name, le_fanntrainbuf)

/* macro for fetching train data resource using train_data variable */
#define PHP_FANN_FETCH_TRAIN_DATA() PHP_FANN_FETCH_TRAIN_DATA_EX(train_data)

/* fetch error data */
#define PHP_FANN_FETCH_ERRDAT() \
	errdat = (struct fann_error *) PHPC_RES_FETCH2(z_errdat, NULL, le_fannbuf, le_fanntrainbuf)

/* macro for getting ann param identified by 0 args */
#define PHP_FANN_GET_PARAM0(_fce, _return)							\
	zval *z_ann; struct fann *ann;										\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) return; \
	PHP_FANN_FETCH_ANN();												\
	_return(_fce(ann))

/* macro for getting ann param identified by 2 args */
#define PHP_FANN_GET_PARAM2(_fce, _return, _zppval, _type1, _type2) \
	zval *z_ann; struct fann *ann;										\
	_type1 param1; _type2 param2;										\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r" #_zppval, &z_ann, &param1, &param2) == FAILURE) \
		return;															\
	PHP_FANN_FETCH_ANN();												\
	_return(_fce(ann, param1, param2))

/* macro for getting ann param (just alias for one param macro) */
#define PHP_FANN_GET_PARAM PHP_FANN_GET_PARAM0

/* macro for setting ann param not identified by arg */
#define PHP_FANN_SET_PARAM0(_fce)										\
	zval *z_ann; struct fann *ann;										\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) return; \
	PHP_FANN_FETCH_ANN();												\
	_fce(ann);															\
	PHP_FANN_ERROR_CHECK_ANN();											\
	RETURN_TRUE

/* macro for setting ann param identified by 1 arg */
#define PHP_FANN_SET_PARAM1(_fce, _zppval, _type)					\
	zval *z_ann; struct fann *ann; _type param;						\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r" #_zppval, &z_ann, &param) == FAILURE) return; \
	PHP_FANN_FETCH_ANN();												\
	_fce(ann, param);													\
	PHP_FANN_ERROR_CHECK_ANN();											\
	RETURN_TRUE


/* macro for setting ann param identified by 2 args */
#define PHP_FANN_SET_PARAM2(_fce, _zppval, _type1, _type2)			\
	zval *z_ann; struct fann *ann;										\
	_type1 param1; _type2 param2;										\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r" #_zppval, &z_ann, &param1, &param2) == FAILURE) \
		return;															\
	PHP_FANN_FETCH_ANN();												\
	_fce(ann, param1, param2);											\
	PHP_FANN_ERROR_CHECK_ANN();											\
	RETURN_TRUE

/* macro for setting ann param identified by 3 args */
#define PHP_FANN_SET_PARAM3(_fce, _zppval, _type1, _type2, _type3)	\
	zval *z_ann; struct fann *ann;										\
	_type1 param1; _type2 param2; _type3 param3;						\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r" #_zppval, &z_ann, &param1, &param2, &param3) \
		== FAILURE) return;												\
	PHP_FANN_FETCH_ANN();												\
	_fce(ann, param1, param2, param3);									\
	PHP_FANN_ERROR_CHECK_ANN();											\
	RETURN_TRUE

/* macro for setting ann param (just alian for one param macro) */
#define PHP_FANN_SET_PARAM PHP_FANN_SET_PARAM1
/* macro for resetting ann param */
#define PHP_FANN_RESET_PARAM PHP_FANN_SET_PARAM0

/* macro for registering FANN constants */
#define REGISTER_FANN_CONSTANT(constant) REGISTER_LONG_CONSTANT(#constant, constant, CONST_CS | CONST_PERSISTENT)

/* {{{ fann_destructor_fannbuf()
   fann resource destructor */
static void fann_destructor_fannbuf(phpc_res_entry_t *rsrc TSRMLS_DC)
{
	php_fann_user_data *user_data;
	struct fann *ann = (struct fann *) rsrc->ptr;
	user_data = (php_fann_user_data *) fann_get_user_data(ann);
	if (user_data != (php_fann_user_data *) NULL) {
		zval_dtor(PHPC_VAL_CAST_TO_PZVAL(user_data->callback));
		PHPC_VAL_FREE(user_data->callback);
		efree(user_data);
	}
	if (ann->error_log) {
		fclose(ann->error_log);
	}
	fann_destroy(ann);
}
/* }}} */

/* {{{ fann_destructor_fanntrainbuf()
   fann_train resource destructor */
static void fann_destructor_fanntrainbuf(phpc_res_entry_t *rsrc TSRMLS_DC)
{
	struct fann_train_data *train_data = (struct fann_train_data *) rsrc->ptr;
	if (train_data->error_log) {
		fclose(train_data->error_log);
	}
	fann_destroy_train(train_data);
}
/* }}} */

/* {{{ PHP_MINIT_FUNCTION
 */
PHP_MINIT_FUNCTION(fann)
{
	/* register struct fann resource destructor */
	le_fannbuf = zend_register_list_destructors_ex(
		fann_destructor_fannbuf, NULL, le_fannbuf_name, module_number);
	/* register struct fann_train resource destructor */
	le_fanntrainbuf = zend_register_list_destructors_ex(
		fann_destructor_fanntrainbuf, NULL, le_fanntrainbuf_name, module_number);

	/* do not print fann errors */
	fann_set_error_log(NULL, NULL);

	/* Fann version constant */
	REGISTER_STRING_CONSTANT("FANN_VERSION", PHP_FANN_LIBFANN_VERSION, CONST_PERSISTENT | CONST_CS);

	/* Train constants */
	REGISTER_FANN_CONSTANT(FANN_TRAIN_INCREMENTAL);
	REGISTER_FANN_CONSTANT(FANN_TRAIN_BATCH);
	REGISTER_FANN_CONSTANT(FANN_TRAIN_RPROP);
	REGISTER_FANN_CONSTANT(FANN_TRAIN_QUICKPROP);
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	REGISTER_FANN_CONSTANT(FANN_TRAIN_SARPROP);
#endif
	/* Activation functions constants */
	REGISTER_FANN_CONSTANT(FANN_LINEAR);
	REGISTER_FANN_CONSTANT(FANN_THRESHOLD);
	REGISTER_FANN_CONSTANT(FANN_THRESHOLD_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_SIGMOID);
	REGISTER_FANN_CONSTANT(FANN_SIGMOID_STEPWISE);
	REGISTER_FANN_CONSTANT(FANN_SIGMOID_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_SIGMOID_SYMMETRIC_STEPWISE);
	REGISTER_FANN_CONSTANT(FANN_GAUSSIAN);
	REGISTER_FANN_CONSTANT(FANN_GAUSSIAN_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_GAUSSIAN_STEPWISE);
	REGISTER_FANN_CONSTANT(FANN_ELLIOT);
	REGISTER_FANN_CONSTANT(FANN_ELLIOT_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_LINEAR_PIECE);
	REGISTER_FANN_CONSTANT(FANN_LINEAR_PIECE_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_SIN_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_COS_SYMMETRIC);
	REGISTER_FANN_CONSTANT(FANN_SIN);
	REGISTER_FANN_CONSTANT(FANN_COS);
	/* Error functions constants */
	REGISTER_FANN_CONSTANT(FANN_ERRORFUNC_LINEAR);
	REGISTER_FANN_CONSTANT(FANN_ERRORFUNC_TANH);
	/* Stop functions constants */
	REGISTER_FANN_CONSTANT(FANN_STOPFUNC_MSE);
	REGISTER_FANN_CONSTANT(FANN_STOPFUNC_BIT);
	/* Network type constants */
	REGISTER_FANN_CONSTANT(FANN_NETTYPE_LAYER);
	REGISTER_FANN_CONSTANT(FANN_NETTYPE_SHORTCUT);
	/* FANN Error Codes */
	REGISTER_FANN_CONSTANT(FANN_E_NO_ERROR);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_OPEN_CONFIG_R);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_OPEN_CONFIG_W);
	REGISTER_FANN_CONSTANT(FANN_E_WRONG_CONFIG_VERSION);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_READ_CONFIG);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_READ_NEURON);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_READ_CONNECTIONS);
	REGISTER_FANN_CONSTANT(FANN_E_WRONG_NUM_CONNECTIONS);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_OPEN_TD_W);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_OPEN_TD_R);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_READ_TD);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_ALLOCATE_MEM);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_TRAIN_ACTIVATION);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_USE_ACTIVATION);
	REGISTER_FANN_CONSTANT(FANN_E_TRAIN_DATA_MISMATCH);
	REGISTER_FANN_CONSTANT(FANN_E_CANT_USE_TRAIN_ALG);
	REGISTER_FANN_CONSTANT(FANN_E_TRAIN_DATA_SUBSET);
	REGISTER_FANN_CONSTANT(FANN_E_INDEX_OUT_OF_BOUND);
	REGISTER_FANN_CONSTANT(FANN_E_SCALE_NOT_PRESENT);
#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
	REGISTER_FANN_CONSTANT(FANN_E_INPUT_NO_MATCH);
	REGISTER_FANN_CONSTANT(FANN_E_OUTPUT_NO_MATCH);
#endif

	/* Init FANNConnection class */
	php_fannconnection_register_class(TSRMLS_C);

	return SUCCESS;
}
/* }}} */

/* {{{ PHP_MSHUTDOWN_FUNCTION
 */
PHP_MSHUTDOWN_FUNCTION(fann)
{
	return SUCCESS;
}
/* }}} */

/* {{{ PHP_MINFO_FUNCTION
 */
PHP_MINFO_FUNCTION(fann)
{
	php_info_print_table_start();
	php_info_print_table_row(2, "FANN support", "enabled");
	php_info_print_table_row(2, "FANN version", PHP_FANN_VERSION);
	php_info_print_table_row(2, "FANN library version", PHP_FANN_LIBFANN_VERSION);
	php_info_print_table_end();
}
/* }}} */

#define PHP_FANN_PATH_FORBIDDEN(_retval) !PHPC_ZVAL_IS_TRUE(_retval)

/* php_fann_get_file_path() {{{ */
static char *php_fann_get_path_for_open(char *path, phpc_str_size_t path_len, int read TSRMLS_DC)
{
	zval retval;
	char *path_for_open;

	if (read) {
		PHPC_PHP_STAT(path, (php_stat_len) path_len, FS_IS_R, &retval TSRMLS_CC);
	} else {
		PHPC_PHP_STAT(path, (php_stat_len) path_len, FS_IS_W, &retval TSRMLS_CC);
		if (PHP_FANN_PATH_FORBIDDEN(retval)) {
			char *dirname = estrndup(path, path_len);
			size_t dirname_len = php_dirname(dirname, (size_t) path_len);
			PHPC_PHP_STAT(dirname, (php_stat_len) dirname_len, FS_IS_W, &retval TSRMLS_CC);
			efree(dirname);
		}
	}
	if (PHP_FANN_PATH_FORBIDDEN(retval))  {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filename '%s' cannot be opened for %s",
		  path, read ? "reading" : "writing");
		path_for_open = NULL;
	} else {
		PHPC_STREAM_LOCATE_URL_WRAPPER(path, &path_for_open, 0);
	}
	return path_for_open;
}
/* }}} */

/* php_fann_array_to_zval() {{{ */
static void php_fann_array_to_zval(const fann_type *from, zval *to, int len)
{
	int i;

	PHPC_ARRAY_INIT_SIZE(to, len);

	for (i = 0; i < len; i++) {
		PHPC_ARRAY_ADD_INDEX_DOUBLE(to, i, (double) from[i]);
	}
}
/* }}} */

/* php_fann_check_num_layers() {{{ */
static int php_fann_check_num_layers(int specified, int provided TSRMLS_DC)
{
	if (specified < 2) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of layers must be greater than 2");
		return FAILURE;
	}
	if (specified != provided) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid number of arguments");
		return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

/* php_fann_check_num_neurons() {{{ */
static int php_fann_check_num_neurons(int num_neurons TSRMLS_DC)
{
	if (num_neurons < 0) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of neurons cannot be negative");
		return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

/* php_fann_check_num_inputs() {{{ */
static int php_fann_check_num_inputs(struct fann *ann, int num_inputs TSRMLS_DC)
{
	if  (fann_get_num_input(ann) != num_inputs) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING,
						 "Number of inputs is different than number of neurons in the input layer");
		return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

/* php_fann_check_num_outputs() {{{ */
static int php_fann_check_num_outputs(struct fann *ann, int num_outputs TSRMLS_DC)
{
	if  (fann_get_num_output(ann) != num_outputs) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING,
						 "Number of outputs is different than number of neurons in the output layer");
		return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

/* php_fann_convert_array() {{{ */
static int php_fann_convert_array(HashTable *source, fann_type *dest)
{
	phpc_val *element;
	int pos = 0;

	PHPC_HASH_FOREACH_VAL(source, element) {
		convert_to_double_ex(element);
		dest[pos++] = (fann_type) PHPC_DVAL_P(element);
	} PHPC_HASH_FOREACH_END();

	return pos;
}
/* }}} */

/* php_fann_process_array() {{{ */
static int php_fann_process_array(struct fann *ann, zval *z_array, fann_type **array, int is_input TSRMLS_DC)
{
	int n = PHPC_HASH_NUM_ELEMENTS(Z_ARRVAL_P(z_array));

	if ((is_input && php_fann_check_num_inputs(ann, n TSRMLS_CC) == FAILURE) ||
			(!is_input && php_fann_check_num_outputs(ann, n TSRMLS_CC))) {
		return 0;
	}
	*array = (fann_type *) emalloc(sizeof(fann_type) * n);

	return php_fann_convert_array(Z_ARRVAL_P(z_array), *array);
}
/* }}} */

/* php_fann_create() {{{ */
static int php_fann_create(int num_args, float *connection_rate,
						   unsigned *num_layers, unsigned **layers TSRMLS_DC)
{
	int i, pos;
	PHPC_ZPP_ARGS_DECLARE();

	PHPC_ZPP_ARGS_LOAD_EX(+, num_args, return FAILURE);

	pos = 0;
	if (connection_rate) {
		convert_to_double_ex(PHPC_ZPP_ARGS_GET_PVAL(pos));
		*connection_rate = PHPC_DVAL_P(PHPC_ZPP_ARGS_GET_PVAL(pos++));
	}

	convert_to_long_ex(PHPC_ZPP_ARGS_GET_PVAL(pos));
	*num_layers = PHPC_LVAL_P(PHPC_ZPP_ARGS_GET_PVAL(pos++));

	if (php_fann_check_num_layers(*num_layers, PHPC_ZPP_ARGS_COUNT - pos TSRMLS_CC) == FAILURE) {
		PHPC_ZPP_ARGS_FREE();
		return FAILURE;
	}

	*layers = (unsigned *) emalloc(*num_layers * sizeof(unsigned));
	i = 0;
	PHPC_ZPP_ARGS_LOOP_START_EX(pos) {
		convert_to_long_ex(PHPC_ZPP_ARGS_GET_CURRENT_PVAL());
		if (php_fann_check_num_neurons(
				PHPC_LVAL_P(PHPC_ZPP_ARGS_GET_CURRENT_PVAL()) TSRMLS_CC) == FAILURE) {
			PHPC_ZPP_ARGS_FREE();
			efree(*layers);
			return FAILURE;
		}
		(*layers)[i++] = PHPC_LVAL_P(PHPC_ZPP_ARGS_GET_CURRENT_PVAL());
	} PHPC_ZPP_ARGS_LOOP_END();

	PHPC_ZPP_ARGS_FREE();

	return SUCCESS;
}
/* }}} */

/* php_fann_create_array() {{{ */
static int php_fann_create_array(int num_args, float *conn_rate,
								 unsigned *num_layers, unsigned **layers TSRMLS_DC)
{
	zval *array;
	phpc_val *pdata;
	int i = 0;
	unsigned long tmpnum;
	double tmprate;

	if (conn_rate) {
		if (zend_parse_parameters(num_args TSRMLS_CC, "dla", &tmprate, &tmpnum, &array) == FAILURE) {
			return FAILURE;
		}
		*conn_rate = (float)tmprate;
		*num_layers = (unsigned)tmpnum;
	}
	else {
		if (zend_parse_parameters(num_args TSRMLS_CC, "la", &tmpnum, &array) == FAILURE) {
			return FAILURE;
		}
		*num_layers = (unsigned)tmpnum;
	}

	if (php_fann_check_num_layers(
			*num_layers, PHPC_HASH_NUM_ELEMENTS(Z_ARRVAL_P(array)) TSRMLS_CC) == FAILURE) {
		return FAILURE;
	}

	*layers = (unsigned *) emalloc(*num_layers * sizeof(unsigned));
	PHPC_HASH_FOREACH_VAL(Z_ARRVAL_P(array), pdata) {
		convert_to_long_ex(pdata);
		if (php_fann_check_num_neurons(PHPC_LVAL_P(pdata) TSRMLS_CC) == FAILURE) {
			efree(*layers);
			return FAILURE;
		}
		(*layers)[i++] = PHPC_LVAL_P(pdata);
	} PHPC_HASH_FOREACH_END();

	return SUCCESS;
}
/* }}} */

/* php_fann_init_ann() {{{ */
static int php_fann_callback(struct fann *ann, struct fann_train_data *train,
							 unsigned int max_epochs,
							 unsigned int epochs_between_reports,
							 float desired_error, unsigned int epochs)
{
	PHPC_FCALL_PARAMS_DECLARE(callback, 6);
	zend_fcall_info fci;
	zend_fcall_info_cache fci_cache;
	phpc_val retval;
	long rc;
	char *is_callable_error = NULL;
	php_fann_user_data *user_data = fann_get_user_data(ann);
	TSRMLS_FETCH();

	if (user_data == (php_fann_user_data *) NULL) {
		return 0;
	}

	if (PHPC_FCALL_INFO_INIT(PHPC_VAL_CAST_TO_PZVAL(user_data->callback), 0,
				&fci, &fci_cache, NULL, &is_callable_error) == FAILURE) {
		if (is_callable_error) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"User callback is not a valid callback, %s", is_callable_error);
			efree(is_callable_error);
		}
		else {
			php_error_docref(NULL TSRMLS_CC, E_WARNING, "User callback is not a valid callback");
		}
		return -1;
	}

	PHPC_FCALL_PARAMS_INIT(callback);
	/* ann */
	PHPC_VAL_ASSIGN(PHPC_FCALL_PARAM_VAL(callback, 0), user_data->z_ann);
	/* train data */
	if (user_data->z_train_data) {
		PHPC_VAL_ASSIGN(PHPC_FCALL_PARAM_VAL(callback, 1), user_data->z_train_data);
	} else {
		PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 1));
		ZVAL_NULL(PHPC_FCALL_PARAM_PZVAL(callback, 1));
	}
	/* max epochs */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 2));
	ZVAL_LONG(PHPC_FCALL_PARAM_PZVAL(callback, 2), (long) max_epochs);
	/* epochs between reports */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 3));
	ZVAL_LONG(PHPC_FCALL_PARAM_PZVAL(callback, 3), (long) epochs_between_reports);
	/* desired error */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 4));
	ZVAL_DOUBLE(PHPC_FCALL_PARAM_PZVAL(callback, 4), (double) desired_error);
	/* epochs */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 5));
	ZVAL_LONG(PHPC_FCALL_PARAM_PZVAL(callback, 5), (long) epochs);

	/* set fci */
	PHPC_FCALL_RETVAL(fci, retval);
	PHPC_FCALL_FCI_INIT(fci, callback, 6, 0);

	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) != SUCCESS ||  PHPC_VAL_ISUNDEF(retval)) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the user callback");
		zval_ptr_dtor(&retval);
		return -1;
	}
	convert_to_boolean(PHPC_VAL_CAST_TO_PZVAL(retval));
	rc = PHPC_VAL_IS_TRUE(retval);
	zval_ptr_dtor(&retval);
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 0));
	if (!user_data->z_train_data)
		zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 1));
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 2));
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 3));
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 4));
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 5));
	if (!rc) {
		return -1;
	}

	return 0;
}
/* }}} */

/* php_fann_update_user_data() {{{ */
static void php_fann_update_user_data(struct fann *ann, zval *z_ann, zval *z_train_data)
{
	php_fann_user_data *user_data = fann_get_user_data(ann);
	if (user_data != (php_fann_user_data *) NULL) {
		user_data->z_ann = z_ann;
		user_data->z_train_data = z_train_data;
	}
}
/* }}} */

/* php_fann_init_ann() {{{ */
static void php_fann_init_ann(struct fann *ann)
{
	/* set callback for reporting - don't print anything during fann_train_on_(data|file) */
	fann_set_callback(ann, (fann_callback_type) php_fann_callback);
}
/* }}} */

/* {{{ proto resource fann_create_standard(int num_layers, int num_neurons1, int num_neurons2, [, int ... ])
   Creates a standard fully connected backpropagation neural network */
PHP_FUNCTION(fann_create_standard)
{
	unsigned num_layers, *layers;
	struct fann *ann;

	if (php_fann_create(ZEND_NUM_ARGS(), NULL, &num_layers, &layers TSRMLS_CC) == FAILURE) {
		RETURN_FALSE;
	}

	ann = fann_create_standard_array(num_layers, layers);
	efree(layers);
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto resource fann_create_standard_array(int num_layers, array layers)
   Creates a standard fully connected backpropagation neural network (array for layers) */
PHP_FUNCTION(fann_create_standard_array)
{
	unsigned num_layers, *layers;
	struct fann *ann;

	if (php_fann_create_array(ZEND_NUM_ARGS(), NULL, &num_layers, &layers TSRMLS_CC) == FAILURE) {
		RETURN_FALSE;
	}

	ann = fann_create_standard_array(num_layers, layers);
	efree(layers);
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto resource fann_create_sparse(float connection_rate, int num_layers, int num_neurons1, int num_neurons2, [, int ... ])
   Creates a standard backpropagation neural network, which is not fully connected */
PHP_FUNCTION(fann_create_sparse)
{
	unsigned num_layers, *layers;
	float connection_rate;
	struct fann *ann;

	if (php_fann_create(ZEND_NUM_ARGS(), &connection_rate, &num_layers, &layers TSRMLS_CC) == FAILURE) {
		RETURN_FALSE;
	}

	ann = fann_create_sparse_array(connection_rate, num_layers, layers);
	efree(layers);
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto resource fann_create_sparse_array(float connection_rate, int num_layers, array layers)
   Creates a standard backpropagation neural network, which is not fully connected
   (using array for layers)  */
PHP_FUNCTION(fann_create_sparse_array)
{
	unsigned num_layers, *layers;
	float connection_rate;
	struct fann *ann;

	if (php_fann_create_array(ZEND_NUM_ARGS(), &connection_rate, &num_layers, &layers TSRMLS_CC) == FAILURE) {
		RETURN_FALSE;
	}

	ann = fann_create_sparse_array(connection_rate, num_layers, layers);
	efree(layers);
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto resource fann_create_shortcut(int num_layers, int num_neurons1, int num_neurons2, [, int ... ])
   Creates a standard backpropagation neural network, which is not fully connected and
   which also has shortcut connections. */
PHP_FUNCTION(fann_create_shortcut)
{
	unsigned num_layers, *layers;
	struct fann *ann;

	if (php_fann_create(ZEND_NUM_ARGS(), NULL, &num_layers, &layers TSRMLS_CC) == FAILURE) {
		RETURN_FALSE;
	}

	ann = fann_create_shortcut_array(num_layers, layers);
	efree(layers);
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto resource fann_create_shortcut_array(int num_layers, array layers)
   reates a standard backpropagation neural network, which is not fully connected and
   which also has shortcut connections (using array of layers) */
PHP_FUNCTION(fann_create_shortcut_array)
{
	unsigned num_layers, *layers;
	struct fann *ann;

	if (php_fann_create_array(ZEND_NUM_ARGS(), NULL, &num_layers, &layers TSRMLS_CC) == FAILURE) {
		RETURN_FALSE;
	}

	ann = fann_create_shortcut_array(num_layers, layers);
	efree(layers);
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto bool fann_destroy(resource ann)
   Destroys neural network */
PHP_FUNCTION(fann_destroy)
{
	zval *z_ann;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}

	PHPC_RES_CLOSE(z_ann);
	RETURN_TRUE;
}
/* }}} */

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
/* {{{ proto resource fann_copy(resource ann)
   Creates a copy of the neural network */
PHP_FUNCTION(fann_copy)
{
	zval *z_ann;
	struct fann *ann, *ann_copy;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();

	ann_copy = fann_copy(ann);
	if (!ann_copy) {
		RETURN_FALSE;
	}
	PHPC_RES_RETVAL(PHPC_RES_REGISTER(ann_copy, le_fannbuf));
}
/* }}} */
#endif

/* {{{ proto array fann_run(resource ann, array input)
   Runs input through the neural network */
PHP_FUNCTION(fann_run)
{
	zval *z_ann, *z_input;
	struct fann *ann;
	fann_type *input, *output;
	int num_outputs, i;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &z_input) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	/* process input array */
	if (!php_fann_process_array(ann, z_input, &input, 1 TSRMLS_CC)) {
		RETURN_FALSE;
	}

	output = fann_run(ann, input);
	efree(input);
	num_outputs = fann_get_num_output(ann);
	PHP_FANN_ERROR_CHECK_ANN();

	PHPC_ARRAY_INIT_SIZE(return_value, num_outputs);
	for (i = 0; i < num_outputs; i++) {
		PHPC_ARRAY_ADD_NEXT_INDEX_DOUBLE(return_value, (double) output[i]);
	}
}
/* }}} */


/* {{{ proto bool fann_randomize_weights(resource ann, double min_weight, double max_weight)
   Gives each connection a random weight between min_weight and max_weight */
PHP_FUNCTION(fann_randomize_weights)
{
	zval *z_ann;
	struct fann *ann;
	double min_weight, max_weight;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rdd", &z_ann, &min_weight, &max_weight) == FAILURE) {
		return;
	}

	PHP_FANN_FETCH_ANN();
	fann_randomize_weights(ann, min_weight, max_weight);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */


/* {{{ proto bool fann_init_weights(resource ann, resource train_data)
   Initializes weights using Widrow + Nguyen’s algorithm */
PHP_FUNCTION(fann_init_weights)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &z_ann, &z_train_data) == FAILURE) {
		return;
	}

	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	fann_init_weights(ann, train_data);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto long fann_get_num_input(resource ann)
   Returns the number of input neurons */
PHP_FUNCTION(fann_get_num_input)
{
	PHP_FANN_GET_PARAM(fann_get_num_input, RETURN_LONG);
}

/* {{{ proto long fann_get_num_output(resource ann)
   Returns the number of output neurons */
PHP_FUNCTION(fann_get_num_output)
{
	PHP_FANN_GET_PARAM(fann_get_num_output, RETURN_LONG);
}

/* {{{ proto long fann_get_total_neurons(resource ann)
   Returns the number of output neurons 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) */
PHP_FUNCTION(fann_get_total_neurons)
{
	PHP_FANN_GET_PARAM(fann_get_total_neurons, RETURN_LONG);
}

/* {{{ proto long fann_get_total_connections(resource ann)
   Returns the total number of connections in the entire network */
PHP_FUNCTION(fann_get_total_connections)
{
	PHP_FANN_GET_PARAM(fann_get_total_connections, RETURN_LONG);
}

/* {{{ proto long fann_get_network_type(resource ann)
   Returns the type of neural network it was created as */
PHP_FUNCTION(fann_get_network_type)
{
	PHP_FANN_GET_PARAM(fann_get_network_type, RETURN_LONG);
}

/* {{{ proto double fann_get_connection_rate(resource ann)
   Returns the connection rate used when the network was created  */
PHP_FUNCTION(fann_get_connection_rate)
{
	PHP_FANN_GET_PARAM(fann_get_connection_rate, RETURN_DOUBLE);
}

/* {{{ proto long fann_get_num_layers(resource ann)
   Returns the number of layers in the network */
PHP_FUNCTION(fann_get_num_layers)
{
	PHP_FANN_GET_PARAM(fann_get_num_layers, RETURN_LONG);
}

/* {{{ proto array fann_get_layer_array(resource ann)
   Returns the number of neurons in each layer in the network (bias is not included) */
PHP_FUNCTION(fann_get_layer_array)
{
	zval *z_ann;
	struct fann *ann;
	unsigned num_layers, *layers, i;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}

	PHP_FANN_FETCH_ANN();
	num_layers = fann_get_num_layers(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	layers = (unsigned *) emalloc(num_layers * sizeof(unsigned));
	fann_get_layer_array(ann, layers);
	PHP_FANN_ERROR_CHECK_ANN();
	PHPC_ARRAY_INIT_SIZE(return_value, num_layers);
	for (i = 0; i < num_layers; i++) {
		PHPC_ARRAY_ADD_INDEX_LONG(return_value, i, layers[i]);
	}
	efree(layers);
}

/* {{{ proto array fann_get_bias_array(resource ann)
   Returns the number of bias in each layer in the network */
PHP_FUNCTION(fann_get_bias_array)
{
	zval *z_ann;
	struct fann *ann;
	unsigned num_layers, *layers, i;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}

	PHP_FANN_FETCH_ANN();
	num_layers = fann_get_num_layers(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	layers = (unsigned *) emalloc(num_layers * sizeof(unsigned));
	fann_get_bias_array(ann, layers);
	PHP_FANN_ERROR_CHECK_ANN();
	PHPC_ARRAY_INIT_SIZE(return_value, num_layers);
	for (i = 0; i < num_layers; i++) {
		PHPC_ARRAY_ADD_INDEX_LONG(return_value, i, layers[i]);
	}
	efree(layers);
}

/* {{{ proto array fann_get_connection_array(resource ann)
   Returns connections in the network */
PHP_FUNCTION(fann_get_connection_array)
{
	zval *z_ann, *z_connection;
	phpc_val pv_connection;
	struct fann *ann;
	struct fann_connection *connections;
	unsigned num_connections, i;
	long from_neuron, to_neuron;
	double weight;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}

	PHP_FANN_FETCH_ANN();
	num_connections = fann_get_total_connections(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	connections = (struct fann_connection *) emalloc(num_connections * sizeof(struct fann_connection));
	fann_get_connection_array(ann, connections);
	PHP_FANN_ERROR_CHECK_ANN();
	PHPC_ARRAY_INIT_SIZE(return_value, num_connections);
	for (i = 0; i < num_connections; i++) {
		from_neuron = (long) connections[i].from_neuron;
		to_neuron = (long) connections[i].to_neuron;
		weight = (double) connections[i].weight;
		PHPC_VAL_MAKE(pv_connection);
		PHPC_VAL_TO_PZVAL(pv_connection, z_connection);
		object_init_ex(z_connection, php_fann_FANNConnection_class);
		PHP_FANN_CONN_PROP_UPDATE(long, z_connection, "from_neuron", from_neuron);
		PHP_FANN_CONN_PROP_UPDATE(long, z_connection, "to_neuron", to_neuron);
		PHP_FANN_CONN_PROP_UPDATE(double, z_connection, "weight",  weight);
		PHPC_ARRAY_ADD_INDEX_ZVAL(return_value, i, z_connection);
	}
	efree(connections);
}

/* {{{ proto bool fann_set_weight_array(resource ann, array connections)
   Sets connections in the network */
PHP_FUNCTION(fann_set_weight_array)
{
	zval *z_ann, *array, *z_connection;
	phpc_val *pv_connection;
	struct fann *ann;
	struct fann_connection *connections;
	unsigned num_connections, i = 0;
	PHPC_READ_PROPERTY_RV_DECLARE;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &array) == FAILURE) {
		return;
	}

	PHP_FANN_FETCH_ANN();
	num_connections = PHPC_HASH_NUM_ELEMENTS(Z_ARRVAL_P(array));
	connections = (struct fann_connection *) emalloc(num_connections * sizeof(struct fann_connection));

	PHPC_HASH_FOREACH_VAL(Z_ARRVAL_P(array), pv_connection) {
		if (PHPC_TYPE_P(pv_connection) == IS_OBJECT && instanceof_function(
				PHPC_OBJCE_P(pv_connection), php_fann_FANNConnection_class TSRMLS_CC)) {
			PHPC_PVAL_TO_PZVAL(pv_connection, z_connection);
			connections[i].from_neuron = Z_LVAL_P(PHP_FANN_CONN_PROP_READ(z_connection, "from_neuron"));
			connections[i].to_neuron = Z_LVAL_P(PHP_FANN_CONN_PROP_READ(z_connection, "to_neuron"));
			connections[i].weight = Z_DVAL_P(PHP_FANN_CONN_PROP_READ(z_connection, "weight"));
			++i;
		}
		else {
			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Weights array can contain only object of FANNConnection");
			efree(connections);
			RETURN_FALSE;
		}
	} PHPC_HASH_FOREACH_END();

	fann_set_weight_array(ann, connections, i);
	efree(connections);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}

/* {{{ proto bool fann_set_weight(resource ann, int from_neuron, int to_neuron, double weight)
   Sets a connection in the network */
PHP_FUNCTION(fann_set_weight)
{
	zval *z_ann;
	struct fann *ann;
	long from_neuron, to_neuron;
	double weight;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlld", &z_ann, &from_neuron, &to_neuron, &weight) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	fann_set_weight(ann, from_neuron, to_neuron, weight);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}

/* {{{ proto bool fann_train(resource ann, array input, array desired_output)
   Trains one iteration with a set of inputs, and a set of desired outputs */
PHP_FUNCTION(fann_train)
{
	zval *z_ann, *z_input, *z_output;
	struct fann *ann;
	fann_type *input, *desired_output;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "raa", &z_ann, &z_input, &z_output) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();

	/* process input array */
	if (!php_fann_process_array(ann, z_input, &input, 1 TSRMLS_CC)) {
		RETURN_FALSE;
	}
	/* process output array */
	if (!php_fann_process_array(ann, z_output, &desired_output, 0 TSRMLS_CC)) {
		efree(input);
		RETURN_FALSE;
	}

	fann_train(ann, input, desired_output);
	efree(input);
	efree(desired_output);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */



/* {{{ proto array fann_test(resource ann, array input, array desired_output)
   Tests with a set of inputs, and a set of desired outputs -
   this operation updates the mean square error, but does not change the network in any way. */
PHP_FUNCTION(fann_test)
{
	zval *z_ann, *z_input, *z_output;
	struct fann *ann;
	fann_type *input, *desired_output, *output;
	int num_outputs, i;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "raa", &z_ann, &z_input, &z_output) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	/* process input array */
	if (!php_fann_process_array(ann, z_input, &input, 1 TSRMLS_CC)) {
		RETURN_FALSE;
	}
	/* process output array */
	if (!(num_outputs = php_fann_process_array(ann, z_output, &desired_output, 0 TSRMLS_CC))) {
		efree(input);
		RETURN_FALSE;
	}

	output = fann_test(ann, input, desired_output);
	efree(input);
	efree(desired_output);
	PHP_FANN_ERROR_CHECK_ANN();

	PHPC_ARRAY_INIT_SIZE(return_value, num_outputs);
	for (i = 0; i < num_outputs; i++) {
		PHPC_ARRAY_ADD_NEXT_INDEX_DOUBLE(return_value, (double) output[i]);
	}
}
/* }}} */

/* {{{ proto double fann_get_MSE(resource ann)
   Reads the mean square error from the network */
PHP_FUNCTION(fann_get_MSE)
{
	PHP_FANN_GET_PARAM(fann_get_MSE, RETURN_DOUBLE);
}

/* {{{ proto int fann_get_bit_fail(resource ann)
   Returns he number of fail bits; means the number of output neurons which differ more than the bit fail limit */
PHP_FUNCTION(fann_get_bit_fail)
{
	PHP_FANN_GET_PARAM(fann_get_bit_fail, RETURN_LONG);
}

/* {{{ proto bool fann_reset_MSE(resource ann)
   Resets the mean square error from the network */
PHP_FUNCTION(fann_reset_MSE)
{
	PHP_FANN_RESET_PARAM(fann_reset_MSE);
}

/* {{{ proto bool fann_train_on_file(resource ann, string filename, int max_epochs, int epochs_between_reports, float desired_error)
   Trains on an entire dataset, for a period of time (data are read from file) */
PHP_FUNCTION(fann_train_on_file)
{
	zval *z_ann;
	char *filename;
	phpc_str_size_t filename_len;
	long max_epochs, epochs_between_reports;
	double desired_error;
	struct fann *ann;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rslld", &z_ann, &filename, &filename_len,
							  &max_epochs, &epochs_between_reports, &desired_error) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	filename = php_fann_get_path_for_open(filename, filename_len, 1 TSRMLS_CC);
	if (!filename) {
		RETURN_FALSE;
	}
	php_fann_update_user_data(ann, z_ann, (zval *) NULL);
	fann_train_on_file(ann, filename, max_epochs, epochs_between_reports, desired_error);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_train_on_data(resource ann, resource data, int max_epochs, int epochs_between_reports, float desired_error)
   Trains on an entire dataset, for a period of time */
PHP_FUNCTION(fann_train_on_data)
{

	zval *z_ann, *z_train_data;
	long max_epochs, epochs_between_reports;
	double desired_error;
	struct fann *ann;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlld", &z_ann, &z_train_data,
							  &max_epochs, &epochs_between_reports, &desired_error) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	php_fann_update_user_data(ann, z_ann, z_train_data);
	fann_train_on_data(ann, train_data, max_epochs, epochs_between_reports, desired_error);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto double fann_train_epoch(resource ann, resource train_data)
   Trains one epoch with a set of training data */
PHP_FUNCTION(fann_train_epoch)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;
	double mse;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &z_ann, &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	mse = (double) fann_train_epoch(ann, train_data);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_DOUBLE(mse);
}
/* }}} */

/* {{{ proto double fann_test_data(resource ann, resource train_data)
   Tests a set of training data and calculates the MSE for the training data */
PHP_FUNCTION(fann_test_data)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;
	double mse;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &z_ann, &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	mse = (double) fann_test_data(ann, train_data);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_DOUBLE(mse);
}
/* }}} */

/* {{{ proto resource fann_read_train_from_file(string filename)
   Reads a file that stores training data */
PHP_FUNCTION(fann_read_train_from_file)
{
	char *filename;
	phpc_str_size_t filename_len;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
		return;
	}
	filename = php_fann_get_path_for_open(filename, filename_len, 1 TSRMLS_CC);
	if (!filename) {
		RETURN_FALSE;
	}
	train_data = fann_read_train_from_file(filename);
	if (!train_data) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid data train file format in '%s'", filename);
		RETURN_FALSE;
	}
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();
	PHP_FANN_RETURN_TRAIN_DATA();
}
/* }}} */

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
/* {{{ proto resource fann_create_train(int num_data, int num_input, int num_output)
   Creates an empty training data struct */
PHP_FUNCTION(fann_create_train)
{
	long num_data, num_input, num_output;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &num_data, &num_input, &num_output) == FAILURE) {
		return;
	}
	train_data = fann_create_train(num_data, num_input, num_output);
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();
	PHP_FANN_RETURN_TRAIN_DATA();
}
/* }}} */

/* {{{ proto resource fann_create_train_from_callback(int num_data, int num_input, int num_output, callable user_function)
   Creates the training data struct from a user supplied function */
PHP_FUNCTION(fann_create_train_from_callback)
{
	PHPC_FCALL_PARAMS_DECLARE(callback, 3);
	phpc_val retval, *pv_input, *pv_output;
	zend_fcall_info fci;
	zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
	phpc_long_t num_data, num_input, num_output;
	int i;
	struct fann_train_data *train_data;


	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllf",
			&num_data, &num_input, &num_output, &fci, &fci_cache) == FAILURE) {
		return;
	}

	train_data = fann_create_train(num_data, num_input, num_output);
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();

	/* initialize callback function */
	PHPC_FCALL_PARAMS_INIT(callback);
	/* number of data */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 0));
	ZVAL_LONG(PHPC_FCALL_PARAM_PZVAL(callback, 0), num_data);
	/* nummber of inputs */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 1));
	ZVAL_LONG(PHPC_FCALL_PARAM_PZVAL(callback, 1), num_input);
	/* number of outputs */
	PHPC_VAL_MAKE(PHPC_FCALL_PARAM_VAL(callback, 2));
	ZVAL_LONG(PHPC_FCALL_PARAM_PZVAL(callback, 2), num_output);

	/* set fci */
	PHPC_FCALL_RETVAL(fci, retval);
	fci.params = PHPC_FCALL_PARAMS_NAME(callback);
	PHPC_FCALL_FCI_INIT(fci, callback, 3, 0);

	/* call callback for each data */
	for (i = 0; i < num_data; i++) {
		if (zend_call_function(&fci, &fci_cache TSRMLS_CC) != SUCCESS || PHPC_VAL_ISUNDEF(retval)) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"An error occurred while invoking the user callback");
			zval_ptr_dtor(&retval);
			RETURN_FALSE;
		}
		if (PHPC_TYPE(retval) != IS_ARRAY) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"The user callback result should be an array");
			zval_ptr_dtor(&retval);
			RETURN_FALSE;
		}
		if (!PHPC_HASH_INDEX_FIND_IN_COND(PHPC_ARRVAL(retval), 0, pv_input) &&
				!PHPC_HASH_CSTR_FIND_IN_COND(PHPC_ARRVAL(retval), "input", pv_input)) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"The return value must have 'input' or 0 key for input");
			zval_ptr_dtor(&retval);
			RETURN_FALSE;
		}
		if (!PHPC_HASH_INDEX_FIND_IN_COND(PHPC_ARRVAL(retval), 1, pv_output) &&
				!PHPC_HASH_CSTR_FIND_IN_COND(PHPC_ARRVAL(retval), "output", pv_output)) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"The return value must have 'output' or 1 key for output");
			zval_ptr_dtor(&retval);
			RETURN_FALSE;
		}
		if (PHPC_TYPE_P(pv_input) != IS_ARRAY ||
				PHPC_HASH_NUM_ELEMENTS(PHPC_ARRVAL_P(pv_input)) != num_input) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"Returned input must be an array with %ld elements", num_input);
			zval_ptr_dtor(&retval);
			RETURN_FALSE;
		}
		if (PHPC_TYPE_P(pv_output) != IS_ARRAY ||
				PHPC_HASH_NUM_ELEMENTS(PHPC_ARRVAL_P(pv_output)) != num_output) {
			php_error_docref(NULL TSRMLS_CC, E_WARNING,
					"Returned output must be an array with %ld elements", num_output);
			zval_ptr_dtor(&retval);
			RETURN_FALSE;
		}
		/* convert input array */
		php_fann_convert_array(PHPC_ARRVAL_P(pv_input), train_data->input[i]);
		/* convert output array */
		php_fann_convert_array(PHPC_ARRVAL_P(pv_output), train_data->output[i]);

		zval_ptr_dtor(&retval);
	}

	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 0));
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 1));
	zval_ptr_dtor(&PHPC_FCALL_PARAM_VAL(callback, 2));

	PHP_FANN_RETURN_TRAIN_DATA();
}
/* }}} */
#endif

/* {{{ proto bool fann_destroy_train(resource train_data)
   Destructs the training data */
PHP_FUNCTION(fann_destroy_train)
{
	zval *z_train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_train_data) == FAILURE) {
		return;
	}

	PHPC_RES_CLOSE(z_train_data);
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_shuffle_train_data(resource train_data)
   Shuffles training data randomizing the order */
PHP_FUNCTION(fann_shuffle_train_data)
{
	zval *z_train_data;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	fann_shuffle_train_data(train_data);
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_scale_train(resource ann, resource train_data)
   Scales input and output data based on previously calculated parameters */
PHP_FUNCTION(fann_scale_train)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &z_ann, &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	fann_scale_train(ann, train_data);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_descale_train(resource ann, resource train_data)
   Descales input and output data based on previously calculated parameters */
PHP_FUNCTION(fann_descale_train)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &z_ann, &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	fann_descale_train(ann, train_data);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_set_input_scaling_params(resource ann, resource train_data, int new_input_min, int new_input_max)
   Calculates input scaling parameters for future use based on training data */
PHP_FUNCTION(fann_set_input_scaling_params)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;
	double new_input_min, new_input_max;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrdd", &z_ann, &z_train_data,
							  &new_input_min, &new_input_max) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	if (fann_set_input_scaling_params(ann, train_data, (float) new_input_min, (float) new_input_max) == 0) {
		RETURN_TRUE;
	}
	else {
		PHP_FANN_ERROR_CHECK_TRAIN_DATA();
		RETURN_FALSE;
	}
}
/* }}} */

/* {{{ proto bool fann_set_output_scaling_params(resource ann, resource train_data, int new_output_min, int new_output_max)
   Calculates output scaling parameters for future use based on training data */
PHP_FUNCTION(fann_set_output_scaling_params)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;
	double new_output_min, new_output_max;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrdd", &z_ann, &z_train_data,
							  &new_output_min, &new_output_max) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	if (fann_set_output_scaling_params(ann, train_data, (float) new_output_min, (float) new_output_max) == 0) {
		RETURN_TRUE;
	}
	else {
		PHP_FANN_ERROR_CHECK_TRAIN_DATA();
		RETURN_FALSE;
	}
}
/* }}} */

/* {{{ proto bool fann_set_scaling_params(resource ann, resource train_data, int new_input_min, int new_input_max, int new_output_min, int new_output_max)
   Calculates input and output scaling parameters for future use based on training data */
PHP_FUNCTION(fann_set_scaling_params)
{
	zval *z_ann, *z_train_data;
	struct fann *ann;
	struct fann_train_data *train_data;
	double new_input_min, new_input_max, new_output_min, new_output_max;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrdddd", &z_ann, &z_train_data,
							  &new_input_min, &new_input_max, &new_output_min, &new_output_max) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	if (fann_set_scaling_params(ann, train_data, (float) new_input_min, (float) new_input_max,
								(float) new_output_min, (float) new_output_max) == 0) {
		RETURN_TRUE;
	}
	else {
		PHP_FANN_ERROR_CHECK_TRAIN_DATA();
		RETURN_FALSE;
	}
}
/* }}} */

/* {{{ proto bool fann_clear_scaling_params(resource ann)
   Clears scaling parameters */
PHP_FUNCTION(fann_clear_scaling_params)
{
    PHP_FANN_RESET_PARAM(fann_clear_scaling_params);
}
/* }}} */

/* {{{ proto array fann_scale_input(resource ann, array input_vector)
   Scales data in input vector before feed it to ann based on previously calculated parameters */
PHP_FUNCTION(fann_scale_input)
{
	struct fann *ann;
	zval *z_array, *z_ann;
	fann_type *array;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &z_array) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	if (!php_fann_process_array(ann, z_array, &array, 1 TSRMLS_CC)) {
		RETURN_FALSE;
	}
	fann_scale_input(ann, array);
	php_fann_array_to_zval(array, return_value, fann_get_num_input(ann));
	efree(array);
	PHP_FANN_ERROR_CHECK_ANN();
}
/* }}} */

/* {{{ proto array fann_scale_output(resource ann, array output_vector)
   Scales data in output vector before feed it to ann based on previously calculated parameters */
PHP_FUNCTION(fann_scale_output)
{
	struct fann *ann;
	zval *z_array, *z_ann;
	fann_type *array;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &z_array) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	if (!php_fann_process_array(ann, z_array, &array, 0 TSRMLS_CC)) {
		RETURN_FALSE;
	}
	fann_scale_output(ann, array);
	php_fann_array_to_zval(array, return_value, fann_get_num_output(ann));
	efree(array);
	PHP_FANN_ERROR_CHECK_ANN();
}
/* }}} */

/* {{{ proto array fann_descale_input(resource ann, array input_vector)
   Scales data in input vector after feed it to ann based on previously calculated parameters */
PHP_FUNCTION(fann_descale_input)
{
	struct fann *ann;
	zval *z_array, *z_ann;
	fann_type *array;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &z_array) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	if (!php_fann_process_array(ann, z_array, &array, 1 TSRMLS_CC)) {
		RETURN_FALSE;
	}
	fann_descale_input(ann, array);
	php_fann_array_to_zval(array, return_value, fann_get_num_input(ann));
	efree(array);
	PHP_FANN_ERROR_CHECK_ANN();
}
/* }}} */

/* {{{ proto array fann_descale_output(resource ann, array output_vector)
   Scales data in output vector after feed it to ann based on previously calculated parameters */
PHP_FUNCTION(fann_descale_output)
{
	struct fann *ann;
	zval *z_array, *z_ann;
	fann_type *array;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &z_array) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	if (!php_fann_process_array(ann, z_array, &array, 0 TSRMLS_CC)) {
		RETURN_FALSE;
	}
	fann_descale_output(ann, array);
	php_fann_array_to_zval(array, return_value, fann_get_num_output(ann));
	efree(array);
	PHP_FANN_ERROR_CHECK_ANN();
}
/* }}} */

#define PHP_FANN_SCALE_TRAIN_DATA(_fce)									\
	zval *z_train_data;													\
	struct fann_train_data *train_data;									\
	double new_min, new_max;											\
	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rdd", &z_train_data, &new_min, &new_max) == FAILURE) { \
		return;															\
	}																	\
	PHP_FANN_FETCH_TRAIN_DATA();										\
	_fce(train_data, (fann_type) new_min, (fann_type) new_max);			\
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();									\
	RETURN_TRUE

/* {{{ proto bool fann_scale_input_train_data(resource train_data, double new_min, double new_max)
   Scales the inputs in the training data to the specified range */
PHP_FUNCTION(fann_scale_input_train_data)
{
	PHP_FANN_SCALE_TRAIN_DATA(fann_scale_input_train_data);
}
/* }}} */

/* {{{ proto bool fann_scale_output_train_data(resource train_data, double new_min, double new_max)
   Scales the outputs in the training data to the specified range */
PHP_FUNCTION(fann_scale_output_train_data)
{
	PHP_FANN_SCALE_TRAIN_DATA(fann_scale_output_train_data);
}
/* }}} */

/* {{{ proto bool fann_scale_train_data(resource train_data, double new_min, double new_max)
   Scales the inputs and outputs in the training data to the specified range */
PHP_FUNCTION(fann_scale_train_data)
{
	PHP_FANN_SCALE_TRAIN_DATA(fann_scale_train_data);
}
/* }}} */

/* {{{ proto resource fann_merge_train_data(resource data1, resource data2)
   Merges the data from data1 and data2 into new train data */
PHP_FUNCTION(fann_merge_train_data)
{
	zval *z_data1, *z_data2;
	struct fann_train_data *data1, *data2, *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &z_data1, &z_data2) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA_EX(data1);
	PHP_FANN_FETCH_TRAIN_DATA_EX(data2);
	train_data = fann_merge_train_data(data1, data2);
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();
	PHP_FANN_RETURN_TRAIN_DATA();
}
/* }}} */

/* {{{ proto resource fann_duplicate_train_data(resource train_data)
   Returns an exact copy of train data */
PHP_FUNCTION(fann_duplicate_train_data)
{
	zval *z_train_data;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	train_data = fann_duplicate_train_data(train_data);
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();
	PHP_FANN_RETURN_TRAIN_DATA();
}
/* }}} */

/* {{{ proto resource fann_subset_train_data(resource train_data, int pos, int length)
   Returns an copy of a subset of the train data, starting at position pos and length elements forward */
PHP_FUNCTION(fann_subset_train_data)
{
	zval *z_train_data;
	struct fann_train_data *train_data;
	long pos, length;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &z_train_data, &pos, &length) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	train_data = fann_subset_train_data(train_data, pos, length);
	PHP_FANN_ERROR_CHECK_TRAIN_DATA();
	PHP_FANN_RETURN_TRAIN_DATA();
}
/* }}} */

/* {{{ proto int fann_length_train_data(resource train_data)
   Returns the number of training patterns in train data */
PHP_FUNCTION(fann_length_train_data)
{
	zval *z_train_data;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	RETURN_LONG((long) fann_length_train_data(train_data));
}
/* }}} */

/* {{{ proto int fann_num_input_train_data(resource train_data)
   Returns the number of inputs in each of the training patterns in train data */
PHP_FUNCTION(fann_num_input_train_data)
{
	zval *z_train_data;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	RETURN_LONG((long) fann_num_input_train_data(train_data));
}
/* }}} */

/* {{{ proto int fann_num_output_train_data(resource train_data)
   Returns the number of outputs in each of the training patterns in train data */
PHP_FUNCTION(fann_num_output_train_data)
{
	zval *z_train_data;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_train_data) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	RETURN_LONG((long) fann_num_output_train_data(train_data));
}
/* }}} */

/* {{{ proto bool fann_save_train(resource train_data, string filename)
   Saves the training structure to the file */
PHP_FUNCTION(fann_save_train)
{
	char *filename;
	phpc_str_size_t filename_len;
	zval *z_train_data;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_train_data, &filename, &filename_len)
		== FAILURE) {
		return;
	}
	PHP_FANN_FETCH_TRAIN_DATA();
	filename = php_fann_get_path_for_open(filename, filename_len, 0 TSRMLS_CC);
	if (!filename) {
		RETURN_FALSE;
	}
	if (fann_save_train(train_data, filename) == 0) {
		RETURN_TRUE;
	}
	else {
		PHP_FANN_ERROR_CHECK_TRAIN_DATA();
		RETURN_FALSE;
	}
}
/* }}} */

/* {{{ proto int fann_get_training_algorithm(resource ann)
   Returns the training algorithm that is used by fann_train_on_data and associated functions */
PHP_FUNCTION(fann_get_training_algorithm)
{
	PHP_FANN_GET_PARAM(fann_get_training_algorithm, RETURN_LONG);
}

/* {{{ proto bool fann_set_training_algorithm(resource ann, int training_algorithm)
   Sets the training algorithm that is used by fann_train_on_data and associated functions */
PHP_FUNCTION(fann_set_training_algorithm)
{
    PHP_FANN_SET_PARAM(fann_set_training_algorithm, l, long);
}
/* }}} */

/* {{{ proto double fann_get_learning_rate(resource ann)
   Returns the learning rate */
PHP_FUNCTION(fann_get_learning_rate)
{
	PHP_FANN_GET_PARAM(fann_get_learning_rate, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_learning_rate(resource ann, double learning_rate)
   Sets the learning rate */
PHP_FUNCTION(fann_set_learning_rate)
{
    PHP_FANN_SET_PARAM(fann_set_learning_rate, d, double);
}
/* }}} */

/* {{{ proto double fann_get_learning_momentum(resource ann)
   Returns the learning momentum */
PHP_FUNCTION(fann_get_learning_momentum)
{
	PHP_FANN_GET_PARAM(fann_get_learning_momentum, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_learning_momentum(resource ann, double learning_momentum)
   Sets the learning momentum */
PHP_FUNCTION(fann_set_learning_momentum)
{
    PHP_FANN_SET_PARAM(fann_set_learning_momentum, d, double);
}
/* }}} */

/* {{{ proto bool fann_get_activation_function(resource ann, int layer, int neuron)
   Returns the activation function for neuron number neuron in layer number layer, counting the input layer as layer 0 */
PHP_FUNCTION(fann_get_activation_function)
{
	PHP_FANN_GET_PARAM2(fann_get_activation_function, RETURN_LONG, ll, long, long);
}
/* }}} */

/* {{{ proto bool fann_set_activation_function(resource ann, int activation_function, int layer, int neuron)
   Sets the activation function for neuron number neuron in layer number layer, counting the input layer as layer 0 */
PHP_FUNCTION(fann_set_activation_function)
{
	PHP_FANN_SET_PARAM3(fann_set_activation_function, lll, long, long, long);
}
/* }}} */

/* {{{ proto bool fann_set_activation_function_layer(resource ann, int activation_function, int layer)
   Sets the activation function for all the neurons in the layer number layer, counting the input layer as layer 0 */
PHP_FUNCTION(fann_set_activation_function_layer)
{
	PHP_FANN_SET_PARAM2(fann_set_activation_function_layer, ll, long, long);
}
/* }}} */

/* {{{ proto bool fann_set_activation_function_hidden(resource ann, int activation_function)
   Sets the activation function for all of the hidden layers */
PHP_FUNCTION(fann_set_activation_function_hidden)
{
	PHP_FANN_SET_PARAM(fann_set_activation_function_hidden, l, long);

}
/* }}} */

/* {{{ proto bool fann_set_activation_function_output(resource ann, int activation_function)
   Sets the activation function for the output layer */
PHP_FUNCTION(fann_set_activation_function_output)
{
	PHP_FANN_SET_PARAM(fann_set_activation_function_output, l, long);
}
/* }}} */

/* {{{ proto double fann_get_activation_steepness(resource ann, int layer, int neuron)
   Returns the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0 */
PHP_FUNCTION(fann_get_activation_steepness)
{
	PHP_FANN_GET_PARAM2(fann_get_activation_steepness, RETURN_DOUBLE, ll, long, long);
}
/* }}} */

/* {{{ proto bool fann_set_activation_steepness(resource ann, double steepness, int layer, int neuron)
   Sets the activation steepness for neuron number neuron in layer number layer, counting the input layer as layer 0 */
PHP_FUNCTION(fann_set_activation_steepness)
{
	PHP_FANN_SET_PARAM3(fann_set_activation_steepness, dll, double, long, long);
}
/* }}} */

/* {{{ proto bool fann_set_activation_steepness_layer(resource ann, double steepness, int layer)
   Sets the activation steepness for all the neurons in the layer number layer, counting the input layer as layer 0 */
PHP_FUNCTION(fann_set_activation_steepness_layer)
{
	PHP_FANN_SET_PARAM2(fann_set_activation_steepness_layer, dl, double, long);
}
/* }}} */

/* {{{ proto bool fann_set_activation_steepness_hidden(resource ann, double steepness)
   Sets the steepness of the activation steepness in all of the hidden layers */
PHP_FUNCTION(fann_set_activation_steepness_hidden)
{
	PHP_FANN_SET_PARAM(fann_set_activation_steepness_hidden, d, double);
}
/* }}} */


/* {{{ proto bool fann_set_activation_steepness_output(resource ann, double steepness)
   Sets the steepness of the activation steepness in the output layer */
PHP_FUNCTION(fann_set_activation_steepness_output)
{
	PHP_FANN_SET_PARAM(fann_set_activation_steepness_output, d, double);
}
/* }}} */

/* {{{ proto int fann_get_train_error_function(resource ann)
   Returns the error function used during training */
PHP_FUNCTION(fann_get_train_error_function)
{
	PHP_FANN_GET_PARAM(fann_get_train_error_function, RETURN_LONG);
}

/* {{{ proto bool fann_set_train_error_function(resource ann, int train_error_function)
   Sets the error function used during training */
PHP_FUNCTION(fann_set_train_error_function)
{
    PHP_FANN_SET_PARAM(fann_set_train_error_function, l, long);
}
/* }}} */

/* {{{ proto int fann_get_train_stop_function(resource ann)
   Returns the stop function used during training */
PHP_FUNCTION(fann_get_train_stop_function)
{
	PHP_FANN_GET_PARAM(fann_get_train_stop_function, RETURN_LONG);
}

/* {{{ proto bool fann_set_train_stop_function(resource ann, int train_stop_function)
   Sets the stop function used during training */
PHP_FUNCTION(fann_set_train_stop_function)
{
    PHP_FANN_SET_PARAM(fann_set_train_stop_function, l, long);
}
/* }}} */

/* {{{ proto bool fann_get_bit_fail_limit(resource ann)
   Returns the bit fail limit used during training */
PHP_FUNCTION(fann_get_bit_fail_limit)
{
	PHP_FANN_GET_PARAM(fann_get_bit_fail_limit, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_bit_fail_limit(resource ann, double bit_fail_limit)
   Sets the bit fail limit used during training */
PHP_FUNCTION(fann_set_bit_fail_limit)
{
    PHP_FANN_SET_PARAM(fann_set_bit_fail_limit, d, double);
}
/* }}} */

/* {{{ proto bool fann_set_callback(resource ann, int callback)
   Sets the callback function for use during training */
PHP_FUNCTION(fann_set_callback)
{
	zval *z_ann, *callback;
	struct fann *ann;
	php_fann_user_data *user_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &z_ann, &callback) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	user_data = (php_fann_user_data *) fann_get_user_data(ann);
	if (user_data == (php_fann_user_data *) NULL) {
		user_data = (php_fann_user_data *) emalloc(sizeof (php_fann_user_data));
		PHPC_VAL_MAKE(user_data->callback);
	}
	PHPC_VAL_COPY(user_data->callback, callback);
	fann_set_user_data(ann, user_data);
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto double fann_get_quickprop_decay(resource ann)
   Returns the quickprop decay factor. */
PHP_FUNCTION(fann_get_quickprop_decay)
{
	PHP_FANN_GET_PARAM(fann_get_quickprop_decay, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_quickprop_decay(resource ann, double quickprop_decay)
   Sets the quickprop decay factor */
PHP_FUNCTION(fann_set_quickprop_decay)
{
    PHP_FANN_SET_PARAM(fann_set_quickprop_decay, d, double);
}
/* }}} */

/* {{{ proto double fann_get_quickprop_mu(resource ann)
   Returns the quickprop mu factor */
PHP_FUNCTION(fann_get_quickprop_mu)
{
	PHP_FANN_GET_PARAM(fann_get_quickprop_mu, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_quickprop_mu(resource ann, double quickprop_mu)
   Sets the quickprop mu factor */
PHP_FUNCTION(fann_set_quickprop_mu)
{
    PHP_FANN_SET_PARAM(fann_set_quickprop_mu, d, double);
}
/* }}} */

/* {{{ proto double fann_get_rprop_increase_factor(resource ann)
   Returns the increase factor is a value larger than 1,
   which is used to increase the step-size during RPROP training */
PHP_FUNCTION(fann_get_rprop_increase_factor)
{
	PHP_FANN_GET_PARAM(fann_get_rprop_increase_factor, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_rprop_increase_factor(resource ann, double rprop_increase_factor)
   Sets the increase factor used during RPROP training */
PHP_FUNCTION(fann_set_rprop_increase_factor)
{
    PHP_FANN_SET_PARAM(fann_set_rprop_increase_factor, d, double);
}
/* }}} */

/* {{{ proto double fann_get_rprop_decrease_factor(resource ann)
   Returns The decrease factor is a value smaller than 1,
   which is used to decrease the step-size during RPROP training */
PHP_FUNCTION(fann_get_rprop_decrease_factor)
{
	PHP_FANN_GET_PARAM(fann_get_rprop_decrease_factor, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_rprop_decrease_factor(resource ann, double rprop_decrease_factor)
   Sets the decrease factor is a value smaller than 1,
   which is used to decrease the step-size during RPROP training */
PHP_FUNCTION(fann_set_rprop_decrease_factor)
{
    PHP_FANN_SET_PARAM(fann_set_rprop_decrease_factor, d, double);
}
/* }}} */

/* {{{ proto double fann_get_rprop_delta_min(resource ann)
   Returns the minimum step-size is a small positive number determining how small the minimum step-size may be */
PHP_FUNCTION(fann_get_rprop_delta_min)
{
	PHP_FANN_GET_PARAM(fann_get_rprop_delta_min, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_rprop_delta_min(resource ann, double rprop_delta_min)
   Sets the minimum step-size is a small positive number determining how small the minimum step-size may be */
PHP_FUNCTION(fann_set_rprop_delta_min)
{
    PHP_FANN_SET_PARAM(fann_set_rprop_delta_min, d, double);
}
/* }}} */

/* {{{ proto bool fann_get_rprop_delta_max(resource ann)
   Returns the maximum step-size is a positive number determining how large the maximum step-size may be */
PHP_FUNCTION(fann_get_rprop_delta_max)
{
	PHP_FANN_GET_PARAM(fann_get_rprop_delta_max, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_rprop_delta_max(resource ann, double rprop_delta_max)
   Sets the maximum step-size is a positive number determining how large the maximum step-size may be */
PHP_FUNCTION(fann_set_rprop_delta_max)
{
    PHP_FANN_SET_PARAM(fann_set_rprop_delta_max, d, double);
}
/* }}} */

/* {{{ proto double fann_get_rprop_delta_zero(resource ann)
   Returns the initial step-size is a positive number determining the initial step size */
PHP_FUNCTION(fann_get_rprop_delta_zero)
{
	PHP_FANN_GET_PARAM(fann_get_rprop_delta_zero, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_rprop_delta_zero(resource ann, double rprop_delta_zero)
   Sets the initial step-size is a positive number determining the initial step size */
PHP_FUNCTION(fann_set_rprop_delta_zero)
{
    PHP_FANN_SET_PARAM(fann_set_rprop_delta_zero, d, double);
}
/* }}} */

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
/* {{{ proto double fann_get_sarprop_weight_decay_shift(resource ann)
   Returns the sarprop weight decay shift */
PHP_FUNCTION(fann_get_sarprop_weight_decay_shift)
{
	PHP_FANN_GET_PARAM(fann_get_sarprop_weight_decay_shift, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_sarprop_weight_decay_shift(resource ann, double sarprop_weight_decay_shift)
   Sets the sarprop weight decay shift */
PHP_FUNCTION(fann_set_sarprop_weight_decay_shift)
{
    PHP_FANN_SET_PARAM(fann_set_sarprop_weight_decay_shift, d, double);
}
/* }}} */

/* {{{ proto double fann_get_sarprop_step_error_threshold_factor(resource ann)
   Returns the sarprop step error threshold factor */
PHP_FUNCTION(fann_get_sarprop_step_error_threshold_factor)
{
	PHP_FANN_GET_PARAM(fann_get_sarprop_step_error_threshold_factor, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_sarprop_step_error_threshold_factor(resource ann, double sarprop_step_error_threshold_factor)
   Sets the sarprop step error threshold factor */
PHP_FUNCTION(fann_set_sarprop_step_error_threshold_factor)
{
    PHP_FANN_SET_PARAM(fann_set_sarprop_step_error_threshold_factor, d, double);
}
/* }}} */

/* {{{ proto double fann_get_sarprop_step_error_shift(resource ann)
   Returns the sarprop step error shift */
PHP_FUNCTION(fann_get_sarprop_step_error_shift)
{
	PHP_FANN_GET_PARAM(fann_get_sarprop_step_error_shift, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_sarprop_step_error_shift(resource ann, double sarprop_step_error_shift)
   Sets the sarprop step error shift */
PHP_FUNCTION(fann_set_sarprop_step_error_shift)
{
    PHP_FANN_SET_PARAM(fann_set_sarprop_step_error_shift, d, double);
}
/* }}} */

/* {{{ proto double fann_get_sarprop_temperature(resource ann)
   Returns the sarprop_temperature */
PHP_FUNCTION(fann_get_sarprop_temperature)
{
	PHP_FANN_GET_PARAM(fann_get_sarprop_temperature, RETURN_DOUBLE);
}

/* {{{ proto bool fann_set_(resource ann, double sarprop_temperature)
   Sets the sarprop_temperature */
PHP_FUNCTION(fann_set_sarprop_temperature)
{
    PHP_FANN_SET_PARAM(fann_set_sarprop_temperature, d, double);
}
/* }}} */
#endif

/* {{{ proto bool fann_cascadetrain_on_data(resource ann, resource data, int max_neurons, int neurons_between_reports, float desired_error)
   Trains on an entire dataset for a period of time using the Cascade2 training algorithm */
PHP_FUNCTION(fann_cascadetrain_on_data)
{
	zval *z_ann, *z_train_data;
	long max_neurons, neurons_between_reports;
	double desired_error;
	struct fann *ann;
	struct fann_train_data *train_data;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlld", &z_ann, &z_train_data,
							  &max_neurons, &neurons_between_reports, &desired_error) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	PHP_FANN_FETCH_TRAIN_DATA();
	php_fann_update_user_data(ann, z_ann, z_train_data);
	fann_cascadetrain_on_data(ann, train_data, max_neurons, neurons_between_reports, desired_error);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_cascadetrain_on_file(resource ann, string filename, int max_neurons, int neurons_between_reports, float desired_error)
   Trains on an entire dataset in file for a period of time using the Cascade2 training algorithm */
PHP_FUNCTION(fann_cascadetrain_on_file)
{
	zval *z_ann;
	char *filename;
	phpc_str_size_t filename_len;
	long max_neurons, neurons_between_reports;
	double desired_error;
	struct fann *ann;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rslld", &z_ann, &filename, &filename_len,
							  &max_neurons, &neurons_between_reports, &desired_error) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	filename = php_fann_get_path_for_open(filename, filename_len, 1 TSRMLS_CC);
	if (!filename) {
		RETURN_FALSE;
	}
	php_fann_update_user_data(ann, z_ann, (zval *) NULL);
	fann_cascadetrain_on_file(ann, filename, max_neurons, neurons_between_reports, desired_error);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_get_cascade_output_change_fraction(resource ann)
   Returns the cascade output change fraction */
PHP_FUNCTION(fann_get_cascade_output_change_fraction)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_output_change_fraction, RETURN_DOUBLE);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_output_change_fraction(resource ann, float cascade_output_change_fraction)
   Sets the cascade output change fraction */
PHP_FUNCTION(fann_set_cascade_output_change_fraction)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_output_change_fraction, d, double);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_output_stagnation_epochs(resource ann)
   Returns the number of cascade output stagnation epochs */
PHP_FUNCTION(fann_get_cascade_output_stagnation_epochs)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_output_stagnation_epochs, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_output_stagnation_epochs(resource ann, int cascade_output_stagnation_epochs)
   Sets the number of cascade output stagnation epochs */
PHP_FUNCTION(fann_set_cascade_output_stagnation_epochs)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_output_stagnation_epochs, l, long);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_candidate_change_fraction(resource ann)
   Returns the cascade candidate change fraction */
PHP_FUNCTION(fann_get_cascade_candidate_change_fraction)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_candidate_change_fraction, RETURN_DOUBLE);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_candidate_change_fraction(resource ann, float cascade_candidate_change_fraction)
   Sets the cascade candidate change fraction */
PHP_FUNCTION(fann_set_cascade_candidate_change_fraction)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_candidate_change_fraction, d, double);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_candidate_stagnation_epochs(resource ann)
   Returns the number of cascade candidate stagnation epochs */
PHP_FUNCTION(fann_get_cascade_candidate_stagnation_epochs)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_candidate_stagnation_epochs, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_candidate_stagnation_epochs(resource ann, int cascade_candidate_stagnation_epochs)
   Sets the number of cascade candidate stagnation epochs */
PHP_FUNCTION(fann_set_cascade_candidate_stagnation_epochs)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_candidate_stagnation_epochs, l, long);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_weight_multiplier(resource ann)
   Returns the weight multiplier */
PHP_FUNCTION(fann_get_cascade_weight_multiplier)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_weight_multiplier, RETURN_DOUBLE);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_weight_multiplier(resource ann, double cascade_weight_multiplier)
   Sets the weight multiplier */
PHP_FUNCTION(fann_set_cascade_weight_multiplier)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_weight_multiplier, d, double);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_candidate_limit(resource ann)
   Returns the candidate limit */
PHP_FUNCTION(fann_get_cascade_candidate_limit)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_candidate_limit, RETURN_DOUBLE);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_candidate_limit(resource ann, double cascade_candidate_limit)
   Sets the candidate limit*/
PHP_FUNCTION(fann_set_cascade_candidate_limit)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_candidate_limit, d, double);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_max_out_epochs(resource ann)
   Returns the maximum out epochs */
PHP_FUNCTION(fann_get_cascade_max_out_epochs)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_max_out_epochs, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_max_out_epochs(resource ann, int cascade_max_out_epochs)
   Sets the maximum out epochs */
PHP_FUNCTION(fann_set_cascade_max_out_epochs)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_max_out_epochs, l, long);
}
/* }}} */

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
/* {{{ proto bool fann_get_cascade_min_out_epochs(resource ann)
   Returns the minimum out epochs */
PHP_FUNCTION(fann_get_cascade_min_out_epochs)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_min_out_epochs, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_min_out_epochs(resource ann, int cascade_min_out_epochs)
   Sets the minimum out epochs */
PHP_FUNCTION(fann_set_cascade_min_out_epochs)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_min_out_epochs, l, long);
}
/* }}} */
#endif

/* {{{ proto bool fann_get_cascade_max_cand_epochs(resource ann)
   Returns the max candidate epochs */
PHP_FUNCTION(fann_get_cascade_max_cand_epochs)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_max_cand_epochs, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_max_cand_epochs(resource ann, int cascade_max_cand_epochs)
   Sets the max candidate epochs */
PHP_FUNCTION(fann_set_cascade_max_cand_epochs)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_max_cand_epochs, l, long);
}
/* }}} */

#if PHP_FANN_LIBFANN_VERSION_ID >= 0x020200
/* {{{ proto bool fann_get_cascade_min_cand_epochs(resource ann)
   Returns the min candidate epochs */
PHP_FUNCTION(fann_get_cascade_min_cand_epochs)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_min_cand_epochs, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_min_cand_epochs(resource ann, int cascade_min_cand_epochs)
   Sets the min candidate epochs */
PHP_FUNCTION(fann_set_cascade_min_cand_epochs)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_min_cand_epochs, l, long);
}
/* }}} */
#endif

/* {{{ proto bool fann_get_cascade_num_candidates(resource ann)
   Returns the number of candidates used during training */
PHP_FUNCTION(fann_get_cascade_num_candidates)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_num_candidates, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_activation_functions_count(resource ann)
   Returns the number of activation functions */
PHP_FUNCTION(fann_get_cascade_activation_functions_count)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_activation_functions_count, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_activation_functions(resource ann)
   Returns the array of cascade candidate activation functions */
PHP_FUNCTION(fann_get_cascade_activation_functions)
{
	zval *z_ann;
	struct fann *ann;
	unsigned num_functions, i;
	enum fann_activationfunc_enum *functions;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	num_functions = fann_get_cascade_activation_functions_count(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	functions = fann_get_cascade_activation_functions(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	PHPC_ARRAY_INIT_SIZE(return_value, num_functions);
	for (i = 0; i < num_functions; i++) {
		PHPC_ARRAY_ADD_INDEX_LONG(return_value, i, (long) functions[i]);
	}
}
/* }}} */

/* {{{ proto bool fann_set_cascade_activation_functions(resource ann, array cascade_activation_functions)
   Sets the array of cascade candidate activation functions */
PHP_FUNCTION(fann_set_cascade_activation_functions)
{
	zval *z_ann, *array;
	phpc_val *element;
	struct fann *ann;
	enum fann_activationfunc_enum *functions;
	unsigned num_functions, i = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &array) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	num_functions = PHPC_HASH_NUM_ELEMENTS(Z_ARRVAL_P(array));
	functions = (enum fann_activationfunc_enum *) emalloc(num_functions * sizeof(enum fann_activationfunc_enum));
	PHPC_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) {
		convert_to_long_ex(element);
		functions[i++] = (enum fann_activationfunc_enum) PHPC_LVAL_P(element);
	} PHPC_HASH_FOREACH_END();
	fann_set_cascade_activation_functions(ann, functions, i);
	efree(functions);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_get_cascade_activation_steepnesses_count(resource ann)
   Returns the number of activation steepnesses */
PHP_FUNCTION(fann_get_cascade_activation_steepnesses_count)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_activation_steepnesses_count, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_get_cascade_activation_steepnesses(resource ann)
   Returns the cascade activation steepnesses array is an array of the different activation functions used by the candidates */
PHP_FUNCTION(fann_get_cascade_activation_steepnesses)
{
	zval *z_ann;
	struct fann *ann;
	unsigned num_steepnesses, i;
	fann_type *steepnesses;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_ann) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	num_steepnesses = fann_get_cascade_activation_steepnesses_count(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	steepnesses = fann_get_cascade_activation_steepnesses(ann);
	PHP_FANN_ERROR_CHECK_ANN();
	PHPC_ARRAY_INIT_SIZE(return_value, num_steepnesses);
	for (i = 0; i < num_steepnesses; i++) {
		PHPC_ARRAY_ADD_INDEX_DOUBLE(return_value, i, (double) steepnesses[i]);
	}
}
/* }}} */

/* {{{ proto bool fann_set_cascade_activation_steepnesses(resource ann, array cascade_activation_steepnesses)
   Sets the cascade activation steepnesses array is an array of the different activation functions used by the candidates */
PHP_FUNCTION(fann_set_cascade_activation_steepnesses)
{
	zval *z_ann, *array;
	phpc_val *element;
	struct fann *ann;
	fann_type *steepnesses;
	unsigned num_steepnesses, i = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &z_ann, &array) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ANN();
	num_steepnesses = zend_hash_num_elements(Z_ARRVAL_P(array));
	steepnesses = (fann_type *) emalloc(num_steepnesses * sizeof(fann_type));
	PHPC_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) {
		convert_to_double_ex(element);
		steepnesses[i++] = (fann_type) PHPC_DVAL_P(element);
	} PHPC_HASH_FOREACH_END();
	fann_set_cascade_activation_steepnesses(ann, steepnesses, i);
	efree(steepnesses);
	PHP_FANN_ERROR_CHECK_ANN();
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool fann_get_cascade_num_candidate_groups(resource ann)
   Returns the number of candidate groups */
PHP_FUNCTION(fann_get_cascade_num_candidate_groups)
{
	PHP_FANN_GET_PARAM(fann_get_cascade_num_candidate_groups, RETURN_LONG);
}
/* }}} */

/* {{{ proto bool fann_set_cascade_num_candidate_groups(resource ann, int cascade_num_candidate_groups)
   Sets the number of candidate groups */
PHP_FUNCTION(fann_set_cascade_num_candidate_groups)
{
    PHP_FANN_SET_PARAM(fann_set_cascade_num_candidate_groups, l, long);
}
/* }}} */

/* {{{ proto resource fann_create_from_file(string configuration_file)
   Initializes neural network from configuration file */
PHP_FUNCTION(fann_create_from_file)
{
	char *cf_name = NULL;
	phpc_str_size_t cf_name_len;
	struct fann *ann;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &cf_name, &cf_name_len) == FAILURE) {
		return;
	}
	cf_name = php_fann_get_path_for_open(cf_name, cf_name_len, 1 TSRMLS_CC);
	if (!cf_name) {
		RETURN_FALSE;
	}
	ann = fann_create_from_file(cf_name);
	if (!ann) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid configuration file '%s'", cf_name);
		RETURN_FALSE;
	}
	PHP_FANN_ERROR_CHECK_ANN();
	php_fann_init_ann(ann);
	PHP_FANN_RETURN_ANN();
}
/* }}} */

/* {{{ proto bool fann_save(resource ann, string configuration_file)
   Save the entire network to a configuration file */
PHP_FUNCTION(fann_save)
{
	zval *z_ann;
	char *cf_name = NULL;
	phpc_str_size_t cf_name_len;
	struct fann *ann;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_ann, &cf_name, &cf_name_len) == FAILURE) {
		return;
	}
	cf_name = php_fann_get_path_for_open(cf_name, cf_name_len, 0 TSRMLS_CC);
	if (!cf_name) {
		RETURN_FALSE;
	}
	PHP_FANN_FETCH_ANN();
	if (fann_save(ann, cf_name) == 0) {
		RETURN_TRUE;
	} else {
		PHP_FANN_ERROR_CHECK_ANN();
		RETURN_FALSE;
	}
}
/* }}} */

/* {{{ proto bool fann_set_error_log(resource errdat, string log_file)
   Changes where errors are logged to */
PHP_FUNCTION(fann_set_error_log)
{
	zval *z_errdat;
	char *log_name = NULL;
	FILE *log_file;
	phpc_str_size_t log_name_len;
	struct fann_error *errdat;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &z_errdat, &log_name, &log_name_len) == FAILURE) {
		return;
	}
	log_name = php_fann_get_path_for_open(log_name, log_name_len, 0 TSRMLS_CC);
	if (!log_name) {
		RETURN_FALSE;
	}
	PHP_FANN_FETCH_ERRDAT();
	if (errdat->error_log)
		fclose(errdat->error_log);
	log_file = fopen(log_name, "w");
	fann_set_error_log(errdat, log_file);
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto int fann_get_errno(resource errdat)
   Returns the last error number */
PHP_FUNCTION(fann_get_errno)
{
	zval *z_errdat;
	struct fann_error *errdat;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_errdat) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ERRDAT();
	RETURN_LONG(fann_get_errno(errdat));
}
/* }}} */

/* {{{ proto void fann_reset_errno(resource errdat)
   Resets the last error number */
PHP_FUNCTION(fann_reset_errno)
{
	zval *z_errdat;
	struct fann_error *errdat;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_errdat) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ERRDAT();
	fann_reset_errno(errdat);
}
/* }}} */

/* {{{ proto void fann_reset_errstr(resource errdat)
   Resets the last error string */
PHP_FUNCTION(fann_reset_errstr)
{
	zval *z_errdat;
	struct fann_error *errdat;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_errdat) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ERRDAT();

	/* Use this in place of fann_reset_errstr that sets NULL which generates segfault later */
	errdat->errstr[0] = 0;
}
/* }}} */

/* {{{ proto string fann_get_errstr(resource errdat)
   Returns the last error string */
PHP_FUNCTION(fann_get_errstr)
{
	zval *z_errdat;
	struct fann_error *errdat;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_errdat) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ERRDAT();
	if (errdat->errstr) {
		PHPC_CSTR_RETURN(errdat->errstr);
	} else {
		RETURN_EMPTY_STRING();
	}
}
/* }}} */

/* {{{ proto void fann_print_error(resource errdat)
   Prints the last error string */
PHP_FUNCTION(fann_print_error)
{
	zval *z_errdat;
	struct fann_error *errdat;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &z_errdat) == FAILURE) {
		return;
	}
	PHP_FANN_FETCH_ERRDAT();
	if (errdat->errstr) {
		php_printf("%s", errdat->errstr);
	} else {
		php_printf("No error");
	}
}
/* }}} */

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: noet sw=4 ts=4 fdm=marker
 * vim<600: noet sw=4 ts=4
 */