Navigation:Home > Content >

b-PSI@Arrays_New.mq4

Time: 2012-03-07 | Download file:b-PSI@Arrays_New.mq4

//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|                                                                  b-PSI@Arrays.mq4 |
//|                                    Copyright © 2013-14, Igor Stepovoi aka TarasBY |
//|                                                                taras_bulba@tut.by |
//| 23.04.2013  Библиотека функций работы с массивами.                                |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|   Данный продукт предназначен для некомерческого использования. Публикация разре- |
//|шена только при указании имени автора (TarasBY). Редактирование исходного кода до- |
//|пустима только при условии сохранения данного текста, ссылок и имени автора.  Про- |
//|дажа библиотеки или отдельных её частей ЗАПРЕЩЕНА.                                 |
//|   Автор не несёт ответственности за возможные убытки, полученные в результате ис- |
//|пользования библиотеки.                                                            |
//|   По всем вопросам, связанным с работой библиотеки, замечаниями или предложениями |
//|по её доработке обращаться на Skype: TarasBY или e-mail.                           |
//+-----------------------------------------------------------------------------------+
//|   This product is intended for non-commercial use.  The publication is only allo- |
//|wed when you specify the name of the author (TarasBY). Edit the source code is va- |
//|lid only under condition of preservation of the text, links and author's name.     |
//|   Selling a module or(and) parts of it PROHIBITED.                                |
//|   The author is not liable for any damages resulting from the use of a module.    |
//|   For all matters relating to the work of the module, comments or suggestions for |
//|their improvement in the contact Skype: TarasBY or e-mail.                         |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
#property copyright "Copyright © 2008-14, TarasBY WM R418875277808; Z670270286972"
#property link      "taras_bulba@tut.by"
#property library
//IIIIIIIIIIIIIIIIIII==================CONSTANS=================IIIIIIIIIIIIIIIIIIIIII+
//IIIIIIIIIIIIIIIIIII========Глобальные переменные модуля=======IIIIIIIIIIIIIIIIIIIIII+
//IIIIIIIIIIIIIIIIIII=========Подключение внешних модулей=======IIIIIIIIIIIIIIIIIIIIII+
//IIIIIIIIIIIIIIIIIII===========Перечень функций модуля=========IIIIIIIIIIIIIIIIIIIIII+
//|***********************************************************************************|
//| РАЗДЕЛ: Работы с массивами                                                        |
//|***********************************************************************************|
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fGet_INDInArrayDBL            - Получаем индекс искомого элемента в массиве double
//+-----------------------------------------------------------------------------------+
(
    double& ar_Extrem[],            // возвращаемый массив экстремумов
    double fd_Value,                // Искомый элемент
    double& ar_Array[],             // Проверяемый массив
    int fi_Digits                   // Округление сравниваемых чисел
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fGet_INDInArrayINT            - Получаем индекс искомого элемента в массиве int
//+-----------------------------------------------------------------------------------+
(
    int fi_Value,                   // Искомый элемент
    int& ar_Array[]                 // Проверяемый массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fGet_INDInArraySTR            - Получаем индекс искомого элемента в массиве string
//+-----------------------------------------------------------------------------------+
(
    string fs_Value,                // Искомый элемент
    string& ar_Array[]              // Проверяемый массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fComplete_ArraysSTR           - Объединяем два массива string
//+-----------------------------------------------------------------------------------+
(
    string& ar_Array1[],            // основной массив
    string& ar_Array2[]             // дополнительный массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fComplete_ArraysINT           - Объединяем два массива int
//+-----------------------------------------------------------------------------------+
(
    int& ar_Array1[],               // основной массив
    int& ar_Array2[]                // дополнительный массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fComplete_ArraysDBL           - Объединяем два массива double
//+-----------------------------------------------------------------------------------+
(
    double& ar_Array1[],            // основной массив
    double& ar_Array2[]             // дополнительный массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fCheck_DublicateSTR           - Проверяем массив string на наличие дубликатов
//+-----------------------------------------------------------------------------------+
(
    string& ar_Array[]              // рабочий массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fCheck_DublicateINT           - Проверяем массив int на наличие дубликатов
//+-----------------------------------------------------------------------------------+
(
    int& ar_Array[]                 // рабочий массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fGet_NumPeriods               - Получаем номер периода графика
//+-----------------------------------------------------------------------------------+
(
    int fi_Period
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fGet_PeriodFromNum            - Получаем периода графика по номеру
//+-----------------------------------------------------------------------------------+
(
    int fi_Num
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void InitializeArray_STR          - Инициализируем массив STRING
//+-----------------------------------------------------------------------------------+
(
    string& fsa_Array[],            // заполняемый массив
    string fs_Value = ""            // заполняемые значения
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fCreat_ArrayGV               - Создаём массив имён временных GV-переменных
//+-----------------------------------------------------------------------------------+
(
    string& ar_Base[],              // рабочий массив
    string& ar_Add[]                // добавляемы массив
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fSplitStrToStr                - Возвращает массив STRING из строки, разделённой sDelimiter
//+-----------------------------------------------------------------------------------+
(
    string fs_List,                 // строка с данными
    string& ar_OUT[],               // возвращаемый массив
    string fs_Delimiter = ","       // разделитель данных в строке
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fAdd_ListToArraySTR           - Добавляем к рабочему массиву значения из строки
//+-----------------------------------------------------------------------------------+
(
    string& ar_Array[],             // рабочий массив
    string fs_List,                 // добавлляемая строка
    string fs_Delimiter = ","       // разделитель значений в строке fs_List
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fCreat_StrToInt              - Возвращает массив INT из элементов массива STRING
//+-----------------------------------------------------------------------------------+
(
    string& ar_Value[],             // массив элементов string
    int& ar_OUT[],                  // возвращаемый массив int
    int fi_IND,                     // количество ячеек в массиве
    int fi_Factor = 1,              // множитель
    string fs_NameArray = ""        // имя возвращаемого массива
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fCreat_StrToDouble           - Возвращает массив DOUBLE из элементов массива STRING
//+-----------------------------------------------------------------------------------+
(
    string& ar_Value[],             // массив элементов string
    double& ar_OUT[],               // возвращаемый массив double
    int fi_IND,                     // количество ячеек в массиве
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = ""        // имя возвращаемого массива
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*string fCreat_StrAndArray         - Возвращает строку из элементов массива INT и сам массив
//+-----------------------------------------------------------------------------------+
(
    int fi_First,                   // значение 1-го эелемента массива
    int& ar_OUT[],                  // возвращаемый массив int
    int fi_cntIND,                  // количество элементов в массиве
    string fs_Delimiter = ","       // разделитель элементов в возвращаемой строке
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*string fCreat_StrFromArray        - Возвращает строку из элементов массива, разделённых fs_Delimiter
//+-----------------------------------------------------------------------------------+
(
    string& ar_Array[],             // массив со значениями
    string fs_Delimiter = ","       // разделитель элементов в возвращаемой строке
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fInit_ArrayINT                - Инициализация рабочего массива int
//+-----------------------------------------------------------------------------------+
(
    int& ar_INT[],                  // Инициализируемый массив
    string fs_List,                 // Инициализируемые значения в строке
    int fi_Range,                   // Размер массива
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "",       // имя возвращаемого массива
    string fs_Delimiter = ","       // Разделитель значений в строке
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fInit_ArrayDBL                - Инициализация рабочего массива double
//+-----------------------------------------------------------------------------------+
(
    double& ar_DBL[],               // Инициализируемый массив
    string fs_List,                 // Инициализируемые значения в строке
    int fi_Range,                   // Размер массива
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "",       // имя возвращаемого массива
    string fs_Delimiter = ","       // Разделитель значений в строке
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fInit_ArrayBOOL               - Инициализация рабочего массива bool
//+-----------------------------------------------------------------------------------+
(
    bool& ar_BOOL[],                // Инициализируемый массив
    string fs_List,                 // Инициализируемые значения в строке
    int fi_Range,                   // Размер массива
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "",       // имя возвращаемого массива
    string fs_Delimiter = ","       // Разделитель значений в строке
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fShiftIndex                  - Освобождаем 0-ячейку со сдвигом вверх для записи текущих значений
//+-----------------------------------------------------------------------------------+
(
    double& ar_MAS[],               // массив значений
    bool fb_Conditions = false      // разрешение на увеличение размерности массива
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fShift_IndexDBL              - Освобождаем 0-ячейку со сдвигом вверх для записи текущих значений
//+-----------------------------------------------------------------------------------+
(
    double& ar_MAS[][],             // массив значений
    double& ar_TMP[][],             // временный массив
    bool fb_Conditions = false      // разрешение на увеличение размерности массива
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fRun_Sort                    - Сортируем индексы массива по убыванию значений массива fda_Value
//+-----------------------------------------------------------------------------------+
(
    int& ar_INDEX[],                // массив индексов для сортировки
    double& fda_Value[]             // массив значений
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*void fSet_FirstIndexDBL           - Заполняем fi_IND-ячейку всех индексов 0-го измерения заданным значением
//+-----------------------------------------------------------------------------------+
(
    double& ar_MAS[][],             // массив значений
    int fi_IND,                     // индекс 2-го измерения массива
    double fd_Value                 // передаваемое значение
)*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//+===================================================================================+
//|***********************************************************************************|
//| РАЗДЕЛ: Работы с массивами                                                        |
//|***********************************************************************************|
//+===================================================================================+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|  UNI:  Получаем индекс искомого элемента в массиве                                |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fGet_INDInArrayDBL (
    double fd_Value,                // Искомый элемент
    double& ar_Array[],             // Проверяемый массив
    int fi_Digits)                  // Округление сравниваемых чисел
//+...................................................................................+
{
//---- 
    for (int li_IND = 0; li_IND < ArraySize (ar_Array); li_IND++)
    {if (NormalizeDouble (ar_Array[li_IND] - fd_Value, fi_Digits) == 0.0) return (li_IND);}
//---- 
    return (-1);
}
//+-----------------------------------------------------------------------------------+
int fGet_INDInArrayINT (
    int fi_Value,                   // Искомый элемент
    int& ar_Array[])                // Проверяемый массив
//+...................................................................................+
{
//---- 
    for (int li_IND = 0; li_IND < ArraySize (ar_Array); li_IND++)
    {if (ar_Array[li_IND] == fi_Value) return (li_IND);}
//---- 
    return (-1);
}
//+-----------------------------------------------------------------------------------+
int fGet_INDInArraySTR (
    string fs_Value,
	string& ar_Array[])
//+...................................................................................+
{
//---- 
    for (int li_IND = 0; li_IND < ArraySize (ar_Array); li_IND++)
    {if (ar_Array[li_IND] == fs_Value) return (li_IND);}
//---- 
    return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|  UNI:  Объединяем два массива                                                     |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fComplete_ArraysSTR (
    string& ar_Array1[],            // основной массив
    string& ar_Array2[])            // дополнительный массив
//+...................................................................................+
{
    int li_size1 = ArraySize (ar_Array1), li_size2 = ArraySize (ar_Array2),
        li_size = li_size1 + li_size2, cnt = 0;
//----
    ArrayResize (ar_Array1, li_size);
    for (int li_IND = li_size1; li_IND < li_size; li_IND++)
    {ar_Array1[li_IND] = ar_Array2[cnt]; cnt++;}
//----
    return (li_size);
}
//+-----------------------------------------------------------------------------------+
int fComplete_ArraysINT (
    int& ar_Array1[],               // основной массив
    int& ar_Array2[])               // дополнительный массив
//+...................................................................................+
{
    int li_size1 = ArraySize (ar_Array1), li_size2 = ArraySize (ar_Array2),
        li_size = li_size1 + li_size2, cnt = 0;
//----
    ArrayResize (ar_Array1, li_size);
    for (int li_IND = li_size1; li_IND < li_size; li_IND++)
    {ar_Array1[li_IND] = ar_Array2[cnt]; cnt++;}
//----
    return (li_size);
}
//+-----------------------------------------------------------------------------------+
int fComplete_ArraysDBL (
    double& ar_Array1[],            // основной массив
    double& ar_Array2[])            // дополнительный массив
//+...................................................................................+
{
    int li_size1 = ArraySize (ar_Array1), li_size2 = ArraySize (ar_Array2),
        li_size = li_size1 + li_size2, cnt = 0;
//----
    ArrayResize (ar_Array1, li_size);
    for (int li_IND = li_size1; li_IND < li_size; li_IND++)
    {ar_Array1[li_IND] = ar_Array2[cnt]; cnt++;}
//----
    return (li_size);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|  UNI:  Проверяем массив на наличие дубликатов                                     |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fCheck_DublicateSTR (string& ar_Array[])  // рабочий массив string
{
    int  li_int, li_size = ArraySize (ar_Array), cnt = 0;
    bool lb_duble;
//----
    for (int li_IND = 0; li_IND < li_size; li_IND++)
    {
        lb_duble = false;
        //---- Осуществляем проверку на дубликаты
        if (cnt > 0)
        {
            for (li_int = 0; li_int < cnt; li_int++)
            {
                if (ar_Array[li_IND] == ar_Array[li_int])
                {lb_duble = true; break;}
            }
        }
        //---- Если дубликат - идём дальше
        if (lb_duble) continue;
        //---- Перезаполняем масссив
        ar_Array[cnt] = ar_Array[li_IND];
        //---- Увеличиваем счётчик
        cnt++;
    }
    //---- Изменяем размер массива
    ArrayResize (ar_Array, cnt);
//----
    return (cnt);
}
//+-----------------------------------------------------------------------------------+
int fCheck_DublicateINT (int& ar_Array[])  // рабочий массив int
{
    int  li_int, li_size = ArraySize (ar_Array), cnt = 0;
    bool lb_duble;
//----
    for (int li_IND = 0; li_IND < li_size; li_IND++)
    {
        lb_duble = false;
        //---- Осуществляем проверку на дубликаты
        if (cnt > 0)
        {
            for (li_int = 0; li_int < cnt; li_int++)
            {
                if (ar_Array[li_IND] == ar_Array[li_int])
                {lb_duble = true; break;}
            }
        }
        //---- Если дубликат - идём дальше
        if (lb_duble) continue;
        //---- Перезаполняем масссив
        ar_Array[cnt] = ar_Array[li_IND];
        //---- Увеличиваем счётчик
        cnt++;
    }
    //---- Изменяем размер массива
    ArrayResize (ar_Array, cnt);
//----
    return (cnt);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|  UNI:  Получаем номер периода графика                                             |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fGet_NumPeriods (int fi_Period)
{
    static int lia_Periods[] = {1,5,15,30,60,240,1440,10080,43200};
//---- 
    for (int l_int = 0; l_int < ArraySize (lia_Periods); l_int++)
    {if (lia_Periods[l_int] == fi_Period) return (l_int);}
//---- 
    return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|  UNI:  Получаем периода графика по номеру                                         |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fGet_PeriodFromNum (int fi_Num)
{
    static int lia_Periods[] = {1,5,15,30,60,240,1440,10080,43200};
//---- 
//---- 
    return (lia_Periods[fi_Num]);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Создаём массив имён временных GV-переменных                                |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fCreat_ArrayGV (
    string& ar_Base[],              // рабочий массив
    string& ar_Add[])               // добавляемый массив
//+...................................................................................+
{
    int  li_int, li_sizeB = ArraySize (ar_Base), li_sizeA = ArraySize (ar_Add);
    bool lb_duble;
//----
    for (int li_IND = 0; li_IND < li_sizeA; li_IND++)
    {
        lb_duble = false;
        //---- Осуществляем проверку на дубликаты
        for (li_int = 0; li_int < li_sizeB; li_int++)
        {
            if (ar_Add[li_IND] == ar_Base[li_int])
            {lb_duble = true; break;}
        }
        //---- Если дубликат - идём дальше
        if (lb_duble) continue;
        //---- Увеличиваем счётчик
        li_sizeB++;
        //---- Увеличиваем базовый массив
        ArrayResize (ar_Base, li_sizeB);
        //---- Вносим в последнюю ячейку новое значение
        ar_Base[li_sizeB - 1] = ar_Add[li_IND];
    }
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Возвращает массив STRING из строки, разделённой sDelimiter                 |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fSplitStrToStr (
    string fs_List,                 // строка с данными
    string& ar_OUT[],               // возвращаемый массив
    string fs_Delimiter = ",")      // разделитель данных в строке
//+...................................................................................+
{
    string tmp_str = "", tmp_char = "";
    int    cnt = 0;
//----
    ArrayResize (ar_OUT, 0);
    //---- Проходимся по строке
    for (int i = 0; i < StringLen (fs_List); i++)
    {
        //---- Проверяем каждый знак\символ
        tmp_char = StringSubstr (fs_List, i, 1);
        //---- Если текущий знак - разделитель
        if (tmp_char == fs_Delimiter)
        {
            //---- Обрезаем строку по краям
            if (StringTrimLeft (StringTrimRight (tmp_str)) != "")
            {
                cnt++;
                //---- Изменяем размер выходного массива
                ArrayResize (ar_OUT, cnt);
                //---- Записываем в последнюю ячейку полученнную строку
                ar_OUT[cnt-1] = tmp_str;
            }
            tmp_str = "";
        }
        //---- Формируем строку
        else {/*if (tmp_char != " ") */tmp_str = tmp_str + tmp_char;}
    }
    //---- Если остался обрезок начальной строки или строка состояла из одного параметра
    if (StringTrimLeft (StringTrimRight (tmp_str)) != "")
    {
        ArrayResize (ar_OUT, cnt + 1);
        ar_OUT[cnt] = tmp_str;
    }
//----
    return (ArraySize (ar_OUT));
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Добавляем к рабочему массиву значения из строки                            |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fAdd_ListToArraySTR (
    string& ar_Array[],             // рабочий массив
    string fs_List,                 // добавлляемая строка
    string fs_Delimiter = ",")      // разделитель значений в строке fs_List
//+...................................................................................+
{
    int li_size = ArraySize (ar_Array);
    if (fs_List == "") return (li_size);
//----
    string lsa_TMP[];
    int    li_N = fSplitStrToStr (fs_List, lsa_TMP, fs_Delimiter);
//----
    //---- Увеличиваем размер рабочего массива с учётом новых исключаемых слов и выражений
    ArrayResize (ar_Array, li_size + li_N);
    for (int li_IND = 0; li_IND < li_N; li_IND++)
    {ar_Array[li_size+li_IND] = lsa_TMP[li_IND];}
    //for (li_IND = 0; li_IND < li_size + li_N; li_IND++) Print (li_IND, ": ", ar_Array[li_IND]);
//----
    return (li_size + li_N);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Возвращает массив INT из элементов массива STRING                          |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fCreat_StrToInt (
    string& ar_Value[],             // массив элементов string
    int& ar_OUT[],                  // возвращаемый массив int
    int fi_IND,                     // количество ячеек в массиве
    int fi_Factor = 1,              // множитель
    string fs_NameArray = "")       // имя возвращаемого массива
//+...................................................................................+
{
    int    li_size = ArraySize (ar_Value);
    string ls_row = "";
//----
    ArrayResize (ar_OUT, fi_IND);
    for (int li_int = 0; li_int < fi_IND; li_int++)
    {
        if (li_int < li_size) {ar_OUT[li_int] = StrToInteger (ar_Value[li_int]) * fi_Factor;}
        else {ar_OUT[li_int] = StrToDouble (ar_Value[li_size - 1]) * fi_Factor;}
        ls_row = StringConcatenate (ls_row, fs_NameArray, "[", li_int, "] = ", ar_OUT[li_int], "; ");
    }
    if (fs_NameArray != "") Print (ls_row);
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Возвращает массив DOUBLE из элементов массива STRING                       |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fCreat_StrToDouble (
    string& ar_Value[],             // массив элементов string
    double& ar_OUT[],               // возвращаемый массив double
    int fi_IND,                     // количество ячеек в массиве
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "")       // имя возвращаемого массива
//+...................................................................................+
{
    int    li_size = ArraySize (ar_Value);
    string ls_row = "";
//----
    ArrayResize (ar_OUT, fi_IND);
    for (int li_int = 0; li_int < fi_IND; li_int++)
    {
        if (li_int < li_size) {ar_OUT[li_int] = StrToDouble (ar_Value[li_int]) * fd_Factor;}
        else {ar_OUT[li_int] = StrToDouble (ar_Value[li_size - 1]) * fd_Factor;}
        ls_row = StringConcatenate (ls_row, fs_NameArray, "[", li_int, "] = ", ar_OUT[li_int], "; ");
    }
    if (fs_NameArray != "") Print (ls_row);
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Возвращает строку из элементов массива INT и сам массив                    |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string fCreat_StrAndArray (
    int fi_First,                   // значение 1-го эелемента массива
    int& ar_OUT[],                  // возвращаемый массив int
    int fi_cntIND,                  // количество элементов в массиве
    string fs_Delimiter = ",")      // разделитель элементов в возвращаемой строке
//+...................................................................................+
{
    string ls_row = "";
//----
    ArrayResize (ar_OUT, fi_cntIND);
    for (int li_int = 0; li_int < fi_cntIND; li_int++)
    {
        if (li_int == fi_cntIND - 1) fs_Delimiter = "";
        ar_OUT[li_int] = fi_First + li_int;
        ls_row = StringConcatenate (ls_row, ar_OUT[li_int], fs_Delimiter);
    }
//----
    return (ls_row);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Возвращает строку из элементов массива, разделённых fs_Delimiter           |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string fCreat_StrFromArray (
    string& ar_Array[],             // массив со значениями
    string fs_Delimiter = ",")      // разделитель элементов в возвращаемой строке
//+...................................................................................+
{
    string ls_row = "";
    int    li_size = ArraySize (ar_Array);
//----
    for (int li_int = 0; li_int < li_size; li_int++)
    {
        if (li_int == li_size - 1) fs_Delimiter = "";
        ls_row = StringConcatenate (ls_row, ar_Array[li_int], fs_Delimiter);
    }
//----
    return (ls_row);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор    : TarasBY, taras_bulba@tut.by                                           |
//+-----------------------------------------------------------------------------------+
//|  Версия   : 02.08.2012                                                            |
//|  Описание : Инициализация рабочего массива.                                       |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fInit_ArrayINT (
    int& ar_INT[],                  // Инициализируемый массив
    string fs_List,                 // Инициализируемые значения в строке
    int fi_Range,                   // Размер массива
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "",       // имя возвращаемого массива
    string fs_Delimiter = ",")      // Разделитель значений в строке
//+...................................................................................+
{
//----
    //---- Ищем в строке разделитель - признак наличия в строке > 1 параметра
    if (StringFind (fs_List, fs_Delimiter) == -1) return (1);
    else
    {
        string lsa_TMP[];
        int    li_cnt = fSplitStrToStr (fs_List, lsa_TMP, ",");
        if (fi_Range > 0)
        {
            if (li_cnt != fi_Range)
            {
                Print (fs_NameArray, ": не соотвествие в размерности массива !!!");
                li_cnt = fi_Range;
            }
        }
        fCreat_StrToInt (lsa_TMP, ar_INT, li_cnt, fd_Factor, fs_NameArray);
    }
//----
    return (li_cnt);
}
//+-----------------------------------------------------------------------------------+
int fInit_ArrayDBL (
    double& ar_DBL[],               // Инициализируемый массив
    string fs_List,                 // Инициализируемые значения в строке
    int fi_Range,                   // Размер массива
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "",       // имя возвращаемого массива
    string fs_Delimiter = ",")      // Разделитель значений в строке
//+...................................................................................+
{
//----
    //---- Ищем в строке разделитель - признак наличия в строке > 1 параметра
    if (StringFind (fs_List, fs_Delimiter) == -1) return (1);
    else
    {
        string lsa_TMP[];
        int    li_cnt = fSplitStrToStr (fs_List, lsa_TMP, ",");
        if (fi_Range > 0)
        {
            if (li_cnt != fi_Range)
            {
                Print (fs_NameArray, ": не соотвествие в размерности массива !!!");
                li_cnt = fi_Range;
            }
        }
        fCreat_StrToDouble (lsa_TMP, ar_DBL, li_cnt, fd_Factor, fs_NameArray);
    }
//----
    return (li_cnt);
}
//+-----------------------------------------------------------------------------------+
int fInit_ArrayBOOL (
    bool& ar_BOOL[],                // Инициализируемый массив
    string fs_List,                 // Инициализируемые значения в строке
    int fi_Range,                   // Размер массива
    double fd_Factor = 1.0,         // множитель
    string fs_NameArray = "",       // имя возвращаемого массива
    string fs_Delimiter = ",")      // Разделитель значений в строке
//+...................................................................................+
{
//----
    //---- Ищем в строке разделитель - признак наличия в строке > 1 параметра
    if (StringFind (fs_List, fs_Delimiter) == -1) return (1);
    else
    {
        string lsa_TMP[];
        int    li_cnt = fSplitStrToStr (fs_List, lsa_TMP, ","), lia_TMP[];
        if (fi_Range > 0)
        {
            if (li_cnt != fi_Range)
            {
                Print (fs_NameArray, ": не соотвествие в размерности массива !!!");
                li_cnt = fi_Range;
            }
        }
        fCreat_StrToInt (lsa_TMP, lia_TMP, li_cnt, fd_Factor, fs_NameArray);
    }
    ArrayCopy (ar_BOOL, lia_TMP);
//----
    return (li_cnt);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Освобождаем 0-ячейку со сдвигом вверх для записи текущих значений          |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fShiftIndex (
    double& ar_MAS[],               // массив значений
    bool fb_Conditions = false)     // разрешение на увеличение размерности массива
//+...................................................................................+
{
    int    li_size = ArraySize (ar_MAS);
    double lda_TMP[];
//----
    //---- Задаём размер временному массиву
    ArrayResize (lda_TMP, li_size);
    //---- Копируем данные во временный массив
    ArrayCopy (lda_TMP, ar_MAS);
    //---- Если задано, увеличиваем размер исходного массива
    if (fb_Conditions) ArrayResize (ar_MAS, li_size + 1);
    //---- Обратно копируем данные из временного массива со здвигом на 1
    ArrayCopy (ar_MAS, lda_TMP, 1);
    //---- Нулевую ячейку исходного массива обнуляем
    ar_MAS[0] = 0.;
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Освобождаем 0-ячейку со сдвигом вверх для записи текущих значений          |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fShift_IndexDBL (
    double& ar_MAS[][],             // массив значений
    double& ar_TMP[][],             // временный массив
    bool fb_Conditions = false)     // разрешение на увеличение размерности массива
//+...................................................................................+
{
    int li_size = ArrayRange (ar_MAS, 0), li_Range1 = ArrayRange (ar_MAS, 1);
//----
    //---- Задаём размер временному массиву
    ArrayResize (ar_TMP, li_size);
    //---- Чистим временный массив
    ArrayInitialize (ar_TMP, 0.);
    //---- Копируем данные во временный массив
    ArrayCopy (ar_TMP, ar_MAS);
    //---- Если задано, увеличиваем размер исходного массива
    if (fb_Conditions) ArrayResize (ar_MAS, li_size + 1);
    //---- Обратно копируем данные из временного массива со здвигом на 1
    ArrayCopy (ar_MAS, ar_TMP, 1 * li_Range1);
    //---- Нулевую ячейку исходного массива обнуляем
    for (int li_IND = 0; li_IND < li_Range1; li_IND++)
    {ar_MAS[0][li_IND] = 0.;}
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  UNI:   Сортируем индексы массива по убыванию значений массива fda_Value          |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fRun_Sort (
    int& ar_INDEX[],                // массив индексов для сортировки
    double& fda_Value[])            // массив значений
//+...................................................................................+
{
    int li_IND, li_int, li_tmp, li_size = ArraySize (fda_Value);
//----
    for (li_IND = 0; li_IND < li_size; li_IND++) {ar_INDEX[li_IND] = li_IND;}
    for (li_IND = 0; li_IND < li_size; li_IND++)
    {
		for (li_int = li_IND + 1; li_int < li_size; li_int++)
		{
			if (fda_Value[ar_INDEX[li_IND]] < fda_Value[ar_INDEX[li_int]])
			{
				li_tmp = ar_INDEX[li_int]; 
				ar_INDEX[li_int] = ar_INDEX[li_IND]; 
				ar_INDEX[li_IND] = li_tmp;
			}
		}
	}
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|  Автор : TarasBY, taras_bulba@tut.by                                              |
//+-----------------------------------------------------------------------------------+
//|        Заполняем fi_IND-ячейку всех индексов 0-го измерения заданным значением    |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fSet_FirstIndexDBL (
    double& ar_MAS[][],             // массив значений
    int fi_IND,                     // индекс 2-го измерения массива
    double fd_Value)                // передаваемое значение
//+...................................................................................+
{
    int li_Size = ArrayRange (ar_MAS, 0);
//----
    for (int li_IND = 0; li_IND < li_Size; li_IND++)
	{ar_MAS[li_IND][fi_IND] = fd_Value;}
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//|        Функция возвращает количество значений равных find в массиве muss[]        |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fFind_ValuesInArray (
    double& muss[],                 // массив в котором ищем
    double find,                    // что ищем
    int begin = -1,                 // откуда (номер элемента в массиве) (если -1 - ищем от начала до кончала) (если -2 - ищем от конца до начала)
    int end = -1,                   // покуда (номер элемента в массиве) (если -1 - ищем до конца)             (если -2 - ищем до начала)
    int accuracy = 8)               // точность сравнения типов double, если меньше 0  - сравниваем без точности
//+...................................................................................+
{
    int size = ArraySize (muss);  
//----
    //---- Блок проверки верности входящих данных 
    //**********************************************************************************
    if (size == 0) return (-1);                 // массив не заполнен
    if (begin < -2) return (-2);                // значение begin меньше допустимого
    if (end < -2) return (-3);                  // значение end   меньше допустимого
    if (begin >= size) return (-4);             // значение begin больше допустимого
    if (end >= size) return (-5);               // значение end   больше допустимого
    //**********************************************************************************
    //---- Блок подготовки данных к расчету
    //**********************************************************************************
    int i, dd = 1,                              // имеет значение +1 или -1
        count = 0;                              // количество совпадений - возвращаемый результат
    if (begin == -1)                            // параметры для расчета от начала до конца
	{
        i = 0;
        end = size - 1;
    }
    else if (begin == -2)                       // параметры для расчета от конца до начала
	{
        i = size - 1;
        begin = 0;
        end = i;
        dd = -1;
    } 
    else
	{
        if (end == -1)                         // параметры для расчета от кудось до конца
		{
            i = begin;                                   
            end = size - 1;
        }
        else if (end == -2)                    // параметры для расчета от кудось до начала
		{
            i = begin;
            end = i;
            begin = 0;
            dd = -1;
        }
        else
		{
            i = begin;
            if (begin > end)                   // если begin>end
		    {
                dd = -1;
                begin = end;
                end = i;
            }
        }   
    }  
    //**********************************************************************************
    //---- Блок расчета
    //**********************************************************************************
    if (accuracy < 0)                          // если точность < 0
	{
        for (; i >= begin && i <= end; i + dd)
		{if (muss[i] == find) count++;}
    }
    else                                     // если точность > 0
	{
        for (; i >= begin && i <= end; i + dd)
        {if (NormalizeDouble (muss[i] - find, accuracy) == 0) count++;}
    }
//----
    return (count);
}*/
//**********************************************************************************
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+

Recommend