Public Function ToRoman(ByVal vnNumber As Integer) As String
Do While vnNumber >= 1000
ToRoman = ToRoman & “M”
vnNumber = vnNumber - 1000
Loop
If vnNumber >= 900 Then
ToRoman = ToRoman & “CM”
vnNumber = vnNumber - 900
End If
If vnNumber >= 500 Then
ToRoman = ToRoman & “D”
vnNumber = vnNumber - 500
ElseIf vnNumber >= 400 Then
ToRoman = ToRoman & “CD”
vnNumber = vnNumber - 400
End If
Do While vnNumber >= 100
ToRoman = ToRoman & “C”
vnNumber = vnNumber - 100
Loop
If vnNumber >= 90 Then
ToRoman = ToRoman & “XC”
vnNumber = vnNumber - 90
End If
If vnNumber >= 50 Then
ToRoman = ToRoman & “L”
vnNumber = vnNumber - 50
ElseIf vnNumber >= 40 Then
ToRoman = ToRoman & “XL”
vnNumber = vnNumber - 40
End If
Do While vnNumber >= 10
ToRoman = ToRoman & “X”
vnNumber = vnNumber - 10
Loop
If vnNumber = 9 Then
ToRoman = ToRoman & “IX”
Else
If vnNumber >= 5 Then
ToRoman = ToRoman & “V”
vnNumber = vnNumber - 5
End If
If vnNumber = 4 Then
ToRoman = ToRoman & “IV”
Else
Do While vnNumber >= 1
ToRoman = ToRoman & “I”
vnNumber = vnNumber - 1
Loop
End If
End If
End Function

Sieve is called because, first of all the numbers denote a prime and gradually “prosivame” so that eventually we, metaphorically speaking, made up numbers (neprvocisla) remain below the screen and the prime sieve.

Data network can save the prime example in this field:

var ErastSito: Array of Boolean;

Fields can do so much as we need. So, if we want to identify prime numbers from 0 to 200, so the field will be 201 spaces. (Indexed array count from 0) array index tells us the number and value of logic tells us whether it is a prime number. True, therefore indicates that this is a prime, False, it is not a prime number.

First, all the numbers in the desired range as a prime mark. Specifically, here you fill the same amount of field ErastSito True.

Gradually, we take the numbers from the lowest ranks, of which we know are primes. We take the lowest number, which we know absolutely that it is prime. Then mark all the multiples of other numbers as neprvocisla. Then proceed to the next lowest prime number, and again denote all other multiples of the neprvocisla. Thus we go through the entire field and finally we left with only prime numbers. Algorithm is still treated in the direction of the prime, which is able to throw one of your times, has a linking requirement Prime-2 * <= range. The range is the maximum number verified. It’s understandable, because the first number that would be a multiple of prime numbers, it was number 2 * prime, and if this number was outside the scope of survey, so I throw anything on the basis of this can not be prime. Moreover, we must avoid endless browsing field.
Example

Specifically, we start by the number 2 The numbers 0 and 1, we know that they are not prime, so he is right on the mark as a false start. We know that the closest any other number, starting with 2, we have taken out of storage, is 100% prime. So we take this field and the lowest prime ErastSito discarded as prime all multiples.

For example, a field from 0 to 17 after passing SITEM Prime 2 will be as follows:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Then go to the next lowest prime number that is greater than 2 It consists of a number 3 And again, we throw away the box (set to False) all of its multiples.

Field from 0 to 17 after passing SITEM Prime 2, 3 will look for more “simple”:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Then we have the number 4, but it is labeled as a composite number (not prime), so we have to find another the next higher prime number. Is it 5, and again you mark all the multiples of 5 as neprvocisla. In this way the primes are thin and eventually left with only prime numbers.

Truth Table

Statements that are equal (tautology)

Implication

Negation of complex utterances

Note: “!” means not, or negation

For example: If we have the “It’s twice,” this can be interpreted as:

Equation 1

This is also valid for Boolean functions (returning a value of True or False). For example, the function is greater than “can be interpreted as

Equation 2

To solve a problem as a solution requiring only know which number is bigger, it is more efficient to use the mathematical algorithm directly.

However, these were not applicable to problems having some of these features:

