view release on metacpan or  search on metacpan

FANN.xs  view on Meta::CPAN

#define _sv2fann_stopfunc_enum(sv) _sv2enum(aTHX_ sv, FANN_STOPFUNC_BIT, "fann_stopfunc_enum")

#define _fann_train_enum2sv(sv) _enum2sv(aTHX_ sv, FANN_TRAIN_NAMES, FANN_TRAIN_QUICKPROP, "fann_train_enum")
#define _fann_activationfunc_enum2sv(sv) _enum2sv(aTHX_ sv, FANN_ACTIVATIONFUNC_NAMES, FANN_LINEAR_PIECE_SYMMETRIC, "fann_activationfunc_enum")
#define _fann_errorfunc_enum2sv(sv) _enum2sv(aTHX_ sv, FANN_ERRORFUNC_NAMES, FANN_ERRORFUNC_TANH, "fann_errorfunc_enum")
#define _fann_stopfunc_enum2sv(sv) _enum2sv(aTHX_ sv, FANN_STOPFUNC_NAMES, FANN_STOPFUNC_BIT, "fann_stopfunc_enum")



/* normalized names for train_data methods */

#define fann_train_data_create_from_file fann_read_train_from_file
#define fann_train_data_shuffle fann_shuffle_train_data
#define fann_train_data_scale_input fann_scale_input_train_data
#define fann_train_data_scale_output fann_scale_output_train_data
#define fann_train_data_scale fann_scale_train_data
#define fann_train_data_merge fann_merge_train_data
#define fann_train_data_subset fann_subset_train_data
#define fann_train_data_length fann_length_train_data
#define fann_train_data_num_input fann_num_input_train_data
#define fann_train_data_num_output fann_num_output_train_data
#define fann_train_data_save fann_save_train

MODULE = AI::FANN		PACKAGE = AI::FANN		PREFIX = fann_

PROTOTYPES: DISABLE

BOOT:
    fann_set_error_log(0, 0);

void
_constants()
  PREINIT:
    unsigned int i;
  PPCODE:
    for (i = 0; my_constant_names[i]; i++) {
        SV *sv = sv_2mortal(newSVpv(my_constant_names[i], 0));
        SvUPGRADE(sv, SVt_PVIV);
        SvUV_set(sv, my_constant_values[i]);
        SvIOK_on(sv);
        SvIsUV_on(sv);
		XPUSHs(sv);
	}
    XSRETURN(i);

struct fann *
fann_new_standard(klass, ...)
    SV *klass;
  PREINIT:
    unsigned int *layers;
    unsigned int i;
    unsigned int num_layers;
  CODE:
    num_layers = items - 1;
    Newx(layers, num_layers, unsigned int);
    SAVEFREEPV(layers);
    for (i = 0; i < num_layers; i++) {
		layers[i] = SvIV(ST(i+1));
    }
    RETVAL = fann_create_standard_array(num_layers, layers);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);

struct fann *
fann_new_sparse(klass, connection_rate, ...)
    SV *klass;
    double connection_rate;
  PREINIT:
    unsigned int *layers;
    unsigned int i;
    unsigned int num_layers;
  CODE:
    num_layers = items - 2;
    Newx(layers, num_layers, unsigned int);
    SAVEFREEPV(layers);
    for (i = 0; i < num_layers; i++) {
		layers[i] = SvIV(ST(i+2));
    }
    RETVAL = fann_create_sparse_array(connection_rate, num_layers, layers);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);

struct fann *
fann_new_shortcut(klass, ...)
    SV *klass;
  PREINIT:
    unsigned int *layers;
    unsigned int i;
    unsigned int num_layers;
  CODE:
    num_layers = items - 1;
    Newx(layers, num_layers, unsigned int);
    SAVEFREEPV(layers);
    for (i = 0; i < num_layers; i++) {
		layers[i] = SvIV(ST(i+1));
    }
    RETVAL = fann_create_shortcut_array(num_layers, layers);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);

