Оригинальный DVD-ROM: eXeL@B DVD !
eXeL@B ВИДЕОКУРС !

ВИДЕОКУРС ВЗЛОМ
выпущен 12 ноября!


УЗНАТЬ БОЛЬШЕ >>
Домой | Статьи | RAR-cтатьи | FAQ | Форум | Скачать | Видеокурс
Новичку | Ссылки | Программирование | Интервью | Архив | Связь

AIChips2



//=============================================================================
//
// Любую дополнительную информацию по программным нейронным микросхемам вы
// всегда можете получить на сайте http://www.aimatrix.nm.ru
//
//===============================================//============================
                                                 //
unit AIChips2;                                   // модуль AIChips2
                                                 //
interface                                        // секция описания интерфейса
                                                 //
  uses Windows, SysUtils;                        // список используемых модулей
                                                 //
//===============================================//============================
//
// Вспомогательная структура для типа TAIselector
//
//===============================================//============================
                                                 //
  type TAIselectorItem = packed record           // структура элемента селектора
                                                 //
    Signal:     Integer;                         // . . . нервный сигнал
    Count:      DWord;                           // . . . повторяемость сигнала
                                                 //
  end;                                           // конец структуры
                                                 //
//===============================================//============================
//
// Тип TAIselector
//
//=============================================================================
//
// Селектор - это механизм выделения доминирующего нервного сигнала среди
// некоторого набора нервных сигналов. Селектор используется внутри ядра
// нейронной микросхемы, чтобы выделить доминирующий в дендритах или
// дендритных слоях сигнал.
//
//===============================================//============================
                                                 //
  type TAIselector = class(TObject)              // Тип TAIselector
                                                 //
  private                                        // ---------------------------
                                                 //
    FSignals:   Array of TAIselectorItem;        // нервные сигналы
                                                 //
  public                                         // ---------------------------
                                                 //
    destructor  Destroy; override;               // деструктор селектора
                                                 // ---------------------------
    function    Dominant:                        // получение доминирующего нервного сигнала
                Integer;                         // ..... возврат = доминирующий сигнал
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 // ---------------------------
    procedure   Memorize(                        // запоминание нервного сигнала
                Signal:         Integer);        // . . . сигнал
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  end;                                           // конец типа TAIselector
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Константы для типа TAIchip
//
//===============================================//============================
                                                 //
const                                            //
                                                 //
  NOSIGNAL  = 0;                                 // сигнал отсутствует
                                                 // ---------------------------
  NEGATIVE  = 1;                                 // признак "Отрицательные следствия"
  POSITIVE  = 2;                                 // признак "Положительные следствия"
  AVERAGE   = 4;                                 // признак "Среднеарифметическое следствие"
                                                 // ---------------------------
  MODE_IAN  = AVERAGE or NEGATIVE;               // режим "Среднеарифметическая интеграция отрицательных следствий"
  MODE_IAP  = AVERAGE or POSITIVE;               // режим "Среднеарифметическая интеграция положительных следствий"
  MODE_IAPN = AVERAGE or POSITIVE or NEGATIVE;   // режим "Среднеарифметическая интеграция всех следствий"
  MODE_IN   = NEGATIVE;                          // режим "Интеграция отрицательных следствий"
  MODE_IP   = POSITIVE;                          // режим "Интеграция положительных следствий"
  MODE_IPN  = POSITIVE or NEGATIVE;              // режим "Интеграция всех следствий"
                                                 //