The representative function of the problem is not continuous. In this case it is not computable. Genetic algorithms can work with all types of functions, and to find an acceptable minimum if you can not find the optimum.

The representative function is dynamic: The ratio of variable changes depending on the values that make them. This relationship can be noticed or not. Type rules

• “X equals Y if the value of X is small;
• X is 1.5, and if the value of X is large
• not know what happens to average values of X “

can not be converted into an algebraic algorithm since there are missing values. Unlike a traditional algorithm, a genetic algorithm can be designed to work under these conditions.
Genetic algorithms and enumerative methods

There is a theoretical possibility of finding solutions to optimization problems by enumerating all possible solutions for all cases and then looking for the same in the resulting database. The problems are then limited to a system of efficient search of the case. For example, books with traditional log tables consist of a long series of calculations for all usual values. The solution is simply to search the list and return the decimal number as the log.

Memorizing multiplication tables are taught to children is another common example. It is expected that when asked how much is seven times five? children respond instantly “35″ without having to mentally calculate multiplication.

This method is feasible provided that the number of values to be manageable. Otherwise the same simple calculation becomes impossible. Example: Generate a table containing all the moves of all possible games of checkers would be impossible in practice.

The “memory” of a set of data is not nothing but construction in memory equivalent to a database that seeks to question and automatically finds the answer.

Genetic algorithms use heuristics to solve problems, which severely limits the number of data to use.

• Your search space (ie, possible solutions) should be bounded within a certain range.
• Must be able to define a fitness function that tells us how good or bad a certain response.
• The solutions must be encoded in a manner that is relatively easy to implement on the computer.

The first point is very important, and it is best to try to solve problems with discrete search spaces even though they are very large. However, you can also try using the technique with continuous search spaces, but preferably where there is a relatively small range of solutions.

The fitness function is simply the objective function of our optimization problem. The genetic algorithm only maximized, but can be easily minimized by using the reciprocal of the function maximizing (be careful, of course, that the reciprocal of the function does not generate a division by zero). One feature that should have this feature is that it be able to “punish” bad solutions, and to “reward” for good, so are the latter which spread more quickly.

The most common encoding of the solutions is by binary strings, although they have also used real numbers and letters. The first of these schemes has enjoyed much popularity because it is the Holland originally proposed, and because it is very easy to implement.

The general rule for building a good objective function is queesta should reflect the value of individual in a “real”, but in many combinatorial optimization problems, where there are lots of restrictions, many of the points in the search space represented such individuals are not valid.

For this approach in which individuals are subject to restrictions have been proposed several solutions. The first would be what might be termed absolute, in which those in- viduals who do not check the restrictions are not considered as such and are still made crossover and mutation to obtain valid individuals or such individuals are assigned a objective function equal to zero.

Another possibility is to rebuild those individuals who do not check the restrictions. This reconstruction is usually performed by a new operator that used to be called sleep.

Another approach is based on the penalization of the objective function. The general idea is dividing the objective function of the individual by an amount (the penalty) it relates to that such restrictions violate individual. This amount can simply take into account the number of constraints well known violadaso expected cost of reconstruction, ie . Cost associated with the conversion of that individual in another that does not violate any restriction.

Another technique that has been used in cases where the computation of the objective function very complex is called approximate evaluation of the objective function. In some cases 0n obtaining approximate objective functions may be better than the exact evaluation
unaunica objective function (of course if the review is at least approximately n times faster than the exact evaluation).

A common problem in the execution of genetic algorithms arises because of the speed with which the algorithm converges. In some cases the convergence is very fast, often called premature convergence, in which the local haciaoptimos algorithm converges, while while in other cases the problem is just the opposite, ie there is a slow convergence algorithm. One possible solution to these problems is by making changes in the
objective function.

The problem of premature convergence, often arises when the selection of individuals is made in proportion to their objective function. If so, can existingtir individuals with an adaptation to the problem than the rest, which moves forward algorithm “dominate” the population. Through a transformation of the objective function in this case an understanding of the range of variation of the objective function, it is intended that these “Superindividuos” not come to dominate the population.

The problem of slow convergence of the algorithm, would be resolved similarly, but in this If making an expansion of the range of the objective function.

The idea of species of organisms, has been imitated in the design of genetic algorithms a method proposed by Goldberg and Richardson (1987), using a modification of the function objective of each individual, so that individuals who are very close to each other devalued its objective function, so that the population gains in diversity

