>_<.

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <ctime>
#include <cmath>

namespace NeuralNetwork {
    struct RandomGenerator {
        RandomGenerator(double _min = 0.0, double _max = 0.1) : min(_min), max(_max) {}
        double operator()(void) {
            double random = std::rand() / RAND_MAX;
            return random * (max - min) - min;
        }
        double min, max;
    };

    template<typename T>
    double hamming_distance(T input_begin, T input_end, T desired_begin, T desired_end) {
        double distance = 0.0;

        for (; input_begin != input_end && desired_begin != desired_end; ++input_begin, ++desired_begin)
            distance += std::pow(*desired_begin - *input_begin, 2);

        return std::sqrt(distance);
    }

    double bipolar_step_function(double x){
        if (x >= 0.0)
            return 1.0;
        return -1.0;
    }

    double bipolar_sigmoid_function(double x){
        return (1.0 - std::exp(-x)) / (1.0 + std::exp(-x));
    }

    template<int N, int M>
    class Perceptron{
    public:
        Perceptron(double (*activation_function)(double), double a = 0.1) {
            this->a = a;                                            // learning rate
            this->activation_function = activation_function;        // activation functoin

            // initialize weights include bias
            for (int i = 0; i < M; i++){
                weights[i].resize(N + 1);
                std::generate_n(weights[i].begin(), N + 1, RandomGenerator(-0.1, 0.1));
            }

            std::fill(output_pattern, output_pattern + M, 0.0);     // initialize output
        }
        ~Perceptron() {}

        template<typename T>
        void recall(T input_begin, T input_end) {
            for (int i = 0; i < M; i++) {
                output_pattern[i] = std::inner_product(weights[i].begin(), weights[i].begin()+N, input_begin, 0.0);
                output_pattern[i] += weights[i][N] * 1.0;

                output_pattern[i] = activation_function(output_pattern[i]); // compute output
            }
        }

        template<typename T>
        double learn(T input_begin, T input_end, T desired_being, T desired_end) {
            recall(input_begin, input_end);	                                        // compute output
            double error = hamming_distance(output_pattern, output_pattern + M,
                                            desired_being, desired_end);	        // compute error

            for (int i = 0; i < M; i++) { 			// for all neurons in output layer
                int j;
                double r = *(desired_being+i) - output_pattern[i];	// compute learning signal

                for (j = 0; j < N; j++)
                    weights[i][j] += a * r * *(input_begin+j);		// compute delta_w and update weight
                weights[i][j] += a * r * 1;                         // update weight of bias
            }

            return error;
        }

    private:
        std::vector<double> weights[M];
        double (*activation_function)(double);
        double a;

    public:
        double output_pattern[M];
    };
}

int main(void)
{
    using namespace std;
    using namespace NeuralNetwork;

    srand(time(NULL));

    const int n = 2;
    const int m = 1;

    Perceptron<n, m> net(bipolar_step_function, 0.3);

    double input_pattern[4][n] = { {-1.0, -1.0}, {-1.0, 1.0}, {1.0, -1.0}, {1.0, 1.0} };
    double desired_pattern[4][m] = { {-1.0}, {1.0}, {1.0}, {1.0} };

    cout.precision(5);
    cout << showpoint << showpos;
    cout << "before learning...." << endl;

    for (int i = 0; i < 4; i++) {
        net.recall(input_pattern[i], input_pattern[i]+n);

        cout << "    [ ";
        copy(input_pattern[i], input_pattern[i]+n, ostream_iterator<double>(cout, " "));
        cout << "] : ";

        copy(net.output_pattern, net.output_pattern+m, ostream_iterator<double>(cout, " "));
        cout << endl;
    }

    cout << "\ntraining...." << endl;

    cout << noshowpos;
    for (int i = 0; i < 200; i++) {
        double error = 0.0;

        for (int j = 0; j < 4; j++)
            error += net.learn(input_pattern[j], input_pattern[j]+n,
                                desired_pattern[j], desired_pattern[j]+m);

        cout << "    #"  << i << " : error : " << error << endl;

        if (error == 0.0) {
            cout << "    Traning complete" << endl;
            break;
        }
    }

    cout << "\nafter learning...." << endl;
    cout << showpos;

    for (int i = 0; i < 4; i++) {
        net.recall(input_pattern[i], input_pattern[i] + n);

        cout << "    [ ";
        copy(input_pattern[i], input_pattern[i]+n, ostream_iterator<double>(cout, " "));
        cout << "] : ";

        copy(net.output_pattern, net.output_pattern+m, ostream_iterator<double>(cout, " "));
        cout << endl;
    }

    return 0;
}

before learning....
    [ -1.0000 -1.0000 ] : -1.0000 
    [ -1.0000 +1.0000 ] : +1.0000 
    [ +1.0000 -1.0000 ] : +1.0000 
    [ +1.0000 +1.0000 ] : +1.0000 

training....
    #0 : error : 0.0000
    Traning complete

after learning....
    [ -1.0000 -1.0000 ] : -1.0000 
    [ -1.0000 +1.0000 ] : +1.0000 
    [ +1.0000 -1.0000 ] : +1.0000 
    [ +1.0000 +1.0000 ] : +1.0000