struct fann *
fann_new_from_file(klass, filename)
    SV *klass;
    char *filename;
  CODE:
    RETVAL = fann_create_from_file(filename);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);

void
fann_DESTROY(self)
    struct fann * self;
  CODE:
    fann_destroy(self);
    sv_unmagic(SvRV(ST(0)), '~');

int
fann_save(self, filename)
    struct fann *self;
    char * filename;
  CODE:
    RETVAL = !fann_save(self, filename);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

fta_output
fann_run(self, input)
    struct fann *self;
    fta_input input;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_randomize_weights(self, min_weight, max_weight)
    struct fann *self;
    fann_type min_weight;
    fann_type max_weight;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_train(self, input, desired_output)
    struct fann *self;
    fta_input input;
    fta_output desired_output;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

fta_output
fann_test(self, input, desired_output)
    struct fann *self;
    fta_input input;
    fta_output desired_output;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_reset_MSE(self)
    struct fann * self;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_train_on_file(self, filename, max_epochs, epochs_between_reports, desired_error) 
    struct fann *self;
    const char *filename;
    unsigned int max_epochs;
    unsigned int epochs_between_reports;
    double desired_error;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_train_on_data(self, data, max_epochs, epochs_between_reports, desired_error)
    struct fann *self;
    struct fann_train_data *data;
    unsigned int max_epochs;
    unsigned int epochs_between_reports;
    double desired_error;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

FANN.xs  view on Meta::CPAN

            funcs[i] = _sv2fann_activationfunc_enum(ST(i+1));
        }
        fann_set_cascade_activation_functions(self, funcs, count);
    }
    count = fann_get_cascade_activation_functions_count(self);
    if (GIMME_V == G_ARRAY) {
        unsigned int i;
        enum fann_activationfunc_enum * funcs = fann_get_cascade_activation_functions(self);
        EXTEND(SP, count);
        for (i = 0; i < count; i++) {
            ST(i) = sv_2mortal(_fann_activationfunc_enum2sv(funcs[i]));
        }
        XSRETURN(count);
    }
    else {
        ST(0) = sv_2mortal(newSVuv(count));
        XSRETURN(1);
    }

void
fann_cascade_activation_steepnesses(self, ...)
    struct fann *self;
  PREINIT:
    unsigned int count;
  PPCODE:
    if (items > 1) {
        unsigned int i;
        fann_type * steepnesses;
        count = items - 1;
        Newx(steepnesses, items - 1, fann_type);
        SAVEFREEPV(steepnesses);
        for (i = 0; i < count; i++) {
            steepnesses[i] = SvNV(ST(i+1));
        }
        fann_set_cascade_activation_steepnesses(self, steepnesses, count);
    }
    count = fann_get_cascade_activation_steepnesses_count(self);
    if (GIMME_V == G_ARRAY) {
        unsigned int i;
        fann_type * steepnesses = fann_get_cascade_activation_steepnesses(self);
        EXTEND(SP, count);
        for (i = 0; i < count; i++) {
            ST(i) = sv_2mortal(newSVuv(steepnesses[i]));
        }
        XSRETURN(count);
    }
    else {
        ST(0) = sv_2mortal(newSVuv(count));
        XSRETURN(1);
    }


MODULE = AI::FANN		PACKAGE = AI::FANN::TrainData		PREFIX = fann_train_data_

struct fann_train_data *
fann_train_data_new_from_file(klass, filename)
    SV *klass;
    const char *filename;
  CODE:
    RETVAL = fann_train_data_create_from_file(filename);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);

struct fann_train_data *
fann_train_data_new_empty(klass, num_data, num_input, num_output)
    SV *klass;
    unsigned int num_data;
    unsigned int num_input;
    unsigned int num_output;
  CODE:
    RETVAL = fann_train_data_create(num_data, num_input, num_output);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);

