From b14c45373a414ed6d68848f13463bb62563eb4c5 Mon Sep 17 00:00:00 2001 From: biyas basak Date: Tue, 10 Jan 2017 18:47:41 +0530 Subject: [PATCH] configured to work with latest node lts --- binding.gyp | 8 +- package.json | 10 +- src/fann-accs.cc | 229 ++++++++++++++++++++++---------------------- src/fann-arrs.cc | 30 +++--- src/fann-cascade.cc | 38 ++++---- src/fann-create.cc | 162 +++++++++++++++---------------- src/fann-train.cc | 66 ++++++------- src/fann-util.cc | 2 +- src/fann.cc | 96 +++++++++---------- src/node-fann.h | 2 +- test/fann_arrs.js | 49 ++++++---- 11 files changed, 355 insertions(+), 337 deletions(-) diff --git a/binding.gyp b/binding.gyp index 68438ce..32ca7bb 100644 --- a/binding.gyp +++ b/binding.gyp @@ -8,7 +8,7 @@ # This next command produces no output but it it will fail # (and cause GYP to fail) if we don't have a recent enough # version of this library. - ' #include #include "node-fann.h" +#include NAN_GETTER(NNet::GetTrainingAlgorithm) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); int size = sizeof(FANN_TRAIN_NAMES)/sizeof(char*); enum fann_train_enum algo = fann_get_training_algorithm(net->FANN); if (algo >= 0 && algo < size) { - NanReturnValue(NormalizeName(FANN_TRAIN_NAMES[algo], TRAIN_PREFIX, sizeof(TRAIN_PREFIX)-1)); + info.GetReturnValue().Set(NormalizeName(FANN_TRAIN_NAMES[algo], TRAIN_PREFIX, sizeof(TRAIN_PREFIX)-1)); } else { - NanReturnUndefined(); + return; } } NAN_METHOD(NNet::GetNetworkType) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); int size = sizeof(FANN_NETTYPE_NAMES)/sizeof(char*); enum fann_nettype_enum ret = fann_get_network_type(net->FANN); if (ret >= 0 && ret < size) { - NanReturnValue(NormalizeName(FANN_NETTYPE_NAMES[ret], NETTYPE_PREFIX, sizeof(NETTYPE_PREFIX)-1)); + info.GetReturnValue().Set(NormalizeName(FANN_NETTYPE_NAMES[ret], NETTYPE_PREFIX, sizeof(NETTYPE_PREFIX)-1)); } else { - NanReturnUndefined(); + return; } } NAN_SETTER(NNet::SetTrainingAlgorithm) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); int size = sizeof(FANN_TRAIN_NAMES)/sizeof(char*); int num = -1; @@ -56,59 +57,59 @@ NAN_SETTER(NNet::SetTrainingAlgorithm) NAN_GETTER(NNet::GetLearningRate) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); float rate = fann_get_learning_rate(net->FANN); - NanReturnValue(NanNew(rate)); + info.GetReturnValue().Set(Nan::New(rate)); } NAN_GETTER(NNet::GetLearningMomentum) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); float momentum = fann_get_learning_momentum(net->FANN); - NanReturnValue(NanNew(momentum)); + info.GetReturnValue().Set(Nan::New(momentum)); } NAN_SETTER(NNet::SetLearningRate) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); fann_set_learning_rate(net->FANN, value->NumberValue()); } NAN_SETTER(NNet::SetLearningMomentum) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); fann_set_learning_momentum(net->FANN, value->NumberValue()); } NAN_METHOD(NNet::ActivationFunction) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); - if (args.Length() < 2) - return NanThrowError("Usage: func = activation_function(layer, neuron) or activation_function(layer, neuron, newfunc)"); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); + if (info.Length() < 2) + return Nan::ThrowError("Usage: func = activation_function(layer, neuron) or activation_function(layer, neuron, newfunc)"); int size = sizeof(FANN_ACTIVATIONFUNC_NAMES)/sizeof(char*); - int layer = args[0]->IntegerValue(); - int neuron = args[1]->IntegerValue(); + int layer = info[0]->IntegerValue(); + int neuron = info[1]->IntegerValue(); - if (args.Length() >= 3) { + if (info.Length() >= 3) { int num = -1; - if (args[2]->IsString()) { - num = _SeekCharArray(args[2].As(), FANN_ACTIVATIONFUNC_NAMES, size, FANN_PREFIX); - } else if (args[2]->IsNumber()) { - num = args[2]->NumberValue(); + if (info[2]->IsString()) { + num = _SeekCharArray(info[2].As(), FANN_ACTIVATIONFUNC_NAMES, size, FANN_PREFIX); + } else if (info[2]->IsNumber()) { + num = info[2]->NumberValue(); } if (num >= 0 && num < size) { @@ -118,24 +119,24 @@ NAN_METHOD(NNet::ActivationFunction) enum fann_activationfunc_enum func = fann_get_activation_function(net->FANN, layer, neuron); if (func >= 0 && func < size) { - NanReturnValue(NormalizeName(FANN_ACTIVATIONFUNC_NAMES[func], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); + info.GetReturnValue().Set(NormalizeName(FANN_ACTIVATIONFUNC_NAMES[func], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); } else { - NanReturnUndefined(); + return; } } NAN_METHOD(NNet::ActivationFunctionHidden) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); int size = sizeof(FANN_ACTIVATIONFUNC_NAMES)/sizeof(char*); - if (args.Length() >= 1) { + if (info.Length() >= 1) { int num = -1; - if (args[0]->IsString()) { - num = _SeekCharArray(args[0].As(), FANN_ACTIVATIONFUNC_NAMES, size, FANN_PREFIX); - } else if (args[0]->IsNumber()) { - num = args[0]->NumberValue(); + if (info[0]->IsString()) { + num = _SeekCharArray(info[0].As(), FANN_ACTIVATIONFUNC_NAMES, size, FANN_PREFIX); + } else if (info[0]->IsNumber()) { + num = info[0]->NumberValue(); } if (num >= 0 && num < size) { @@ -145,24 +146,24 @@ NAN_METHOD(NNet::ActivationFunctionHidden) enum fann_activationfunc_enum func = fann_get_activation_function(net->FANN, 1, 0); if (func >= 0 && func < size) { - NanReturnValue(NormalizeName(FANN_ACTIVATIONFUNC_NAMES[func], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); + info.GetReturnValue().Set(NormalizeName(FANN_ACTIVATIONFUNC_NAMES[func], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); } else { - NanReturnUndefined(); + return; } } NAN_METHOD(NNet::ActivationFunctionOutput) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); int size = sizeof(FANN_ACTIVATIONFUNC_NAMES)/sizeof(char*); - if (args.Length() >= 1) { + if (info.Length() >= 1) { int num = -1; - if (args[0]->IsString()) { - num = _SeekCharArray(args[0].As(), FANN_ACTIVATIONFUNC_NAMES, size, FANN_PREFIX); - } else if (args[0]->IsNumber()) { - num = args[0]->NumberValue(); + if (info[0]->IsString()) { + num = _SeekCharArray(info[0].As(), FANN_ACTIVATIONFUNC_NAMES, size, FANN_PREFIX); + } else if (info[0]->IsNumber()) { + num = info[0]->NumberValue(); } if (num >= 0 && num < size) { @@ -172,88 +173,88 @@ NAN_METHOD(NNet::ActivationFunctionOutput) enum fann_activationfunc_enum func = fann_get_activation_function(net->FANN, fann_get_num_layers(net->FANN)-1, 0); if (func >= 0 && func < size) { - NanReturnValue(NormalizeName(FANN_ACTIVATIONFUNC_NAMES[func], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); + info.GetReturnValue().Set(NormalizeName(FANN_ACTIVATIONFUNC_NAMES[func], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); } else { - NanReturnUndefined(); + return; } } NAN_METHOD(NNet::GetMse) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); float ret = fann_get_MSE(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_METHOD(NNet::GetNumInput) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); unsigned int ret = fann_get_num_input(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_METHOD(NNet::GetNumOutput) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); unsigned int ret = fann_get_num_output(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_METHOD(NNet::GetTotalNeurons) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); unsigned int ret = fann_get_total_neurons(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_METHOD(NNet::GetTotalConnections) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); unsigned int ret = fann_get_total_connections(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_METHOD(NNet::GetConnectionRate) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); float ret = fann_get_connection_rate(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_METHOD(NNet::GetNumLayers) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); unsigned int ret = fann_get_num_layers(net->FANN); - NanReturnValue(NanNew(ret)); + info.GetReturnValue().Set(Nan::New(ret)); } NAN_GETTER(NNet::GetLayerArray) { - NanScope(); - Local self = args.Holder(); - NNet *net = ObjectWrap::Unwrap(self); - NanReturnValue(net->GetLayers()); + Nan::HandleScope scope; + Local self = info.Holder(); + NNet *net = Nan::ObjectWrap::Unwrap(self); + info.GetReturnValue().Set(net->GetLayers()); } NAN_METHOD(NNet::GetLayerArray) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); - NanReturnValue(net->GetLayers()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); + info.GetReturnValue().Set(net->GetLayers()); } Local NNet::GetLayers() @@ -262,9 +263,9 @@ Local NNet::GetLayers() unsigned int* layers = new unsigned int[size]; fann_get_layer_array(FANN, layers); - Local result_arr = NanNew(); + Local result_arr = Nan::New(); for (int i=0; iSet(i, NanNew(layers[i])); + result_arr->Set(i, Nan::New(layers[i])); } delete[] layers; @@ -273,54 +274,54 @@ Local NNet::GetLayers() NAN_METHOD(NNet::GetBiasArray) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); int size = fann_get_num_layers(net->FANN); unsigned int* layers = new unsigned int[size]; fann_get_bias_array(net->FANN, layers); - Local result_arr = NanNew(); + Local result_arr = Nan::New(); for (int i=0; iSet(i, NanNew(layers[i])); + result_arr->Set(i, Nan::New(layers[i])); } delete[] layers; - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } NAN_METHOD(NNet::GetWeights) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); int size = fann_get_total_connections(net->FANN); struct fann_connection *conns = new struct fann_connection[size]; fann_get_connection_array(net->FANN, conns); - Local result_object = NanNew(); + Local result_object = Nan::New(); for (int i=0; i obj; if (!result_object->Has(conns[i].from_neuron)) { - obj = NanNew(); + obj = Nan::New(); result_object->Set(conns[i].from_neuron, obj); } else { obj = result_object->Get(conns[i].from_neuron).As(); } - obj->Set(conns[i].to_neuron, NanNew(conns[i].weight)); + obj->Set(conns[i].to_neuron, Nan::New(conns[i].weight)); } delete[] conns; - NanReturnValue(result_object); + info.GetReturnValue().Set(result_object); } NAN_METHOD(NNet::SetWeightsArr) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); - if (!args[0]->IsObject()) - return NanThrowError("First argument should be object"); - Local arg = args[0].As(); + if (!info[0]->IsObject()) + return Nan::ThrowError("First argument should be object"); + Local arg = info[0].As(); Local keys = arg->GetOwnPropertyNames(); struct fann_connection *conns = new struct fann_connection[fann_get_total_connections(net->FANN)]; @@ -340,24 +341,24 @@ NAN_METHOD(NNet::SetWeightsArr) fann_set_weight_array(net->FANN, conns, counter); delete[] conns; - NanReturnUndefined(); + return; } NAN_METHOD(NNet::SetWeights) { - NanScope(); - if (args[0]->IsObject()) - return SetWeightsArr(args); + Nan::HandleScope scope; + if (info[0]->IsObject()) + return SetWeightsArr(info); - NNet *net = ObjectWrap::Unwrap(args.This()); - if (args.Length() < 3) - return NanThrowError("Usage: set_weights(new_object) or set_weight(from_neuron, to_neuron, weight)"); + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); + if (info.Length() < 3) + return Nan::ThrowError("Usage: set_weights(new_object) or set_weight(from_neuron, to_neuron, weight)"); - unsigned int from_neuron = args[0]->IntegerValue(); - unsigned int to_neuron = args[1]->IntegerValue(); - fann_type weight = args[2]->NumberValue(); + unsigned int from_neuron = info[0]->IntegerValue(); + unsigned int to_neuron = info[1]->IntegerValue(); + fann_type weight = info[2]->NumberValue(); fann_set_weight(net->FANN, from_neuron, to_neuron, weight); - NanReturnUndefined(); + return; } diff --git a/src/fann-arrs.cc b/src/fann-arrs.cc index 77537e6..2c4f757 100644 --- a/src/fann-arrs.cc +++ b/src/fann-arrs.cc @@ -6,66 +6,66 @@ NAN_METHOD(GetTrainingAlgorithmList) { - NanScope(); + Nan::HandleScope scope; int size = sizeof(FANN_TRAIN_NAMES)/sizeof(char*); - Local result_arr = NanNew(size); + Local result_arr = Nan::New(size); for (int i=0; iSet(i, NormalizeName(FANN_TRAIN_NAMES[i], TRAIN_PREFIX, sizeof(TRAIN_PREFIX)-1)); } - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } NAN_METHOD(GetActivationFunctionList) { - NanScope(); + Nan::HandleScope scope; int size = sizeof(FANN_ACTIVATIONFUNC_NAMES)/sizeof(char*); - Local result_arr = NanNew(size); + Local result_arr = Nan::New(size); for (int i=0; iSet(i, NormalizeName(FANN_ACTIVATIONFUNC_NAMES[i], FANN_PREFIX, sizeof(FANN_PREFIX)-1)); } - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } NAN_METHOD(GetNetworkTypeList) { - NanScope(); + Nan::HandleScope scope; int size = sizeof(FANN_NETTYPE_NAMES)/sizeof(char*); - Local result_arr = NanNew(size); + Local result_arr = Nan::New(size); for (int i=0; iSet(i, NormalizeName(FANN_NETTYPE_NAMES[i], NETTYPE_PREFIX, sizeof(NETTYPE_PREFIX)-1)); } - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } NAN_METHOD(GetErrorFuncList) { - NanScope(); + Nan::HandleScope scope; int size = sizeof(FANN_ERRORFUNC_NAMES)/sizeof(char*); - Local result_arr = NanNew(size); + Local result_arr = Nan::New(size); for (int i=0; iSet(i, NormalizeName(FANN_ERRORFUNC_NAMES[i], ERRORFUNC_PREFIX, sizeof(ERRORFUNC_PREFIX)-1)); } - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } NAN_METHOD(GetStopFuncList) { - NanScope(); + Nan::HandleScope scope; int size = sizeof(FANN_STOPFUNC_NAMES)/sizeof(char*); - Local result_arr = NanNew(size); + Local result_arr = Nan::New(size); for (int i=0; iSet(i, NormalizeName(FANN_STOPFUNC_NAMES[i], STOPFUNC_PREFIX, sizeof(STOPFUNC_PREFIX)-1)); } - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } diff --git a/src/fann-cascade.cc b/src/fann-cascade.cc index 24587f8..44393c7 100644 --- a/src/fann-cascade.cc +++ b/src/fann-cascade.cc @@ -11,40 +11,40 @@ void NNet::CascadeTrainOnData(struct fann_train_data *traindata, unsigned int ma NAN_METHOD(NNet::CascadeTrain) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = Nan::ObjectWrap::Unwrap(info.This()); struct fann_train_data *traindata = NULL; - if (args.Length() < 1) - return NanThrowError("No arguments supplied"); + if (info.Length() < 1) + return Nan::ThrowError("No arguments supplied"); - if (!args[0]->IsArray()) - return NanThrowError("First argument should be 2d-array (training data set)"); + if (!info[0]->IsArray()) + return Nan::ThrowError("First argument should be 2d-array (training data set)"); - Local dataset = args[0].As(); + Local dataset = info[0].As(); net->MakeTrainData(dataset, &traindata); if (traindata == NULL) - return NanThrowError("Internal error"); + return Nan::ThrowError("Internal error"); unsigned int max_neurons = 100000; unsigned int neurons_between_reports = 1000; float desired_error = 0.001; int scale = 0; - if (args.Length() >= 2) { - Local params = args[1].As(); - if (params->Has(NanNew("neurons"))) { - max_neurons = params->Get(NanNew("neurons"))->IntegerValue(); + if (info.Length() >= 2) { + Local params = info[1].As(); + if (params->Has(Nan::New("neurons").ToLocalChecked())) { + max_neurons = params->Get(Nan::New("neurons").ToLocalChecked())->IntegerValue(); } - if (params->Has(NanNew("neurons_between_reports"))) { - neurons_between_reports = params->Get(NanNew("neurons_between_reports"))->IntegerValue(); + if (params->Has(Nan::New("neurons_between_reports").ToLocalChecked())) { + neurons_between_reports = params->Get(Nan::New("neurons_between_reports").ToLocalChecked())->IntegerValue(); } - if (params->Has(NanNew("error"))) { - desired_error = params->Get(NanNew("error"))->NumberValue(); + if (params->Has(Nan::New("error").ToLocalChecked())) { + desired_error = params->Get(Nan::New("error").ToLocalChecked())->NumberValue(); } - if (params->Has(NanNew("scale"))) { - scale = params->Get(NanNew("scale"))->BooleanValue(); + if (params->Has(Nan::New("scale").ToLocalChecked())) { + scale = params->Get(Nan::New("scale").ToLocalChecked())->BooleanValue(); } } if (scale) { @@ -53,6 +53,6 @@ NAN_METHOD(NNet::CascadeTrain) } net->CascadeTrainOnData(traindata, max_neurons, neurons_between_reports, desired_error); fann_destroy_train(traindata); - NanReturnUndefined(); + return; } diff --git a/src/fann-create.cc b/src/fann-create.cc index d9f894f..a6731cb 100644 --- a/src/fann-create.cc +++ b/src/fann-create.cc @@ -20,7 +20,7 @@ NNet::~NNet() int NNet::_GetLayersFromArray(unsigned int *&layers, Local a) { - NanScope(); + Nan::HandleScope scope; int len = a->Length(); if (len < 2) return 0; @@ -37,50 +37,50 @@ int NNet::_GetLayersFromArray(unsigned int *&layers, Local a) NAN_METHOD(NNet::NewStandard) { - NanScope(); + Nan::HandleScope scope; NNet *net = new NNet(); - net->Wrap(args.This()); - net->CreateStandard(args); - NanReturnValue(args.This()); + net->Wrap(info.This()); + net->CreateStandard(info); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(NNet::NewSparse) { - NanScope(); + Nan::HandleScope scope; NNet *net = new NNet(); - net->Wrap(args.This()); - net->CreateSparse(args); - NanReturnValue(args.This()); + net->Wrap(info.This()); + net->CreateSparse(info); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(NNet::NewShortcut) { - NanScope(); + Nan::HandleScope scope; NNet *net = new NNet(); - net->Wrap(args.This()); - net->CreateShortcut(args); - NanReturnValue(args.This()); + net->Wrap(info.This()); + net->CreateShortcut(info); + info.GetReturnValue().Set(info.This()); } NAN_METHOD(NNet::NewFromFile) { - NanScope(); + Nan::HandleScope scope; NNet *net = new NNet(); - net->Wrap(args.This()); - net->CreateFromFile(args); - NanReturnValue(args.This()); + net->Wrap(info.This()); + net->CreateFromFile(info); + info.GetReturnValue().Set(info.This()); } /* for FANN >= 2.2.0 NAN_METHOD(NNet::CloneNet) { NanScope(); -// if (!NNet::HasInstance(args[0])) -// return NanThrowError("First argument must be existing network."); +// if (!NNet::HasInstance(info[0])) +// return Nan::ThrowError("First argument must be existing network."); NNet *net = new NNet(); - net->Wrap(args.This()); - net->CreateClone(args); - NanReturnValue(args.This()); + net->Wrap(info.This()); + net->CreateClone(info); + info.GetReturnValue().Set(info.This()); }*/ NAN_METHOD(NNet::CreateStandard) @@ -88,26 +88,26 @@ NAN_METHOD(NNet::CreateStandard) unsigned int* layers = NULL; int len = 0; - if (args.Length() < 1) - return NanThrowError("No arguments supplied"); + if (info.Length() < 1) + return Nan::ThrowError("No arguments supplied"); - if (args[0]->IsArray()) { - len = _GetLayersFromArray(layers, args[0].As()); + if (info[0]->IsArray()) { + len = _GetLayersFromArray(layers, info[0].As()); } else { - Local arr = NanNew(); - for (int i=0; iSet(i, args[i]); + Local arr = Nan::New(); + for (int i=0; iSet(i, info[i]); } len = _GetLayersFromArray(layers, arr); } if (len <= 0) { if (layers != NULL) delete[] layers; - return NanThrowError("Wrong arguments supplied"); + return Nan::ThrowError("Wrong arguments supplied"); } FANN = fann_create_standard_array(len, layers); if (FANN == NULL) - return NanThrowError("Failed to create neural network"); + return Nan::ThrowError("Failed to create neural network"); /*const float desired_error = (const float) 0.001; const unsigned int max_epochs = 500000; @@ -121,7 +121,7 @@ fann_save(ann, "xor_float.net"); fann_destroy(ann);*/ delete[] layers; - NanReturnUndefined(); + return; } NAN_METHOD(NNet::CreateSparse) @@ -129,33 +129,33 @@ NAN_METHOD(NNet::CreateSparse) unsigned int* layers = NULL; int len = 0; - if (args.Length() < 1) - return NanThrowError("No arguments supplied"); + if (info.Length() < 1) + return Nan::ThrowError("No arguments supplied"); - if (!args[0]->IsNumber()) - return NanThrowError("First argument should be float"); + if (!info[0]->IsNumber()) + return Nan::ThrowError("First argument should be float"); - if (args[1]->IsArray()) { - len = _GetLayersFromArray(layers, args[1].As()); + if (info[1]->IsArray()) { + len = _GetLayersFromArray(layers, info[1].As()); } else { - Local arr = NanNew(); + Local arr = Nan::New(); /* skip 1st argument here */ - for (int i=1; iSet(i-1, args[i]); + for (int i=1; iSet(i-1, info[i]); } len = _GetLayersFromArray(layers, arr); } if (len <= 0) { if (layers != NULL) delete[] layers; - return NanThrowError("Wrong arguments supplied"); + return Nan::ThrowError("Wrong arguments supplied"); } - FANN = fann_create_sparse_array(args[0]->NumberValue(), len, layers); + FANN = fann_create_sparse_array(info[0]->NumberValue(), len, layers); if (FANN == NULL) - return NanThrowError("Failed to create neural network"); + return Nan::ThrowError("Failed to create neural network"); delete[] layers; - NanReturnUndefined(); + return; } NAN_METHOD(NNet::CreateShortcut) @@ -163,80 +163,80 @@ NAN_METHOD(NNet::CreateShortcut) unsigned int* layers = NULL; int len = 0; - if (args.Length() < 1) - return NanThrowError("No arguments supplied"); + if (info.Length() < 1) + return Nan::ThrowError("No arguments supplied"); - if (args[0]->IsArray()) { - len = _GetLayersFromArray(layers, args[0].As()); + if (info[0]->IsArray()) { + len = _GetLayersFromArray(layers, info[0].As()); } else { - Local arr = NanNew(); - for (int i=0; iSet(i, args[i]); + Local arr = Nan::New(); + for (int i=0; iSet(i, info[i]); } len = _GetLayersFromArray(layers, arr); } if (len <= 0) { if (layers != NULL) delete[] layers; - return NanThrowError("Wrong arguments supplied"); + return Nan::ThrowError("Wrong arguments supplied"); } FANN = fann_create_shortcut_array(len, layers); if (FANN == NULL) - return NanThrowError("Failed to create neural network"); + return Nan::ThrowError("Failed to create neural network"); delete[] layers; - NanReturnUndefined(); + return; } NAN_METHOD(NNet::CreateFromFile) { - NanScope(); - if (args.Length() != 1 || !args[0]->IsString()) - return NanThrowError("usage: new FANN.load(\"filename.nnet\")"); + Nan::HandleScope scope; + if (info.Length() != 1 || !info[0]->IsString()) + return Nan::ThrowError("usage: new FANN.load(\"filename.nnet\")"); - String::Utf8Value name(args[0].As()); + String::Utf8Value name(info[0].As()); FANN = fann_create_from_file(*name); if (FANN == NULL) - return NanThrowError("Failed to create neural network"); + return Nan::ThrowError("Failed to create neural network"); - NanReturnUndefined(); + return; } NAN_METHOD(NNet::SaveToFile) { - NanScope(); - if (args.Length() != 1 || !args[0]->IsString()) - return NanThrowError("usage: net.save(\"filename.nnet\")"); + Nan::HandleScope scope; + if (info.Length() != 1 || !info[0]->IsString()) + return Nan::ThrowError("usage: net.save(\"filename.nnet\")"); - NNet *net = ObjectWrap::Unwrap(args.This()); + NNet *net = ObjectWrap::Unwrap(info.This()); - String::Utf8Value name(args[0].As()); + String::Utf8Value name(info[0].As()); fann_save(net->FANN, *name); - NanReturnUndefined(); + return; } /* for FANN >= 2.2.0 NAN_METHOD(NNet::CreateClone) { - NNet *currnet = ObjectWrap::Unwrap(args.This()); - NNet *oldnet = ObjectWrap::Unwrap(args[0]->ToObject()); + NNet *currnet = ObjectWrap::Unwrap(info.This()); + NNet *oldnet = ObjectWrap::Unwrap(info[0]->ToObject()); currnet->FANN = fann_copy(oldnet->FANN); // printf("!!!!!!!!!!!!!! %d %d\n", currnet->something, oldnet->something); - NanReturnUndefined(); + return; }*/ NAN_METHOD(NNet::Run) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); - if (args.Length() < 1) - return NanThrowError("No arguments supplied"); - if (!args[0]->IsArray()) - return NanThrowError("First argument should be array"); - - Local datain = args[0].As(); + Nan::HandleScope scope; + NNet *net = ObjectWrap::Unwrap(info.This()); + if (info.Length() < 1) + return Nan::ThrowError("No arguments supplied"); + if (!info[0]->IsArray()) + return Nan::ThrowError("First argument should be array"); + + Local datain = info[0].As(); fann_type *dataset_in = new fann_type[datain->Length()]; for (unsigned i=0; iLength(); i++) { dataset_in[i] = datain->Get(i)->NumberValue(); @@ -249,11 +249,11 @@ NAN_METHOD(NNet::Run) } int dim = fann_get_num_output(net->FANN); - Local result_arr = NanNew(dim); + Local result_arr = Nan::New(dim); for (int i=0; iSet(i, NanNew(result[i])); + result_arr->Set(i, Nan::New(result[i])); } - NanReturnValue(result_arr); + info.GetReturnValue().Set(result_arr); } diff --git a/src/fann-train.cc b/src/fann-train.cc index 0542931..0a6b287 100644 --- a/src/fann-train.cc +++ b/src/fann-train.cc @@ -68,42 +68,42 @@ void NNet::TrainOnData(struct fann_train_data *traindata, unsigned int max_epoch NAN_METHOD(NNet::Train) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); + Nan::HandleScope scope; + NNet *net = ObjectWrap::Unwrap(info.This()); struct fann_train_data *traindata = NULL; - if (args.Length() < 1) - return NanThrowError("No arguments supplied"); + if (info.Length() < 1) + return Nan::ThrowError("No arguments supplied"); - if (!args[0]->IsArray()) - return NanThrowError("First argument should be 2d-array (training data set)"); + if (!info[0]->IsArray()) + return Nan::ThrowError("First argument should be 2d-array (training data set)"); - Local dataset = args[0].As(); + Local dataset = info[0].As(); const char* error = net->MakeTrainData(dataset, &traindata); if (error != NULL) - return NanThrowError(error); + return Nan::ThrowError(error); if (traindata == NULL) - return NanThrowError("Internal error"); + return Nan::ThrowError("Internal error"); unsigned int max_epochs = 100000; unsigned int epochs_between_reports = 1000; float desired_error = 0.001; int scale = 0; - if (args.Length() >= 2) { - Local params = args[1].As(); - if (params->Has(NanNew("epochs"))) { - max_epochs = params->Get(NanNew("epochs"))->IntegerValue(); + if (info.Length() >= 2) { + Local params = info[1].As(); + if (params->Has(Nan::New("epochs").ToLocalChecked())) { + max_epochs = params->Get(Nan::New("epochs").ToLocalChecked())->IntegerValue(); } - if (params->Has(NanNew("epochs_between_reports"))) { - epochs_between_reports = params->Get(NanNew("epochs_between_reports"))->IntegerValue(); + if (params->Has(Nan::New("epochs_between_reports").ToLocalChecked())) { + epochs_between_reports = params->Get(Nan::New("epochs_between_reports").ToLocalChecked())->IntegerValue(); } - if (params->Has(NanNew("error"))) { - desired_error = params->Get(NanNew("error"))->NumberValue(); + if (params->Has(Nan::New("error").ToLocalChecked())) { + desired_error = params->Get(Nan::New("error").ToLocalChecked())->NumberValue(); } - if (params->Has(NanNew("scale"))) { - scale = params->Get(NanNew("scale"))->BooleanValue(); + if (params->Has(Nan::New("scale").ToLocalChecked())) { + scale = params->Get(Nan::New("scale").ToLocalChecked())->BooleanValue(); } } if (scale) { @@ -112,23 +112,23 @@ NAN_METHOD(NNet::Train) } net->TrainOnData(traindata, max_epochs, epochs_between_reports, desired_error); fann_destroy_train(traindata); - NanReturnUndefined(); + return; } NAN_METHOD(NNet::TrainOnce) { - NanScope(); - NNet *net = ObjectWrap::Unwrap(args.This()); - if (args.Length() < 2) - return NanThrowError("2 arguments needed"); - - if (!args[0]->IsArray()) - return NanThrowError("First argument should be array (training input)"); - if (!args[1]->IsArray()) - return NanThrowError("Second argument should be array (training output)"); - - Local datain = args[0].As(); - Local dataout = args[1].As(); + Nan::HandleScope scope; + NNet *net = ObjectWrap::Unwrap(info.This()); + if (info.Length() < 2) + return Nan::ThrowError("2 arguments needed"); + + if (!info[0]->IsArray()) + return Nan::ThrowError("First argument should be array (training input)"); + if (!info[1]->IsArray()) + return Nan::ThrowError("Second argument should be array (training output)"); + + Local datain = info[0].As(); + Local dataout = info[1].As(); fann_type *dataset_in = new fann_type[datain->Length()]; fann_type *dataset_out = new fann_type[dataout->Length()]; for (unsigned i=0; iLength(); i++) { @@ -142,6 +142,6 @@ NAN_METHOD(NNet::TrainOnce) delete[] dataset_in; delete[] dataset_out; - NanReturnUndefined(); + return; } diff --git a/src/fann-util.cc b/src/fann-util.cc index 064665c..e2348d4 100644 --- a/src/fann-util.cc +++ b/src/fann-util.cc @@ -27,7 +27,7 @@ Handle NormalizeName(const char* origname, const char* prefix, int prefix // strncpy(algname, origname, 63); strncpy_lower(algname, origname, 64); algname[63] = 0; - return NanNew(algname); + return Nan::New(algname).ToLocalChecked(); } int _SeekCharArray(Local _value, const char* const* array, int size, const char* prefix) diff --git a/src/fann.cc b/src/fann.cc index 1d98de3..d7edb6a 100644 --- a/src/fann.cc +++ b/src/fann.cc @@ -8,74 +8,74 @@ void NNet::PrototypeInit(Local t) { t->InstanceTemplate()->SetInternalFieldCount(1); - t->SetClassName(NanNew("FANN")); - NODE_SET_PROTOTYPE_METHOD(t, "train", Train); - NODE_SET_PROTOTYPE_METHOD(t, "cascadetrain", CascadeTrain); - NODE_SET_PROTOTYPE_METHOD(t, "train_once", TrainOnce); - NODE_SET_PROTOTYPE_METHOD(t, "run", Run); - NODE_SET_PROTOTYPE_METHOD(t, "save", SaveToFile); + t->SetClassName(Nan::New("FANN").ToLocalChecked()); + Nan::SetPrototypeMethod(t, "train", Train); + Nan::SetPrototypeMethod(t, "cascadetrain", CascadeTrain); + Nan::SetPrototypeMethod(t, "train_once", TrainOnce); + Nan::SetPrototypeMethod(t, "run", Run); + Nan::SetPrototypeMethod(t, "save", SaveToFile); // deprecated in favor of require('fann').get_... - /*NODE_SET_PROTOTYPE_METHOD(t, "get_all_training_algorithms", GetTrainingAlgorithmList); - NODE_SET_PROTOTYPE_METHOD(t, "get_all_activation_functions", GetActivationFunctionList); - NODE_SET_PROTOTYPE_METHOD(t, "get_all_network_types", GetNetworkTypeList); - NODE_SET_PROTOTYPE_METHOD(t, "get_all_stop_functions", GetStopFuncList); - NODE_SET_PROTOTYPE_METHOD(t, "get_all_error_functions", GetErrorFuncList);*/ + /*Nan::SetPrototypeMethod(t, "get_all_training_algorithms", GetTrainingAlgorithmList); + Nan::SetPrototypeMethod(t, "get_all_activation_functions", GetActivationFunctionList); + Nan::SetPrototypeMethod(t, "get_all_network_types", GetNetworkTypeList); + Nan::SetPrototypeMethod(t, "get_all_stop_functions", GetStopFuncList); + Nan::SetPrototypeMethod(t, "get_all_error_functions", GetErrorFuncList);*/ - NODE_SET_PROTOTYPE_METHOD(t, "activation_function", ActivationFunction); - NODE_SET_PROTOTYPE_METHOD(t, "activation_function_hidden", ActivationFunctionHidden); - NODE_SET_PROTOTYPE_METHOD(t, "activation_function_output", ActivationFunctionOutput); - NODE_SET_PROTOTYPE_METHOD(t, "get_num_input", GetNumInput); - NODE_SET_PROTOTYPE_METHOD(t, "get_MSE", GetMse); - NODE_SET_PROTOTYPE_METHOD(t, "get_num_output", GetNumOutput); - NODE_SET_PROTOTYPE_METHOD(t, "get_total_neurons", GetTotalNeurons); - NODE_SET_PROTOTYPE_METHOD(t, "get_total_connections", GetTotalConnections); - NODE_SET_PROTOTYPE_METHOD(t, "get_network_type", GetNetworkType); - NODE_SET_PROTOTYPE_METHOD(t, "get_connection_rate", GetConnectionRate); + Nan::SetPrototypeMethod(t, "activation_function", ActivationFunction); + Nan::SetPrototypeMethod(t, "activation_function_hidden", ActivationFunctionHidden); + Nan::SetPrototypeMethod(t, "activation_function_output", ActivationFunctionOutput); + Nan::SetPrototypeMethod(t, "get_num_input", GetNumInput); + Nan::SetPrototypeMethod(t, "get_MSE", GetMse); + Nan::SetPrototypeMethod(t, "get_num_output", GetNumOutput); + Nan::SetPrototypeMethod(t, "get_total_neurons", GetTotalNeurons); + Nan::SetPrototypeMethod(t, "get_total_connections", GetTotalConnections); + Nan::SetPrototypeMethod(t, "get_network_type", GetNetworkType); + Nan::SetPrototypeMethod(t, "get_connection_rate", GetConnectionRate); // use net->layers instead ? - NODE_SET_PROTOTYPE_METHOD(t, "get_num_layers", GetNumLayers); - NODE_SET_PROTOTYPE_METHOD(t, "get_layer_array", GetLayerArray); + Nan::SetPrototypeMethod(t, "get_num_layers", GetNumLayers); + Nan::SetPrototypeMethod(t, "get_layer_array", GetLayerArray); - NODE_SET_PROTOTYPE_METHOD(t, "get_bias_array", GetBiasArray); - NODE_SET_PROTOTYPE_METHOD(t, "get_weight_array", GetWeights); - NODE_SET_PROTOTYPE_METHOD(t, "set_weight_array", SetWeights); - NODE_SET_PROTOTYPE_METHOD(t, "get_weight", GetWeights); - NODE_SET_PROTOTYPE_METHOD(t, "set_weight", SetWeights); - t->InstanceTemplate()->SetAccessor(NanNew("training_algorithm"), GetTrainingAlgorithm, SetTrainingAlgorithm); - t->InstanceTemplate()->SetAccessor(NanNew("learning_rate"), GetLearningRate, SetLearningRate); - t->InstanceTemplate()->SetAccessor(NanNew("learning_momentum"), GetLearningMomentum, SetLearningMomentum); - t->InstanceTemplate()->SetAccessor(NanNew("layers"), GetLayerArray); + Nan::SetPrototypeMethod(t, "get_bias_array", GetBiasArray); + Nan::SetPrototypeMethod(t, "get_weight_array", GetWeights); + Nan::SetPrototypeMethod(t, "set_weight_array", SetWeights); + Nan::SetPrototypeMethod(t, "get_weight", GetWeights); + Nan::SetPrototypeMethod(t, "set_weight", SetWeights); + Nan::SetAccessor(t->InstanceTemplate(), Nan::New("training_algorithm").ToLocalChecked(), GetTrainingAlgorithm, SetTrainingAlgorithm); + Nan::SetAccessor(t->InstanceTemplate(), Nan::New("learning_rate").ToLocalChecked(), GetLearningRate, SetLearningRate); + Nan::SetAccessor(t->InstanceTemplate(), Nan::New("learning_momentum").ToLocalChecked(), GetLearningMomentum, SetLearningMomentum); + Nan::SetAccessor(t->InstanceTemplate(), Nan::New("layers").ToLocalChecked(), GetLayerArray); } void NNet::Initialize(Handle t) { - NanScope(); - Local t1 = NanNew(NewStandard); - Local t2 = NanNew(NewSparse); - Local t3 = NanNew(NewShortcut); - Local t4 = NanNew(NewFromFile); -// Local t5 = NanNew(CloneNet); + Nan::HandleScope scope; + Local t1 = Nan::New(NewStandard); + Local t2 = Nan::New(NewSparse); + Local t3 = Nan::New(NewShortcut); + Local t4 = Nan::New(NewFromFile); +// Local t5 = Nan::New(CloneNet); PrototypeInit(t1); PrototypeInit(t2); PrototypeInit(t3); PrototypeInit(t4); - t->Set(NanNew("standard"), t1->GetFunction()); - t->Set(NanNew("sparse"), t2->GetFunction()); - t->Set(NanNew("shortcut"), t3->GetFunction()); - t->Set(NanNew("load"), t4->GetFunction()); + t->Set(Nan::New("standard").ToLocalChecked(), t1->GetFunction()); + t->Set(Nan::New("sparse").ToLocalChecked(), t2->GetFunction()); + t->Set(Nan::New("shortcut").ToLocalChecked(), t3->GetFunction()); + t->Set(Nan::New("load").ToLocalChecked(), t4->GetFunction()); // t->Set(String::NewSymbol("clone"), t4->GetFunction()); - NODE_SET_METHOD(t, "get_all_training_algorithms", GetTrainingAlgorithmList); - NODE_SET_METHOD(t, "get_all_activation_functions", GetActivationFunctionList); - NODE_SET_METHOD(t, "get_all_network_types", GetNetworkTypeList); - NODE_SET_METHOD(t, "get_all_stop_functions", GetStopFuncList); - NODE_SET_METHOD(t, "get_all_error_functions", GetErrorFuncList); + Nan::SetMethod(t, "get_all_training_algorithms", GetTrainingAlgorithmList); + Nan::SetMethod(t, "get_all_activation_functions", GetActivationFunctionList); + Nan::SetMethod(t, "get_all_network_types", GetNetworkTypeList); + Nan::SetMethod(t, "get_all_stop_functions", GetStopFuncList); + Nan::SetMethod(t, "get_all_error_functions", GetErrorFuncList); } extern "C" void init (Handle target) { - NanScope(); + Nan::HandleScope scope; NNet::Initialize(target); } diff --git a/src/node-fann.h b/src/node-fann.h index 617da04..c9a8118 100644 --- a/src/node-fann.h +++ b/src/node-fann.h @@ -4,7 +4,7 @@ #include "node-futil.h" -class NNet : public ObjectWrap +class NNet : public Nan::ObjectWrap { public: int something; diff --git a/test/fann_arrs.js b/test/fann_arrs.js index bd230eb..b8a1434 100644 --- a/test/fann_arrs.js +++ b/test/fann_arrs.js @@ -1,12 +1,26 @@ -var assert = require('assert') -var fann = require('../') +var assert = require('assert'); +var fann = require('../'); +var exec = require('child_process').exec; describe('fann_arrs', function () { - var net + var net; + var expected_algorithms=[ 'incremental', 'batch', 'rprop', 'quickprop' ]; - before(function () { - net = new fann.standard(1,10,1) - }) + before(function (done) { + net = new fann.standard(1,10,1); + exec('pkg-config --modversion fann',function(err,out){ + if(!err){ + var version=out.trim().split('.'); + version.forEach(function(val,index){ + version[index]=Number.parseInt(val); + }); + if(version[0]==2 && version[1]>=2){ + expected_algorithms.push('sarprop'); + } + } + done(); + }) + }); it('get all activation functions', function () { var expected = [ @@ -27,28 +41,27 @@ describe('fann_arrs', function () { 'sin_symmetric', 'cos_symmetric', 'sin', - 'cos' ] + 'cos' ]; assert.deepEqual(fann.get_all_activation_functions(), expected) - }) + }); - it('get all training algoritums', function () { - var expected = [ 'incremental', 'batch', 'rprop', 'quickprop' ] - assert.deepEqual(fann.get_all_training_algorithms(), expected) - }) + it('get all training algorithms', function () { + assert.deepEqual(fann.get_all_training_algorithms(), expected_algorithms) + }); it('get all stop functions', function () { - var expected = [ 'mse', 'bit' ] + var expected = [ 'mse', 'bit' ]; assert.deepEqual(fann.get_all_stop_functions(), expected) - }) + }); it('get all error functions', function () { - var expected = [ 'linear', 'tanh' ] + var expected = [ 'linear', 'tanh' ]; assert.deepEqual(fann.get_all_error_functions(), expected) - }) + }); it('get all network types', function () { - var expected = [ 'layer', 'shortcut' ] + var expected = [ 'layer', 'shortcut' ]; assert.deepEqual(fann.get_all_network_types(), expected) }) -}) +});