nikolz (Все сообщения пользователя)

while db==nil do db = CreateDataSource("TQBR", "SBER",INTERVAL_H1)  sleep(10); end

while db==nil do db = CreateDataSource("TQBR", "SBER", "INTERVAL_H1")  sleep(10); end

Settings = {Name = "*Kijun-sen",kijun_period = 6,}

function OnCalculate(i)
   Hi=H(i) or H1; Li=L(i) or L1; x1=x;
   if i1>i then
      ma=Hi; mi=Li; jma=i; jmi=i;
   end
   if Hi and Li then
      local j=i-Settings.kijun_period; if j<1 then j=1; end
      if j>jma or j>jmi then
         ma=Hi; mi=Li; jma=i; jmi=i;
         while i>j do
            Hi,Li=H(j),L(j)
            if Hi and Hi>ma then ma = Hi jma=j; end
            if Li and Li<mi then  mi =Li jmi=j;end
            j=j+1
         end
      else
         if Hi>ma then ma=Hi; jma=i; end
         if mi>Li then mi=Li; jmi=i; end
      end
      x=(ma + mi)/2;    H1,L1,i1=Hi,Li,i;
   end
return x1
end

function OnChangeSettings()
   i1=0;jma=0; jmi=0; H1=0; L1=0;ma=0;mi=0;
end

function Init()
OnChangeSettings()
Settings.line = {{ Name=Settings.Name, Color=RGB(32,255,128), Type=TYPE_LINE, Width = 2,}}
return #Settings.line  end

Settings = {Name = "*ind_nk",period = 6,}

function OnCalculate(i)
   Hi=H(i) or H1; Li=L(i) or L1;
   Oi=O(i) or O1; Ci=C(i) or C1;
   if i1>i then
      ma=Hi; mi=Li; jma=i; jmi=i;
   end
   if Hi and Li and i1~=i then

      local j=i-Settings.period; if j<1 then j=1; end
      if j>jma or j>jmi then
         ma=Hi; mi=Li; jma=i; jmi=i;
         while i>j do
            Hi,Li=H(j),L(j)
            if Hi and Hi>ma then ma = Hi jma=j; end
            if Li and Li<mi then  mi =Li jmi=j;end
            j=j+1
         end
      else
         if Hi>ma then ma=Hi; jma=i; end
         if mi>Li then mi=Li; jmi=i;
         end
         if x then
            local z=2*Li-Hi; if Li>x and Ci>Oi then mi=z; jmi=i; end
            z=2*Hi-Li; if x>Hi and Oi>Ci then ma=z; jma=i; end
         end
      end
      if ma and mi then x=(ma + mi)/2; end
      H1,L1,O1,C1,i1=Hi,Li,Oi,Ci,i;
   end
return x
end

function OnChangeSettings()
   i1=0;jma=0; jmi=0; H1=0; L1=0;ma=0;mi=0;
end

function Init()
OnChangeSettings()
Settings.line = {{ Name=Settings.Name, Color=RGB(255,255,255), Type=TYPE_LINE, Width = 2,}}
return #Settings.line  end

Settings = {Name = "*Kijun-sen",kijun_period = 6,}

function OnCalculate(i)
   Hi=H(i) or H1; Li=L(i) or L1; x1=x;
   if i1>i then
      ma=Hi; mi=Li; jma=i; jmi=i;
   end
   if Hi and Li then
      local j=i-Settings.kijun_period; if j<1 then j=1; end
      if j>jma or j>jmi then
         ma=Hi; mi=Li; jma=i; jmi=i;
         while i>j do
            Hi,Li=H(j),L(j)
            if Hi and Hi>ma then ma = Hi jma=j; end
            if Li and Li<mi then  mi =Li jmi=j;end
            j=j+1
         end
      else
         if Hi>ma then ma=Hi; jma=i; end
         if mi>Li then mi=Li; jmi=i; end
      end
      x=(ma + mi)/2;    H1,L1,i1=Hi,Li,i;
   end
return x1
end

function OnChangeSettings()
   i1=0;jma=0; jmi=0; H1=0; L1=0;ma=0;mi=0;
