Содержание:


Введение………………………………………………………………………………………… 3

I. Теоритические аспекты решения задач с помощью генетических алгоритмов. 4

1. Классический ГА.. 8

1.1 Постановка задачи и функция приспособленности. 8

1.2 Принцип работы ГА.. 10

1.3 Алгоритм работы.. 10

1.4 Отбор. 11

1.5 Скрещивание. 12

1.6 Мутация. 13

1.7 Критерии останова. 13

2.Преимущества и недостатки ГА.. 14

2.1 Преимущества ГА.. 14

2.2 Недостатки ГА.. 14

3. Некотoрые модели генетических алгоритмов. 15

3.1 Canonical GA (I. Holland) 15

3.2 Genitor (D.Whitley) 15

3.3 Hybrid algorithm (L. “Dave” Davis) 16

3.4 Island Models GA.. 16

3.5 CHC (Eshelman) 17

 II. Пример практической реализации генетического алгоритма. 19

1.1 Математическое обоснование принципа работы программы.. 19

1.2 Принцип работы программы.. 22

1.3 Листинг программы.. 30

 Заключение. 34

Список используемой литературы.. 35
Введение

 В настоящее время все более актуальными становятся задачи оптимизации, поиска, реализации распределенных и (или) параллельных систем. Многие из них легко реализуемы простыми математическими методами, но некоторые задачи требуют к себе особого подхода. Эти задачи либо не разрешимы простыми методами, либо их решение потребует значительного времени и объема ресурсов.

В процессе изучения различных подходов к решению таких задач выдвигается гипотеза что,  решение задач возможно с помощью генетических алгоритмов.[1]

Объектом изучения данной учебно-исследовательской  работы являются генетические алгоритмы.

Предметом изучения – применение генетических алгоритмов для нахождения решения задачи.

Задача данной учебно-исследовательской  работы состоит в изучении теоретического аспекта использования генетических алгоритмов, а так же  в практической реализации  задачи с использованием генетического алгоритма.
I.                 
Теоретические аспекты решения задач с помощью генетических алгоритмов

Природа поражает своей сложностью и богатством проявлений. Среди примеров можно назвать сложные социальные системы, иммунные и нейронные системы, сложные взаимосвязи между видами. Они - всего лишь некоторые из чудес, ставшие очевидными при глубоком исследовании природы вокруг нас. Наука - это одна из систем, которая объясняет окружающее и помогает приспособиться к новой информации, получаемой из внешней среды. Многое из того, что мы видим и наблюдаем, можно объяснить теорией эволюции через наследственность, изменение и отбор.[2]

На мировоззрение людей сильно повлияла теория эволюции Чарльза Дарвина, представленная в работе "Происхождение Видов", в 1859 году. Множество областей научного знания многим обязана революции, вызванной теорией эволюции и развития. Но Дарвин, подобно многим современникам, предполагающим, что в основе развития лежит естественный отбор, не мог не ошибаться. Например, он не смог показать механизм наследования, при котором поддерживается изменчивость. Однако Дарвин обнаружил главный механизм развития: отбор в соединении с изменчивостью. Во многих случаях, специфические особенности развития через изменчивость и отбор все еще не бесспорные, однако, основные механизмы объясняют невероятно широкий спектр явлений, наблюдаемые в природе.

Поэтому не удивительно, что ученые, занимающиеся компьютерными исследованиями, в поисках вдохновения обратились к теории эволюции. Возможность того, что вычислительная система, наделенная простыми механизмами изменчивости и отбора, могла бы функционировать по аналогии с законами эволюции в естественных системах, была очень привлекательной. Эта надежда является причиной появления ряда вычислительных систем, построенных на принципах естественного отбора.[3]

История эволюционных вычислений началась с разработки ряда разных независимых моделей. Основными из них были генетические алгоритмы и классификационные системы Голанда (Holland), разработанные в начале 60-х годов. После выхода книги, ставшей классикой - "Адаптация в естественных и искусственных системах" ("Adaptation in Natural and Artifical Systems", 1975), направление получило общее признание.[4] 