//===============================================//============================
//
// Тип TAIchip
//
//=============================================================================
//
// Нейронная микросхема - базовый класс для создания всевозможных нейронных
// микросхем. В этом классе реализованы все необходимые методы
// по взаимодействию микросхем в нейронных схемах.
//
//===============================================//============================
                                                 //
  type TAIchip = class(TObject)                  // Тип TAIchip
                                                 //
    Name:       String;                          // имя микросхемы
    Relative:   Boolean;                         // признак "Значение нервного сигнала относительно"
    NewLayer:   Boolean;                         // признак "Новый дендритный слой"
    Mode:       Byte;                            // режим работы ядра микросхемы
                                                 //
  private                                        // ---------------------------
                                                 //
    FAxon:      Integer;                         // аксон
    FCore:      Integer;                         // ядро нервного сигнала
    FBusy:      Integer;                         // идентификатор занимающего процесса
    FDendrits:  Array of TAIchip;                // дендриты
    FOuts:      Array of TAIchip;                // микросхемы, подключенные к аксону
                                                 // ---------------------------
    procedure   RunChip(                         // выполнение функций микросхемы
                BusyID:         Integer);        // . . . идентификатор занимающего процесса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 // ---------------------------
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                virtual;                         // ..... можно перекрывать в наследуемых классах
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 // ---------------------------
    procedure   SetAxon(                         // установка нервного сигнала в аксоне
                Value:          Integer);        // . . . нервный сигнал
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  public                                         // ---------------------------
                                                 //
    constructor Create(                          // конструктор микросхемы
                chipName:       String);         // . . . имя создаваемой микросхемы
                virtual;                         // ..... можно перекрывать в наследуемых классах
                                                 // ---------------------------
    destructor  Destroy; override;               // деструктор микросхемы
                                                 // ---------------------------
    procedure   Connect(                         // подключение дендрита к аксону другой микросхемы
                chipBody:       TAIchip);        // . . . микросхема, к которой подключается дендрит
                                                 // ---------------------------
    function    Dangling:                        // получение признака "Повисший ли выход у микросхемы"
                Boolean;                         // ..... возврат = повисший выход или нет
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 // ---------------------------
    procedure   LogOut(                          // регистрация соединения аксона с дендритом другой микросхемы
                chipBody:       TAIchip);        // . . . микросхема, с которой регистрируется соединение
                                                 // ---------------------------
    procedure   Run;                             // запуск выполнения нейронной схемы
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 // ---------------------------
    property    Axon: Integer                    // свойство "Аксон микросхемы"
                read FAxon                       // . . . откуда берется значение
                write SetAxon;                   // . . . где сохраняется значение
                                                 //
  end;                                           // конец типа TAIchip
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Событие для типа TAIreceptor и TAIeffector
//
//===============================================//============================
                                                 //
  TAIevent    = procedure(                       // событие "Внешнее событие"
                chipBody:       TAIchip);        // . . . инициатор выполнения внешнего события
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
//===============================================//============================
//
// Тип TAIreceptor
//
//=============================================================================
//
// Рецептор - микросхема, с помощью которой раздражающий нервный сигнал
// поступает из внешней среды в нейронную схему. Передача сигнала
// осуществляется при помощи внешней процедуры.
//
//===============================================//============================
                                                 //
  type TAIreceptor = class(TAIchip)              // Тип TAIreceptor
                                                 //
    Operation:  TAIevent;                        // внешняя процедура
                                                 //
  private                                        // ---------------------------
                                                 //
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  end;                                           // конец типа TAIreceptor
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Тип TAIeffector
//
//=============================================================================
//
// Эффектор - микросхема, передающая нервный сигнал из нейронной схемы во
// внешнюю среду. Передача сигнала осуществляется при помощи внешней
// процедуры.
//
//===============================================//============================
                                                 //
  type TAIeffector = class(TAIchip)              // Тип TAIeffector
                                                 //
    Operation:  TAIevent;                        // внешняя процедура
                                                 //
  private                                        // ---------------------------
                                                 //
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  end;                                           // конец типа TAIeffector
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Тип TAIneuronII
//
//=============================================================================
//
//
//===============================================//============================
                                                 //
  type TAIneuronII = class(TAIchip)              // Тип TAIneuronII
                                                 //
  private                                        // ---------------------------
                                                 //
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  end;                                           // конец типа TAIneuronII
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Тип TAIneuronIS
//
//=============================================================================
//
//
//===============================================//============================
                                                 //
  type TAIneuronIS = class(TAIchip)              // Тип TAIneuronIS
                                                 //
  private                                        // ---------------------------
                                                 //
    FSelector:  TAIselector;                     // селектор сигнала дендритных слоев
                                                 // ---------------------------
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  public                                         // ---------------------------
                                                 //
    constructor Create(                          // конструктор микросхемы
                chipName:       String);         // . . . имя создаваемой микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                                                 // ---------------------------
    destructor  Destroy; override;               // деструктор микросхемы
                                                 //
  end;                                           // конец типа TAIneuronIS
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Тип TAIneuronSI
//
//=============================================================================
//
//
//===============================================//============================
                                                 //
  type TAIneuronSI = class(TAIchip)              // Тип TAIneuronSI
                                                 //
  private                                        // ---------------------------
                                                 //
    FSelector:  TAIselector;                     // селектор сигнала дендритного слоя
                                                 // ---------------------------
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  public                                         // ---------------------------
                                                 //
    constructor Create(                          // конструктор микросхемы
                chipName:       String);         // . . . имя создаваемой микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                                                 // ---------------------------
    destructor  Destroy; override;               // деструктор микросхемы
                                                 //
  end;                                           // конец типа TAIneuronSI
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Тип TAIneuronSS
//
//=============================================================================
//
//
//===============================================//============================
                                                 //
  type TAIneuronSS = class(TAIchip)              // Тип TAIneuronSS
                                                 //
  private                                        // ---------------------------
                                                 //
    FSelector1: TAIselector;                     // селектор сигнала дендритных слоев
    FSelector2: TAIselector;                     // селектор сигнала дендритного слоя
                                                 // ---------------------------
    procedure   RunCore;                         // выполнение функций ядра микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                register;                        // ..... передача параметров через регистры EAX, EDX, ECX
                                                 //
  public                                         // ---------------------------
                                                 //
    constructor Create(                          // конструктор микросхемы
                chipName:       String);         // . . . имя создаваемой микросхемы
                override;                        // ..... перекрытие метода предшествующего класса
                                                 // ---------------------------
    destructor  Destroy; override;               // деструктор микросхемы
                                                 //
  end;                                           // конец типа TAIneuronSS
                                                 //
                                                 // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
//
// Секция реализации типов модуля AIChips2
//
//===============================================//============================
                                                 //
implementation                                   //
                                                 //
//===============================================//============================
// TAIselector.Destroy                                              деструктор
//=============================================================================
//
// Деструктор Destroy уничтожает селектор типа TAIselector.
//
//===============================================//============================
                                                 //
destructor TAIselector.Destroy;                  // деструктор селектора
                                                 //
begin                                            // ===========================
                                                 //
  FSignals := nil;                               // удалить нервные сигналы
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIselector.Dominant                                    общедоступный метод
//=============================================================================
//
// Метод Dominant извлекает из селектора доминирующий нервный сигнал.
//
//===============================================//============================
                                                 //
function TAIselector.Dominant:                   // получение доминирующего нервного сигнала
                     Integer;                    // ..... возврат = доминирующий сигнал
                                                 //
var                                              // ===========================
                                                 //
  Count:  Integer;                               // количество сигналов в селекторе
  Index:  Integer;                               // индекс проверяемого сигнала
                                                 // ---------------------------
  SCount: DWord;                                 // повторяемость сигнала
                                                 //
begin                                            // ===========================
                                                 //
  Result := NOSIGNAL;                            // возврат = нет сигнала
                                                 // ---------------------------
  Count := Length(FSignals);                     // взять количество сигналов
  if Count = 0 then Exit;                        // выйти, если в селекторе нет сигналов
                                                 // ---------------------------
  Result := FSignals[0].Signal;                  // возврат = первый нервный сигнал
  SCount := FSignals[0].Count;                   // запомнить повторяемость сигнала
                                                 // ---------------------------
  Index := 1;                                    // проверку начнем со второго сигнала
  while Index < Count do begin                   // цикл по всем сигналам
    if FSignals[Index].Count >= SCount then begin// если найден более доминирующий сигнал
      if FSignals[Index].Count >SCount then begin// если этот сигнал точно доминирует
        SCount := FSignals[Index].Count;         // запомнить повторяемость сигнала
        Result := FSignals[Index].Signal;        // возврат = доминирующий сигнал
      end else begin                             // иначе (выбранный сигнал не доминирует)
        Result := NOSIGNAL;                      // возврат = нет сигнала
      end;                                       // конец IF
    end;                                         // конец IF
    Inc(Index);                                  // +1 сигнал проверили
  end;                                           // конец цикла
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIselector.Memorize                                    общедоступный метод
//=============================================================================
//
// Метод Memorize запоминает в селекторе указанный нервный сигнал.
//
//===============================================//============================
                                                 //
