perceptron.js

  const assert = (pred) => { if (! pred) throw new Error("Assertion failed"); };

  class Connection {
    constructor(prevs, next) {
      if (prevs.length != next.weights.length) {
        throw new RangeError("prevs length should be equal to next weights length");
      }

      if (! prevs.map(p => p.weights.length).reduce((x, y) => x && x == y ? x : false)) {
        throw new RangeError("all perceptron in prevs should have same weights length");
      }

      Object.assign(this, { prevs, next });
    }

    process(inputs) {
      const nextInput = this.prevs.map(p => p.process(inputs))
      const result = this.next.process(nextInput);

      return result;
    }
  }

  class Perceptron {
    constructor(bias, weights) {
      Object.assign(this, { weights, bias });
    }

    process(inputs) {
      if (inputs.length != this.weights.length) {
        throw new RangeError(`inputs length should equal to weights (weights: ${this.weights.length}, inputs: ${inputs.length})`);
      }

      let result = this.bias;
      for (let i = 0; i < inputs.length; ++i) {
        result += this.weights[i] * inputs[i];
      }

      return result > 0 ? 1 : 0;
    }
  }
  
  const gateAnd = new Perceptron(-.7, [.5, .5]);
  assert(gateAnd.process([0, 0]) == 0);
  assert(gateAnd.process([0, 1]) == 0);
  assert(gateAnd.process([1, 0]) == 0);
  assert(gateAnd.process([1, 1]) == 1);
  
  const gateOr = new Perceptron(-.2, [.5, .5]);
  assert(gateOr.process([0, 0]) == 0);
  assert(gateOr.process([0, 1]) == 1);
  assert(gateOr.process([1, 0]) == 1);
  assert(gateOr.process([1, 1]) == 1);

  const gateNand = new Perceptron(.7, [-.5, -.5]);
  assert(gateNand.process([0, 0]) == 1);
  assert(gateNand.process([0, 1]) == 1);
  assert(gateNand.process([1, 0]) == 1);
  assert(gateNand.process([1, 1]) == 0);

  const gateXor = new Connection([gateNand, gateOr], gateAnd);
  assert(gateXor.process([0, 0]) == 0);
  assert(gateXor.process([0, 1]) == 1);
  assert(gateXor.process([1, 0]) == 1);
  assert(gateXor.process([1, 1]) == 0);