end

function Init()
OnChangeSettings()
Settings.line = {{ Name=Settings.Name, Color=RGB(32,255,128), Type=TYPE_LINE, Width = 2,}}
return #Settings.line  end

Settings = {
   Name = "*Kijun-sen",
    kijun_period = 15,
   line = {{
       Name = "Kijun-sen",
       Color = RGB(255,255,255),
       Type = TYPE_LINE,
       Width = 2,
   }}
}

function Init()  return 1  end

function OnCalculate(i)
   local Hi,Li=H(i),L(i);
   if Hi and Li then
      local j=i-Settings.kijun_period; if j<1 then j=1; end
      max=Hi; min=Li;
      while i>j do
         Hi,Li=H(j),L(j)
         if Hi and Hi>max then max = Hi  end
         if Li and Li<min then  min =Li end
      j=j+1 end
      x=(max + min)/2;
   end
return x
end

Settings = {
   Name = "*Kijun-sen",
    kijun_period = 15,
   line = {{
       Name = "Kijun-sen",
       Color = RGB(255,255,255),
       Type = TYPE_LINE,
       Width = 2,
   }}
}

function Init()  return 1  end

function OnCalculate(i)
   local Hi,Li=H(i),L(i);
   if Hi and Li then
      if max==nil then max=Hi end
      if min==nil then min=Li end
      if Hi>max or min>Li then
      local j=i-Settings.kijun_period; if j<1 then j=1; end
         max=Hi; min=Li;
         while i>j do
            local Hj,Lj=H(j),L(j)
            if Hj and Hj>max then max = Hj  end
            if Lj and Lj<min then  min =Lj end
         j=j+1 end
      end
      x=(max + min)/2;
   end
return x;
end

Settings = {
   Name = "*Kijun-sen",
    kijun_period = 26,  -- Период Kijun-sen (можно изменить)
   line = {{
       Name = "Kijun-sen",
       Color = RGB(0,255,255),
       Type = TYPE_LINE,
       Width = 2,
   }}
}

function Init()  return 1 end

function OnCalculate(i)
   if H(i) and L(i) then
      local j=i-Settings.kijun_period; if j<1 then j=1; end
      max=H(i); min=L(i);
      while i>j do
         local H,L=H(j),L(j)
         if H and H>max then max = H  end
         if L and L<min then  min =L end
      j=j+1 end
      return (max + min)/2;
   end
end

Settings = {
   Name = "*Kijun-sen",
    kijun_period = 26,  -- Период Kijun-sen (можно изменить)
   line = {{
       Name = "Kijun-sen",
       Color = RGB(0, 0, 255),
       Type = TYPE_LINE,
       Width = 2,
   }}
}

function Init()  return 1 end

function OnCalculate(i)
   high = H(i) low = L(i)
   if high and low then
      if i==1 then
         max = H(1)  min = L(1)
      else
      if i%Settings.kijun_period==0 then  max = high; min =low end
      if high > max then max = high  end
      if low < min then  min = low    end
   return (max + min)/2;
      end
   end
end

Settings = {
   Name = "*Kijun-sen",
   kijun_period = 26,  -- Период Kijun-sen (можно изменить)
   line = {{
       Name = "Kijun-sen",
       Color = RGB(0, 0, 255),
       Type = TYPE_LINE,
       Width = 2,

   }}
}

Settings = {
   Name = "*Kijun-sen",
   line = {{
       Name = "Kijun-sen",
       Color = RGB(0, 0, 255),
       Type = TYPE_LINE,
       Width = 2,
      kijun_period = 26  -- Период Kijun-sen (можно изменить)
   }}
}

function Init()  return 1 end

function OnCalculate(i)
   if i==1 then
      max_high = H(1)
       min_low = L(1)
   else
   if i%Settings.kijun_period==0 then  max_high = H(i); min_low = L(i) end
      current_high = H(i)
       current_low = L(i)
   -- Поиск максимума и минимума за период
      if current_high > max_high then max_high = current_high  end
      if current_low < min_low then  min_low = current_low     end
   -- Расчет Kijun-sen
   end
   return (max_high + min_low) / 2
