# Crate genx[−][src]

## Expand description

**Genx** provides modular building blocks to run simulations of optimization
and search problems using Genetic Algorithms (GA).

The vision for genx is to be a **flexible** and greatly **extensible** library for implementing genetic
algorithm applications. genx is written in Rust. The library’s API utilizes *functional
programming* paradigm and exposes it’s API in that manner only.

The implementation is split into **building blocks** which are all represented
by traits. This crate provides most common and probably all possible implementation
for all building blocks. So it can be used for many problems out of the box.

### Basic Example

#### Selection

Here’s a trivial example that returns back individual selected using stochastic universal sampling

```
use genx::selection::stochastic_universal::stochastic_universal_selection;
let num_parents:usize = 10;
let fitness_values = vec![2.4,8.4,3.2,9.4,9.0,11.0,4.5,0.6,4.4,2.3,5.6,10.0,0.2,9.0,4.8,7.7];
let result = stochastic_universal_selection(&fitness_values, num_parents, None)
.iter()
.map(|&a| fitness_values[a])
.collect::<Vec<f32>>();
```

`stochastic_universal_selection`

takes in the `fitness_value`

vector, number of parents it needs to select and a seed value
which is `Option<u64>`

. It returns back the indices of selected individuals which we map to actual fitness values.

#### Mutation

Mutation function takes in a single individual, distribution index, max_perturbation and returns in the mutated individual using polynomial mutation for real valued individual.

```
use genx::mutation::polynomial::polynomial_mutation;
let individual = 29.11;
let result = polynomial_mutation(individual, 4.2, 4.0, None);
```

The returned value may or may not be equal as is mutated based on a randomly generated value which for deterministic results can be seeded.

### Building Blocks

The genetic algorithm needs a population that it evolves with each iteration. A population contains a number of individuals. Each individual represents a possible candidate solution for an optimization problem for which the best solution is searched for.

#### Steps in Genetic Algorithm

A Genetic Algorithm proceeds through following operations:

**Encoding**: Binary, Real Values, Order, Tree, etc.**Selection**: Selecting individuals after fitness evaluation.**Crossover**: Creating new individuals from selected pool of individuals.**Mutation**: Making stark changes in generated individual for diversification.**Convergence**: Test for goal accomplishment or convergence.

#### Available Building Blocks

The building blocks available in the crate (defined as traits) are:

This crate provides multiple implementations for each one of those operators. So one can experiment with combining the different implementations to compose the best algorithm for a specific search or optimization problem.

### Usage

Add this to your `Cargo.toml`

:

```
[dependencies]
genx = "0.4.0"
```

If you are not using Rust 2018 edition add this to your crate root:

`extern crate genx;`

### Why Genetic Algorithms

Genetic Algorithms are at the core of soft computing which is a branch of computing that comes to rescue when problem at hand is not feasible to be solved using hard computing. There are several advantages of genetic algorithms:

- Algorithms are adaptive and can adjust to the change of dynamic environment
- The approach makes use of approximate solutions to solve problems that may be either unsolvable or too time-consuming to solve with current hardware.
- Imprecise but usable solutions to complex computational problems allowing researchers to approach some problems that traditional computing cannot process.

## Modules

The `mutation`

module provides implementation of the
functions for various mutation schemes for binary encoded
and real value encoded individuals.

The `selection`

module provides implementation of the
functions to select a set of individuals out of the total
population to do crossover for generating new individuals.