Программа для анализа и отбора способа реакции на входные данные

; Описание:
; программа для анализа и отбора способа реакции на входные данные
 
; Принцип:
; Создаётся файл в который записываются таблицы, состоящие из: 
; 1) Восьми байт кода события, единственное в таблице, а в файле в количестве, ограниченном диапазоном принимаемых значений переменной данного типа. (0 - "+infinity", но лучше ограничить до 1 000 000 000 000 так как счёт пойдёт на терабайты занимаемого дискового пространства.)
; 2) Двух байт индекса выхода, в количестве, ограниченном диапазоном принимаемых значений переменной данного типа. (0 - 65536)
; 3) Одного байта возможного значения выхода, в не ограниченном количестве, с ограниченным диапазоном принимаемых значений.(0 - 255)
; Для каждого кода события создаётся своё количество индексов выходов и для каждого индекса своё количество принимаемых значений до 255.
;Как предполагается будет работать - таблица из файла считывается, входное значение ищется, сравнивается, веса модифицируются, положение дел постоянно анализируется и результат модифицируется.
 
; Процедуры по порядку:
; 1 - Create_table создаёт таблицу расчитывая размер по переданным параметрам диапазонов значений в количестве задаваемом одним из параметров
; 2 - Compare процедура сравнивающая два параметра и возвращающая результат в процентах
; 3 - Save_table_in_file запись таблицы в файл
; 4 - Load_table_from_file чтение таблицы из файла
; 5 - Weight_modification модификация весов, распределяющая веса таким образом чтобы небыло одинаковых, не доработана, требуется исключить модификацию двух самых больших весов
; 6 - Search_the_largest_weight поиск наибольшего веса, индекс веса - значение на выходе
; 7 - Функция обратного вызова в процедуре Search_the_largest_weight, нужна для перерасчёта результата после выдачи каждого значения на выход
; 8 - Heuristic_Search процедура вычисляющая код(сумму) входного массива, проверял около получаса используя список и массив размерностью 300х300, вроде повторов небыло.
;     Процедура ищет еод события в памяти, загружает таблицы из файла и сохраняет в файл, короче перебирает все таблицы на наличе кода, попутно запоминает позицию наиболее похожего кода,
;     решает что делать в случай отсутствия полого совпадения кода.
 
; Указатели на память:
; *mem_buff - таблица таблиц в памяти, загружаются в неё таблицы пачками.
; *stimul - значение, решающее как модифицировать вес, является суммой входных значений, определяющей, негативно действие или позитивно и следовательно влияющей на реакцию программы в именно данном случае
 
; Структура таблиц расчитаывается на количество кодов событий более 100 000 000 000.
 
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
; создание таблицы
Procedure Create_table(*mem_buff, number_of_codes, range, number_of_outputs, number_of_inputs) ; не готово
  *mem_buff = ReAllocateMemory(*mem_buff, number_of_codes * 8 + number_of_codes * (range * number_of_outputs + number_of_outputs * 2 + range * number_of_inputs + number_of_inputs * 2))
  ProcedureReturn size
EndProcedure ; 8, 2, 1
 
; сравнение
Procedure Compare(One, Two) ; готово
  Procent = One / 100
  If Procent <> 0
    Shodstvo = Two / Procent
    If Shodstvo > 100 And Shodstvo < 200
      ProcedureReturn Shodstvo - 100   
    ElseIf Shodstvo <= 100 And Shodstvo >= 0
      ProcedureReturn Shodstvo
    EndIf
  EndIf
EndProcedure
 
; работа с файлом
Procedure Save_table_in_file(file_name.s, *mem_buff) ; вроде готово
  OpenFile(0, file_name)
  WriteData(0, *mem_buff, MemorySize(*mem_buff))
  CloseFile(0)
  ProcedureReturn 1
EndProcedure
 
Procedure Load_table_from_file(file_name.s, *mem_buff, number_of_table) ; вроде готово
  ReadFile(0, file_name)
  For n = 0 To number_of_table - 1
    ReadData(0, *mem_buff, MemorySize(*mem_buff))
  Next
  CloseFile(0)
  ProcedureReturn 1
