.. _method-moga-crossover_type:

""""""""""""""
crossover_type
""""""""""""""


Select a crossover type for JEGA methods


.. toctree::
   :hidden:
   :maxdepth: 1

   method-moga-crossover_type-multi_point_binary
   method-moga-crossover_type-multi_point_parameterized_binary
   method-moga-crossover_type-multi_point_real
   method-moga-crossover_type-shuffle_random
   method-moga-crossover_type-crossover_rate


**Specification**

- *Alias:* None

- *Arguments:* None

- *Default:* shuffle_random


**Child Keywords:**

+-------------------------+--------------------+--------------------------------------+-----------------------------------------------+
| Required/Optional       | Description of     | Dakota Keyword                       | Dakota Keyword Description                    |
|                         | Group              |                                      |                                               |
+=========================+====================+======================================+===============================================+
| Required (Choose One)   | Crossover Type     | `multi_point_binary`__               | Use bit switching for crossover events        |
|                         |                    +--------------------------------------+-----------------------------------------------+
|                         |                    | `multi_point_parameterized_binary`__ | Use bit switching to crossover each design    |
|                         |                    |                                      | variable                                      |
|                         |                    +--------------------------------------+-----------------------------------------------+
|                         |                    | `multi_point_real`__                 | Perform crossover in real valued genome       |
|                         |                    +--------------------------------------+-----------------------------------------------+
|                         |                    | `shuffle_random`__                   | Perform crossover by choosing design          |
|                         |                    |                                      | variable(s)                                   |
+-------------------------+--------------------+--------------------------------------+-----------------------------------------------+
| Optional                                     | `crossover_rate`__                   | Specify the probability of a crossover event  |
+----------------------------------------------+--------------------------------------+-----------------------------------------------+

.. __: method-moga-crossover_type-multi_point_binary.html
__ method-moga-crossover_type-multi_point_parameterized_binary.html
__ method-moga-crossover_type-multi_point_real.html
__ method-moga-crossover_type-shuffle_random.html
__ method-moga-crossover_type-crossover_rate.html



**Description**


There are many crossover types available. ``multi_point_binary``
crossover requires an integer number, N, of crossover points. This
crossover type performs a bit switching crossover at N crossover
points in the binary encoded genome of two designs. Thus, crossover
may occur at any point along a solution chromosome (in the middle of a
gene representing a design variable, for example).
``multi_point_parameterized_binary`` crossover is similar in that it
performs a bit switching crossover routine at N crossover points.
However, this crossover type performs crossover on each design
variable individually. So the individual chromosomes are crossed at N
locations.  ``multi_point_real`` crossover performs a variable
switching crossover routing at N crossover points in the real real
valued genome of two designs. In this scheme, crossover only occurs
between design variables (chromosomes). Note that the standard
solution chromosome representation in the JEGA algorithm is real
encoded and can handle integer or real design variables. For any
crossover types that use a binary representation, real variables are
converted to long integers by multiplying the real number by 10^6 and
then truncating. Note that this assumes a precision of only six
decimal places. Discrete variables are represented as integers
(indices within a list of possible values) within the algorithm and
thus require no special treatment by the binary operators.

The final crossover type is ``shuffle_random``. This crossover type
performs crossover by choosing design variables at random from a
specified number of parents enough times that the requested number of
children are produced. For example, consider the case of 3 parents
producing 2 children. This operator would go through and for each
design variable, select one of the parents as the donor for the child.
So it creates a random shuffle of the parent design variable values.
The relative numbers of children and parents are controllable to allow
for as much mixing as desired. The more parents involved, the less
likely that the children will wind up exact duplicates of the parents.

All crossover types take a ``crossover_rate``. The crossover rate is
used to calculate the number of crossover operations that take place.
The number of crossovers is equal to the rate * population_size.