procedure TAIselector.Memorize(                  // запоминание нервного сигнала
                      Signal: Integer);          // . . . сигнал
                                                 //
var                                              // ===========================
                                                 //
  Count: Integer;                                // количество сигналов в селекторе
  Index: Integer;                                // индекс проверяемого сигнала
                                                 //
begin                                            // ===========================
                                                 //
  Count := Length(FSignals);                     // взять количество сигналов
  Index := 0;                                    // проверку начнем с первого сигнала
  while Index < Count do begin                   // цикл по всем сигналам
    if FSignals[Index].Signal = Signal then begin// если сигнал найден
      Inc(FSignals[Index].Count);                // увеличить повторяемость сигнала
      Exit;                                      // выйти
    end;                                         // конец IF
    Inc(Index);                                  // +1 сигнал проверили
  end;                                           // конец цикла
                                                 // ---------------------------
  SetLength(FSignals, Count+1);                  // добавить еще один сигнал
  FSignals[Count].Signal := Signal;              // запомнить значение сигнала
  FSignals[Count].Count := 0;                    // повторяемость сигнала = 1 (0=1)
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIchip.Create                                                  конструктор
//=============================================================================
//
// Конструктор Create создает микросхему типа TAIchip. Во входном параметре
// конструктора передается имя, которое программист хотел бы назначить
// создаваемой микросхеме. Если строка имени пустая, тогда микросхеме
// автоматически дается уникальное имя на основе ее же указателя.
//
//===============================================//============================
                                                 //
constructor TAIchip.Create(                      // конструктор микросхемы
                    chipName: String);           // . . . имя создаваемой микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  Name := Trim(chipName);                        // удалить из имени микросхемы ведущие и замыкающие пробелы
  if Name = '' then begin                        // если имя микросхемы не указано
    Name := IntToStr(DWord(Self));               // дать микросхеме имя по ее указателю
  end;                                           // конец IF
                                                 // ---------------------------
  Relative := True;                              // признак = относительное значение нервного сигнала
  NewLayer := False;                             // признак = новый дендритный слой не нужен
  Mode := MODE_IAPN;                             // установить режим работы ядра микросхемы
  FAxon := NOSIGNAL;                             // аксон = нет сигнала
  FCore := NOSIGNAL;                             // ядро сигнала = нет сигнала
  FBusy := 0;                                    // сбросить идентификатор занимающего процесса
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.Destroy                                                  деструктор
//=============================================================================
//
// Деструктор Destroy уничтожает микросхему типа TAIchip. Для стабильной работы
// программного кода лучше всего использовать в теле программы метод Free,
// так как этот метод сам вызывает метод Destroy, если микросхема еще
// не уничтожена.
//
//===============================================//============================
                                                 //
destructor TAIchip.Destroy;                      // деструктор микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  FDendrits := nil;                              // удалить дендриты
  FOuts := nil;                                  // удалить соединения аксона
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.Connect                                         общедоступный метод
//=============================================================================
//
// Метод Connect выполняет подключение дендрита к аксону другой микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIchip.Connect(                       // подключение дендрита к аксону другой микросхемы
                  chipBody: TAIchip);            // . . . микросхема, к которой подключается дендрит
                                                 //
var                                              // ===========================
                                                 //
  Count: Integer;                                // количество дендритов
                                                 //
begin                                            // ===========================
                                                 //
  if chipBody = nil then Exit;                   // выйти, если не указана микросхема
  Count := Length(FDendrits);                    // взять количество дендритов
  if Count = 0 then NewLayer := False;           // если дендритов еще нет
  if NewLayer then Inc(Count);                   // если нужен новый дендритный слой
  SetLength(FDendrits, Count+1);                 // добавить еще один дендрит
  if NewLayer then FDendrits[Count-1] := nil;    // если нужен новый дендритный слой
  NewLayer := False;                             // признак = новый дендритный слой не нужен
  FDendrits[Count] := chipBody;                  // подключить дендрит к аксону указанной микросхемы
  chipBody.LogOut(Self);                         // зарегистрировать в той микросхеме соединение
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.Dangling                                        общедоступный метод
//=============================================================================
//
// Метод Dangling возвращает True, если аксон микросхемы не подключен к
// какой-либо другой микросхеме.
//
//-----------------------------------------------------------------------------
//
// Входные параметры:
//
//      EAX = указатель на микросхему, для которой проверяется признак
//            "Повисший ли выход у микросхемы"
//
//===============================================//============================
                                                 //
function TAIchip.Dangling:                       // получение признака "Повисший ли выход у микросхемы"
                 Boolean;                        // ..... возврат = повисший выход или нет
                                                 //
asm                                              // ===========================
                                                 //
        mov     edx, dword ptr [eax+FOuts]       // EDX = адрес массива соединений аксона
        or      edx, edx                         // массив соединений существует?
        jz      @_Dangling_Exit                  // если нет, выйти
        mov     ecx, dword ptr [edx-4]           // ECX = количество соединений
        or      ecx, ecx                         // соединения существуют?
        jz      @_Dangling_Exit                  // если нет, выйти
                                                 //
@_Dangling_Check:                                // ---------------------------
                                                 //
        cmp     eax, dword ptr [edx]             // это соединение с другой микросхемой?
        jz      @_Dangling_Next                  // если нет, перейти к следующему соединению
        xor     eax, eax                         // EAX = выход микросхемы не повисший
        jmp     @_Dangling_Exit                  // выйти
                                                 //
@_Dangling_Next:                                 // ---------------------------
                                                 //
        add     edx, 4                           // EDX = адрес следующего соединения
        dec     ecx                              // +1 соединение обслужили
        jnz     @_Dangling_Check                 // если еще остались соединения
                                                 //
