# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _libfann
else:
    import _libfann

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libfann.delete_SwigPyIterator

    def value(self):
        return _libfann.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _libfann.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _libfann.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _libfann.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _libfann.SwigPyIterator_equal(self, x)

    def copy(self):
        return _libfann.SwigPyIterator_copy(self)

    def next(self):
        return _libfann.SwigPyIterator_next(self)

    def __next__(self):
        return _libfann.SwigPyIterator___next__(self)

    def previous(self):
        return _libfann.SwigPyIterator_previous(self)

    def advance(self, n):
        return _libfann.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _libfann.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _libfann.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _libfann.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _libfann.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _libfann.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _libfann.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _libfann:
_libfann.SwigPyIterator_swigregister(SwigPyIterator)
ERRORFUNC_LINEAR = _libfann.ERRORFUNC_LINEAR
ERRORFUNC_TANH = _libfann.ERRORFUNC_TANH
STOPFUNC_MSE = _libfann.STOPFUNC_MSE
STOPFUNC_BIT = _libfann.STOPFUNC_BIT
TRAIN_INCREMENTAL = _libfann.TRAIN_INCREMENTAL
TRAIN_BATCH = _libfann.TRAIN_BATCH
TRAIN_RPROP = _libfann.TRAIN_RPROP
TRAIN_QUICKPROP = _libfann.TRAIN_QUICKPROP
TRAIN_SARPROP = _libfann.TRAIN_SARPROP
LINEAR = _libfann.LINEAR
THRESHOLD = _libfann.THRESHOLD
THRESHOLD_SYMMETRIC = _libfann.THRESHOLD_SYMMETRIC
SIGMOID = _libfann.SIGMOID
SIGMOID_STEPWISE = _libfann.SIGMOID_STEPWISE
SIGMOID_SYMMETRIC = _libfann.SIGMOID_SYMMETRIC
SIGMOID_SYMMETRIC_STEPWISE = _libfann.SIGMOID_SYMMETRIC_STEPWISE
GAUSSIAN = _libfann.GAUSSIAN
GAUSSIAN_SYMMETRIC = _libfann.GAUSSIAN_SYMMETRIC
GAUSSIAN_STEPWISE = _libfann.GAUSSIAN_STEPWISE
ELLIOT = _libfann.ELLIOT
ELLIOT_SYMMETRIC = _libfann.ELLIOT_SYMMETRIC
LINEAR_PIECE = _libfann.LINEAR_PIECE
LINEAR_PIECE_SYMMETRIC = _libfann.LINEAR_PIECE_SYMMETRIC
SIN_SYMMETRIC = _libfann.SIN_SYMMETRIC
COS_SYMMETRIC = _libfann.COS_SYMMETRIC
LAYER = _libfann.LAYER
SHORTCUT = _libfann.SHORTCUT
class training_data_parent(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _libfann.training_data_parent_swiginit(self, _libfann.new_training_data_parent(*args))
    __swig_destroy__ = _libfann.delete_training_data_parent

    def destroy_train(self):
        return _libfann.training_data_parent_destroy_train(self)

    def read_train_from_file(self, filename):
        return _libfann.training_data_parent_read_train_from_file(self, filename)

    def save_train(self, filename):
        return _libfann.training_data_parent_save_train(self, filename)

    def save_train_to_fixed(self, filename, decimal_point):
        return _libfann.training_data_parent_save_train_to_fixed(self, filename, decimal_point)

    def shuffle_train_data(self):
        return _libfann.training_data_parent_shuffle_train_data(self)

    def merge_train_data(self, data):
        return _libfann.training_data_parent_merge_train_data(self, data)

    def length_train_data(self):
        return _libfann.training_data_parent_length_train_data(self)

    def num_input_train_data(self):
        return _libfann.training_data_parent_num_input_train_data(self)

    def num_output_train_data(self):
        return _libfann.training_data_parent_num_output_train_data(self)

    def get_input(self):
        return _libfann.training_data_parent_get_input(self)

    def get_output(self):
        return _libfann.training_data_parent_get_output(self)

    def set_train_data(self, num_data, num_input, input, num_output, output):
        return _libfann.training_data_parent_set_train_data(self, num_data, num_input, input, num_output, output)

    def create_train_from_callback(self, num_data, num_input, num_output, user_function):
        return _libfann.training_data_parent_create_train_from_callback(self, num_data, num_input, num_output, user_function)

    def scale_input_train_data(self, new_min, new_max):
        return _libfann.training_data_parent_scale_input_train_data(self, new_min, new_max)

    def scale_output_train_data(self, new_min, new_max):
        return _libfann.training_data_parent_scale_output_train_data(self, new_min, new_max)

    def scale_train_data(self, new_min, new_max):
        return _libfann.training_data_parent_scale_train_data(self, new_min, new_max)

    def subset_train_data(self, pos, length):
        return _libfann.training_data_parent_subset_train_data(self, pos, length)

# Register training_data_parent in _libfann:
_libfann.training_data_parent_swigregister(training_data_parent)
class neural_net_parent(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _libfann.neural_net_parent_swiginit(self, _libfann.new_neural_net_parent(*args))

    def copy_from_struct_fann(self, other):
        return _libfann.neural_net_parent_copy_from_struct_fann(self, other)
    __swig_destroy__ = _libfann.delete_neural_net_parent

    def destroy(self):
        return _libfann.neural_net_parent_destroy(self)

    def create_standard(self, num_layers):
        return _libfann.neural_net_parent_create_standard(self, num_layers)

    def create_standard_array(self, num_layers, layers):
        return _libfann.neural_net_parent_create_standard_array(self, num_layers, layers)

    def create_sparse(self, connection_rate, num_layers):
        return _libfann.neural_net_parent_create_sparse(self, connection_rate, num_layers)

    def create_sparse_array(self, connection_rate, num_layers, layers):
        return _libfann.neural_net_parent_create_sparse_array(self, connection_rate, num_layers, layers)

    def create_shortcut(self, num_layers):
        return _libfann.neural_net_parent_create_shortcut(self, num_layers)

    def create_shortcut_array(self, num_layers, layers):
        return _libfann.neural_net_parent_create_shortcut_array(self, num_layers, layers)

    def run(self, input):
        return _libfann.neural_net_parent_run(self, input)

    def randomize_weights(self, min_weight, max_weight):
        return _libfann.neural_net_parent_randomize_weights(self, min_weight, max_weight)

    def init_weights(self, data):
        return _libfann.neural_net_parent_init_weights(self, data)

    def print_connections(self):
        return _libfann.neural_net_parent_print_connections(self)

    def create_from_file(self, configuration_file):
        return _libfann.neural_net_parent_create_from_file(self, configuration_file)

    def save(self, configuration_file):
        return _libfann.neural_net_parent_save(self, configuration_file)

    def save_to_fixed(self, configuration_file):
        return _libfann.neural_net_parent_save_to_fixed(self, configuration_file)

    def train(self, input, desired_output):
        return _libfann.neural_net_parent_train(self, input, desired_output)

    def train_epoch(self, data):
        return _libfann.neural_net_parent_train_epoch(self, data)

    def train_on_data(self, data, max_epochs, epochs_between_reports, desired_error):
        return _libfann.neural_net_parent_train_on_data(self, data, max_epochs, epochs_between_reports, desired_error)

    def train_on_file(self, filename, max_epochs, epochs_between_reports, desired_error):
        return _libfann.neural_net_parent_train_on_file(self, filename, max_epochs, epochs_between_reports, desired_error)

    def test(self, input, desired_output):
        return _libfann.neural_net_parent_test(self, input, desired_output)

    def test_data(self, data):
        return _libfann.neural_net_parent_test_data(self, data)

    def get_MSE(self):
        return _libfann.neural_net_parent_get_MSE(self)

    def reset_MSE(self):
        return _libfann.neural_net_parent_reset_MSE(self)

    def set_callback(self, callback, user_data):
        return _libfann.neural_net_parent_set_callback(self, callback, user_data)

    def print_parameters(self):
        return _libfann.neural_net_parent_print_parameters(self)

    def get_training_algorithm(self):
        return _libfann.neural_net_parent_get_training_algorithm(self)

    def set_training_algorithm(self, training_algorithm):
        return _libfann.neural_net_parent_set_training_algorithm(self, training_algorithm)

    def get_learning_rate(self):
        return _libfann.neural_net_parent_get_learning_rate(self)

    def set_learning_rate(self, learning_rate):
        return _libfann.neural_net_parent_set_learning_rate(self, learning_rate)

    def get_activation_function(self, layer, neuron):
        return _libfann.neural_net_parent_get_activation_function(self, layer, neuron)

    def set_activation_function(self, activation_function, layer, neuron):
        return _libfann.neural_net_parent_set_activation_function(self, activation_function, layer, neuron)

    def set_activation_function_layer(self, activation_function, layer):
        return _libfann.neural_net_parent_set_activation_function_layer(self, activation_function, layer)

    def set_activation_function_hidden(self, activation_function):
        return _libfann.neural_net_parent_set_activation_function_hidden(self, activation_function)

    def set_activation_function_output(self, activation_function):
        return _libfann.neural_net_parent_set_activation_function_output(self, activation_function)

    def get_activation_steepness(self, layer, neuron):
        return _libfann.neural_net_parent_get_activation_steepness(self, layer, neuron)

    def set_activation_steepness(self, steepness, layer, neuron):
        return _libfann.neural_net_parent_set_activation_steepness(self, steepness, layer, neuron)

    def set_activation_steepness_layer(self, steepness, layer):
        return _libfann.neural_net_parent_set_activation_steepness_layer(self, steepness, layer)

    def set_activation_steepness_hidden(self, steepness):
        return _libfann.neural_net_parent_set_activation_steepness_hidden(self, steepness)

    def set_activation_steepness_output(self, steepness):
        return _libfann.neural_net_parent_set_activation_steepness_output(self, steepness)

    def get_train_error_function(self):
        return _libfann.neural_net_parent_get_train_error_function(self)

    def set_train_error_function(self, train_error_function):
        return _libfann.neural_net_parent_set_train_error_function(self, train_error_function)

    def get_quickprop_decay(self):
        return _libfann.neural_net_parent_get_quickprop_decay(self)

    def set_quickprop_decay(self, quickprop_decay):
        return _libfann.neural_net_parent_set_quickprop_decay(self, quickprop_decay)

    def get_quickprop_mu(self):
        return _libfann.neural_net_parent_get_quickprop_mu(self)

    def set_quickprop_mu(self, quickprop_mu):
        return _libfann.neural_net_parent_set_quickprop_mu(self, quickprop_mu)

    def get_rprop_increase_factor(self):
        return _libfann.neural_net_parent_get_rprop_increase_factor(self)

    def set_rprop_increase_factor(self, rprop_increase_factor):
        return _libfann.neural_net_parent_set_rprop_increase_factor(self, rprop_increase_factor)

    def get_rprop_decrease_factor(self):
        return _libfann.neural_net_parent_get_rprop_decrease_factor(self)

    def set_rprop_decrease_factor(self, rprop_decrease_factor):
        return _libfann.neural_net_parent_set_rprop_decrease_factor(self, rprop_decrease_factor)

    def get_rprop_delta_zero(self):
        return _libfann.neural_net_parent_get_rprop_delta_zero(self)

    def set_rprop_delta_zero(self, rprop_delta_zero):
        return _libfann.neural_net_parent_set_rprop_delta_zero(self, rprop_delta_zero)

    def get_rprop_delta_min(self):
        return _libfann.neural_net_parent_get_rprop_delta_min(self)

    def set_rprop_delta_min(self, rprop_delta_min):
        return _libfann.neural_net_parent_set_rprop_delta_min(self, rprop_delta_min)

    def get_rprop_delta_max(self):
        return _libfann.neural_net_parent_get_rprop_delta_max(self)

    def set_rprop_delta_max(self, rprop_delta_max):
        return _libfann.neural_net_parent_set_rprop_delta_max(self, rprop_delta_max)

    def get_sarprop_weight_decay_shift(self):
        return _libfann.neural_net_parent_get_sarprop_weight_decay_shift(self)

    def set_sarprop_weight_decay_shift(self, sarprop_weight_decay_shift):
        return _libfann.neural_net_parent_set_sarprop_weight_decay_shift(self, sarprop_weight_decay_shift)

    def get_sarprop_step_error_threshold_factor(self):
        return _libfann.neural_net_parent_get_sarprop_step_error_threshold_factor(self)

    def set_sarprop_step_error_threshold_factor(self, sarprop_step_error_threshold_factor):
        return _libfann.neural_net_parent_set_sarprop_step_error_threshold_factor(self, sarprop_step_error_threshold_factor)

    def get_sarprop_step_error_shift(self):
        return _libfann.neural_net_parent_get_sarprop_step_error_shift(self)

    def set_sarprop_step_error_shift(self, sarprop_step_error_shift):
        return _libfann.neural_net_parent_set_sarprop_step_error_shift(self, sarprop_step_error_shift)

    def get_sarprop_temperature(self):
        return _libfann.neural_net_parent_get_sarprop_temperature(self)

    def set_sarprop_temperature(self, sarprop_temperature):
        return _libfann.neural_net_parent_set_sarprop_temperature(self, sarprop_temperature)

    def get_num_input(self):
        return _libfann.neural_net_parent_get_num_input(self)

    def get_num_output(self):
        return _libfann.neural_net_parent_get_num_output(self)

    def get_total_neurons(self):
        return _libfann.neural_net_parent_get_total_neurons(self)

    def get_total_connections(self):
        return _libfann.neural_net_parent_get_total_connections(self)

    def get_network_type(self):
        return _libfann.neural_net_parent_get_network_type(self)

    def get_connection_rate(self):
        return _libfann.neural_net_parent_get_connection_rate(self)

    def get_num_layers(self):
        return _libfann.neural_net_parent_get_num_layers(self)

    def get_layer_array(self, layers):
        return _libfann.neural_net_parent_get_layer_array(self, layers)

    def get_bias_array(self, bias):
        return _libfann.neural_net_parent_get_bias_array(self, bias)

    def get_connection_array(self, connections):
        return _libfann.neural_net_parent_get_connection_array(self, connections)

    def set_weight_array(self, connections, num_connections):
        return _libfann.neural_net_parent_set_weight_array(self, connections, num_connections)

    def set_weight(self, from_neuron, to_neuron, weight):
        return _libfann.neural_net_parent_set_weight(self, from_neuron, to_neuron, weight)

    def get_learning_momentum(self):
        return _libfann.neural_net_parent_get_learning_momentum(self)

    def set_learning_momentum(self, learning_momentum):
        return _libfann.neural_net_parent_set_learning_momentum(self, learning_momentum)

    def get_train_stop_function(self):
        return _libfann.neural_net_parent_get_train_stop_function(self)

    def set_train_stop_function(self, train_stop_function):
        return _libfann.neural_net_parent_set_train_stop_function(self, train_stop_function)

    def get_bit_fail_limit(self):
        return _libfann.neural_net_parent_get_bit_fail_limit(self)

    def set_bit_fail_limit(self, bit_fail_limit):
        return _libfann.neural_net_parent_set_bit_fail_limit(self, bit_fail_limit)

    def get_bit_fail(self):
        return _libfann.neural_net_parent_get_bit_fail(self)

    def cascadetrain_on_data(self, data, max_neurons, neurons_between_reports, desired_error):
        return _libfann.neural_net_parent_cascadetrain_on_data(self, data, max_neurons, neurons_between_reports, desired_error)

    def cascadetrain_on_file(self, filename, max_neurons, neurons_between_reports, desired_error):
        return _libfann.neural_net_parent_cascadetrain_on_file(self, filename, max_neurons, neurons_between_reports, desired_error)

    def get_cascade_output_change_fraction(self):
        return _libfann.neural_net_parent_get_cascade_output_change_fraction(self)

    def set_cascade_output_change_fraction(self, cascade_output_change_fraction):
        return _libfann.neural_net_parent_set_cascade_output_change_fraction(self, cascade_output_change_fraction)

    def get_cascade_output_stagnation_epochs(self):
        return _libfann.neural_net_parent_get_cascade_output_stagnation_epochs(self)

    def set_cascade_output_stagnation_epochs(self, cascade_output_stagnation_epochs):
        return _libfann.neural_net_parent_set_cascade_output_stagnation_epochs(self, cascade_output_stagnation_epochs)

    def get_cascade_candidate_change_fraction(self):
        return _libfann.neural_net_parent_get_cascade_candidate_change_fraction(self)

    def set_cascade_candidate_change_fraction(self, cascade_candidate_change_fraction):
        return _libfann.neural_net_parent_set_cascade_candidate_change_fraction(self, cascade_candidate_change_fraction)

    def get_cascade_candidate_stagnation_epochs(self):
        return _libfann.neural_net_parent_get_cascade_candidate_stagnation_epochs(self)

    def set_cascade_candidate_stagnation_epochs(self, cascade_candidate_stagnation_epochs):
        return _libfann.neural_net_parent_set_cascade_candidate_stagnation_epochs(self, cascade_candidate_stagnation_epochs)

    def get_cascade_weight_multiplier(self):
        return _libfann.neural_net_parent_get_cascade_weight_multiplier(self)

    def set_cascade_weight_multiplier(self, cascade_weight_multiplier):
        return _libfann.neural_net_parent_set_cascade_weight_multiplier(self, cascade_weight_multiplier)

    def get_cascade_candidate_limit(self):
        return _libfann.neural_net_parent_get_cascade_candidate_limit(self)

    def set_cascade_candidate_limit(self, cascade_candidate_limit):
        return _libfann.neural_net_parent_set_cascade_candidate_limit(self, cascade_candidate_limit)

    def get_cascade_max_out_epochs(self):
        return _libfann.neural_net_parent_get_cascade_max_out_epochs(self)

    def set_cascade_max_out_epochs(self, cascade_max_out_epochs):
        return _libfann.neural_net_parent_set_cascade_max_out_epochs(self, cascade_max_out_epochs)

    def get_cascade_max_cand_epochs(self):
        return _libfann.neural_net_parent_get_cascade_max_cand_epochs(self)

    def set_cascade_max_cand_epochs(self, cascade_max_cand_epochs):
        return _libfann.neural_net_parent_set_cascade_max_cand_epochs(self, cascade_max_cand_epochs)

    def get_cascade_num_candidates(self):
        return _libfann.neural_net_parent_get_cascade_num_candidates(self)

    def get_cascade_activation_functions_count(self):
        return _libfann.neural_net_parent_get_cascade_activation_functions_count(self)

    def get_cascade_activation_functions(self):
        return _libfann.neural_net_parent_get_cascade_activation_functions(self)

    def set_cascade_activation_functions(self, cascade_activation_functions, cascade_activation_functions_count):
        return _libfann.neural_net_parent_set_cascade_activation_functions(self, cascade_activation_functions, cascade_activation_functions_count)

    def get_cascade_activation_steepnesses_count(self):
        return _libfann.neural_net_parent_get_cascade_activation_steepnesses_count(self)

    def get_cascade_activation_steepnesses(self):
        return _libfann.neural_net_parent_get_cascade_activation_steepnesses(self)

    def set_cascade_activation_steepnesses(self, cascade_activation_steepnesses, cascade_activation_steepnesses_count):
        return _libfann.neural_net_parent_set_cascade_activation_steepnesses(self, cascade_activation_steepnesses, cascade_activation_steepnesses_count)

    def get_cascade_num_candidate_groups(self):
        return _libfann.neural_net_parent_get_cascade_num_candidate_groups(self)

    def set_cascade_num_candidate_groups(self, cascade_num_candidate_groups):
        return _libfann.neural_net_parent_set_cascade_num_candidate_groups(self, cascade_num_candidate_groups)

    def scale_train(self, data):
        return _libfann.neural_net_parent_scale_train(self, data)

    def descale_train(self, data):
        return _libfann.neural_net_parent_descale_train(self, data)

    def set_input_scaling_params(self, data, new_input_min, new_input_max):
        return _libfann.neural_net_parent_set_input_scaling_params(self, data, new_input_min, new_input_max)

    def set_output_scaling_params(self, data, new_output_min, new_output_max):
        return _libfann.neural_net_parent_set_output_scaling_params(self, data, new_output_min, new_output_max)

    def set_scaling_params(self, data, new_input_min, new_input_max, new_output_min, new_output_max):
        return _libfann.neural_net_parent_set_scaling_params(self, data, new_input_min, new_input_max, new_output_min, new_output_max)

    def clear_scaling_params(self):
        return _libfann.neural_net_parent_clear_scaling_params(self)

    def scale_input(self, input_vector):
        return _libfann.neural_net_parent_scale_input(self, input_vector)

    def scale_output(self, output_vector):
        return _libfann.neural_net_parent_scale_output(self, output_vector)

    def descale_input(self, input_vector):
        return _libfann.neural_net_parent_descale_input(self, input_vector)

    def descale_output(self, output_vector):
        return _libfann.neural_net_parent_descale_output(self, output_vector)

    def set_error_log(self, log_file):
        return _libfann.neural_net_parent_set_error_log(self, log_file)

    def get_errno(self):
        return _libfann.neural_net_parent_get_errno(self)

    def reset_errno(self):
        return _libfann.neural_net_parent_reset_errno(self)

    def reset_errstr(self):
        return _libfann.neural_net_parent_reset_errstr(self)

    def get_errstr(self):
        return _libfann.neural_net_parent_get_errstr(self)

    def print_error(self):
        return _libfann.neural_net_parent_print_error(self)

# Register neural_net_parent in _libfann:
_libfann.neural_net_parent_swigregister(neural_net_parent)
class training_data(training_data_parent):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _libfann.training_data_swiginit(self, _libfann.new_training_data(*args))
    __swig_destroy__ = _libfann.delete_training_data

    def get_input(self):
        return _libfann.training_data_get_input(self)

    def get_output(self):
        return _libfann.training_data_get_output(self)

    def set_train_data(self, input, output):
        return _libfann.training_data_set_train_data(self, input, output)

# Register training_data in _libfann:
_libfann.training_data_swigregister(training_data)
class neural_net(neural_net_parent):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _libfann.neural_net_swiginit(self, _libfann.new_neural_net())
    __swig_destroy__ = _libfann.delete_neural_net

    def create_standard_array(self, layers):
        return _libfann.neural_net_create_standard_array(self, layers)

    def create_sparse_array(self, connection_rate, layers):
        return _libfann.neural_net_create_sparse_array(self, connection_rate, layers)

    def create_shortcut_array(self, layers):
        return _libfann.neural_net_create_shortcut_array(self, layers)

    def run(self, input):
        return _libfann.neural_net_run(self, input)

    def train(self, input, desired_output):
        return _libfann.neural_net_train(self, input, desired_output)

    def test(self, input, desired_output):
        return _libfann.neural_net_test(self, input, desired_output)

    def get_layer_array(self):
        return _libfann.neural_net_get_layer_array(self)

    def get_bias_array(self):
        return _libfann.neural_net_get_bias_array(self)

    def get_connection_array(self):
        return _libfann.neural_net_get_connection_array(self)

    def set_weight_array(self, connections):
        return _libfann.neural_net_set_weight_array(self, connections)

    def get_cascade_activation_steepnesses(self):
        return _libfann.neural_net_get_cascade_activation_steepnesses(self)

    def set_cascade_activation_steepnesses(self, cascade_activation_steepnesses):
        return _libfann.neural_net_set_cascade_activation_steepnesses(self, cascade_activation_steepnesses)

# Register neural_net in _libfann:
_libfann.neural_net_swigregister(neural_net)