Главная трудность при построении вычислительных систем, основанных на принципах естественного отбора и применении этих систем в прикладных задачах, состоит в том, что естественные системы довольно хаотичные, а все наши действия, фактически, носят четкую направленность. Мы используем компьютер как инструмент для решения определенных задач, что мы сами и формулируем, и акцентируем внимание на максимально быстром выполнении при минимальных затратах. Естественные системы не имеют таких целей или ограничений, во всяком случае, нам они не известны. Выживание в природе не направлено к фиксированной цели, вместо этого эволюция делает шаг вперед в любом доступном направлении. Возможно это большое обобщение, но усилия, направленные на моделирование эволюции по аналогии с естественными системами можно разбить на две больших категории:

1.     системы, смоделированные на биологических принципах. Они успешно используются для задач функциональной оптимизации и могут легко быть описаны небиологическим языком;

2.     системы, которые биологически более правдоподобны, но на практике неэффективными. Они больше похожи на биологические системы, имеют сложное и интересное поведение, и, наверняка, в ближайшем будущем получат практическое применение.

Конечно, на практике нельзя разделять эти вещи так строго. Эти категории - просто два полюса, между которыми лежат разные вычислительные системы. Ближе к первому полюсу - эволюционные алгоритмы, такие как Эволюционное Программирование (Evolutionary Programming), Генетические Алгоритмы (Genetic Algorithms) и Эволюционные Стратегии (Evolution Strategies). Ближе ко второму полюсу - системы, которые могут быть классифицированы как Искусственная Жизнь (Artificial Life).[5]

Генетические алгоритмы являются частью группы методов, называемой эволюционными вычислениями, которые объединяют различные варианты использования эволюционных принципов для достижения поставленной цели.

Также в ней выделяют следующие направления:

·        Эволюционные стратегии

o       Метод оптимизации, основанный на идеях адаптации и эволюции. Степень мутации в данном случае меняется со временем – это приводит к, так называемой, самоадаптации.

·        Генетическое программирование

o       Применение эволюционного подхода к популяции программ.

·        Эволюционное программирование

o       Было впервые предложено Л.Дж. Фогелем в 1960 году для моделирования эволюции как процесса обучения с целью создания искусственного интеллекта. Он использовал конечные автоматы, предсказывающие символы в цифровых последовательностях, которые, эволюционируя, становились более приспособленными к решению поставленной задачи.[6]


Генетические алгоритмы применяются для решения следующих задач:

·        Оптимизация функций

·        Оптимизация запросов в базах данных

·        Разнообразные задачи на графах (задача коммивояжера, раскраска, нахождение паросочетаний)

·        Настройка и обучение искусственной нейронной сети

·        Задачи компоновки

·        Составление расписаний

·        Игровые стратегии

·        Аппроксимация функций

·        Искусственная жизнь

·        Биоинформатика [7]

II. Практическая часть реализации генетических алгоритмов

В данной учебно-исследовательской работе приведен пример программы использующей генетический алгоритм. Программа создана посредством среды программирования С++. Алгоритм компонента представляет собой применение методов, известных в теории эволюции, для эвристического поиска решений переборных задач.
1. Математическое обоснование принципа работы программы
Проверим эффективность работы генетических алгоритмов на примере нахождения значений коэффициентов неизвестных в Диофа́нтовом уравнении.

 Диофа́нтово уравнение или уравнение в целых числах — это уравнение с целыми коэффициентами и неизвестными, которые могут принимать только целые значения. Названы в честь древнегреческого математика Диофанта.[26]

Рассмотрим диофантово уравнение: a+2b+3c+4d=30, где a, b, c и d - некоторые положительные целые. Применение ГА за очень короткое время находит искомое решение (a, b, c, d).

Архитектура ГА-систем позволяет найти решение быстрее за счет более 'осмысленного' перебора. Мы не перебираем все подряд, но приближаемся от случайно выбранных решений к лучшим.

Для начала выберем 5 случайных решений: 1 =< a,b,c,d =< 30. Вообще говоря, мы можем использовать меньшее ограничение для b,c,d, но для упрощения пусть будет 30.


Таблица 1: 1-е поколение хромосом и их содержимое
Чтобы вычислить коэффициенты выживаемости (fitness), подставим каждое решение в выражение a+2b+3c+4d. Расстояние от полученного значения до 30 и будет нужным значением.



Таблица 2: Коэффициенты выживаемости первого поколения хромосом (набора решений)
Так как меньшие значения ближе к 30, то они более желательны. В нашем случае большие численные значения коэффициентов выживаемости подходят, увы, меньше. Чтобы создать систему, где хромосомы с более подходящими значениями имеют большие шансы оказаться родителями, мы должны вычислить, с какой вероятностью (в %) может быть выбрана каждая. Одно решение заключается в том, чтобы взять сумму обратных значений коэффициентов, и исходя из этого вычислять проценты. (Заметим, что все решения были сгенерированы Генератором Случайных Чисел - ГСЧ)

