Сравнивает элементы двух матриц/векторов на совпадение с точностью до значащих цифр
По поводу умножения на 100 см. пример на той же странице (*) с вычитанием скаляра из вектора:
doubleavr=r.Mean(); // среднее значение массива vectord=r-avr; // вычислим массив отклонений от среднего значения
Дело в том, что получив разницу между чисел или булево значение о равенстве мы вынуждены для дальнейшей работы всё равно проводить сравнение полученных результатов. А если мы по результатам применения неравенств к матрицам получим ответ булевый, то сможем применить switch для ветвления дальнейших действий, что ускорит процесс вычисления.
Конечно я смотрю всё, что сейчас публикуется разработчиками.
Добавил генератор исходных данных - теперь можно пробовать подумать об ускорении вычислений.
2022.09.2703:14:00.344 Terminal Windows 7 Service Pack 1 build 7601, Intel Atom N570 @ 1.66GHz, 0 / 1 Gb memory, 16 / 280 Gb disk, IE 11, UAC, GMT+32022.09.2908:59:12.379 Scripts script Primer (FORTS-USDRUB,M15) removed
2022.09.2908:59:40.042 Scripts script Primer (FORTS-USDRUB,M15) loaded successfully
Компьютер потратил 28 секунд на таблицу из 1000000 элементов. Конечно, компьютер слабенький - но всё же это не мало времени.
//+------------------------------------------------------------------+//| Primer.mq5 |//| Copyright 2016, MetaQuotes Software Corp. |//| https://www.mql5.com |//+------------------------------------------------------------------+#property copyright"-Aleks-"#property link"https://www.mql5.com/ru/users/-aleks-"#property version"1.00"#property script_show_inputs#property strictsinputbool Random_Data=false;//Генерировать таблицу с данными?input group "Параметры генерируемой таблицы"sinputint Strok_Total_Data_Random=1000;//Всего строкsinputint Stolb_Total_Data_Random=1000;//Всего столбцов//+------------------------------------------------------------------+//| Script program start function |//+------------------------------------------------------------------+float arr_Data[];//Массив для первичных данных - выборкаfloat arr_Quant[];//Массив с таблицами неравенств (сплитов)char arr_Target[];//Массив с целевымиfloat arr_MiniData[]=//Массив для проверки логики с малым числом примеров - первичные данные
{
7,0,1,
8,1,2,
9,0,3,
10,1,1,
11,0,2,
12,1,3,
13,0,1,
14,1,2,
15,0,3,
16,1,1
};
float arr_MiniQuant[]=//Массив для проверки логики с малым числом примеров - таблицы неравенств (сплитов)
{
0,10.5,
0,14.5,
0,15.5,
1,0.5,
2,0.5,
2,1.5
};
char arr_MiniTarget[]=//Массив с целевыми
{
0,
1,
0,
1,
0,
1,
0,
1,
0,
1
};
int Strok_Total_Data=10;//Количество строк в таблице Dataint Stolb_Total_Data=3;//Количество столбцов в таблице Dataint Strok_Total_Quant=6;//Количество строк в таблице Quantint Stolb_Total_Quant=2;//Количество столбцов в таблице Quant//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+voidOnStart()
{
if(Random_Data==true)//Сгенерируем данные для оценки времени работы алгоритма
{
MathSrand(GetTickCount());
float N_Random=0.0;//Переменная для сохранения случайного числаint Strok_Total_Quant_Random=0;
int Size_Arr_RandomData=Strok_Total_Data_Random*Stolb_Total_Data_Random;
float arr_RandomData[];
float arr_RandomQuant[];
int arr_RandomTarget[];
ArrayResize(arr_RandomData,Size_Arr_RandomData);
ArrayResize(arr_RandomTarget,Strok_Total_Data_Random);
for(int i=0; i<Size_Arr_RandomData; i++) //Выберем комбинации
{
N_Random=RandomFloat(20);//Определяем число случайным образом
arr_RandomData[i]=N_Random;
}
for(int i=0; i<Strok_Total_Data_Random; i++) //Выберем комбинации
{
N_Random=RandomFloat(2);//Определяем число случайным образом
arr_RandomTarget[i]=(int)N_Random;
}
for(int i=0; i<Stolb_Total_Data_Random; i++) //Выберем комбинации
{
N_Random=RandomFloat(20);//Определяем число сплитовif(N_Random<1)N_Random=1;
int Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
ArrayResize(arr_RandomQuant,Size_arr_RandomQuant+(int)N_Random*2);
Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
float arr_N_Random[];
ArrayResize(arr_N_Random,(int)N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_N_Random[n]=RandomFloat(20);//Определяем значение сплитов
}
ArraySort(arr_N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n]=(float)i;//Номер столбца
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n+1]=arr_N_Random[n];//Значение сплита
}
}
ArrayCopy(arr_Data,arr_RandomData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_RandomQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_RandomTarget,0,0,WHOLE_ARRAY);
Strok_Total_Data=Strok_Total_Data_Random;
Stolb_Total_Data=Stolb_Total_Data_Random;
Strok_Total_Quant_Random=ArraySize(arr_RandomQuant)/2;
Strok_Total_Quant=Strok_Total_Quant_Random;
}
else
{
ArrayCopy(arr_Data,arr_MiniData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_MiniQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_MiniTarget,0,0,WHOLE_ARRAY);
}
int arr_N_Quant[];//Массив в котором будем хранить число сплитов квантовой таблицы для каждого предиктораArrayResize(arr_N_Quant,Stolb_Total_Data);
ArrayInitialize(arr_N_Quant,-1);
int New_Size=0;//Для установки размера массиваint N_Calc=1;//Счетчикint N_Pred=0;//Счетчик столбцов (//Номер предиктора)for(int i=1; i<Strok_Total_Quant; i++)//Найдем число сплитов для каждого предиктора
{
//Print("2*i=",2*i," 2*(i-1)=",2*(i-1));if(arr_Quant[2*i]>arr_Quant[2*(i-1)])
{
arr_N_Quant[N_Pred++]=N_Calc;
if(New_Size<N_Calc)
{
New_Size=N_Calc;
}
N_Calc=1;
}
else N_Calc++;
if(i+1==Strok_Total_Quant)arr_N_Quant[N_Pred++]=N_Calc;//Если последний индекс столбца, то сохраним его
}
int arr_Max_Calc[];//Массив в котором будем искать максимум после сортировкиArrayCopy(arr_Max_Calc,arr_N_Quant);//Скопируем массивArraySort(arr_Max_Calc);//Отсортируем массивint Max_Ind=ArrayMaximum(arr_Max_Calc,0,WHOLE_ARRAY);//Присвоем индекс максимального значения массиваint Max_N=arr_Max_Calc[Max_Ind];//Присвоем максимальное значение массиваfloat arr_Quant_Trans[];//Массив, куда запишем преобразованную таблицу с неравенствамиint Size_arr_Quant_Trans=(Max_N+1)*Stolb_Total_Data;//Размер массива транспонированной квантовой таблицыArrayResize(arr_Quant_Trans,Size_arr_Quant_Trans);
ArrayInitialize(arr_Quant_Trans,0);
int Calc_Split=0;//Счетчик для подсчета числа сплитовint Index=0;
New_Size=0;
N_Calc=1;//Счетчик числа сплитов предиктора
N_Pred=0;
double Split=0.0;//Значение сплитаfor(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
{
arr_Quant_Trans[Stolb_Total_Data*(N_Calc)+N_Pred]=arr_Quant[2*i-1];//Значение сплитаif(arr_Quant[2*i]>arr_Quant[2*(i-1)])//Новый сплит
{
Index=(int)arr_Quant[2*(i-1)];
arr_Quant_Trans[Index]=(float)N_Calc;//Число сплитов в предикторе / столбца
arr_N_Quant[N_Pred++]=N_Calc;
if(New_Size<N_Calc)
{
New_Size=N_Calc;
}
N_Calc=1;
}
else N_Calc++;
if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбца
{
arr_N_Quant[N_Pred++]=N_Calc;//Если последний индекс столбца, то сохраним его
Index=(int)arr_Quant[2*i];
arr_Quant_Trans[Index]=(float)N_Calc;//Число сплитов в предикторе / столбце
arr_Quant_Trans[Stolb_Total_Data*(N_Calc)+N_Pred-1]=arr_Quant[2*i+1];//Значение сплита -1 так как это последнее значение, а счетчик N_Pred ранее по коду учел новое
}
}
ushort arr_Data_Q[];//Таблица №3 с результатами классификации(квантования) выборки.ArrayResize(arr_Data_Q,Strok_Total_Data*Stolb_Total_Data);
ArrayInitialize(arr_Data_Q,0);
int Index_Data=0;//Индекс массива arr_Data и arr_Data_Qint Index_Quant_A=0;//Индекс массива arr_Quant_Trans для границы Аint Index_Quant_B=0;//Индекс массива arr_Quant_Trans для границы Бfloat arr_Proc_Target[];//Процент принадлежности классов к целевойfloat arr_Proc_Otklik[];//Процент откликов классов ко всей таблице (выборке).ArrayResize(arr_Proc_Target,((Max_N+1)*Stolb_Total_Data)*2);//Делаем по размеру квантовой таблицы, умноженной на число разных значений (типов) целевыхArrayResize(arr_Proc_Otklik,((Max_N+1)*Stolb_Total_Data));//Делаем по размеру квантовой таблицыArrayInitialize(arr_Proc_Target,0);
ArrayInitialize(arr_Proc_Otklik,0);
for(int p=0; p<Stolb_Total_Data; p++)
{
ushort arr_N_Class_Target[];//Считаем число целевых по их типам для каждого условного класса после квантованияushort arr_N_Class_Otklik[];//Считаем число откликов для каждого условного класса после квантования в выборкеArrayResize(arr_N_Class_Target,((int)arr_Quant_Trans[p]+1)*2);//Умножаем на количество разных целевых ("0" и "1")ArrayResize(arr_N_Class_Otklik,((int)arr_Quant_Trans[p]+1));//ArrayInitialize(arr_N_Class_Target,0);
ArrayInitialize(arr_N_Class_Otklik,0);
for(int i=0; i<Strok_Total_Data; i++)
{
Index_Data=Stolb_Total_Data*i+p;
for(ushort q=0; q<arr_Quant_Trans[p]+1; q++)
{
if(arr_Quant_Trans[p]<1)
{
arr_Data_Q[Index_Data]=0;//Обнуляем значение предиктора, так как нет информации о сплитахbreak;
}
else
{
if(q==0)//Первый сплит
{
Index_Quant_A=Stolb_Total_Data*(q+1)+p;//Рассчитаем индекс первой границыif(arr_Data[Index_Data]<=arr_Quant_Trans[Index_Quant_A])
{
arr_Data_Q[Index_Data]=q+1;
break;
}
}
else
{
Index_Quant_A=Stolb_Total_Data*(q+1-1)+p;//Рассчитаем индекс первой границы
Index_Quant_B=Stolb_Total_Data*(q+1)+p;//Рассчитаем индекс последней границыif(q==arr_Quant_Trans[p])//Последний сплит "q" будет равно arr_Quant_Trans[p] при выходе за пределы массива)
{
if(arr_Data[Index_Data]>arr_Quant_Trans[Index_Quant_A])
{
arr_Data_Q[Index_Data]=q+1;
break;
}
}
else//Средние сплиты
{
if(arr_Data[Index_Data]>arr_Quant_Trans[Index_Quant_A] && arr_Data[Index_Data]<=arr_Quant_Trans[Index_Quant_B])
{
arr_Data_Q[Index_Data]=q+1;
break;
}
}
}
}
}
int Calc_Index=0;
switch(arr_Target[i])
{
case0:
Calc_Index=((int)arr_Data_Q[Index_Data]-1)*2;
break;
case1:
Calc_Index=((int)arr_Data_Q[Index_Data]-1)*2+1;
break;
}
arr_N_Class_Target[Calc_Index]++;//Прибавим 1 для подсчета целевой
Calc_Index=((int)arr_Data_Q[Index_Data]-1);//Индекс для массива arr_N_Class_Otklik
arr_N_Class_Otklik[Calc_Index]++;//Прибавим 1 для подсчета откликов
}
for(ushort q=0; q<arr_Quant_Trans[p]+1; q++)//Посчитаем проценты
{
int Summ=arr_N_Class_Target[2*q]+arr_N_Class_Target[2*q+1];
//Print("Summ=",Summ);if (Summ>0)
{
arr_Proc_Target[Stolb_Total_Data*2*q+p*2]=float((double)arr_N_Class_Target[2*q]/(double)Summ*100.0);//Целевая "0"
arr_Proc_Target[Stolb_Total_Data*2*q+p*2+1]=float((double)arr_N_Class_Target[2*q+1]/(double)Summ*100.0);//Целевая "1"
}
arr_Proc_Otklik[Stolb_Total_Data*q+p]=float((double)arr_N_Class_Otklik[q]/(double)Strok_Total_Data*100.0);
}
}
Print("Задача №1 Таблица №3 с результатами классификации выборки.");
ArrayPrint(arr_Data_Q);
Print("Таблица №5 с результатами вычислений процента принадлежности классов к целевой.");
ArrayPrint(arr_Proc_Target);
Print("Таблица №6 с результатами вычислений процента откликов классов ко всей таблице (выборке).");
ArrayPrint(arr_Proc_Otklik);
}
//+------------------------------------------------------------------+//+------------------------------------------------------------------+//|Определяем комбинацию случайным образом//+------------------------------------------------------------------+float RandomFloat(float max_vl)
{
return (float)MathFloor((MathRand()+MathRand()*32767.0)/1073741824.0*max_vl); //случайное Int от 0 до 1073741824
}
//+------------------------------------------------------------------+
Сам код, если есть идеи как ускорить или перевести на OpencCL - пишите.
//+------------------------------------------------------------------+//| Primer.mq5 |//| Copyright 2016, MetaQuotes Software Corp. |//| https://www.mql5.com |//+------------------------------------------------------------------+#property copyright"-Aleks-"#property link"https://www.mql5.com/ru/users/-aleks-"#property version"1.00"#property script_show_inputs#property strictsinputbool Random_Data=false;//Генерировать таблицу с данными?input group "Параметры генерируемой таблицы"sinputint Strok_Total_Data_Random=1000;//Всего строкsinputint Stolb_Total_Data_Random=1000;//Всего столбцов//+------------------------------------------------------------------+//| Script program start function |//+------------------------------------------------------------------+float arr_Data[];//Массив для первичных данных - выборкаfloat arr_Quant[];//Массив с таблицами неравенств (сплитов)char arr_Target[];//Массив с целевымиfloat arr_MiniData[]=//Массив для проверки логики с малым числом примеров - первичные данные
{
7,0,1,
8,1,2,
9,0,3,
10,1,1,
11,0,2,
12,1,3,
13,0,1,
14,1,2,
15,0,3,
16,1,1
};
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+float arr_MiniQuant[]=//Массив для проверки логики с малым числом примеров - таблицы неравенств (сплитов)
{
0,10.5,
0,14.5,
0,15.5,
1,0.5,
2,0.5,
2,1.5
};
char arr_MiniTarget[]=//Массив с целевыми
{
0,
1,
0,
1,
0,
1,
0,
1,
0,
1
};
int Strok_Total_Data=10;//Количество строк в таблице Dataint Stolb_Total_Data=3;//Количество столбцов в таблице Dataint Strok_Total_Quant=6;//Количество строк в таблице Quantint Stolb_Total_Quant=2;//Количество столбцов в таблице Quant//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+voidOnStart()
{
if(Random_Data==true)//Сгенерируем данные для оценки времени работы алгоритма
{
MathSrand(GetTickCount());
float N_Random=0.0;//Переменная для сохранения случайного числаint Strok_Total_Quant_Random=0;
int Size_Arr_RandomData=Strok_Total_Data_Random*Stolb_Total_Data_Random;
float arr_RandomData[];
float arr_RandomQuant[];
int arr_RandomTarget[];
ArrayResize(arr_RandomData,Size_Arr_RandomData);
ArrayResize(arr_RandomTarget,Strok_Total_Data_Random);
for(int i=0; i<Size_Arr_RandomData; i++) //Выберем комбинации
{
N_Random=RandomFloat(20);//Определяем число случайным образом
arr_RandomData[i]=N_Random;
}
for(int i=0; i<Strok_Total_Data_Random; i++) //Выберем комбинации
{
N_Random=RandomFloat(2);//Определяем число случайным образом
arr_RandomTarget[i]=(int)N_Random;
}
for(int i=0; i<Stolb_Total_Data_Random; i++) //Выберем комбинации для квантовой таблицы
{
N_Random=RandomFloat(20);//Определяем число сплитовif(N_Random<1)
N_Random=1;
int Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
ArrayResize(arr_RandomQuant,Size_arr_RandomQuant+(int)N_Random*2);
Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
float arr_N_Random[];
ArrayResize(arr_N_Random,(int)N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_N_Random[n]=RandomFloat(20);//Определяем значение сплитов
}
ArraySort(arr_N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n]=(float)i;//Номер столбца
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n+1]=arr_N_Random[n];//Значение сплита
}
}
ArrayCopy(arr_Data,arr_RandomData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_RandomQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_RandomTarget,0,0,WHOLE_ARRAY);
Strok_Total_Data=Strok_Total_Data_Random;
Stolb_Total_Data=Stolb_Total_Data_Random;
Strok_Total_Quant_Random=ArraySize(arr_RandomQuant)/2;
Strok_Total_Quant=Strok_Total_Quant_Random;
}
else
{
ArrayCopy(arr_Data,arr_MiniData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_MiniQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_MiniTarget,0,0,WHOLE_ARRAY);
}
matrixf m_Data;//Матрица с основной таблицей
m_Data.Init(Strok_Total_Data*Stolb_Total_Data, 1);//Инициализировали матрицу
vectorf V_Data;//Вектор для передачи массива в матрицу
V_Data.Assign(arr_Data);//Скопировали массив в вектор//Print("data after Assign", V_Data);
m_Data.Col(V_Data,0);//Скопировали вектор в матрицу
m_Data.Reshape(Strok_Total_Data, Stolb_Total_Data);//Имзенили размер матрицы вместе с данными//Print("data after Reshape", m_Data);
matrixf m_Quant;//Матрица с квантовой таблицей
m_Quant.Init(Strok_Total_Quant*2, 1);//Инициализировали матрицу
vectorf V_Quant;//Вектор для передачи массива в матрицу
V_Quant.Assign(arr_Quant);//Скопировали массив в вектор//Print("data after Assign", m_Quant);
m_Quant.Col(V_Quant,0);//Скопировали вектор в матрицу
m_Quant.Reshape(Strok_Total_Quant, 2);//Имзенили пропорцию матрицы вместе с данными//Print("data after Reshape", m_Quant);
vectorf V_Target;//Вектор для передачи массива в матрицу
V_Target.Assign(arr_Target);//Скопировали массив в вектор//Print("data after Assign", V_Target);int New_Size=0;//Для установки размера массиваint N_Calc=1;//Счетчикint N_Pred=0;//Счетчик столбцов (//Номер предиктора)for(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
{
if(m_Quant[i][0]>m_Quant[i-1][0])//Новый предиктор
{
if(New_Size<N_Calc)
{
New_Size=N_Calc;
}
N_Pred++;
N_Calc=0;
}
++N_Calc;
if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбцаif(New_Size<N_Calc)
{
New_Size=N_Calc;
}
}
int Max_N=New_Size;//Присвоем максимальное значение массива//Print("Max_N=",Max_N);
matrixf m_Quant_Trans;//Матрица с преобразованной квантовой таблицей
m_Quant_Trans.Init(Max_N+1, Stolb_Total_Data);//Инициализировали матрицу
m_Quant_Trans.Fill(0);//Заполняем матрицу нулями
New_Size=0;
N_Calc=1;//Счетчик числа сплитов предиктора
N_Pred=0;
for(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
{
if(m_Quant[i][0]>m_Quant[i-1][0])//Новый предиктор
{
m_Quant_Trans[0][N_Pred]=(float)N_Calc;//Сохраним число сплитовif(N_Pred==0)
{
m_Quant_Trans[1][0]=m_Quant[0][1];
}
N_Pred++;
N_Calc=0;
}
m_Quant_Trans[++N_Calc][N_Pred]=m_Quant[i][1];
if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбца
{
m_Quant_Trans[0][N_Pred]=(float)N_Calc;//Сохраним число сплитов
}
}
Print("data after m_Quant_Trans", m_Quant_Trans);
matrixf m_Data_Q;//Матрица с преобразованной квантовой таблицей
m_Data_Q.Init(Strok_Total_Data, Stolb_Total_Data);//Инициализировали матрицу
m_Data_Q.Fill(0);//Заполняем матрицу нулями
matrixf m_Proc_Target;
m_Proc_Target.Init(Max_N+1, Stolb_Total_Data*2);//Инициализировали матрицу
m_Proc_Target.Fill(0);//Заполняем матрицу нулями
matrixf m_Proc_Otklik;
m_Proc_Otklik.Init(Max_N+1, Stolb_Total_Data);//Инициализировали матрицу
m_Proc_Otklik.Fill(0);//Заполняем матрицу нулямиfor(int p=0; p<Stolb_Total_Data; p++)//Столбцы
{
ushort arr_N_Class_Target[];//Считаем число целевых по их типам для каждого условного класса после квантованияushort arr_N_Class_Otklik[];//Считаем число откликов для каждого условного класса после квантования в выборкеArrayResize(arr_N_Class_Target,((int)m_Quant_Trans[0][p]+1)*2);//Умножаем на количество разных целевых ("0" и "1")ArrayResize(arr_N_Class_Otklik,((int)m_Quant_Trans[0][p]+1));//ArrayInitialize(arr_N_Class_Target,0);
ArrayInitialize(arr_N_Class_Otklik,0);
for(int i=0; i<Strok_Total_Data; i++)//Строки
{
for(ushort q=0; q<m_Quant_Trans[0][p]+1; q++)//Сплиты
{
if(m_Quant_Trans[0][p]<1)
{
m_Data_Q[i][p]=0;//Обнуляем значение предиктора, так как нет информации о сплитахbreak;
}
else
{
if(q==0)//Первый сплит
{
if(m_Data[i][p]<=m_Quant_Trans[q+1][p])
{
m_Data_Q[i][p]=(float)q+1;
break;
}
}
else
{
if(q==m_Quant_Trans[0][p])//Последний сплит "q" будет равно arr_Quant_Trans[p] при выходе за пределы массива)
{
if(m_Data[i][p]>m_Quant_Trans[q][p])
{
m_Data_Q[i][p]=(float)q+1;
break;
}
}
else//Средние сплиты
{
if(m_Data[i][p]>m_Quant_Trans[q][p] && m_Data[i][p]<=m_Quant_Trans[q+1][p])
{
m_Data_Q[i][p]=(float)q+1;
break;
}
}
}
}
}
int Calc_Index=0;
switch(arr_Target[i])
{
case0:
Calc_Index=((int)m_Data_Q[i][p]-1)*2;
break;
case1:
Calc_Index=((int)m_Data_Q[i][p]-1)*2+1;
break;
}
arr_N_Class_Target[Calc_Index]++;//Прибавим 1 для подсчета целевой
Calc_Index=((int)m_Data_Q[i][p]-1);//Индекс для массива arr_N_Class_Otklik
arr_N_Class_Otklik[Calc_Index]++;//Прибавим 1 для подсчета откликов
}
for(ushort q=0; q<m_Quant_Trans[0][p]+1; q++)//Посчитаем проценты
{
int Summ=arr_N_Class_Target[2*q]+arr_N_Class_Target[2*q+1];
//Print("Summ=",Summ);if(Summ>0)
{
m_Proc_Target[q][p*2]=float((double)arr_N_Class_Target[2*q]/(double)Summ*100.0);//Целевая "0"
m_Proc_Target[q][p*2+1]=float((double)arr_N_Class_Target[2*q+1]/(double)Summ*100.0);//Целевая "1"
}
m_Proc_Otklik[q][p]=float((double)arr_N_Class_Otklik[q]/(double)Strok_Total_Data*100.0);
}
}
Print("Задача №1 Таблица №3 с результатами классификации выборки.");
Print(m_Data_Q);
Print("Таблица №5 с результатами вычислений процента принадлежности классов к целевой.");
Print(m_Proc_Target);
Print("Таблица №6 с результатами вычислений процента откликов классов ко всей таблице (выборке).");
Print(m_Proc_Otklik);
}
//+------------------------------------------------------------------+//+------------------------------------------------------------------+//|Определяем комбинацию случайным образом//+------------------------------------------------------------------+float RandomFloat(float max_vl)
{
return (float)MathFloor((MathRand()+MathRand()*32767.0)/1073741824.0*max_vl); //случайное Int от 0 до 1073741824
}
//+------------------------------------------------------------------+//+------------------------------------------------------------------+//+------------------------------------------------------------------+
А вот памяти в пике терминал потреблял 687 мегабайт - Primer_00 (на массивах) и 1257 мегабайт (на матрицах) - Primer_01, что конечно не очень хорошо. Да, можно было бы очистить массив с датой, но в реальной задаче мне она нужна, поэтому не вижу смысла.
Aleksey Vyazmikin #: А вот памяти в пики терминал потреблял 687 мегабайт - Primer_00 (на массивах) и 1257 мегабайт (на матрицах) - Primer_01, что конечно не очень хорошо. Да, можно было бы очистить массив с датой, но в реальной задаче мне она нужна, поэтому не вижу смысла.
Видимо я описался, провел ещё раз замер матрица 10000 на 10000, терминал с 1 чартом, на массивах 661, на матрице 1636, на новом коде с матрицей пишу сразу результаты в m_Data, минуя m_Data_Q, таким образом экономим на памяти - расчет занял 1244 мегабайт.
Немного ускорил код, упростив и сократив вычисления индекса массивов.
//+------------------------------------------------------------------+//| Primer.mq5 |//| Copyright 2016, MetaQuotes Software Corp. |//| https://www.mql5.com |//+------------------------------------------------------------------+#property copyright"-Aleks-"#property link"https://www.mql5.com/ru/users/-aleks-"#property version"1.00"#property script_show_inputs#property strictsinputbool Random_Data=false;//Генерировать таблицу с данными?input group "Параметры генерируемой таблицы"sinputint Strok_Total_Data_Random=1000;//Всего строкsinputint Stolb_Total_Data_Random=1000;//Всего столбцов//+------------------------------------------------------------------+//| Script program start function |//+------------------------------------------------------------------+float arr_Data[];//Массив для первичных данных - выборкаfloat arr_Quant[];//Массив с таблицами неравенств (сплитов)char arr_Target[];//Массив с целевымиfloat arr_MiniData[]=//Массив для проверки логики с малым числом примеров - первичные данные
{
7,0,1,
8,1,2,
9,0,3,
10,1,1,
11,0,2,
12,1,3,
13,0,1,
14,1,2,
15,0,3,
16,1,1
};
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+float arr_MiniQuant[]=//Массив для проверки логики с малым числом примеров - таблицы неравенств (сплитов)
{
0,10.5,
0,14.5,
0,15.5,
1,0.5,
2,0.5,
2,1.5
};
char arr_MiniTarget[]=//Массив с целевыми
{
0,
1,
0,
1,
0,
1,
0,
1,
0,
1
};
int Strok_Total_Data=10;//Количество строк в таблице Dataint Stolb_Total_Data=3;//Количество столбцов в таблице Dataint Strok_Total_Quant=6;//Количество строк в таблице Quantint Stolb_Total_Quant=2;//Количество столбцов в таблице Quant//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+voidOnStart()
{
if(Random_Data==true)//Сгенерируем данные для оценки времени работы алгоритма
{
MathSrand(GetTickCount());
float N_Random=0.0;//Переменная для сохранения случайного числаint Strok_Total_Quant_Random=0;
int Size_Arr_RandomData=Strok_Total_Data_Random*Stolb_Total_Data_Random;
float arr_RandomData[];
float arr_RandomQuant[];
int arr_RandomTarget[];
ArrayResize(arr_RandomData,Size_Arr_RandomData);
ArrayResize(arr_RandomTarget,Strok_Total_Data_Random);
for(int i=0; i<Size_Arr_RandomData; i++) //Выберем комбинации
{
N_Random=RandomFloat(20);//Определяем число случайным образом
arr_RandomData[i]=N_Random;
}
for(int i=0; i<Strok_Total_Data_Random; i++) //Выберем комбинации
{
N_Random=RandomFloat(2);//Определяем число случайным образом
arr_RandomTarget[i]=(int)N_Random;
}
for(int i=0; i<Stolb_Total_Data_Random; i++) //Выберем комбинации для квантовой таблицы
{
N_Random=RandomFloat(20);//Определяем число сплитовif(N_Random<1)
N_Random=1;
int Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
ArrayResize(arr_RandomQuant,Size_arr_RandomQuant+(int)N_Random*2);
Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
float arr_N_Random[];
ArrayResize(arr_N_Random,(int)N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_N_Random[n]=RandomFloat(20);//Определяем значение сплитов
}
ArraySort(arr_N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n]=(float)i;//Номер столбца
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n+1]=arr_N_Random[n];//Значение сплита
}
}
ArrayCopy(arr_Data,arr_RandomData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_RandomQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_RandomTarget,0,0,WHOLE_ARRAY);
Strok_Total_Data=Strok_Total_Data_Random;
Stolb_Total_Data=Stolb_Total_Data_Random;
Strok_Total_Quant_Random=ArraySize(arr_RandomQuant)/2;
Strok_Total_Quant=Strok_Total_Quant_Random;
}
else
{
ArrayCopy(arr_Data,arr_MiniData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_MiniQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_MiniTarget,0,0,WHOLE_ARRAY);
}
matrixf m_Data;//Матрица с основной таблицей
m_Data.Init(Strok_Total_Data*Stolb_Total_Data, 1);//Инициализировали матрицу
vectorf V_Data;//Вектор для передачи массива в матрицу
V_Data.Assign(arr_Data);//Скопировали массив в вектор//Print("data after Assign", V_Data);
m_Data.Col(V_Data,0);//Скопировали вектор в матрицу
m_Data.Reshape(Strok_Total_Data, Stolb_Total_Data);//Имзенили размер матрицы вместе с данными//Print("data after Reshape", m_Data);
matrixf m_Quant;//Матрица с квантовой таблицей
m_Quant.Init(Strok_Total_Quant*2, 1);//Инициализировали матрицу
vectorf V_Quant;//Вектор для передачи массива в матрицу
V_Quant.Assign(arr_Quant);//Скопировали массив в вектор//Print("data after Assign", m_Quant);
m_Quant.Col(V_Quant,0);//Скопировали вектор в матрицу
m_Quant.Reshape(Strok_Total_Quant, 2);//Имзенили пропорцию матрицы вместе с данными//Print("data after Reshape", m_Quant);
vectorf V_Target;//Вектор для передачи массива в матрицу
V_Target.Assign(arr_Target);//Скопировали массив в вектор//Print("data after Assign", V_Target);int New_Size=0;//Для установки размера массиваint N_Calc=1;//Счетчикint N_Pred=0;//Счетчик столбцов (//Номер предиктора)for(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
{
if(m_Quant[i][0]>m_Quant[i-1][0])//Новый предиктор
{
if(New_Size<N_Calc)
{
New_Size=N_Calc;
}
N_Pred++;
N_Calc=0;
}
++N_Calc;
if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбцаif(New_Size<N_Calc)
{
New_Size=N_Calc;
}
}
int Max_N=New_Size;//Присвоем максимальное значение массива//Print("Max_N=",Max_N);
matrixf m_Quant_Trans;//Матрица с преобразованной квантовой таблицей
m_Quant_Trans.Init(Max_N+1, Stolb_Total_Data);//Инициализировали матрицу
m_Quant_Trans.Fill(0);//Заполняем матрицу нулями
New_Size=0;
N_Calc=1;//Счетчик числа сплитов предиктора
N_Pred=0;
for(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
{
if(m_Quant[i][0]>m_Quant[i-1][0])//Новый предиктор
{
m_Quant_Trans[0][N_Pred]=(float)N_Calc;//Сохраним число сплитовif(N_Pred==0)
{
m_Quant_Trans[1][0]=m_Quant[0][1];
}
N_Pred++;
N_Calc=0;
}
m_Quant_Trans[++N_Calc][N_Pred]=m_Quant[i][1];
if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбца
{
m_Quant_Trans[0][N_Pred]=(float)N_Calc;//Сохраним число сплитов
}
}
Print("data after m_Quant_Trans", m_Quant_Trans);
/*
matrixf m_Data_Q;//Матрица с преобразованной квантовой таблицей
m_Data_Q.Init(Strok_Total_Data, Stolb_Total_Data);//Инициализировали матрицу
m_Data_Q.Fill(0);//Заполняем матрицу нулями
*/
matrixf m_Proc_Target;
m_Proc_Target.Init(Max_N+1, Stolb_Total_Data*2);//Инициализировали матрицу
m_Proc_Target.Fill(0);//Заполняем матрицу нулями
matrixf m_Proc_Otklik;
m_Proc_Otklik.Init(Max_N+1, Stolb_Total_Data);//Инициализировали матрицу
m_Proc_Otklik.Fill(0);//Заполняем матрицу нулямиushort arr_N_Class_Target[];//Считаем число целевых по их типам для каждого условного класса после квантованияushort arr_N_Class_Otklik[];//Считаем число откликов для каждого условного класса после квантования в выборкеint Index=0;
for(int p=0; p<Stolb_Total_Data; p++)//Столбцы
{
ArrayResize(arr_N_Class_Target,((int)m_Quant_Trans[0][p]+1)*2);//Умножаем на количество разных целевых ("0" и "1")ArrayResize(arr_N_Class_Otklik,((int)m_Quant_Trans[0][p]+1));//ArrayInitialize(arr_N_Class_Target,0);
ArrayInitialize(arr_N_Class_Otklik,0);
for(int i=0; i<Strok_Total_Data; i++)//Строки
{
for(ushort q=0; q<m_Quant_Trans[0][p]+1; q++)//Сплиты
{
Index=q;
if(m_Quant_Trans[0][p]<1)
{
m_Data[i][p]=0;//Обнуляем значение предиктора, так как нет информации о сплитахbreak;
}
else
{
if(q==0)//Первый сплит
{
if(m_Data[i][p]<=m_Quant_Trans[q+1][p])
{
m_Data[i][p]=(float)q+1;
break;
}
}
else
{
if(q==m_Quant_Trans[0][p])//Последний сплит "q" будет равно arr_Quant_Trans[p] при выходе за пределы массива)
{
if(m_Data[i][p]>m_Quant_Trans[q][p])
{
m_Data[i][p]=(float)q+1;
break;
}
}
else//Средние сплиты
{
if(m_Data[i][p]>m_Quant_Trans[q][p] && m_Data[i][p]<=m_Quant_Trans[q+1][p])
{
m_Data[i][p]=(float)q+1;
break;
}
}
}
}
}
int Calc_Index=0;
switch(arr_Target[i])
{
case0:
Calc_Index=Index*2;
break;
case1:
Calc_Index=Index*2+1;
break;
}
arr_N_Class_Target[Calc_Index]++;//Прибавим 1 для подсчета целевой
Calc_Index=Index;//Индекс для массива arr_N_Class_Otklik
arr_N_Class_Otklik[Calc_Index]++;//Прибавим 1 для подсчета откликов
}
int Pn2=p*2;
int Qn2=0;
for(ushort q=0; q<m_Quant_Trans[0][p]+1; q++)//Посчитаем проценты
{
Qn2=q*2;
int Summ=arr_N_Class_Target[Qn2]+arr_N_Class_Target[Qn2+1];
//Print("Summ=",Summ);if(Summ>0)
{
m_Proc_Target[q][Pn2]=float((double)arr_N_Class_Target[Qn2]/(double)Summ*100.0);//Целевая "0"
m_Proc_Target[q][Pn2+1]=float((double)arr_N_Class_Target[Qn2+1]/(double)Summ*100.0);//Целевая "1"
}
m_Proc_Otklik[q][p]=float((double)arr_N_Class_Otklik[q]/(double)Strok_Total_Data*100.0);
}
}
Print("Задача №1 Таблица №3 с результатами классификации выборки.");
Print(m_Data);
Print("Таблица №5 с результатами вычислений процента принадлежности классов к целевой.");
Print(m_Proc_Target);
Print("Таблица №6 с результатами вычислений процента откликов классов ко всей таблице (выборке).");
Print(m_Proc_Otklik);
}
//+------------------------------------------------------------------+//+------------------------------------------------------------------+//|Определяем комбинацию случайным образом//+------------------------------------------------------------------+float RandomFloat(float max_vl)
{
return (float)MathFloor((MathRand()+MathRand()*32767.0)/1073741824.0*max_vl); //случайное Int от 0 до 1073741824
}
//+------------------------------------------------------------------+
Сделал версию на OpenCL, если сравнивать с последним скриптом, то получается, что таблица 10000 на 10000 рассчиталась за 4,3 секунды, при этом время вычисления основного цикла для прошлого и текущего варианта было следующее
Для варианта с использованием матриц:
2022.11.0122:10:47.672 Primer_02 (EURUSD,M1) Время вычислений основного цикла=5864.159
Для варианта на OpenCL
2022.11.0122:11:17.904 Primer_03 (EURUSD,M1) Время вычислений основного цикла=1520.418
Т.е. увеличение скорости примерно в 3 раза, на мой взгляд прирост недостаточный, даже я бы сказал маленький, что бы идти и покупать видеокарту.
Но, будем объективны, возможно мой код можно оптимизировать, что значительно повысит производительность - пишите, если знаете, как это сделать!
Код скрипта:
//+------------------------------------------------------------------+//| Primer.mq5 |//| Copyright 2016, MetaQuotes Software Corp. |//| https://www.mql5.com |//+------------------------------------------------------------------+#property copyright"-Aleks-"#property link"https://www.mql5.com/ru/users/-aleks-"#property version"1.00"#property script_show_inputs#property strict//--- COpenCL class#include <OpenCL/OpenCL.mqh>
COpenCL m_OpenCL;
//--- исходные коды кернелов#resource "tester.cl"asstring cl_tester
sinputbool Random_Data=false;//Генерировать таблицу с данными?input group "Параметры генерируемой таблицы"sinputint Strok_Total_Data_Random=1000;//Всего строкsinputint Stolb_Total_Data_Random=1000;//Всего столбцов//+------------------------------------------------------------------+//| Script program start function |//+------------------------------------------------------------------+float arr_Data[];//Массив для первичных данных - выборкаfloat arr_Quant[];//Массив с таблицами неравенств (сплитов)char arr_Target[];//Массив с целевымиfloat arr_MiniData[]=//Массив для проверки логики с малым числом примеров - первичные данные
{
7,0,1,
8,1,2,
9,0,3,
10,1,1,
11,0,2,
12,1,3,
13,0,1,
14,1,2,
15,0,3,
16,1,1
};
float arr_MiniQuant[]=//Массив для проверки логики с малым числом примеров - таблицы неравенств (сплитов)
{
0,10.5,
0,14.5,
0,15.5,
1,0.5,
2,0.5,
2,1.5
};
char arr_MiniTarget[]=//Массив с целевыми
{
0,
1,
0,
1,
0,
1,
0,
1,
0,
1
};
int Strok_Total_Data=10;//Количество строк в таблице Dataint Stolb_Total_Data=3;//Количество столбцов в таблице Dataint Strok_Total_Quant=6;//Количество строк в таблице Quantint Stolb_Total_Quant=2;//Количество столбцов в таблице Quant//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+voidOnStart()
{
if(Random_Data==true)//Сгенерируем данные для оценки времени работы алгоритма
{
MathSrand(GetTickCount());
float N_Random=0.0;//Переменная для сохранения случайного числаint Strok_Total_Quant_Random=0;
int Size_Arr_RandomData=Strok_Total_Data_Random*Stolb_Total_Data_Random;
float arr_RandomData[];
float arr_RandomQuant[];
int arr_RandomTarget[];
ArrayResize(arr_RandomData,Size_Arr_RandomData);
ArrayResize(arr_RandomTarget,Strok_Total_Data_Random);
for(int i=0; i<Size_Arr_RandomData; i++) //Выберем комбинации
{
N_Random=RandomFloat(20);//Определяем число случайным образом
arr_RandomData[i]=N_Random;
}
for(int i=0; i<Strok_Total_Data_Random; i++) //Выберем комбинации
{
N_Random=RandomFloat(2);//Определяем число случайным образом
arr_RandomTarget[i]=(int)N_Random;
}
for(int i=0; i<Stolb_Total_Data_Random; i++) //Выберем комбинации для квантовой таблицы
{
N_Random=RandomFloat(20);//Определяем число сплитовif(N_Random<1)
N_Random=1;
int Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
ArrayResize(arr_RandomQuant,Size_arr_RandomQuant+(int)N_Random*2);
Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
float arr_N_Random[];
ArrayResize(arr_N_Random,(int)N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_N_Random[n]=RandomFloat(20);//Определяем значение сплитов
}
ArraySort(arr_N_Random);
for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
{
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n]=(float)i;//Номер столбца
arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n+1]=arr_N_Random[n];//Значение сплита
}
}
ArrayCopy(arr_Data,arr_RandomData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_RandomQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_RandomTarget,0,0,WHOLE_ARRAY);
Strok_Total_Data=Strok_Total_Data_Random;
Stolb_Total_Data=Stolb_Total_Data_Random;
Strok_Total_Quant_Random=ArraySize(arr_RandomQuant)/2;
Strok_Total_Quant=Strok_Total_Quant_Random;
}
else
{
ArrayCopy(arr_Data,arr_MiniData,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Quant,arr_MiniQuant,0,0,WHOLE_ARRAY);
ArrayCopy(arr_Target,arr_MiniTarget,0,0,WHOLE_ARRAY);
}
int arr_N_Quant[];//Массив в котором будем хранить число сплитов квантовой таблицы для каждого предиктораArrayResize(arr_N_Quant,Stolb_Total_Data);
ArrayInitialize(arr_N_Quant,-1);
int New_Size=0;//Для установки размера массиваint N_Calc=1;//Счетчикint N_Pred=0;//Счетчик столбцов (//Номер предиктора)for(int i=1; i<Strok_Total_Quant; i++)//Найдем число сплитов для каждого предиктора
{
if(arr_Quant[2*i]>arr_Quant[2*(i-1)])
{
arr_N_Quant[N_Pred++]=N_Calc;
if(New_Size<N_Calc)
{
New_Size=N_Calc;
}
N_Calc=1;
}
else
N_Calc++;
if(i+1==Strok_Total_Quant)
arr_N_Quant[N_Pred++]=N_Calc;//Если последний индекс столбца, то сохраним его
}
int arr_Max_Calc[];//Массив в котором будем искать максимум после сортировкиArrayCopy(arr_Max_Calc,arr_N_Quant);//Скопируем массивArraySort(arr_Max_Calc);//Отсортируем массивint Max_Ind=ArrayMaximum(arr_Max_Calc,0,WHOLE_ARRAY);//Присвоем индекс максимального значения массиваint Max_N=arr_Max_Calc[Max_Ind];//Присвоем максимальное значение массиваint Size_arr_Quant_Trans=(Max_N+1)*Stolb_Total_Data;//Размер массива транспонированной квантовой таблицыfloat arr_Quant_Trans[];//Массив, куда запишем преобразованную таблицу с неравенствамиArrayResize(arr_Quant_Trans,Size_arr_Quant_Trans);
ArrayInitialize(arr_Quant_Trans,0);
Print("New_Size=",New_Size," Max_N=",Max_N);
int Index=0;
New_Size=0;
N_Calc=1;//Счетчик числа сплитов предиктора
N_Pred=0;
double Split=0.0;//Значение сплитаfor(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
{
Index=(int)arr_Quant[2*(i-1)];
arr_Quant_Trans[Stolb_Total_Data*(N_Calc)+Index]=arr_Quant[2*i-1];//Значение сплитаif(arr_Quant[2*i]>arr_Quant[2*(i-1)])//Новый сплит
{
arr_Quant_Trans[Index]=(float)N_Calc;//Число сплитов в предикторе / столбцаif(New_Size<N_Calc)
{
New_Size=N_Calc;
}
N_Calc=1;
}
else
N_Calc++;
if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбца
{
Index=(int)arr_Quant[2*i];
arr_Quant_Trans[Index]=(float)N_Calc;//Число сплитов в предикторе / столбце
arr_Quant_Trans[Stolb_Total_Data*(N_Calc)+Index]=arr_Quant[2*i+1];//Значение сплита -1 так как это последнее значение, а счетчик N_Calc ранее по коду учел новое
}
}
ushort arr_Data_Q[];//Таблица №3 с результатами классификации(квантования) выборки.ArrayResize(arr_Data_Q,Strok_Total_Data*Stolb_Total_Data);
ArrayInitialize(arr_Data_Q,0);
float arr_Proc_Target[];//Процент принадлежности классов к целевойfloat arr_Proc_Otklik[];//Процент откликов классов ко всей таблице (выборке).ArrayResize(arr_Proc_Target,((Max_N+1)*Stolb_Total_Data)*2);//Делаем по размеру квантовой таблицы, умноженной на число разных значений (типов) целевыхArrayResize(arr_Proc_Otklik,((Max_N+1)*Stolb_Total_Data));//Делаем по размеру квантовой таблицыArrayInitialize(arr_Proc_Target,0);
ArrayInitialize(arr_Proc_Otklik,0);
int arr_N_Class_Target[];//Считаем число целевых по их типам для каждого условного класса после квантованияint arr_N_Class_Otklik[];//Считаем число откликов для каждого условного класса после квантования в выборкеArrayResize(arr_N_Class_Target,(Max_N+1)*2);//Умножаем на количество разных целевых ("0" и "1")ArrayResize(arr_N_Class_Otklik,(Max_N+1)*2);
ArrayInitialize(arr_N_Class_Target,0);
ArrayInitialize(arr_N_Class_Otklik,0);
int index_kernel=0;
int index_kernel_array_fill=1;
int Handle_Context=0;
//---Инициализация файла с кернеламиPrint("Initialize=",m_OpenCL.Initialize(cl_tester,true));
//CLProgramCreate(Handle_Context,cl_tester);//--- установка количества кернеловPrint("SetKernelsCount=",m_OpenCL.SetKernelsCount(2));
//--- создание кернеловPrint("KernelCreate=",m_OpenCL.KernelCreate(index_kernel,"CalcPred"));
Print("KernelCreate=",m_OpenCL.KernelCreate(index_kernel_array_fill,"array_fill"));
//--- создание буферов - указать количество буферовPrint("SetBuffersCount=",m_OpenCL.SetBuffersCount(6));
//--- копирование буфера на видеокартуPrint("BufferFromArray=",m_OpenCL.BufferFromArray(0,arr_Data,0,Stolb_Total_Data*Strok_Total_Data,CL_MEM_READ_ONLY));
Print("BufferFromArray=",m_OpenCL.BufferFromArray(1,arr_Quant_Trans,0,Size_arr_Quant_Trans,CL_MEM_READ_ONLY));
Print("BufferFromArray=",m_OpenCL.BufferFromArray(2,arr_Target,0,Strok_Total_Data,CL_MEM_READ_ONLY));
Print("BufferFromArray=",m_OpenCL.BufferFromArray(3,arr_Data_Q,0,Stolb_Total_Data*Strok_Total_Data,CL_MEM_READ_WRITE));
Print("BufferFromArray=",m_OpenCL.BufferFromArray(4,arr_N_Class_Target,0,(Max_N+1)*2,CL_MEM_READ_WRITE));
Print("BufferFromArray=",m_OpenCL.BufferFromArray(5,arr_N_Class_Otklik,0,Max_N+1,CL_MEM_READ_WRITE));
//---привязка буфера к аргументу кернела CalcPredPrint("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,0,0));
Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,1,1));
Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,2,2));
Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,3,3));
Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,4,4));
Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,5,5));
//---привязка параметра фукнкции к кернелу CalcPredint p=0;
Print("SetArgument=",m_OpenCL.SetArgument(index_kernel,6,p));
Print("SetArgument=",m_OpenCL.SetArgument(index_kernel,7,Stolb_Total_Data));
//---привязка буфера к аргументу кернела index_kernel_array_fillPrint("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel_array_fill,0,4));
Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel_array_fill,1,5));
//---привязка параметра фукнкции к кернелу index_kernel_array_fillint ZeroInint=0;
Print("SetArgument=",m_OpenCL.SetArgument(index_kernel_array_fill,2,ZeroInint));
//--- пространство задач для кернела index_kernel - одномерное CalcPreduint global_work_size[1];
//--- 1-е измерение
global_work_size[0]=Strok_Total_Data;
//--- пространство задач для кернела index_kernel_array_fill//--- 1-е измерениеuint global_work_size_02[1];
global_work_size_02[0]=(Max_N+1)*2;
//--- начальное смещение в пространстве задач для обоих измерений равно нулюuint global_work_offset[1]= {0};
ulong mcs=GetMicrosecondCount();
for(/*int*/ p=0; p<Stolb_Total_Data; p++)
{
m_OpenCL.SetArgument(index_kernel,6,p);//Передаем значение переменной "p" на видеокарту
m_OpenCL.Execute(index_kernel,1,global_work_offset,global_work_size);//Запускаем в работу основной воркер
m_OpenCL.BufferRead(4,arr_N_Class_Target,0,0,(Max_N+1)*2);//Читаем буфер/массив с видеокарты arr_N_Class_Target
m_OpenCL.BufferRead(5,arr_N_Class_Otklik,0,0,Max_N+1);//Читаем буфер/массив с видеокарты arr_N_Class_Otklikfor(ushort q=0; q<arr_Quant_Trans[p]+1; q++)//Посчитаем проценты
{
int Summ=arr_N_Class_Target[2*q]+arr_N_Class_Target[2*q+1];
if (Summ>0)
{
arr_Proc_Target[Stolb_Total_Data*2*q+p*2]=float((double)arr_N_Class_Target[2*q]/(double)Summ*100.0);//Целевая "0"
arr_Proc_Target[Stolb_Total_Data*2*q+p*2+1]=float((double)arr_N_Class_Target[2*q+1]/(double)Summ*100.0);//Целевая "1"
}
arr_Proc_Otklik[Stolb_Total_Data*q+p]=float((double)arr_N_Class_Otklik[q]/(double)Strok_Total_Data*100.0);
}
m_OpenCL.Execute(index_kernel_array_fill,1,global_work_offset,global_work_size_02);//Обнулим буферы/массивы arr_N_Class_Otklik и arr_N_Class_Target
}
Print("Время вычислений основного цикла=",(GetMicrosecondCount()-mcs)/1000.0);
Print("BufferRead=",m_OpenCL.BufferRead(3,arr_Data_Q,0,0,Stolb_Total_Data*Strok_Total_Data));
Print("Задача №1 Таблица №3 с результатами классификации выборки.");
ArrayPrint(arr_Data_Q);
Print("Таблица №5 с результатами вычислений процента принадлежности классов к целевой.");
ArrayPrint(arr_Proc_Target);
Print("Таблица №6 с результатами вычислений процента откликов классов ко всей таблице (выборке).");
ArrayPrint(arr_Proc_Otklik);
m_OpenCL.Shutdown();
}
//+------------------------------------------------------------------+//|Определяем комбинацию случайным образом//+------------------------------------------------------------------+float RandomFloat(float max_vl)
{
return (float)MathFloor((MathRand()+MathRand()*32767.0)/1073741824.0*max_vl); //случайное Int от 0 до 1073741824
}
Сами кернелы
//+------------------------------------------------------------------+//| tester.cl |//| Copyright 2018, Serhii Shevchuk |//| https://www.mql5.com/ru/users/decanium |//+------------------------------------------------------------------+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable
#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable
#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable
#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable
#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
//+------------------------------------------------------------------+//| Расчет//+------------------------------------------------------------------+
__kernel void CalcPred(
__global float *arr_Data,
__global float *arr_Quant_Trans,
__global char *arr_Target,
__global ushort *arr_Data_Q,
// __global ushort *arr_N_Class_Target,// __global ushort *arr_N_Class_Otklik,
__global int *arr_N_Class_Target,
__global int *arr_N_Class_Otklik,
int p,
int Stolb_Total_Data
)
{
int Index_Data=0;//Индекс массива arr_Data и arr_Data_Qint Index_Quant_A=0;//Индекс массива arr_Quant_Trans для границы Аint Index_Quant_B=0;//Индекс массива arr_Quant_Trans для границы Бint Index=0;
int Calc_Index=0;
//--- работает в одном измерении
size_t i=get_global_id(0);
Index_Data=Stolb_Total_Data*i+p;
for(ushort q=0; q<arr_Quant_Trans[p]+1; q++)
{
Index=q;
if(arr_Quant_Trans[p]<1)
{
arr_Data_Q[Index_Data]=0;//Обнуляем значение предиктора, так как нет информации о сплитахbreak;
}
else
{
if(q==0)//Первый сплит
{
Index_Quant_A=Stolb_Total_Data*(q+1)+p;//Рассчитаем индекс первой границыif(arr_Data[Index_Data]<=arr_Quant_Trans[Index_Quant_A])
{
arr_Data_Q[Index_Data]=q+1;
break;
}
}
else
{
Index_Quant_A=Stolb_Total_Data*(q+1-1)+p;//Рассчитаем индекс первой границы
Index_Quant_B=Stolb_Total_Data*(q+1)+p;//Рассчитаем индекс последней границыif(q==arr_Quant_Trans[p])//Последний сплит "q" будет равно arr_Quant_Trans[p] при выходе за пределы массива)
{
if(arr_Data[Index_Data]>arr_Quant_Trans[Index_Quant_A])
{
arr_Data_Q[Index_Data]=q+1;
break;
}
}
else//Средние сплиты
{
if(arr_Data[Index_Data]>arr_Quant_Trans[Index_Quant_A] && arr_Data[Index_Data]<=arr_Quant_Trans[Index_Quant_B])
{
arr_Data_Q[Index_Data]=q+1;
break;
}
}
}
}
}
switch(arr_Target[i])
{
case0:
Calc_Index=Index*2;
break;
case1:
Calc_Index=Index*2+1;
break;
}
atomic_inc(&arr_N_Class_Target[Calc_Index]);//Прибавим 1 для подсчета целевой
Calc_Index=Index;//Индекс для массива arr_N_Class_Otklik
atomic_inc(&arr_N_Class_Otklik[Calc_Index]);//Прибавим 1 для подсчета откликов
}
//+------------------------------------------------------------------+//| Заполнение буфера указанным значением |//+------------------------------------------------------------------+
__kernel void array_fill(__global int *Buf_A,__global int *Buf_B,constint value)
{
//--- работает в одном измерении
size_t x=get_global_id(0);
Buf_A[x]=value;
Buf_B[x]=value;
}
Сейчас к матрицам надо относится как к динамичному двухмерному массиву - и тут применение уже шире, чем математический прок от матриц.
Ну, у меня этот код был сделан с применением самописного класса матрицы. Тебе это разве интересно?
Вот, например, включаемый файл класса ядра метода МНК (mqh и mq5 файлы приложу ниже, они используют мою общую библиотеку, и для применения их надо будет подкорректировать, но основную мысль из них можно увидеть и так) - решается вопрос аппроксимации от нулевой до третьей степени. Перегружаем виртуальные функции, дающие пары (x;y) и число таких пар, и получаем готовый класс для аппроксимации. Именно с помощью этого класса были нарисованы границы параболического и кубического каналов в картинке выше:
/*
CLSMCore - класс, осуществляющий метод наименьших квадратов. Ядро.
Для использования - необходимо пронаследовать свой класс от ядра и перегрузить чисто виртуальные функции.
*/#include <MyLib\DebugOrRelease\DebugSupport.mqh>
#include <MyLib\Common\TrendEnums.mqh>
struct SLSMPowers
{
double m_dThirdPower;
double m_dSecondPower;
double m_dFirstPower;
double m_dNullPower;
};
enum EQntExtremums
{
QE_NO_EXTREMUMS = 0,
QE_MAXIMUM = 1,
QE_MINIMUM = 2,
QE_BOTH = 3
};
struct SLSMExtremums
{
EQntExtremums m_qeExtremums;
double m_dMinX;
double m_dMinY;
double m_dMaxX;
double m_dMaxY;
};
class CLSMCore
{
public:
// Степени многочленовstaticconstuint LSM_FLAT_POWER;
staticconstuint LSM_TREND_POWER;
staticconstuint LSM_PARABOLIC_POWER;
staticconstuint LSM_CUBIC_POWER;
staticconstdouble LSM_DEFAULT_POINT_WEIGHT; // Вес точки по умолчаниюprotected:
// Функции, которые обязательно следует перегрузить// Именно эти функции возвращают число точек и их координаты.virtualuint _N() = 0; // Число точекvirtualdouble _X(uint uiIdx) = 0; // Значение X точки с индексом uiIdxvirtualdouble _Y(uint uiIdx) =0; // Значение Y точки с индексом uiIdx// Функци, которые можно не перегружать, если необходимо значение по умолчанию.// Это функции для указания веса и полярной точки.virtualdouble _W(uint uiIdx) { return(LSM_DEFAULT_POINT_WEIGHT); }; // Значение веса точки с индексом uiIdxvirtualint _PolarIdx() { return(WRONG_VALUE); } // Индекс точки, через которую должна проходить прямая, при отрицательном значении - такой точки нет. // Функция, проверяющаяя, что МНК указанного типа возможен// (Количество точек ненулевого веса должно быть на один больше, чем степень многочлена)virtualbool _LSMIsAvailible(ELSMType ltType);
// Расчетные функции.// Во всех случаях учитываются веса точек Wi и отнимается полярная точка (Xpol,Ypol), если ее индекс валиден,// обозначается "с" - корректированноеvirtualdouble _SummXc(); // Summ((Xi-Xpol)*Wi)virtualdouble _SummXc2(); // Summ((Xi-Xpol)^2*Wi)virtualdouble _SummXc3(); // Summ((Xi-Xpol)^3*Wi)virtualdouble _SummXc4(); // Summ((Xi-Xpol)^4*Wi)virtualdouble _SummXc5(); // Summ((Xi-Xpol)^5*Wi)virtualdouble _SummXc6(); // Summ((Xi-Xpol)^6*Wi)virtualdouble _SummX2c2(); // Summ((Xi^2-Xpol^2)^2*Wi) virtualdouble _SummX3c2(); // Summ((Xi^3-Xpol^3)^2*Wi)virtualdouble _SummXcYc(); // Summ((Xi-Xpol)*(Yi-Ypol)*Wi)virtualdouble _SummX2cXc(); // Summ((Xi^2-Xpol^2)*(Xi-Xpol)*Wi) - virtualdouble _SummX2cYc(); // Summ((Xi^2-Xpol^2)*(Yi-Ypol)*Wi)// virtual double _SummXcX2c(); // Summ((Xi-Xpol)*(Xi^2-Xpol^2)*Wi) - оказывается, это одна и та же функцияvirtualdouble _SummX3cX2c(); // Summ((Xi^3-Xpol^3)*(Xi^2-Xpol^2)*Wi) virtualdouble _SummX3cXc(); // Summ((Xi^3-Xpol^3)*(Xi-Xpol)*Wi) virtualdouble _SummX3cYc(); // Summ((Xi^3-Xpol^3)*(Yi-Ypol)*Wi) virtualdouble _SummYc(); // Summ((Yi-Ypol)*Wi)virtualdouble _SummW(); // Summ(Wi)// Функциии расчета для аппроксимированных значений.// Функции возвращают коэффициенты определенных кривых. // Последняя функция возвращает сразу все коэффициенты в структуре, ее чаще всего и имеет смысл использовать.// Функции вынесены в protected-секцию, чтобы можно было организовать различные способы доступа к данным// Для расчетов используются перегруженные функции: _N(); _X(); _Y(); _W(); _PolarIdx().// Функция расчета горизонтальной прямой (по сути среднего арифметического)double _CountFlatLevel();
// Функция расчета тренда для случая, когда есть точка-полюс, через которую должна лежать прямая// Предполагается, что _PolarIdx() != WRONG_VALUE (проверка по ASSERT)double _CountPolarTrend(double & rdPolarLevel);
// Функция расчета обычной прямой c трендом// Предполагается, что _PolarIdx() == WRONG_VALUE (проверка по ASSERT)double _CountTrend(double & rdLevel);
// Функция расчета параболы для случая, когда есть точка полюс, через которую парабола должна проходить.// Заполняет соответствующие коэффициенты// Предполагается, что _PolarIdx() != WRONG_VALUE (проверка по ASSERT)void _CountPolarParabola(double & rdSecondPower,double & rdFirstPower,double & rdNullPower);
// Функция расчета параболы.// Заполняет соответствующие коэффициенты// Предполагается, что _PolarIdx() == WRONG_VALUE (проверка по ASSERT)void _CountParabola(double & rdSecondPower,double & rdFirstPower,double & rdNullPower);
// Функция расчета кубической параболы для случая, когда есть точка полюс, через которую парабола должна проходить.// Заполняет соответствующие коэффициенты// Предполагается, что _PolarIdx() != WRONG_VALUE (проверка по ASSERT)void _CountPolarCubic(double & rdThirdPower,double & rdSecondPower,double & rdFirstPower,double & rdNullPower);
// Функция расчета кубической параболы.// Заполняет соответствующие коэффициенты// Предполагается, что _PolarIdx() == WRONG_VALUE (проверка по ASSERT)void _CountCubic(double & rdThirdPower,double & rdSecondPower,double & rdFirstPower,double & rdNullPower);
// Функция расчета указанной кривой.// Заполняет соответствующие коэффициенты (несуществующие коэффициента заполняются нулями// В зависимости от величины, возвращаемой _PolarIdx(), вызываются полярные или обычные функции
SLSMPowers _CountLSM(ELSMType ltType);
// Функция возвращает параболическую кривую, построенную по трем первым точкам массивов с координатами.static SLSMPowers _GetParabolicCurvePyPoints(double & dArrX[],double & dArrY[]);
// Функция возвращает кубическую кривую, построенную по четырем первым точкам массивов с координатами.static SLSMPowers _GetCubicCurvePyPoints(double & dArrX[],double & dArrY[]);
staticvoid _TraceDouble(string strName,double dValue,int iDoubleDigits);
public:
CLSMCore() {};
~CLSMCore() {};
// Заполнение данной структуры одинаковыми значениями степеней.staticvoid SetPowers(SLSMPowers & lpPowers,double dPower) { lpPowers.m_dNullPower = dPower; lpPowers.m_dFirstPower = dPower; lpPowers.m_dSecondPower = dPower; lpPowers.m_dThirdPower = dPower; };
// Расчет многочлена с данными степенями и аргументом. staticdouble CountLSMPolynom(double dX,SLSMPowers & lpPowers) { return(dX*(dX*(dX*lpPowers.m_dThirdPower + lpPowers.m_dSecondPower)+lpPowers.m_dFirstPower)+lpPowers.m_dNullPower); };
// Расчет производной порядка uiDerivativeStep для аргумента dX и коэффициентов lpPowersstaticdouble CountDerivative(double dX,SLSMPowers & lpPowers,uint uiDerivativeStep = 1);
// Расчет числа экстремумов для указанных степеней и, если они есть - заполняет их значения.// Возвращает структуру количеством экстремумов и их данными.// В структуре данных заполняется:// Для флета - в обоих экстремумах устанавливается Y, абсцисса у обоих устанавливается на EMPTY_VALUE// Для тренда - все значения устанавливаются на EMPTY_VALUE// Для параболы - существующий экстремум устанавливается на реальный экстремум, несуществующий на EMPTY_VALUE// Для кубики - устанавливаются оба экстремума (если они есть), либо все устанавливается на EMPTY_VALUE (если экстремумов нет).static SLSMExtremums GetExtremums(SLSMPowers & lpPowers);
// Функция возвращает степени уравнения, проходящие через минимальное число точек (в зависимости от ltEqPower):// Количество точек должно быть достаточным, исследуются только первые необходимые. static SLSMPowers GetCurvePyPoints(double & dArrX[],double & dArrY[], ELSMType ltEqPower);
// Функция предназначена для трассировки указанного полинома от dX1 до dX2 числом промежуточных шагов uiMidSteps // Значения коэффициентов полинома преобразуются функцией DoubleToString() c параметром 16// Для значений точек полинома используются параметры iXDoubleDitits и iYDoubleDigitsstaticvoid TracePolynom(SLSMPowers & lpPowers,double dX1,double dX2,uint uiMidSteps,int iXDoubleDitits,int iYDoubleDigits);
// Функция предначена для нахождения блока uiBlockSize точек в массиве adArray, ближайших к значению dValue.// Возвращает индекс минимального индекса в блоке. // Предназначена для аппроксимации.// Если у нас есть массив adArray[], и нужно найти несколько точек, ближайших к данной, // чтобы провести через них аппроксимирующую кривую, то вызываем эту функцию, и она находит первый (минимальный) индекс такого блока. // Предполагается, что uiBlockSize не больше размера массива. Если это так - возвращается UINT_MAX (внутри ASSERT) staticuint GetBestIdx4Approx(double dValue,double & adArray[],uint uiBlockSize);
// Статические функции для матричных вычислений// Функция вычисляет детерминант матрицы размера 3х3.// Значения передаются по строкам.staticdouble Determinant_3(double dX11,double dX12,double dX13,double dX21,double dX22,double dX23,double dX31,double dX32,double dX33) { return(dX11*dX22*dX33 - dX11*dX23*dX32 - dX12*dX21*dX33 + dX12*dX23*dX31 + dX13*dX21*dX32 - dX13*dX22*dX31);};
// Функция вычисляет детерминант матрицы размера 4х4.// Значения передаются по строкам.staticdouble Determinant_4(double dX11,double dX12,double dX13,double dX14,double dX21,double dX22,double dX23,double dX24,double dX31,double dX32,double dX33,double dX34,double dX41,double dX42,double dX43,double dX44);
// Функция использует предыдущую, выбирая размер блока для соответствующего типа аппроксимации.staticuint GetBestIdx4Approx(double dValue,double & adArray[],ELSMType ltType);
};
Ну, у меня этот код был сделан с применением самописного класса матрицы. Тебе это разве интересно?
Интересно увидеть код с матрицами нового формата в сравнении со старым. Оценить прирост производительности. Да и код должен тогда значительно лучше восприниматься по идеи.
Для авторизации и пользования сайтом MQL5.com необходимо разрешить использование файлов Сookie.
Пожалуйста, включите в вашем браузере данную настройку, иначе вы не сможете авторизоваться.
Вы вошли в аккаунт. Двухфакторная аутентификация отключена. Настройте её заново и отсканируйте новый QR-код или продолжите с отключённой двухфакторной аутентификацией.
Не надо просить разработчиков, если нужна матрица отличий - вычитаем матрицы друг их друга, поскольку https://www.mql5.com/ru/docs/matrix/matrix_operations (*):
"Математические операции — сложение, вычитание, умножение и деление — можно производить над матрицами и векторами почленно. "
Если нужны более хитрые сравнения, то https://www.mql5.com/ru/docs/matrix/matrix_manipulations :
Compare
Сравнивает элементы двух матриц/векторов с указанной точностью
CompareByDigits
Сравнивает элементы двух матриц/векторов на совпадение с точностью до значащих цифр
По поводу умножения на 100 см. пример на той же странице (*) с вычитанием скаляра из вектора:
double avr=r.Mean(); // среднее значение массива
vector d=r-avr; // вычислим массив отклонений от среднего значения
Дело в том, что получив разницу между чисел или булево значение о равенстве мы вынуждены для дальнейшей работы всё равно проводить сравнение полученных результатов. А если мы по результатам применения неравенств к матрицам получим ответ булевый, то сможем применить switch для ветвления дальнейших действий, что ускорит процесс вычисления.
Конечно я смотрю всё, что сейчас публикуется разработчиками.
Добавил генератор исходных данных - теперь можно пробовать подумать об ускорении вычислений.
Компьютер потратил 28 секунд на таблицу из 1000000 элементов. Конечно, компьютер слабенький - но всё же это не мало времени.
Ниже код с использованием матриц. Генерацию случайными числами я оставил на базе массивов - думаю источник должен быть сопоставим.
Не заменил на вектора или матрицы массивы:
Прошлый код (Primer_00 - 22 секунды) и новый (Primer_01 - 14 секунд) - выборка 10000 строк и 10000 столбцов, процессор FX-8350.
Прирост получается 8 секунд, не плохо.
Сам код, если есть идеи как ускорить или перевести на OpencCL - пишите.
А вот памяти в пики терминал потреблял 687 мегабайт - Primer_00 (на массивах) и 1257 мегабайт (на матрицах) - Primer_01, что конечно не очень хорошо. Да, можно было бы очистить массив с датой, но в реальной задаче мне она нужна, поэтому не вижу смысла.
Видимо я описался, провел ещё раз замер матрица 10000 на 10000, терминал с 1 чартом, на массивах 661, на матрице 1636, на новом коде с матрицей пишу сразу результаты в m_Data, минуя m_Data_Q, таким образом экономим на памяти - расчет занял 1244 мегабайт.
Немного ускорил код, упростив и сократив вычисления индекса массивов.
Сделал версию на OpenCL, если сравнивать с последним скриптом, то получается, что таблица 10000 на 10000 рассчиталась за 4,3 секунды, при этом время вычисления основного цикла для прошлого и текущего варианта было следующее
Т.е. увеличение скорости примерно в 3 раза, на мой взгляд прирост недостаточный, даже я бы сказал маленький, что бы идти и покупать видеокарту.
Но, будем объективны, возможно мой код можно оптимизировать, что значительно повысит производительность - пишите, если знаете, как это сделать!
Код скрипта:
Сами кернелы
По идее, матрицы появились как метод решения систем линейных уравнений с многими переменными.
Соответственно, на мой взгляд, главное направление использования матриц - это задачи, предусматривающие такие расчёты.
Классический пример - Метод Наименьших Квадратов.
Вот, я когда-то делал индикатор:
Скриншоты торговой платформы MetaTrader
EURGBP, M15, 2018.09.03
Alpari International Limited, MetaTrader 4, Real
По идее, матрицы появились как метод решения систем линейных уравнений с многими переменными.
Соответственно, на мой взгляд, главное направление использования матриц - это задачи, предусматривающие такие расчёты.
Классический пример - Метод Наименьших Квадратов.
Вот, я когда-то делал индикатор:
Хорошо бы обсуждать код, какие то примеры...
Сейчас к матрицам надо относится как к динамичному двухмерному массиву - и тут применение уже шире, чем математический прок от матриц.
Хорошо бы обсуждать код, какие то примеры...
Сейчас к матрицам надо относится как к динамичному двухмерному массиву - и тут применение уже шире, чем математический прок от матриц.
Ну, у меня этот код был сделан с применением самописного класса матрицы. Тебе это разве интересно?
Вот, например, включаемый файл класса ядра метода МНК (mqh и mq5 файлы приложу ниже, они используют мою общую библиотеку, и для применения их надо будет подкорректировать, но основную мысль из них можно увидеть и так) - решается вопрос аппроксимации от нулевой до третьей степени. Перегружаем виртуальные функции, дающие пары (x;y) и число таких пар, и получаем готовый класс для аппроксимации. Именно с помощью этого класса были нарисованы границы параболического и кубического каналов в картинке выше:
Ну, у меня этот код был сделан с применением самописного класса матрицы. Тебе это разве интересно?
Интересно увидеть код с матрицами нового формата в сравнении со старым. Оценить прирост производительности. Да и код должен тогда значительно лучше восприниматься по идеи.