@_Dangling_Exit:                                 // ---------------------------
                                                 //
        or      eax, eax                         // выход микросхемы повисший?
        setnz   al                               // если да, AL = 1
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.LogOut                                          общедоступный метод
//=============================================================================
//
// Метод LogOut выполняет в микросхеме регистрацию, что к ее аксону
// подключился дендрит какой-то микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIchip.LogOut(                        // регистрация соединения аксона с дендритом другой микросхемы
                  chipBody: TAIchip);            // . . . микросхема, с которой регистрируется соединение
                                                 //
var                                              // ===========================
                                                 //
  Count: Integer;                                // количество соединений аксона
  Index: Integer;                                // индекс проверяемого соединения
                                                 //
begin                                            // ===========================
                                                 //
  if chipBody = nil then Exit;                   // выйти, если не указана микросхема
  if Self = chipBody then Exit;                  // выйти, если регистрируется соединение с собой же
  Count := Length(FOuts);                        // взять количество соединений аксона
  Index := 0;                                    // проверку начнем с первого соединения
  while Index < Count do begin                   // цикл по всем соединениям
    if FOuts[Index] = chipBody then Exit;        // выйти, если уже зарегистрировано такое соединение
    Inc(Index);                                  // +1 соединение проверили
  end;                                           // конец цикла
  SetLength(FOuts, Count+1);                     // добавить еще одно соединение
  FOuts[Count] := chipBody;                      // запомнить в соединении указанную микросхему
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.Run                                             общедоступный метод
//=============================================================================
//
// Метод Run запускает выполнение всей нейронной схемы. В новом варианте
// нейронных микросхем выполнение нейронной схемы запускается методом Run
// (без явных входных параметров) любой из микросхем, обязательно подключенной
// к схеме.
//
//-----------------------------------------------------------------------------
//
// Входные параметры:
//
//      EAX = указатель на микросхему, которой дали команду на выполнение всей
//            нейронной схемы
//
//===============================================//============================
                                                 //
procedure TAIchip.Run;                           // запуск выполнения нейронной схемы
                                                 //
asm                                              // ===========================
                                                 //
        mov     edx, dword ptr [eax+FBusy]       // EDX = идентификатор занимающего процесса
        inc     edx                              // получить новый идентификатор процесса
        jmp     TAIchip.RunChip                  // выполнить RunChip текущей микросхемы
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.RunChip                                                личный метод
//=============================================================================
//
// Метод RunChip активирует выполнение всех функций микросхемы.
//
//-----------------------------------------------------------------------------
//
// Входные параметры:
//
//      EAX = указатель на микросхему, функции которой должны быть выполнены
//      EDX = численное значение идентификатора занимающего процесса
//
//===============================================//============================
                                                 //
procedure TAIchip.RunChip(                       // выполнение функций микросхемы
                  BusyID: Integer);              // . . . идентификатор занимающего процесса
                                                 //
asm                                              // ===========================
                                                 //
        cmp     edx, dword ptr [eax+FBusy]       // текущая микросхема уже обработана?
        jz      @_RunChip_Exit                   // если да, выйти
        mov     dword ptr [eax+FBusy], edx       // запомнить идентификатор занимающего процесса
                                                 // ---------------------------
        push    esi                              // сохранить ESI
        push    ecx                              // сохранить ECX
        mov     esi, dword ptr [eax+FDendrits]   // ESI = адрес массива дендритов
        or      esi, esi                         // массив дендритов существует?
        jz      @_RunChip_RunCore                // если нет, выполнить ядро микросхемы
        mov     ecx, dword ptr [esi-4]           // ECX = количество дендритов
        or      ecx, ecx                         // дендриты существуют?
        jz      @_RunChip_RunCore                // если нет, выполнить ядро микросхемы
                                                 //
@_RunChip_RunInput:                              // ---------------------------
                                                 //
        cmp     eax, dword ptr [esi]             // дендрит соединен с другой микросхемой?
        jz      @_RunChip_RunInputNext           // если нет, перейти к следующему дендриту
        cmp     dword ptr [esi], 0               // дендрит указывает на микросхему?
        jz      @_RunChip_RunInputNext           // если нет, перейти к следующему дендриту
        xchg    eax, dword ptr [esi]             // EAX = другая микросхема
        call    TAIchip.RunChip                  // выполнить RunChip той микросхемы
        xchg    eax, dword ptr [esi]             // восстановить EAX
                                                 //
@_RunChip_RunInputNext:                          // ---------------------------
                                                 //
        add     esi, 4                           // ESI = адрес следующего дендрита
        dec     ecx                              // +1 дендрит обслужили
        jnz     @_RunChip_RunInput               // если еще остались дендриты
                                                 //
@_RunChip_RunCore:                               // ---------------------------
                                                 //
        mov     ecx, [eax]                       // ECX = адрес указателя на метод RunCore
        push    edx                              // сохранить EDX
        mov     esi, eax                         // сохранить EAX
        call    dword ptr [ecx]                  // выполнить RunCore микросхемы
        mov     eax, esi                         // восстановить EAX
        pop     edx                              // восстановить EDX
                                                 // ---------------------------
        mov     esi, dword ptr [eax+FOuts]       // ESI = адрес массива соединений аксона
        or      esi, esi                         // массив соединений существует?
        jz      @_RunChip_PopAndExit             // если нет, выйти
        mov     ecx, dword ptr [esi-4]           // ECX = количество соединений
        or      ecx, ecx                         // соединения существуют?
        jz      @_RunChip_PopAndExit             // если нет, выйти
                                                 //
@_RunChip_RunOutput:                             // ---------------------------
                                                 //
        cmp     eax, dword ptr [esi]             // это соединение с другой микросхемой?
        jz      @_RunChip_RunOutputNext          // если нет, перейти к следующему соединению
        xchg    eax, dword ptr [esi]             // EAX = другая микросхема
        call    TAIchip.RunChip                  // выполнить RunChip той микросхемы
        xchg    eax, dword ptr [esi]             // восстановить EAX
                                                 //