end

Settings = {
    Name = "*Kijun-sen",
    line = {{
        Name = "Kijun-sen",
        Color = RGB(0, 0, 255),
        Type = TYPE_LINE,
        Width = 2
    }}
}

function Init()
    return 1
end

local kijun_period = 26  -- Период Kijun-sen (можно изменить)

function OnCalculate(index)
    -- Проверяем, достаточно ли данных для расчета
    if index < kijun_period - 1 then
        return nil
    end
    
    -- Инициализация переменных для экстремумов
    local max_high = High(index - kijun_period + 1)
    local min_low = Low(index - kijun_period + 1)
    
    -- Поиск максимума и минимума за период
    for i = index - kijun_period + 2, index do
        local current_high = High(i)
        local current_low = Low(i)
        
        if current_high > max_high then
            max_high = current_high
        end
        
        if current_low < min_low then
            min_low = current_low
        end
    end
    
    -- Расчет Kijun-sen
    return (max_high + min_low) / 2
end

{
    "instruments": [
        {
            "name": "SBER",
            "start_date": "2015-01-01",
            "decimal_places": 2,
            "intervals": [1, 10, 60, 24],
            "parameters": ["open", "high", "low", "close", "volume"],
            "board": "TQBR"
        },
        {
            "name": "GAZP",
            "start_date": "2015-01-01",
            "decimal_places": 2,
            "intervals": [1, 10, 60, 24],
            "parameters": ["open", "high", "low", "close", "volume"],
            "board": "TQBR"
        }
    ]
}

import os
import pandas as pd
import requests
import json
from datetime import datetime, timedelta

def load_config(config_file="config.json"):
    """
    Загружает конфигурацию из JSON файла

    Параметры:
    config_file (str): Путь к файлу конфигурации

    Возвращает:
    dict: Конфигурация
    """
    if not os.path.exists(config_file):
        print(f"Файл конфигурации {config_file} не найден")
        return None

    try:
        with open(config_file, 'r', encoding='utf-8') as f:
            config = json.load(f)
        return config
    except Exception as e:
        print(f"Ошибка при загрузке конфигурации: {e}")
        return None

def fetch_moex_data(ticker, start_date, end_date, interval=60):
    """
    Загружает данные с MOEX API для указанного тикера и временного периода

    Параметры:
    ticker (str): Тикер инструмента
    start_date (datetime): Начальная дата загрузки
    end_date (datetime): Конечная дата загрузки
    interval (int): Интервал свечей в минутах (по умолчанию 60 минут)

    Возвращает:
    pd.DataFrame: DataFrame с загруженными данными
    """
    data = []
    current_start = start_date
    print(f"Загрузка данных с MOEX для {ticker} (интервал: {interval} мин) с {start_date} по {end_date}...")

    while True:
        url = f"http://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities/{ticker}/candles.json"
        params = {
            'from': current_start.strftime('%Y-%m-%d'),
            'till': end_date.strftime('%Y-%m-%d'),
            'interval': interval,
            'start': 0
        }

        try:
            response = requests.get(url, params=params)
            response.raise_for_status()  # Проверка на ошибки HTTP
            json_data = response.json()

            if 'candles' not in json_data or 'data' not in json_data['candles']:
                print("Нет данных в ответе API")
                break

            candles = pd.DataFrame(json_data['candles']['data'],
                                  columns=json_data['candles']['columns'])

            if len(candles) == 0:
                break

            data.append(candles)

            # Обновляем время для следующего запроса
            current_start = (pd.to_datetime(candles['end'].iloc[-1]) + timedelta(minutes=interval))

            if len(candles) < 500:  # Если получено меньше 500 записей, это последняя порция
                break

        except requests.exceptions.RequestException as e:
            print(f"Ошибка при запросе данных: {e}")
            break

    print(f"Загружено {len(data)} блоков данных")

    if not data:
        return pd.DataFrame()

    # Объединяем все блоки данных и удаляем дубликаты
    return pd.concat(data).drop_duplicates()

