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+