@_RunChip_RunOutputNext:                         // ---------------------------
                                                 //
        add     esi, 4                           // ESI = адрес следующего соединения
        dec     ecx                              // +1 соединение обслужили
        jnz     @_RunChip_RunOutput              // если еще остались соединения
                                                 //
@_RunChip_PopAndExit:                            // ---------------------------
                                                 //
        pop     ecx                              // восстановить ECX
        pop     esi                              // восстановить ESI
                                                 //
@_RunChip_Exit:                                  // ---------------------------
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.RunCore                                  перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы. В классе
// TAIchip этот метод не содержит ничего. В наследуемых классах он должен
// перекрываться и, собственно, содержать алгоритм работы ядра микросхемы
// нового класса.
//
//-----------------------------------------------------------------------------
//
// Входные параметры:
//
//      EAX = указатель на микросхему, функции ядра которой должны быть
//            выполнены
//
//===============================================//============================
                                                 //
procedure TAIchip.RunCore;                       // выполнение функций ядра микросхемы
                                                 //
asm                                              // ===========================
                                                 //
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIchip.SetAxon                                                личный метод
//=============================================================================
//
// Метод SetAxon устанавливает указанный нервный сигнал в аксоне микросхемы.
// Этот метод автоматически вызывается при записи значения в общедоступное
// свойство Axon микросхемы.
//
//-----------------------------------------------------------------------------
//
// Входные параметры:
//
//      EAX = указатель на микросхему, в аксоне которой устанавливается новый
//            нервный сигнал
//      EDX = численное значение нового нервного сигнала
//
//===============================================//============================
                                                 //
procedure TAIchip.SetAxon(                       // установка нервного сигнала в аксоне
                  Value: Integer);               // . . . нервный сигнал
                                                 //
asm                                              // ===========================
                                                 //
        mov     dword ptr [eax+FAxon], edx       // аксон = нервный сигнал
        cmp     byte ptr [eax+Relative], 0       // на выходе абсолютный сигнал?
        jz      @_SetAxon_Exit                   // если да, выйти
        xchg    dword ptr [eax+FCore], edx       // ядро = нервный сигнал
        sub     dword ptr [eax+FAxon], edx       // аксон = относительный сигнал
                                                 //
@_SetAxon_Exit:                                  // ---------------------------
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIreceptor.RunCore                              перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIreceptor.RunCore;                   // выполнение функций ядра микросхемы
                                                 //
asm                                              // ===========================
                                                 //
        cmp     dword ptr [eax+Operation], 0     // внешняя процедура назначена?
        jz      @_Receptor_RunCore_Exit          // если нет, выйти
        call    dword ptr [eax+Operation]        // выполнить эту процедуру
                                                 //
@_Receptor_RunCore_Exit:                         // ---------------------------
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIeffector.RunCore                              перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIeffector.RunCore;                   // выполнение функций ядра микросхемы
                                                 //
asm                                              // ===========================
                                                 //
        push    esi                              // сохранить ESI
        push    ebx                              // сохранить EBX
        xor     ebx, ebx                         // очистить EBX
                                                 //
@_Effector_RunCore_Next:                         // ---------------------------
                                                 //
        mov     esi, dword ptr [eax+FDendrits]   // ESI = адрес массива дендритов
        or      esi, esi                         // массив дендритов существует?
        jz      @_Effector_RunCore_Exit          // если нет, выйти
        mov     ecx, dword ptr [esi-4]           // ECX = количество дендритов
        cmp     ebx, ecx                         // все дендриты обслужены?
        jae     @_Effector_RunCore_Exit          // если да, выйти
                                                 // ---------------------------
        cmp     dword ptr [eax+Operation], 0     // внешняя процедура назначена?
        jz      @_Effector_RunCore_Exit          // если нет, выйти
                                                 // ---------------------------
        mov     edx, dword ptr [esi]             // EDX = другая микросхема
        mov     edx, dword ptr [edx+FAxon]       // EDX = нервный сигнал
        call    TAIchip.SetAxon                  // передать в аксон нервный сигнал
        push    eax                              // сохранить EAX
        call    dword ptr [eax+Operation]        // выполнить эту процедуру
        pop     eax                              // восстановить EAX
        inc     ebx                              // +1 дендрит обслужен
        add     esi, 4                           // ESI = адрес следующего дендрита
        jmp     @_Effector_RunCore_Next          // обслужить следующий дендрит
                                                 //
@_Effector_RunCore_Exit:                         // ---------------------------
                                                 //
        pop     ebx                              // восстановить EBX
        pop     esi                              // восстановить ESI
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIneuronII.RunCore                              перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIneuronII.RunCore;                   // выполнение функций ядра микросхемы
                                                 //
asm                                              // ===========================
                                                 //
        push    ebp                              // сохранить EBP
        push    edi                              // сохранить EDI
        push    esi                              // сохранить ESI
        push    ebx                              // сохранить EBX
                                                 // ---------------------------
        mov     ebp, eax                         // EBP = адрес текущей микросхемы
        mov     edx, NOSIGNAL                    // EDX = сигнал в дендритных слоях
                                                 // ---------------------------
        mov     esi, dword ptr [ebp+FDendrits]   // ESI = адрес массива дендритов
        or      esi, esi                         // массив дендритов существует?
        jz      @_NeuronII_RunCore_SetAxon       // если нет, установить выходной сигнал
        mov     ecx, dword ptr [esi-4]           // ECX = количество дендритов
                                                 // ---------------------------
        xor     edi, edi                         // EDI = количество дендритных слоев
        mov     eax, NOSIGNAL                    // EAX = сигнал в дендритном слое
        xor     ebx, ebx                         // EBX = количество дендритов в слое
                                                 //
@_NeuronII_RunCore_Check:                        // ---------------------------
                                                 //
        cmp     dword ptr [esi], 0               // дендритный слой закончился?
        jnz     @_NeuronII_RunCore_Process       // если нет, обработать дендрит
                                                 // ---------------------------
        call    @_NeuronII_RunCore_EndLayer      // дендритный слой завершен
        mov     eax, NOSIGNAL                    // EAX = сигнал в дендритном слое
        xor     ebx, ebx                         // EBX = количество дендритов в слое
        jmp     @_NeuronII_RunCore_Next          // перейти к следующему дендриту
                                                 //