def process_raw_data(raw_data):
    """
    Обрабатывает сырые данные: разделяет begin на date и time, удаляет end

    Параметры:
    raw_data (pd.DataFrame): Сырые данные с MOEX

    Возвращает:
    pd.DataFrame: Обработанные данные
    """
    # Разделение begin на date и time
    raw_data['date'] = pd.to_datetime(raw_data['begin']).dt.date

    # Преобразование времени в формат без двоеточий (HHMMSS)
    raw_data['time'] = pd.to_datetime(raw_data['begin']).dt.strftime('%H%M%S')

    # Удаление ненужных столбцов
    columns_to_keep = ['date', 'time', 'open', 'high', 'low', 'close', 'volume']
    processed_data = raw_data[columns_to_keep].copy()

    # Сортировка по дате и времени
    processed_data = processed_data.sort_values(['date', 'time'])

    return processed_data

def get_last_available_date(ticker_dir):
    """
    Определяет последнюю дату, за которую есть данные в структуре каталогов

    Параметры:
    ticker_dir (str): Путь к каталогу тикера

    Возвращает:
    datetime.date: Последняя дата или None, если данных нет
    """
    last_date = None

    # Проходим по всем подкаталогам (годы)
    if not os.path.exists(ticker_dir):
        return None

    for year_dir in os.listdir(ticker_dir):
        year_path = os.path.join(ticker_dir, year_dir)
        if not os.path.isdir(year_path):
            continue

        # Проходим по месяцам
        for month_dir in os.listdir(year_path):
            month_path = os.path.join(year_path, month_dir)
            if not os.path.isdir(month_path):
                continue

            # Проходим по дням
            for day_dir in os.listdir(month_path):
                day_path = os.path.join(month_path, day_dir)
                if not os.path.isdir(day_path):
                    continue

                # Проверяем, что имя дня - это число (день месяца)
                if not day_dir.isdigit():
                    continue

                # Формируем дату: год, месяц, день
                try:
                    year = int(year_dir)
                    month = int(month_dir)
                    day = int(day_dir)
                    current_date = datetime(year, month, day).date()
                except:
                    continue

                # Сравниваем с последней датой
                if last_date is None or current_date > last_date:
                    last_date = current_date

    return last_date

def update_data_file(ticker, interval, output_dir, start_date, end_date):
    """
    Обновляет файлы данных, добавляя новые записи при необходимости

    Параметры:
    ticker (str): Тикер инструмента
    interval (int): Интервал свечей в минутах
    output_dir (str): Путь к каталогу для сохранения данных
    start_date (datetime): Начальная дата для загрузки
    end_date (datetime): Конечная дата для загрузки

    Возвращает:
    None
    """
    # Определяем последнюю дату, за которую есть данные
    last_date = get_last_available_date(output_dir)

    if last_date is None:
        # Данных нет, загружаем с начальной даты
        new_start_date = start_date
        print("Не найдено существующих данных. Загружаем все данные...")
    else:
        # Загружаем с последней даты (включительно)
        new_start_date = datetime.combine(last_date, datetime.min.time())
        print(f"Найдены данные до {last_date}. Загружаем новые данные начиная с этой даты...")

    # Загружаем данные с MOEX
    raw_data = fetch_moex_data(ticker, new_start_date, end_date, interval)

    if raw_data.empty:
        print("Нет новых данных для загрузки")
        return

    # Обрабатываем данные
    processed_data = process_raw_data(raw_data)

    # Сохраняем данные, разбивая по датам
    save_data_by_date(ticker, interval, output_dir, processed_data)

    print(f"Загружено и сохранено {len(processed_data)} записей")

