!7

cmodule PerceptronSpike > DynPrintLogAndEnabled {
  sclass Example {
    double[] inputs;
    int answer;

    *() {}
    *(double x, double y, int a) {
      inputs = new double[] {x, y, 1};
      answer = a;
    }
  }

  switchable int nExamples = 200;
  L<Example> examples;
  switchable double c = 1;
  switchable bool randomizeC = false;
  switchable bool startWithRandomWeights = true;
  transient double[] weights;
  transient double error;

  start-thread {
    if (l(examples) != nExamples)
      setField(examples := repF(nExamples, () -> {
        int x = rand(640), y = rand(360);
        ret new Example(x, y, y < f(x) ? -1 : 1);
      }));
      
    int n = l(first(examples).inputs);
    print(+n);
    weights = new double[n];
    if (startWithRandomWeights)
      for i over weights: weights[i] = random(-1.0, 1.0);

    double lastError = -1;
    long round = 0;
    while ping (lastError != 0) {
      if (!enabled) continue with sleepSeconds(1);
      ++round;
      double error = train();
      if (error != lastError) {
        print("Error: " + error + ", round " + round + ", weights: " + sfu(weights));
        lastError = error;
      }
    }
  }
  
  double train() {
    double error = 0;
    for (Example e : examples) error += abs(train(e));
    ret error/l(examples);
  }
  
  // function to be learned
  private double f(double x) {
    ret x * 0.7 + 40;
  }

  int feedForward(double[] inputs) {
    double sum = 0;
    for i over weights: sum += inputs[i] * weights[i];
    ret activate(sum);
  }

  int activate(double s) {
    return s > 0 ? 1 : -1;
  }

  double train(Example e) {
    int guess = feedForward(e.inputs);
    double error = e.answer - guess;
    double cc = c/nExamples;
    for i over weights: weights[i] += (randomizeC ? rand(cc) : cc) * error * e.inputs[i];
    ret error;
  }
}