Таблица 3: Вероятность оказаться родителем

Для выбора 5-и пар родителей (каждая из которых будет иметь 1 потомка, всего - 5 новых решений), представим, что у нас есть 10000-стонняя игральная кость, на 880 сторонах отмечена хромосома 1, на 3080 - хромосома 2, на 2640 сторонах - хромосома 3, на 556 - хромосома 4 и на 2640 сторонах отмечена хромосома 5. Чтобы выбрать первую пару кидаем кость два раза и выбираем выпавшие хромосомы. Таким же образом выбирая остальных, получаем:

Таблица 4: Симуляция выбора родителей
Каждый потомок содержит информацию о генах и отца и от матери. Вообще говоря, это можно обеспечить различными способами, однако в нашем случае можно использовать т.н. "кроссовер" (cross-over). Пусть мать содержит следующий набор решений: a1,b1,c1,d1, а отец - a2,b2,c2,d2, тогда возможно 6 различных кроссоверов (| = разделительная линия):



Таблица 5: Кроссоверы между родителями
Есть достаточно много путей передачи информации потомку, и кроссовер - только один из них. Расположение разделителя может быть абсолютно произвольным, как и то, отец или мать будут слева от черты.

А теперь попробуем проделать это с нашими потомками


Таблица 6: Симуляция кросс-оверов хромосом родителей
Теперь мы можем вычислить коэффициенты выживаемости (fitness) потомков.

Таблица 7: Коэффициенты выживаемости потомков (fitness)
Средняя приспособленность (fitness) потомков оказалась 38.8, в то время как у родителей этот коэффициент равнялся 59.4. Следующее поколение может мутировать. Например, мы можем заменить одно из значений какой-нибудь хромосомы на случайное целое от 1 до 30.

Продолжая таким образом, одна хромосома в конце концов достигнет коэффициента выживаемости 0, то есть станет решением.     