EndProcedure
 
; модификация весов
Procedure Weight_modification(*mem_buff, *stimul, outcome_output, start_position, stop_position) ; не готово
  If PeekL(*stimul) > 0 And PeekA(*mem_buff + start_position + outcome_output) < 255
    PokeA(*mem_buff + start_position + outcome_output, PeekA(*mem_buff + start_position + outcome_output) + 1)
  EndIf
  
  If PeekL(*stimul) < 0 And PeekA(*mem_buff + start_position + outcome_output) > 0
    PokeA(*mem_buff + start_position + outcome_output, PeekA(*mem_buff + start_position + outcome_output) - 1)
  EndIf
  
  If PeekL(*stimul) > 0
    For n = start_position To stop_position
      If PeekA(*mem_buff + n) < wei And n <> outcome_output + start_position And PeekA(*mem_buff + n) > 0
        wei = PeekA(*mem_buff + n)
        position = n
      EndIf
    Next
    PokeA(*mem_buff + position, PeekA(*mem_buff + position) - 1)
    
  ElseIf PeekL(*stimul) < 0
    For n = start_position To stop_position
      If PeekA(*mem_buff + n) > wei And n <> outcome_output + start_position And PeekA(*mem_buff + n) < 255
        wei = PeekA(*mem_buff + n)
        position = n
      EndIf
    Next
    PokeA(*mem_buff + position, PeekA(*mem_buff + position) + 1) 
  EndIf
  ProcedureReturn 1
EndProcedure
 
; поиск лучшего веса
Procedure Search_the_largest_weight(*mem_buff, *callback_function, position, range, number_of_outputs, number_of_inputs) ; вроде готово
  For a = 0 To number_of_outputs - 1  
    For n = position + 8 + range * a + 2 * (a + 1) To position + 8 + range * a + 2 * (a + 1) + range + 1
      If PeekA(*mem_buff + n) > Wei
        outcome_output = n - position - 8 - 2 * (a + 1) : Wei = PeekA(*mem_buff + n)
      EndIf
    Next
    outcome_callback = CallCFunctionFast(*callback_function, outcome_output)
    outcome_modification = Weight_modification(*mem_buff, *stimul, outcome_output, position + 8 + range * a + 2 * (a + 1), position + 8 + range * a + 2 * (a + 1) + range + 1)
  Next
  ProcedureReturn 1
EndProcedure
 
; вычисление суммы и поиск кода события
Procedure Heuristic_Search(*callback_function, *mem_buff, *stimul, number_of_codes, number_of_outputs, range, number_of_inputs) ; не готово *callback_function=@Procedure()
  code.d = 0
  For n = 0 To MemorySize(*mem_buff) - 1
    code = code + PeekA(*mem_buff + n) * (n + 1)  
  Next
  
  position = -1
  For n = 0 To MemorySize(*mem_buff) / number_of_codes - 1
    st = n * (number_of_outputs * range + n * number_of_outputs * 2)
    If PeekU(*mem_buff + st) = code
      outcome_output = Search_the_largest_weight(*mem_buff, *callback_function, st, range, number_of_outputs, number_of_inputs)
    Else
      outcome_cmp = Compare(PeekL(*mem_buff + st), code)
      If outcome_cmp > outcome_cmp_Old
        outcome_cmp_Old = outcome_cmp : position = st
      EndIf    
    EndIf    
  Next
  
  outcome_output = Search_the_largest_weight(*mem_buff, *callback_function, position, range, number_of_outputs, number_of_inputs)
  
  *new_table = AllocateMemory(size_of_outputs)
  PokeL(*new_table, code)
  outcome_modification = Weight_modification(*mem_buff, *stimul, outcome_output, start_position, stop_position)
  ProcedureReturn 1
EndProcedure
 
Procedure Core() ; наверное вообще не понадобится
  
EndProcedure