@_NeuronII_RunCore_EndLayer:                     // ---------------------------
                                                 //
        inc     edi                              // +1 дендритный слой пройден
        cmp     ebx, 1                           // дендритов было больше одного?
        jbe     @_NeuronII_RunCore_EndLayer_Add  // если нет, добавить сигнал
        test    byte ptr [ebp+Mode], AVERAGE     // нужно среднеарифметическое интегрирование?
        jz      @_NeuronII_RunCore_EndLayer_Add  // если нет, добавить сигнал
                                                 // ---------------------------
        push    edx                              // сохранить EDX
        cdq                                      // преобразовать EAX в EDX:EAX
        idiv    ebx                              // получить в EAX среднеарифметическое
        pop     edx                              // восстановить EDX
                                                 //
@_NeuronII_RunCore_EndLayer_Add:                 // ---------------------------
                                                 //
        add     edx, eax                         // добавить в EDX сигнал слоя
        ret                                      // возврат из подпрограммы
                                                 //
@_NeuronII_RunCore_Process:                      // ---------------------------
                                                 //
        push    edx                              // сохранить EDX
        mov     dl, byte ptr [ebp+Mode]          // DL = режим работы ядра микросхемы
        and     dl, MODE_IPN                     // оставить в DL нужные разряды
        cmp     dl, MODE_IPN                     // нужны все сигналы?
                                                 // ---------------------------
        mov     edx, dword ptr [esi]             // EDX = другая микросхема
        mov     edx, dword ptr [edx+FAxon]       // EDX = нервный сигнал
                                                 // ---------------------------
        jz      @_NeuronII_RunCore_Add           // если нужны все сигналы, добавить сигнал
        test    byte ptr [ebp+Mode], MODE_IPN    // нужны все сигналы?
        jz      @_NeuronII_RunCore_Add           // если да, добавить сигнал
                                                 // ---------------------------
        cmp     edx, NOSIGNAL                    // есть ли нервный сигнал?
        jz      @_NeuronII_RunCore_NoAdd         // если нет, не добавлять сигнал
                                                 // ---------------------------
        test    byte ptr [ebp+Mode], POSITIVE    // нужны положительные сигналы?
        jz      @_NeuronII_RunCore_Negative      // если нет, проверить отрицательный сигнал
        test    edx, 80000000h                   // сигнал положительный?
        jz      @_NeuronII_RunCore_Add           // если да, добавить сигнал
        jmp     @_NeuronII_RunCore_NoAdd         // иначе не добавлять сигнал
                                                 //
@_NeuronII_RunCore_Negative:                     // ---------------------------
                                                 //
        test    edx, 80000000h                   // сигнал отрицательный?
        jz      @_NeuronII_RunCore_NoAdd         // если нет, не добавлять сигнал
                                                 //
@_NeuronII_RunCore_Add:                          // ---------------------------
                                                 //
        inc     ebx                              // +1 дендрит в слое
        add     eax, edx                         // добавить в EAX сигнал дендрита
                                                 //
@_NeuronII_RunCore_NoAdd:                        // ---------------------------
                                                 //
        pop     edx                              // восстановить EDX
                                                 //
@_NeuronII_RunCore_Next:                         // ---------------------------
                                                 //
        add     esi, 4                           // ESI = адрес следующего дендрита
        dec     ecx                              // +1 дендрит обслужили
        jnz     @_NeuronII_RunCore_Check         // если еще остались дендриты
                                                 // ---------------------------
        call    @_NeuronII_RunCore_EndLayer      // дендритный слой завершен
        cmp     edi, 1                           // дендритных слоев было больше одного?
        jbe     @_NeuronII_RunCore_SetAxon       // если нет, установить выходной сигнал
        test    byte ptr [ebp+Mode], AVERAGE     // нужно среднеарифметическое интегрирование?
        jz      @_NeuronII_RunCore_SetAxon       // если нет, установить выходной сигнал
                                                 // ---------------------------
        mov     eax, edx                         // EAX = сигнал в дендритных слоях
        cdq                                      // преобразовать EAX в EDX:EAX
        idiv    edi                              // получить в EAX среднеарифметическое
        mov     edx, eax                         // EDX = сигнал в дендритных слоях
                                                 //
@_NeuronII_RunCore_SetAxon:                      // ---------------------------
                                                 //
        mov     eax, ebp                         // EAX = адрес текущей микросхемы
        call    TAIchip.SetAxon                  // передать в аксон нервный сигнал
                                                 // ---------------------------
        pop     ebx                              // восстановить EBX
        pop     esi                              // восстановить ESI
        pop     edi                              // восстановить EDI
        pop     ebp                              // восстановить EBP
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIneuronIS.Create                                              конструктор
//=============================================================================
//
// Конструктор Create создает микросхему типа TAIneuronIS.
//
//===============================================//============================
                                                 //
constructor TAIneuronIS.Create(                  // конструктор микросхемы
                        chipName: String);       // . . . имя создаваемой микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  inherited Create(chipName);                    // выполнить конструктор предка
  FSelector := TAIselector.Create;               // создать селектор сигнала дендритных слоев
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIneuronIS.Destroy                                              деструктор
//=============================================================================
//
// Деструктор Destroy уничтожает микросхему типа TAIneuronIS.
//
//===============================================//============================
                                                 //
destructor TAIneuronIS.Destroy;                  // деструктор микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  FSelector.Free;                                // удалить селектор сигнала дендритных слоев
  inherited Destroy;                             // выполнить деструктор предка
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIneuronIS.RunCore                              перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIneuronIS.RunCore;                   // выполнение функций ядра микросхемы
                                                 //
var                                              // ===========================
                                                 //
  Count:    Integer;                             // количество дендритов
  Index:    Integer;                             // индекс обслуживаемого дендрита
                                                 // ---------------------------
  LCount:   Integer;                             // количество дендритов в слое
  Signal:   Integer;                             // новый сигнал в дендритном слое
                                                 //