def save_data_by_date(ticker, interval, output_dir, data):
    """
    Сохраняет данные с разбиением по датам в подкаталоги

    Параметры:
    ticker (str): Тикер инструмента
    interval (int): Интервал в минутах
    output_dir (str): Базовый каталог для сохранения
    data (pd.DataFrame): Данные для сохранения

    Возвращает:
    None
    """
    # Получаем имя интервала
    interval_name = get_interval_name(interval)

    # Группируем данные по датам
    grouped = data.groupby('date')

    for date, day_data in grouped:
        # Разбиваем дату на год, месяц, день
        year = date.year
        month = date.month
        day = date.day

        # Форматируем месяц и день с ведущими нулями
        month_str = f"{month:02d}"
        day_str = f"{day:02d}"

        # Формируем путь к каталогу для этой даты
        date_dir = os.path.join(output_dir, str(year), month_str, day_str)

        # Создаем каталог, если он не существует
        os.makedirs(date_dir, exist_ok=True)

        # Создаем подкаталог для интервала
        interval_dir = os.path.join(date_dir, interval_name)
        os.makedirs(interval_dir, exist_ok=True)

        # Удаляем столбец date перед сохранением
        day_data_to_save = day_data.drop(columns=['date'])

        # Сохраняем каждый параметр в отдельный файл
        for column in day_data_to_save.columns:
            file_path = os.path.join(interval_dir, column)

            # Сохраняем столбец без индекса и без заголовка
            day_data_to_save[column].to_csv(file_path, index=False, header=False)

            print(f"Сохранено {len(day_data_to_save[column])} значений параметра '{column}' за {date} в {file_path}")

def get_interval_name(interval):
    """
    Преобразует интервал в минутах в текстовое представление

    Параметры:
    interval (int): Интервал в минутах

    Возвращает:
    str: Текстовое представление интервала
    """
    if interval == 1:
        return "1min"
    elif interval == 10:
        return "10min"
    elif interval == 60:
        return "1hour"
    elif interval == 1440:
        return "1day"
    else:
        return f"{interval}min"

if __name__ == "__main__":
    # Загрузка конфигурации
    config = load_config()
    if not config:
        print("Не удалось загрузить конфигурацию. Выход...")
        exit(1)

    # Параметры загрузки
    end_date = datetime.now()

    print(f"Начало загрузки данных для тикеров: {', '.join([item['ticker'] for item in config['tickers']])}")
    print(f"Период: с {min([datetime.strptime(item['start_date'], '%Y-%m-%d') for item in config['tickers']])} по {end_date.strftime('%Y-%m-%d')}")
    print("-" * 50)

    # Обработка каждого тикера и интервала
    for ticker_config in config['tickers']:
        ticker = ticker_config['ticker']
        start_date_str = ticker_config['start_date']
        intervals = ticker_config['intervals']

        # Преобразование начальной даты из строки в datetime
        try:
            start_date = datetime.strptime(start_date_str, '%Y-%m-%d')
        except ValueError:
            print(f"Ошибка в формате даты для тикера {ticker}: {start_date_str}")
            continue

        print(f"\nОбработка тикера: {ticker} (начальная дата: {start_date_str})")
        print(f"Интервалы: {', '.join([get_interval_name(i) for i in intervals])}")

        # Формирование пути к каталогу для сохранения данных
        base_dir = "moex"
        ticker_dir = os.path.join(base_dir, ticker)

        # Обработка каждого интервала для текущего тикера
        for interval in intervals:
            print(f"\nОбработка интервала: {get_interval_name(interval)}")

            # Обновление файла данных
            update_data_file(ticker, interval, ticker_dir, start_date, end_date)

            # Проверка сохраненных данных
            print("\nПроверка сохраненных данных:")
            interval_name = get_interval_name(interval)

            # Проверяем наличие подкаталогов с датами
            if os.path.exists(ticker_dir):
                # Собираем все даты из структуры каталогов
                dates_found = []

                # Проходим по годам
                for year_dir in sorted(os.listdir(ticker_dir)):
                    year_path = os.path.join(ticker_dir, year_dir)
                    if not os.path.isdir(year_path):
                        continue

                    # Проходим по месяцам
                    for month_dir in sorted(os.listdir(year_path)):
                        month_path = os.path.join(year_path, month_dir)
                        if not os.path.isdir(month_path):
                            continue

                        # Проходим по дням
                        for day_dir in sorted(os.listdir(month_path)):
                            day_path = os.path.join(month_path, day_dir)
                            if not os.path.isdir(day_path):
                                continue

                            # Проверяем наличие подкаталога с интервалом
                            interval_path = os.path.join(day_path, interval_name)
                            if os.path.isdir(interval_path):
                                # Формируем дату для отображения
                                try:
                                    year = int(year_dir)
                                    month = int(month_dir)
                                    day = int(day_dir)
                                    date_str = f"{year:04d}-{month:02d}-{day:02d}"
                                    dates_found.append(date_str)
                                except:
                                    pass

                if dates_found:
                    print(f"Найдено {len(dates_found)} дат с данными:")
                    # Показываем последние 5 дат
                    for date_str in sorted(dates_found)[-5:]:
                        # Формируем путь к каталогу интервала
                        interval_path = os.path.join(ticker_dir, date_str.split('-')[0],
                                                    date_str.split('-')[1], date_str.split('-')[2],
                                                    interval_name)

                   #     if os.path.exists(interval_path):
                    #        print(f"  {date_str}:")

                            # Проверяем наличие файлов с параметрами
                    #        for param in ['time', 'open', 'high', 'low', 'close', 'volume']:
                    #            param_file = os.path.join(interval_path, param)
                    #            if os.path.exists(param_file):
                    #                # Читаем файл
                    #                param_data = pd.read_csv(param_file, header=None)
                    #                print(f"    {param}: {len(param_data)} значений")

                                    # Выводим последние 3 значения для проверки
                               #     if len(param_data) > 0:
                               #         print(f"      Последние 3 значения: {', '.join(map(str, param_data.tail(3).values.flatten()))}")
                    #    else:
                    #        print(f"  {date_str}: каталог интервала не найден")
                else:
                    print("Данные не найдены")
            else:
                print(f"Каталог тикера {ticker} не найден")

            print("-" * 30)

   #     print("-" * 50)

    print("\nЗагрузка данных завершена для всех инструментов и интервалов")