void
fann_train_data_data(self, index, ...)
    struct fann_train_data *self;
    unsigned int index;
  PREINIT:
    AV *input;
    AV *output;
    unsigned int i;
  PPCODE:
    if (index >= self->num_data)
        Perl_croak(aTHX_"index %d is out of range", index);
    switch (items) {
    case 4:
        input = _srv2av(aTHX_ ST(2), self->num_input, "input");
        for (i = 0; i < self->num_input; i++) {
            SV **svp = av_fetch(input, i, 0);
            self->input[index][i] = SvNV(svp ? *svp : &PL_sv_undef);
        }
        output = _srv2av(aTHX_ ST(3), self->num_output, "output");
        for (i = 0; i < self->num_output; i++) {
            SV **svp = av_fetch(output, i, 0);
            self->output[index][i] = SvNV(svp ? *svp : &PL_sv_undef);
        }
    case 2:
        if (GIMME_V == G_ARRAY) {
            input = newAV();
            output = newAV();
            av_extend(input, self->num_input - 1);
            av_extend(output, self->num_output - 1);
            for (i = 0; i < self->num_input; i++) {
                SV *sv = newSVnv(self->input[index][i]);
                av_store(input, i, sv);
            }
            for (i = 0; i < self->num_output; i++) {
                SV *sv = newSVnv(self->output[index][i]);
                av_store(output, i, sv);
            }
            ST(0) = sv_2mortal(newRV_inc((SV*)input));
            ST(1) = sv_2mortal(newRV_inc((SV*)output));
            XSRETURN(2);
        }
        else {
            ST(0) = &PL_sv_yes;
            XSRETURN(1);
        }
        break;
    default:
        Perl_croak(aTHX_ "Usage: AI::FANN::TrainData::data(self, index [, input, output])");
    }

struct fann_train_data *
fann_train_data_new(klass, input, output, ...)
    SV *klass;
    AV *input;
    AV *output;
  PREINIT:
    unsigned int num_data;
    unsigned int num_input;
    unsigned int num_output;
    unsigned int i;
  CODE:
    if (!(items & 1)) {
		Perl_croak(aTHX_ "wrong number of arguments in constructor");
    }
    num_data = items >> 1;
    num_input = av_len(input) + 1;
    if (!num_input)
        Perl_croak(aTHX_ "input array is empty");
    num_output = av_len(output) + 1;
    if (!num_output)
        Perl_croak(aTHX_ "output array is empty");
    RETVAL = fann_train_data_create(num_data, num_input, num_output);
  OUTPUT:
    RETVAL
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)RETVAL);
    /* we do that at cleanup to ensure that the just created object is
     * freed if we croak */
    if (RETVAL) {
        for (i = 0; i < num_data; i++) {
            unsigned int j;
            input = _srv2av(aTHX_ ST(1 + i * 2), num_input, "input");
            for (j = 0; j < num_input; j++) {
                SV **svp = av_fetch(input, j, 0);
                RETVAL->input[i][j] = SvNV(svp ? *svp : &PL_sv_undef);
            }
            output = _srv2av(aTHX_ ST(2 + i * 2), num_output, "output");
            for (j = 0; j < num_output; j++) {
                SV **svp = av_fetch(output, j, 0);
                RETVAL->output[i][j] = SvNV(svp ? *svp : &PL_sv_undef);
            }
        }
    }

void
fann_train_data_DESTROY(self)
    struct fann_train_data * self;
  CODE:
    fann_destroy_train(self);
    sv_unmagic(SvRV(ST(0)), '~');

void
fann_train_data_shuffle(self)
    struct fann_train_data *self;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_train_data_scale_input(self, new_min, new_max)
    struct fann_train_data *self;
    fann_type new_min;
    fann_type new_max;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_train_data_scale_output(self, new_min, new_max)
    struct fann_train_data *self;
    fann_type new_min;
    fann_type new_max;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

void
fann_train_data_scale(self, new_min, new_max)
    struct fann_train_data *self;
    fann_type new_min;
    fann_type new_max;
  CLEANUP:
    _check_error(aTHX_ (struct fann_error *)self);

struct fann_train_data*
fann_train_data_subset(self, pos, length)