Albertbol

class NeuralNetwork {
  constructor(
    inputNodes,
    hiddenNodes,
    outputNodes,
    learningRate,
    bias,
    trainingCycles,
    normalizer
  ) {

Albertbol

  normalize(inputArray) {
    return inputArray.map((input) => {
      return input / this.normalizer
    })
  }

Albertbol

  feedforward(inputArray) {
    inputArray = this.normalize(inputArray)
    const input = Matrix.fromArray(inputArray)
    const hidden = this.calculateFF(
      input,
      this.weightsInputToHidden,
      this.biasForHidden
    )
    const output = this.calculateFF(
      hidden,

Albertbol

module.exports = class Matrix {
  static randomNormalized() {
    let r = 0
    const v = 4
    for (let i = v; i > 0; i--) {
      r += Math.random()
    }
    return r / v
  }

Albertbol

class GeneticAlgorithm {
  constructor(phraseToGuess, populationSize, mutationRate, pow) {
    this.phraseToGuess = phraseToGuess
    this.populationSize = populationSize
    this.mutationRate = mutationRate
    this.pow = pow
    this.population = []
    this.foundIndex = -1
    this.cycle = 0
    this.rateSum = 0

Albertbol

const mutationRate = 0.01
mutate(child) {
  const chars = child.split('')
  for (let i = 0; i < chars.length; i++) {
    if (Math.random() <= mutationRate) {
      chars[i] = newChar()
    }
  }
  return chars.join('')
}

Albertbol

crossover(a, b) {
  const midpoint = Math.floor(Math.random() * (phraseToGuess.length - 2)) + 1
  let crossed = ''
  for (let i = 0; i < phraseToGuess.length; i++) {
    if (i <= midpoint) {
      crossed += a[i]
    } else {
      crossed += b[i]
    }
  }

Albertbol

selection() {
  let index = 0
  let random = Math.random()
  while (random > 0) {
    random = random - population[index].powRate
    index++
  }
  index-- // index++ jumped to the next phrase
  return population[index]
}

Albertbol

DNAchanges() {
  population.forEach((_, index) => {
    const a = selection()
    const b = selection()
    let child = crossover(a.randomPhrase, b.randomPhrase)
    child = mutate(child)
    population[index].randomPhrase = child
  })
}

Albertbol

normalization() {
  let powSum = 0
  population.forEach((p, i) => {
    powSum += population[i].powRate
  })
  population.forEach((p, i) => {
    population[i].powRate = p.powRate / powSum
  })
}