Вот переписанная функция на Lua с учетом особенностей языка:

function rman(src, len)
    -- Создаем матрицу как таблицу таблиц
    local m = {}
    for k = 1, len do
        -- Используем 1-индексацию, храним исходный индекс как k-1 (0-based)
        m[k] = { 
            src[k] or 0,  -- nz() аналог: заменяем nil/NaN на 0
            k - 1         -- сохраняем 0-based индекс
        }
    end

    -- Сортировка по первому элементу (значению) по убыванию
    table.sort(m, function(a, b) 
        return a[1] > b[1] 
    end)

    -- Вычисление суммы квадратов разностей
    local sum = 0.0
    for k = 1, len do
        local original_index = m[k][2]  -- исходный 0-based индекс
        local current_index = k - 1     -- текущий 0-based индекс
        sum = sum + math.pow(original_index - current_index, 2)
    end

    return sum
end


Ключевые отличия и пояснения:Индексация:Lua использует 1-based индексацию, 
поэтому циклы идут от 1 до len Исходные индексы (0-based) сохраняются как k - 1Матрица:
Реализована как таблица таблиц m = {}Каждая строка: { значение, исходный_индекс }
Обработка NaN/nil:Аналог nz() - src[k] or 0 заменяет nil/NaN на 0
Для строгой проверки NaN можно добавить: type(src[k]) == "number" and src[k] == src[k]
Сортировка:Используется table.sort() с кастомным компаратором 
Сортировка по первому элементу (значению) по убываниюВычисление суммы:
В цикле сравниваются исходный индекс и текущая позицияРазница возводится в квадрат через math.pow()
Пример использования:lua

local data = {10, 30, 20, 50, 40}
local result = rman(data, #data)
print(result)  -- Выведет: 10.0

Особенности реализации:Функция принимает таблицу src и длину len 
Возвращает число (сумму квадратов разностей)Корректно обрабатывает:
Отрицательные числа Нулевые значенияДубликаты в исходных данныхНеопределенные значения (nil/NaN)
Для работы с очень большими массивами (>100K элементов) рекомендуется оптимизировать сортировку, 
но для типичных случаев (например, технический анализ) текущая реализация эффективна.