// transfer functions

Sigmoid sigmoid(2.0f); // sigmoid of parameter 2.0

Heaviside heaviside; // heaviside of default parameter 0

// learning rate and initial weight range

float eps = 0.5f;

float range = 1.0f;

// input layer has 2 neurons, uses heaviside transfer function

InputLayer il(2, heaviside);

// hidden layer is connected to input layer, has 4 neurons, uses sigmoid,

// has learning rate 'eps' and initial weights in (-range, range)

Layer hl(&il, 2, sigmoid, eps, range);

// output layer is connected to hidden layer, has 1 neuron, uses heaviside

// transfer function

OutputLayer ol(&hl, 1, heaviside, eps, range);

// MLP network constructor takes input and output layers and

// a NULL-terminated list of hidden layers in the same order

// they were connected

MultiLayerPerceptron mlp(&il, &ol, &hl, NULL);

// a simple way to train the network is to generate some examples

// of input-output couples

for (int epochs = 0; epochs < 100; ++epochs)

     for (int i = 0; i <= 1; ++i)

          for (int j = 0; j <= 1; ++j) {

               float input[2] = {i, j};

               float desired_output = XOR(i, j);

               mlp.train(input, &desired_output);

          }

// then we can test the network fitness so far

float input[2] = {1, 0};

float output;

mlp.compute(input, &output);

cout << "XOR(1, 0) = " << output << endl;

// or we can set up a text file for batch training

ifstream datafile("xor.txt");

// trains the network and returns true if it reached a mean square error

// under 0.001f in no more than 100000 epochs

bool success = mlp.optimize(datafile, 0.001f, 100000);

cout << "Success: " << success << endl;

// we can save the network on a text file

ofstream savefile("net.txt");

mlp.save(savefile);

savefile.close();

// load the network from a text file

ifstream loadfile("net.txt");

mlp.load(loadfile);

loadfile.close();