Системы с большей популяцией (например, 50 вместо 5-и сходятся к желаемому уровню (0) более быстро и стабильно.[27]
1.
1
 
Принцип работы программы
Oбранимся к теоретическим пояснениям в практической реализации данной задачи в среде программирования С++ :

Первым делом посмотрим на заголовок класса:
#include <stdlib.h>
#include <time.h>
#define MAXPOP 25
struct gene {
   int alleles[4];
   int fitness;
   float likelihood;
   // Test for equality.
   operator==(gene gn) {
      for (int i=0;i<4;i++) {
         if (gn.alleles[i] != alleles[i]) return false;
      }
      return true;
   }
};
class CDiophantine {
   public:
      CDiophantine(int, int, int, int, int);
      int Solve();
      // Returns a given gene.
      gene GetGene(int i) { return population[i];}
   protected:
      int ca,cb,cc,cd;
      int result;
      gene population[MAXPOP];
      int Fitness(gene &);
      void GenerateLikelihoods();
      float MultInv();inverse.
      int CreateFitnesses();
      void CreateNewPopulation();

      int GetIndex(float val);
      gene Breed(int p1, int p2);
};
Существуют две структуры: gene и класс CDiophantine. gene используется для слежения за различными наборами решений. Создаваямая популяция - популяция ген. Эта генетическая структура отслеживает свои коэффициенты выживаемости и вероятность оказаться родителем. Также есть небольшая функция проверки на равенство.
Теперь по функциям:
Fitness function
Вычисляет коэффициент выживаемости (приспособленности - fitness) каждого гена. В нашем случае это - модуль разности между желаемым результатом и полученным значением. Этот класс использует две функции: первая вычисляет все коэффициенты, а вторая – поменьше - вычисляет коэффициент для какого-то одного гена.
int CDiophantine::Fitness(gene &gn) {
   int total = ca * gn.alleles[0] + cb * gn.alleles[1]
             + cc * gn.alleles[2] + cd * gn.alleles[3];
   return gn.fitness = abs(total - result);
}
int CDiophantine::CreateFitnesses() {
   float avgfit = 0;
   int fitness = 0;
   for(int i=0;i<MAXPOP;i++) {
      fitness = Fitness(population[i]);
      avgfit += fitness;
      if (fitness == 0) {
         return i;
      }
   }
  

   return 0;
}
Заметим, что если fitness = 0, то найдено решение - возврат. После вычисления приспособленности (fitness) нам нужно вычислить вероятность выбора этого гена в качестве родительского.

Likelihood functions

Как и было объяснено, вероятность вычисляется как сумма обращенных коэффициентов, деленная на величину, обратную к коэффициенту данному значению. Вероятности кумулятивны (складываются), что делает очень легким вычисления с родителями. Например:


В программе, при одинаковых начальных значениях, вероятности сложатся: представьте их в виде кусков пирога. Первый ген - от 0 до 8.80%, следующий идет до 39.6% (так как он начинает 8.8). Таблица вероятностей будет выглядеть приблизительно так:





Последнее значение всегда будет 100. Имея в нашем арсенале теорию, посмотрим на код. Он очень прост: преобразование к float необходимо для того, чтобы избегать целочисленного деления. Есть две функции: одна вычисляет smi, а другая генерирует вероятности оказаться родителем.
float CDiophantine::MultInv() {
   float sum = 0;
   for(int i=0;i<MAXPOP;i++) {
      sum += 1/((float)population[i].fitness);
   }

   return sum;
}

void CDiophantine::GenerateLikelihoods() {
   float multinv = MultInv();
   float last = 0;
   for(int i=0;i<MAXPOP;i++) {
      population[i].likelihood = last
      = last + ((1/((float)population[i].fitness) / multinv) * 100);
   }
}
Итак, у нас есть и коэффициенты выживаемости (fitness) и необходимые вероятности (likelihood). Можно переходить к размножению (breeding).

Breeding Functions

Функции размножения состоят из трех: получить индекс гена, отвечающего случайному числу от 1 до 100, непосредственно вычислить кроссовер двух генов и главной функции генерации нового поколения. Рассмотрим все эти функции одновременно и то, как они друг друга вызывают. Вот главная функция размножения:
void CDiophantine::CreateNewPopulation() {
   gene temppop[MAXPOP];
   for(int i=0;i<MAXPOP;i++) {
      int parent1 = 0, parent2 = 0, iterations = 0;
      while(parent1 == parent2 || population[parent1]
            == population[parent2]) {
         parent1 = GetIndex((float)(rand() % 101));
         parent2 = GetIndex((float)(rand() % 101));
         if (++iterations > (MAXPOP * MAXPOP)) break;

      }

      temppop[i] = Breed(parent1, parent2);  // Create a child.
   }

   for(i=0;i<MAXPOP;i++) population[i] = temppop[i];
}
Итак, первым делом мы создаем случайную популяцию генов. Затем делаем цикл по всем генам. Выбирая гены, мы не хотим, чтобы они оказались одинаковы (ни к чему скрещиваться с самим собой,  и вообще - нам не нужны одинаковые гены (operator = в gene). При выборе родителя, генерируем случайное число, а затем вызываем GetIndex. GetIndex использует идею кумулятивности вероятностей (likelihoods), она просто делает итерации по всем генам, пока не найден ген, содержащий число:
   int CDiophantine::GetIndex(float val) {
   float last = 0;
   for(int i=0;i<MAXPOP;i++) {
      if (last <= val && val <= population[i].likelihood) return i;
      else last = population[i].likelihood;
   }

   return 4;
}
Возвращаясь к функции CreateNewPopulation(): если число итераций превосходит MAXPOP2, она выберет любых родителей. После того, как родители выбраны, они скрещиваются: их индексы передаются вверх на функцию размножения (Breed). Breed function возвращает ген, который помещается во временную популяцию. Вот код:
gene CDiophantine::Breed(int p1, int p2) {

   int crossover = rand() % 3+1;
   int first = rand() % 100;
   gene child = population[p1];
   int initial = 0, final = 3;
   if (first < 50) initial = crossover;
   else final = crossover+1;
   for(int i=initial;i<final;i++) {
      child.alleles[i] = population[p2].alleles[i];
      if (rand() % 101 < 5) child.alleles[i] = rand() % (result + 1);
   }
  return child;
}
В конце концов мы определим точку кроссовера. Заметим, что мы не хотим, чтобы кроссовер состоял из копирования только одного родителя. Сгенерируем случайное число, которое определит наш кроссовер. Остальное понятно и очевидно. Добавлена маленькая мутация, влияющая на скрещивание. 5% - вероятность появления нового числа.

Теперь уже можно взглянуть на функцию Solve(),которая возвратит аллель, содержащую решение. Она всего лишь итеративно вызывает вышеописанные функции. Заметим, что мы присутствует проверка: удалось ли функции получить результат, используя начальную популяцию. Это маловероятно, однако лучше проверить.
int CDiophantine::Solve() {
  int fitness = -1;
  // Generate initial population.
  srand((unsigned)time(NULL));
  for(int i=0;i<MAXPOP;i++) {
    for (int j=0;j<4;j++) {
      population[i].alleles[j] = rand() % (result + 1);
    }
  }
  if (fitness = CreateFitnesses()) {
    return fitness;
  }
  int iterations = 0;
  while (fitness != 0 || iterations < 50) {
    GenerateLikelihoods();
    CreateNewPopulation();
    if (fitness = CreateFitnesses()) {
      return fitness;
    }

    iterations++;
  }

  return -1;
}
Описание завершено.
2.
Листинг

программы

#include <stdlib.h>

#include <time.h>

#include <iostream.h>
#define MAXPOP  25
struct gene {

            int alleles[4];

            int fitness;

            float likelihood;
            // Test for equality.

            operator==(gene gn) {

                        for (int i=0;i<4;i++) {

                                   if (gn.alleles[i] != alleles[i] }

 return false;

                        }
                        return true;

            }

};
class CDiophantine {

            public:

                        CDiophantine(int, int, int, int, int);                     // Constructor with coefficients for a,b,c,d.

                        int Solve();                                                                              // Solve the equation.

                       

                        // Returns a given gene.

                        gene GetGene(int i) { return population[i];}
            protected:

                        int ca,cb,cc,cd;                                                           // The coefficients.

                        int result;

                        gene population[MAXPOP];                                                   // Population.
                        int Fitness(gene &);                                                                 // Fitness function.

                        void GenerateLikelihoods();                                                    // Generate likelihoods.

                        float MultInv();                                    // Creates the multiplicative inverse.

                        int CreateFitnesses();

                        void CreateNewPopulation();

                        int GetIndex(float val);
                        gene Breed(int p1, int p2);
};
CDiophantine::CDiophantine(int a, int b, int c, int d, int res) : ca(a), cb(b), cc(c), cd(d), result(res) {}
int CDiophantine::Solve() {

            int fitness = -1;
            // Generate initial population.

            srand((unsigned)time(NULL));
            for(int i=0;i<MAXPOP;i++) {             // Fill the population with numbers between

                        for (int j=0;j<4;j++) {                                                             // 0 and the result.

                                   population[i].alleles[j] = rand() % (result + 1);

                        }

            }
            if (fitness = CreateFitnesses()) {

                        return fitness;

            }
            int iterations = 0;                                                         // Keep record of the iterations.

            while (fitness != 0 || iterations < 50) {// Repeat until solution found, or over 50 iterations.

                        GenerateLikelihoods();                                    // Create the likelihoods.

                        CreateNewPopulation();

                        if (fitness = CreateFitnesses()) {

                                   return fitness;

                        }

                       

                        iterations++;

            }
            return -1;

}
int CDiophantine::Fitness(gene &gn) {

            int total = ca * gn.alleles[0] + cb * gn.alleles[1] + cc * gn.alleles[2] + cd * gn.alleles[3];
            return gn.fitness = abs(total - result);

}
int CDiophantine::CreateFitnesses() {

            float avgfit = 0;

            int fitness = 0;

            for(int i=0;i<MAXPOP;i++) {

                        fitness = Fitness(population[i]);

                        avgfit += fitness;

                        if (fitness == 0) {

                                   return i;

                        }

            }

           

            return 0;

}
float CDiophantine::MultInv() {

            float sum = 0;
            for(int i=0;i<MAXPOP;i++) {

                        sum += 1/((float)population[i].fitness);

            }
            return sum;

}
void CDiophantine::GenerateLikelihoods() {

            float multinv = MultInv();
            float last = 0;

            for(int i=0;i<MAXPOP;i++) {

            population[i].likelihood = last = last + ((1/((float)population[i].fitness) / multinv) * 100);

            }

}
int CDiophantine::GetIndex(float val) {

            float last = 0;

            for(int i=0;i<MAXPOP;i++) {

                        if (last <= val && val <= population[i].likelihood) return i;

                        else last = population[i].likelihood;

            }

           

            return 4;

}
gene CDiophantine::Breed(int p1, int p2) {

            int crossover = rand() % 3+1;              // Create the crossover point (not first).

            int first = rand() % 100;                                                          // Which parent comes first?
            gene child = population[p1];                                        // Child is all first parent initially.
            int initial = 0, final = 3;                                                 // The crossover boundaries.

            if (first < 50) initial = crossover;                       // If first parent first. start from crossover.

            else final = crossover+1;                                                         // Else end at crossover.
            for(int i=initial;i<final;i++) {                                                     // Crossover!

                        child.alleles[i] = population[p2].alleles[i];

                        if (rand() % 101 < 5) child.alleles[i] = rand() % (result + 1);

            }
            return child;                                                                                        // Return the kid...

}
void CDiophantine::CreateNewPopulation() {

            gene temppop[MAXPOP];
            for(int i=0;i<MAXPOP;i++) {

                        int parent1 = 0, parent2 = 0, iterations = 0;

                        while(parent1 == parent2 || population[parent1] == population[parent2]) {

                                   parent1 = GetIndex((float)(rand() % 101));

                                   parent2 = GetIndex((float)(rand() % 101));

                                   if (++iterations > 25) break;

                        }

                       

                        temppop[i] = Breed(parent1, parent2);                        // Create a child.

            }
            for(i=0;i<MAXPOP;i++) population[i] = temppop[i];

}
void main() {
            CDiophantine dp(1,2,3,4,30);
            int ans;

            ans = dp.Solve();

            if (ans == -1) {

                        cout << "No solution found." << endl;

            } else {

                        gene gn = dp.GetGene(ans);
                        cout << "The solution set to a+2b+3c+4d=30 is:\n";

                        cout << "a = " << gn.alleles[0] << "." << endl;

                        cout << "b = " << gn.alleles[1] << "." << endl;

                        cout << "c = " << gn.alleles[2] << "." << endl;

                        cout << "d = " << gn.alleles[3] << "." << endl;

            }

}
Заключение
Мы с вами проделали большой путь, открывая для себя генетические алгоритмы, их, казалось бы, тривиальную и одновременно с этим гениальную идею, взятую из природы.  По окончанию работы можно сделать выводы о том, что: во-первых, генетические алгоритмы являются универсальным методом оптимизации многопараметрических функций, что позволяет решать широкий спектр задач; во-вторых, они имеют множество модификаций и сильно зависят от параметров. Зачастую небольшое изменение одного из них может привести к неожиданному улучшению результата.  Но следует помнить, что применение ГА полезно лишь в тех случаях, когда для данной задачи нет подходящего специального алгоритма решения.

Несмотря на небольшое количество задач в данной научно-исследовательской работе, которое мы с вами рассмотрели: решение Диофантова уравнения и задачу коммивояжера, мы полностью подтверждаем гипотезу. Задачи оптимизации  успешно решаются при помощи генетических алгоритмов.
Список используемой литературы
1.     http://www.basegroup.ru/download/genebase.htm

2.     http://www.basegroup.ru/genetic/math.htm

3.     http://saisa.chat.ru/ga.html

4.     http://algolist.manual.ru/ai/ga/ga1.php

5.     http://www.ai.tsi.lv/ru/ga/ga_intro.html

6.     http://port33.ru/users/acp/articles/Genetic_algorithms/index.html

7.     http://paklin.newmail.ru/mater/gene_net.html

8.     http://www.iki.rssi.ru/ehips/genetic.htm

9.     http://fdmhi.mega.ru/ru/senn_ga.htm

10.                 http://www.vspu.ru/public_html/cterra/20.html

11.                 http://www.chat.ru/~saisa

12.                 http://www.xakep.ru/post/18589/default.asp

13.                 http://g-u-t.chat.ru/ga/oper.htm

14.                 http://iissvit.narod.ru/rass/vip4.htm

15.                 http://www.nestor.minsk.by/kg/index.html

16.                 http://algo.ekaboka.com/algo-rus/index.htm

17.                 http://www.neuroproject.ru

18.                 http://math.nsc.ru/AP/benchmarks/UFLP/uflp_ga.html

19.                 http://www.interface.ru/home.asp?artId=8109

20.                 http://algolist.ru/ai/ga/dioph.php

21.                 http://ru.wikipedia.org/wiki/Диофантово_уравнение

---