The few assumptions required can handle very complex problems. The function to be optimized can be the result of a simulation.

The selection identifies statistically the best individuals of a population and eliminate the bad. Found in the literature a number of important principles for selecting more or less adapted to the problems they treat. As part of our work, the two selection principles listed below were tested and evaluated:

• Roulette wheel selection [ Gol89c ];
• Stochastic Remainder Without replacement selection [ Gol89c ];

The principle of Roulette wheel selection 2 is associated with each individual segment whose length is proportional to its fitness. We reproduce here the principle of random selection used in the wheels of casinos with a linear structure. These segments are then concatenated on an axis that is normalized between 0 and 1. It then draws a random number uniformly distributed between 0 and 1, then what is “ looking at”the selected segment. With this system, large segments, that is to say the right individuals will be addressed more often than small ones. When the population size is reduced, it is difficult to obtain in practice the expectation of selection because of the lack of prints. Selection bias is stronger or weaker depending on the size of the population.

The Stochastic Remainder Without replacement selection avoids this problem and gives good results for our applications. Describe this principle of selection:

• For each element i, we calculate the ratio r i of its fitness on the average fitness.
• Let e (r i) the integer part of r i, each element is reproduced exactly e (r i) times.
• Roulette wheel selection described above is applied to the affected individuals of fitness r i - e (r i).

Given the fact that small populations will be used later, this principle of selection is most effective in practical applications and will be used later.

For discrete problems, the mutation operator is usually to draw a random gene in the chromosome and replaced by a random value (see Figure-1 ). If the notion of distance exists, this value can be chosen in the vicinity of the initial value.

In the ongoing problems, the procedure is somewhat the same way by taking a random gene in the chromosome, plus a Gaussian noise generally. The standard deviation of this noise is difficult to choose a priori. We discuss this issue in more detail, presenting a primer solution, in Section

The figure below shows schematically an iteration of the GA to form two new individuals of a population of children. This step is repeated until the child population is complete.

The process of production of child populations is continued until a termination condition is met. As a termination condition is suitable, the number of calculated generations or the fitness value of population (average or best). If no improvement of fitness value higher, so the search be aborted.

]]> http://www.intelligenceunited.com/?feed=rss2&p=3286 http://www.intelligenceunited.com/?p=3283 http://www.intelligenceunited.com/?p=3283#comments Sat, 27 Nov 2010 04:13:31 +0000 admin http://www.intelligenceunited.com/?p=3283 Genetic algorithms are
among the stochastic search methods. This attempt on the basis of one or more
feasible solutions (points in the solution space / search space) to approach
step by step, the optimal solution.

GA work with a lot of
these points / acceptable solutions. This is also referred to as artificial
individuals.

All of the genetic
algorithms - Applications summarized examples were based on a simple
binary-coded GA programmed (JSGA: JAVA based Simple Genetic Algorithm). GA work
on the basis of artificial individuals that exist (according to the nature) of a
set of chromosomes and a fitness value. In nature, the fitness value must be a
complex quantity that really describes the adaptation of the individual to the
environment. It can also be a single variable (such as length, eye color ,..).
Depending on what is the subject of consideration. In the context of genetic
algorithms starts from the simple assumption that a link between the chromosomes
and the fitness value exists and that any change of the chromosome set in a
change of fitness value leads. If there are identical sets of chromosomes, the
same changes lead to the chromosome sets of identical fitness value changes. The
following comments relate to the application example, maximum search . Here, the
maximum of a 2-D function (y = f (x)) are determined using a genetic algorithm.
In the example, various functions can be selected. We want to refer to the
following examples of selection, crossover and mutation on the function F0 of
the application example (opposite).

In this simple case, an artificial individual consists only of a single
binary-coded x-value (from the domain of the function) and the associated y
value (y = f (x)).

The binary-coded x-value (xc-value) here plays the role of a chromosome, the
y-value the role of fitness value.
 

A lot of individuals is called population.
 

Coding


The underlying binary coded GA does not work with the real x-values, but with a
coded form. In this case, with a coding of each x-value in a sequence of
0 and 1 Here are some simple examples of the coding are given. For simplicity
here, assume a fixed length of 8 characters and of positive integers.