Support for async function in abeatsb and fitnesstest

[Devin345458]

Support for async function in abeatsb and fitnesstest

[ElectronicaGitHub]

interface GeneticAlgorithmSettings<T> {
  mutationFunction: (phenotype: T) => T;
  crossoverFunction: (a: T, b: T) => [T, T];
  fitnessFunction: (phenotype: T) => Promise<number>;
  doesABeatBFunction?: (a: T, b: T) => Promise<boolean>;
  population: T[];
  populationSize: number;
}

function geneticAlgorithmConstructor<T>(options?: Partial<GeneticAlgorithmSettings<T>>) {
  function settingDefaults(): GeneticAlgorithmSettings<T> {
    return {
      mutationFunction: (phenotype: T) => phenotype,
      crossoverFunction: (a: T, b: T) => [a, b],
      fitnessFunction: async (phenotype: T) => 0,
      population: [],
      populationSize: 100,
    };
  }

  function settingWithDefaults(settings?: Partial<GeneticAlgorithmSettings<T>>, defaults: GeneticAlgorithmSettings<T> = settingDefaults()): GeneticAlgorithmSettings<T> {
    const mergedSettings: GeneticAlgorithmSettings<T> = {
      ...defaults,
      ...settings,
      population: settings?.population || defaults.population,
      populationSize: settings?.populationSize || defaults.populationSize,
    };

    if (mergedSettings.population.length <= 0) throw Error("population must be an array and contain at least 1 phenotype");
    if (mergedSettings.populationSize <= 0) throw Error("populationSize must be greater than 0");

    return mergedSettings;
  }

  let settings = settingWithDefaults(options);

  function populate() {
    var size = settings.population.length;
    while (settings.population.length < settings.populationSize) {
      settings.population.push(
        mutate(
          cloneJSON(settings.population[Math.floor(Math.random() * size)])
        )
      );
    }
  }

  function cloneJSON<U>(object: U): U {
    return JSON.parse(JSON.stringify(object));
  }

  function mutate(phenotype: T) {
    return settings.mutationFunction(cloneJSON(phenotype));
  }

  function crossover(phenotype: T) {
    phenotype = cloneJSON(phenotype);
    var mate = settings.population[Math.floor(Math.random() * settings.population.length)];
    mate = cloneJSON(mate);
    return settings.crossoverFunction(phenotype, mate)[0];
  }

  async function doesABeatB(a: T, b: T) {
    if (settings.doesABeatBFunction) {
      return settings.doesABeatBFunction(a, b);
    } else {
      const fitnessA = await settings.fitnessFunction(a);
      const fitnessB = await settings.fitnessFunction(b);
      return fitnessA >= fitnessB;
    }
  }

  async function compete() {
    const nextGeneration: T[] = [];

    for (let p = 0; p < settings.population.length - 1; p += 2) {
      const phenotype = settings.population[p];
      const competitor = settings.population[p + 1];

      nextGeneration.push(phenotype);
      if (await doesABeatB(phenotype, competitor)) {
        if (Math.random() < 0.5) {
          nextGeneration.push(mutate(phenotype));
        } else {
          nextGeneration.push(crossover(phenotype));
        }
      } else {
        nextGeneration.push(competitor);
      }
    }

    settings.population = nextGeneration;
  }

  function randomizePopulationOrder() {
    for (var index = 0; index < settings.population.length; index++) {
      var otherIndex = Math.floor(Math.random() * settings.population.length);
      var temp = settings.population[otherIndex];
      settings.population[otherIndex] = settings.population[index];
      settings.population[index] = temp;
    }
  }

  return {
    evolve: async function (options?: Partial<GeneticAlgorithmSettings<T>>) {
      if (options) {
        settings = settingWithDefaults(options, settings);
      }
      
      populate();
      randomizePopulationOrder();
      await compete();
      return this;
    },
    best: async function() {
      var scored = await this.scoredPopulation();
      var result = scored.reduce(function(a, b) {
        return a.score >= b.score ? a : b;
      }, scored[0]).phenotype;
      return cloneJSON(result);
    },
    bestScore: async function() {
      return await settings.fitnessFunction(await this.best());
    },
    population: function() {
      return cloneJSON(this.config().population);
    },
    scoredPopulation: async function() {
      const population = this.population();
      const scoredPopulation = await Promise.all(population.map(async function(phenotype: T) {
        return {
          phenotype: cloneJSON(phenotype),
          score: await settings.fitnessFunction(phenotype)
        };
      }));
      return scoredPopulation;
    },
    config: function(): GeneticAlgorithmSettings<T> {
      return {
        mutationFunction: settings.mutationFunction,
        crossoverFunction: settings.crossoverFunction,
        fitnessFunction: settings.fitnessFunction,
        doesABeatBFunction: settings.doesABeatBFunction,
        population: cloneJSON(settings.population),
        populationSize: settings.populationSize
      };
    },
    clone: function(options?: Partial<GeneticAlgorithmSettings<T>>) {
      return geneticAlgorithmConstructor(
        settingWithDefaults(options, this.config())
      );
    }
  };
}

export default geneticAlgorithmConstructor;

that's the updated code I'm using for async