JCLEC core packages

From JCLEC wiki
Jump to: navigation, search

The structure of JCLEC core is organized in packages, that is, sets of classes and interfaces grouped by a specific criterion. In this page we describe the main packages in the JCLEC core.


This package contains all JCLEC interfaces.


This package contains base implementations to all interfaces defined in the net.sf.jclec package and other auxiliary classes largely used in the evolutionary algorithm library.


This package contains several implementations of the IFitness interface. The package contains also the definition for several classes that establish order relationships between IFitness objects (they implement the java.util.Comparator interface). Such objects are used in different algorithm phases like, for instance, parent selection or system update.


This package has implementations for several selection methods (implementations of the ISelector interface). At the present time, we have implementations for the next methods: roulette selection, Boltzmann selection, stochastic remaining selection, universal stochastic selection, range selection, tournament selection, NAM selection and UFS selection.


This package defines the necessary classes to implement binary encoded genetic algorithms. For instance, the BinArrayIndividual class defines individuals with a bits array as genotype. On the other hand, the BinArraySpecies class defines the structure of BinArrayIndividuals (its length and the schema that represent them). The package also has implementations for operators that work selectively over individuals with binary lineal genotype: one point, two points and uniform crossover, one allele and uniform mutation.


This package defines the IntArrayIndividual class that represents an individual with a list of integer values as genotype, and the IntArrayIndividualSpecies class, that represents this kind of individuals. It also contains the implementation for several operators that work with this type of individuals: one point, two points and uniform crossover, one allele and uniform mutators.


This package contains the necessary classes to implement a real coded genetic algorithm. It has the RealArrayIndividual class that represents an individual with a vector of real values as genotype. It also has the RealArrayIndividualSpecies class that defines the structure of a set of real encoded individuals (number of alleles and range of allowed values for each allele).

The package has some operators (creation of new individuals, crossover and mutation) that work specifically over this type of individuals. It has two-arided recombination operators (arithmetic, BGA linear, BLX-alpha, fuzzy, extended linear, extended fuzzy, SBX, UNDX and others) and mutation operators (random, not uniform, modal continuous, modal discrete and Muhlenbein mutation). It also has some multi-parent crossover operators (panmitic discrete, intermediate generalized, recombination of set of genes, recombination by mixing m-tuples, majority mix, half mix, uniform crossover, crossover based on occurrences and aptitude, diagonal crossover, mass center crossover, seed crossover, UNDX-n crossover) and crossover based on confidence intervals (CIXL1 and CIXL2).


This package defines a type of individual, called ExprTreeIndividual, that can be used in conventional and strongly typed genetic programming (GP) algorithms. The package also defines the ExprTreeIndividualSpecies class that defines the structure of a set of individuals of this type and operators to manipulate them in a consistent way: the branch crossover and branch mutation operators. Also, package contains other mutation operators (one node, all nodes, expand branch, truncate branch, promote node, demote node and gaussian) used in the implementation of evolutionary programming algorithms.


This package has an implementation for Grammar Based Genetic Programming (GBGP). In this paradigm, individuals have a syntax tree (that belongs to a user-defined grammar) as genotype. This grammar contributes to have a better control over the structure of individuals and over genetic operators. It lets incorporate knowledge about the problem domain and to bias the search toward the most appropriate regions of the search space. The package has implementations for typical operators (selective crossover, selective and directed mutation) and others proposed that have shown its utility in the resolution of some problems of symbolic regression.


This package has an implementation for Gene Expression Programming. In this paradigm, individuals present an integer lineal genotype that maps to an expression tree. This tree will be used in the evaluation of individuals. The package has the typical operators for the following paradigms: mutation, one point and two points recombination, gene recombination, gene transposition, IS transposition and RIS transposition. net.fs.jclec.ge

This package contains an implementation for Grammatical Evolution. In this paradigm, individuals contain a binary array as genotype that maps to a sequence of productions of a free-context grammar. The phenotype is obtained starting from the terminal symbol of the grammar and applying the change defined by the individual genotype. The package also has the typical genetic operators for this paradigm.

net.fs.jclec.algorithms and related packages

This package has an abstract implementation for the IAlgorithm interface and final implementations for several types of evolutionary algorithms. In the current version of JCLEC, the implemented algorithms are:

   * Classic algorithms: simple generational, steady state and CHC.
   * Multi-objective algorithms: NSGA-II and SPEA2.
   * Memetic algorithms: generational and steady state.
   * Scatter search algorithm.
   * Niching algorithms: clearing, sequential and fitness sharing.