begin                                            // ===========================
                                                 //
  Signal := NOSIGNAL;                            // пока новый сигнал в дендритном слое не вычислен
  LCount := 0;                                   // пока количество дендритов в слое не известно
                                                 // ---------------------------
  Count := Length(FDendrits);                    // взять количество дендритов
  Index := 0;                                    // обслуживание начнем с первого дендрита
  while Index < Count do begin                   // цикл по всем дендритам
    if FDendrits[Index] = nil then begin         // если дендритный слой закончился
      if LCount > 1 then begin                   // если дендритов более одного
        if Mode and AVERAGE <> 0 then begin      // если нужно среднеарифметическое
          Signal := Signal div LCount;           // вычислить среднее значение сигнала
        end;                                     // конец IF
      end;                                       // конец IF
      FSelector.Memorize(Signal);                // запомнить сигнал дендритного слоя
      Signal := NOSIGNAL;                        // пока новый сигнал не вычислен
      LCount := 0;                               // пока количество дендритов не известно
    end else begin                               // иначе (дендритный слой продолжается)
      if (Mode and MODE_IPN = MODE_IPN)          // если нужны все следствия
      or (Mode and MODE_IPN = 0) then begin      // . . . . . . . . . . . .
        Inc(LCount);                             // +1 дендрит в слое
        Signal := Signal +                       // добавить значение сигнала из дендрита
                  FDendrits[Index].FAxon;        // . . . . . . . . . . . . . . . . . . .
      end else begin                             // иначе (нужны не все следствия)
        if Mode and POSITIVE <> 0 then begin     // если нужны положительные следствия
          if FDendrits[Index].FAxon>0 then begin // если сигнал положительный
            Inc(LCount);                         // +1 дендрит в слое
            Signal := Signal +                   // добавить значение сигнала из дендрита
                      FDendrits[Index].FAxon;    // . . . . . . . . . . . . . . . . . . .
          end;                                   // конец IF
        end else begin                           // иначе (нужны отрицательные следствия)
          if FDendrits[Index].FAxon<0 then begin // если сигнал отрицательный
            Inc(LCount);                         // +1 дендрит в слое
            Signal := Signal +                   // добавить значение сигнала из дендрита
                      FDendrits[Index].FAxon;    // . . . . . . . . . . . . . . . . . . .
          end;                                   // конец IF
        end;                                     // конец IF
      end;                                       // конец IF
    end;                                         // конец IF
    Inc(Index);                                  // +1 дендрит обслужили
  end;                                           // конец цикла
                                                 // ---------------------------
  if LCount > 1 then begin                       // если дендритов более одного
    if Mode and AVERAGE <> 0 then begin          // если нужно среднеарифметическое
      Signal := Signal div LCount;               // вычислить среднее значение сигнала
    end;                                         // конец IF
  end;                                           // конец IF
  FSelector.Memorize(Signal);                    // запомнить сигнал дендритного слоя
                                                 // ---------------------------
  Axon := FSelector.Dominant;                    // передать в аксон доминирующий сигнал
  FSelector.FSignals := nil;                     // очистить селектор сигнала дендритных слоев
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIneuronSI.Create                                              конструктор
//=============================================================================
//
// Конструктор Create создает микросхему типа TAIneuronSI.
//
//===============================================//============================
                                                 //
constructor TAIneuronSI.Create(                  // конструктор микросхемы
                        chipName: String);       // . . . имя создаваемой микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  inherited Create(chipName);                    // выполнить конструктор предка
  FSelector := TAIselector.Create;               // создать селектор сигнала дендритного слоя
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIneuronSI.Destroy                                              деструктор
//=============================================================================
//
// Деструктор Destroy уничтожает микросхему типа TAIneuronSI.
//
//===============================================//============================
                                                 //
destructor TAIneuronSI.Destroy;                  // деструктор микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  FSelector.Free;                                // удалить селектор сигнала дендритного слоя
  inherited Destroy;                             // выполнить деструктор предка
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIneuronSI.RunCore                              перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIneuronSI.RunCore;                   // выполнение функций ядра микросхемы
                                                 //
var                                              // ===========================
                                                 //
  Count:    Integer;                             // количество дендритов
  Index:    Integer;                             // индекс обслуживаемого дендрита
                                                 // ---------------------------
  LCount:   Integer;                             // количество дендритных слоев
  Signal:   Integer;                             // новый сигнал в дендритных слоях
  Dominant: Integer;                             // доминирующий сигнал
                                                 //
