// class is persistable

sclass Perceptron implements IPred<double[]> {

  srecord Example(double[] inputs, bool answer) {

    double getInput(int i) { ret i < inputs.length ? inputs[i] : 1; }

  }

  L<Example> examples = syncList();

  double c = 1;

  bool randomizeC = true, startWithRandomWeights = false;

  long trainingRound;

  double error = -1; // -1 = not trained yet

  double[] weights;

  *() {}

  *(L<Example> *examples) {}

  ItIt<Double> trainingIterator() {

    if (empty(examples)) ret emptyItIt();

    int n = l(first(examples).inputs)+1;

    if (weights == null) {

      weights = new double[n];

      if (startWithRandomWeights)

        for i over weights: weights[i] = random(-1.0, 1.0);

    }

    ret iff(() -> {

      if (error == 0) ret endMarker();

      ++trainingRound;

      double lastError = error;

      trainARound();

      ret error != lastError ? error : null;

    });

  }

  double trainARound() {

    double error = 0;

    int n = l(examples);

    if (n == 0) ret -1;

    for (Example e : concIter(examples)) error += abs(trainAnExample(e));

    ret this.error = error/n;

  }

  int feedForward(double[] inputs) {

    double sum = last(weights);

    for i over inputs: sum += inputs[i] * weights[i];

    ret activate(sum);

  }

  public Bool get(double[] inputs) {

    ret feedForward(inputs) > 0;

  }

  int activate(double s) {

    return s > 0 ? 1 : -1;

  }

  double recalcError() {

    double error = 0;

    int n = l(examples);

    if (n == 0) ret -1;

    for (Example e : concIter(examples))

      error += abs(errorForExample(e));

    ret this.error = error/n;

  }

  double errorForExample(Example e) {

    int guess = feedForward(e.inputs);

    ret (e.answer ? 1 : -1) - guess;

  }

  double trainAnExample(Example e) {

    double error = errorForExample(e);

    if (error != 0) {

      double cc = c/l(examples);

      for i over weights:

        weights[i] += (randomizeC ? rand(cc) : cc) * error * e.getInput(i);

    }

    ret error;

  }

  void printWithWeights {

    print("Error: " + error + ", round " + trainingRound + ", weights: " + sfu(weights));

  }

  // scaling the weights doesn't make a difference

  // returns true if it worked (error did not increase)

  bool scaleWeights(double factor) {

    for i over weights:

      weights[i] *= factor;

    double lastError = error;

    if (recalcError() > lastError)

      ret false with warn("Error increased from \*lastError*/ to \*error*/ during scale weight with factor \*factor*/");

    true;

  }

  void addExample(double[] inputs, bool answer) {

    examples.add(new Example(inputs, answer));

    error = -1;

  }

}