begin                                            // ===========================
                                                 //
  Signal := NOSIGNAL;                            // пока новый сигнал в дендритных слоях не вычислен
  LCount := 0;                                   // пока количество дендритных слоев не известно
                                                 // ---------------------------
  Count := Length(FDendrits);                    // взять количество дендритов
  Index := 0;                                    // обслуживание начнем с первого дендрита
  while Index < Count do begin                   // цикл по всем дендритам
    if FDendrits[Index] = nil then begin         // если дендритный слой закончился
      if (Mode and MODE_IPN = MODE_IPN)          // если нужны все следствия
      or (Mode and MODE_IPN = 0) then begin      // . . . . . . . . . . . .
        Inc(LCount);                             // +1 дендритный слой
        Signal := Signal + FSelector.Dominant;   // добавить доминирующий сигнал дендритного слоя
      end else begin                             // иначе (нужны не все следствия)
        Dominant := FSelector.Dominant;          // взять доминирующий сигнал дендритного слоя
        if Mode and POSITIVE <> 0 then begin     // если нужны положительные следствия
          if Dominant > 0 then begin             // если сигнал положительный
            Inc(LCount);                         // +1 дендритный слой
            Signal := Signal + Dominant;         // добавить доминирующий сигнал дендритного слоя
          end;                                   // конец IF
        end else begin                           // иначе (нужны отрицательные следствия)
          if Dominant < 0 then begin             // если сигнал отрицательный
            Inc(LCount);                         // +1 дендритный слой
            Signal := Signal + Dominant;         // добавить доминирующий сигнал дендритного слоя
          end;                                   // конец IF
        end;                                     // конец IF
      end;                                       // конец IF
      FSelector.FSignals := nil;                 // очистить селектор сигнала дендритного слоя
    end else begin                               // иначе (дендритный слой продолжается)
      FSelector.Memorize(FDendrits[Index].FAxon);// запомнить сигнал дендрита
    end;                                         // конец IF
    Inc(Index);                                  // +1 дендрит обслужили
  end;                                           // конец цикла
                                                 // ---------------------------
  if (Mode and MODE_IPN = MODE_IPN)              // если нужны все следствия
  or (Mode and MODE_IPN = 0) then begin          // . . . . . . . . . . . .
    Inc(LCount);                                 // +1 дендритный слой
    Signal := Signal + FSelector.Dominant;       // добавить доминирующий сигнал дендритного слоя
  end else begin                                 // иначе (нужны не все следствия)
    Dominant := FSelector.Dominant;              // взять доминирующий сигнал дендритного слоя
    if Mode and POSITIVE <> 0 then begin         // если нужны положительные следствия
      if Dominant > 0 then begin                 // если сигнал положительный
        Inc(LCount);                             // +1 дендритный слой
        Signal := Signal + Dominant;             // добавить доминирующий сигнал дендритного слоя
      end;                                       // конец IF
    end else begin                               // иначе (нужны отрицательные следствия)
      if Dominant < 0 then begin                 // если сигнал отрицательный
        Inc(LCount);                             // +1 дендритный слой
        Signal := Signal + Dominant;             // добавить доминирующий сигнал дендритного слоя
      end;                                       // конец IF
    end;                                         // конец IF
  end;                                           // конец IF
  FSelector.FSignals := nil;                     // очистить селектор сигнала дендритного слоя
                                                 // ---------------------------
  if LCount > 1 then begin                       // если дендритных слоев более одного
    if Mode and AVERAGE <> 0 then begin          // если нужно среднеарифметическое
      Signal := Signal div LCount;               // вычислить среднее значение сигнала
    end;                                         // конец IF
  end;                                           // конец IF
                                                 // ---------------------------
  Axon := Signal;                                // передать в аксон новый сигнал
                                                 //
end;                                             // ===========================
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
                                                 //
//===============================================//============================
// TAIneuronSS.Create                                              конструктор
//=============================================================================
//
// Конструктор Create создает микросхему типа TAIneuronSS.
//
//===============================================//============================
                                                 //
constructor TAIneuronSS.Create(                  // конструктор микросхемы
                        chipName: String);       // . . . имя создаваемой микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  inherited Create(chipName);                    // выполнить конструктор предка
  FSelector1 := TAIselector.Create;              // создать селектор сигнала дендритных слоев
  FSelector2 := TAIselector.Create;              // создать селектор сигнала дендритного слоя
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIneuronSS.Destroy                                              деструктор
//=============================================================================
//
// Деструктор Destroy уничтожает микросхему типа TAIneuronSS.
//
//===============================================//============================
                                                 //
destructor TAIneuronSS.Destroy;                  // деструктор микросхемы
                                                 //
begin                                            // ===========================
                                                 //
  FSelector1.Free;                               // удалить селектор сигнала дендритных слоев
  FSelector2.Free;                               // удалить селектор сигнала дендритного слоя
  inherited Destroy;                             // выполнить деструктор предка
                                                 //
end;                                             // ===========================
                                                 //
//===============================================//============================
// TAIneuronSS.RunCore                              перекрываемый личный метод
//=============================================================================
//
// Метод RunCore занимается выполнением работы ядра микросхемы.
//
//===============================================//============================
                                                 //
procedure TAIneuronSS.RunCore;                   // выполнение функций ядра микросхемы
                                                 //
var                                              // ===========================
                                                 //
  Count:   Integer;                              // количество дендритов
  Index:   Integer;                              // индекс обслуживаемого дендрита
  Several: Boolean;                              // признак "Несколько дендритных слоев"
                                                 //
begin                                            // ===========================
                                                 //
  Several := False;                              // признак = пока один дендритный слой
                                                 // ---------------------------
  Count := Length(FDendrits);                    // взять количество дендритов
  Index := 0;                                    // обслуживание начнем с первого дендрита
  while Index < Count do begin                   // цикл по всем дендритам
    if FDendrits[Index] = nil then begin         // если дендритный слой закончился
      Several := True;                           // признак = несколько дендритных слоев
      FSelector1.Memorize(FSelector2.Dominant);  // запомнить сигнал дендритного слоя
      FSelector2.FSignals := nil;                // очистить селектор сигнала дендритного слоя
    end else begin                               // иначе (дендритный слой продолжается)
      FSelector2.Memorize(FDendrits[Index]       // запомнить сигнал дендрита
                          .FAxon);               // . . . . . . . . . . . . .
    end;                                         // конец IF
    Inc(Index);                                  // +1 дендрит обслужили
  end;                                           // конец цикла
                                                 // ---------------------------
  if Several then begin                          // если несколько дендритных слоев
    FSelector1.Memorize(FSelector2.Dominant);    // запомнить сигнал дендритного слоя
    FSelector2.FSignals := nil;                  // очистить селектор сигнала дендритного слоя
    Axon := FSelector1.Dominant;                 // передать в аксон доминирующий сигнал
    FSelector1.FSignals := nil;                  // очистить селектор сигнала дендритных слоев
  end else begin                                 // иначе (один дендритный слой)
    Axon := FSelector2.Dominant;                 // передать в аксон доминирующий сигнал
    FSelector2.FSignals := nil;                  // очистить селектор сигнала дендритного слоя
  end;                                           // конец IF
                                                 //
end;                                             // ===========================
                                                 //
end.                                             // конец модуля AIChips2
                                                 // ===========================


Хотите поделиться своими творениями? Размещу с удовольствием, мыльте!

К списку статей


Есть комментарии, вопросы, ссылки на полезные ресурсы? Все это можно указать здесь:

E-mail для ответа:

Сообщение:



Материалы находятся на сайте https://exelab.ru/pro/



Оригинальный DVD-ROM: eXeL@B DVD !


Вы находитесь на EXELAB.rU
Проект ReactOS