Densità della serie numerica - pagina 3
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Mi sono ricordato di un modo di fare clustering. Va più o meno così: si assegnano gruppi di elementi (cluster) in un insieme, in modo tale che la distanza massima tra gli elementi di un cluster sia inferiore alla distanza minima da qualsiasi elemento di quel cluster all'elemento non in quel cluster. La distanza può essere una distanza ordinaria, un modulo di differenza di numeri reali. Naturalmente, non ci sarà necessariamente un solo cluster di questo tipo. Forse non hai bisogno esattamente di un cluster, forse dovresti confrontarli tra loro anche in altri modi. Per esempio, il tempo medio di occorrenza di un livello nel gruppo.
Questo è interessante, ma finora non riesco a capire come determinare quali numeri sono nel cluster - con la forza bruta? Poi, suppongo, ci saranno gruppi che si sovrappongono l'un l'altro, perché se definiamo un cluster cercando il delta più piccolo, ma più grande rispetto ad altri elementi, allora l'eliminazione di qualche elemento da tale cluster sposterà il cluster stesso - la distanza tra i cluster sarà importante, se è significativa, allora dovrebbe funzionare.
La distanza tra due punti sull'asse reale si misura come il modulo della loro differenza. In matematica, si parla comunemente di metrica. Come si misura la distanza nel piano tra punti, coppie di numeri, ognuno dei quali è reale? Ancora una volta abbiamo la familiare soluzione pronta - la distanza euclidea, la radice del quadrato della somma dei quadrati delle differenze subordinate. E i matematici hanno altre metriche sul piano, per esempio il modulo maggiore di due differenze, la somma dei moduli delle differenze(http://ad.cctpu.edu.ru/Math_method/math/45.htm). E questo solo nel caso di coppie di numeri. Solo due numeri, e sempre due. E devi inserire una misura di prossimità in una situazione molto più complicata. Non ci sono due numeri in un gruppo, e ci sono numeri diversi in gruppi diversi.
Dobbiamo identificare il gruppo più grande, o gli stessi gruppi per il numero di elementi che li compongono. Il mio svantaggio è la mia incapacità di leggere correttamente formule complesse, quindi devo cercare di capire tutto dagli esempi e dai commenti ad essi.
Ci sono metriche in matematica che misurano la distanza tra due funzioni. Ma di nuovo, sempre tra due. Anche in questo caso non è adatto a voi, avete un gruppo.
Ecco perché è importante capirlo a fondo da soli. Scrivi, forse possiamo formalizzarlo in un algoritmo per ottenere una caratteristica numerica di prossimità in un insieme.
Tuttavia, considerate anche di rinunciare a cercare di crearlo. Il link qui sopra dice quali requisiti deve soddisfare la metrica. Non sono apparsi lì di punto in bianco, senza nessuno di loro si verificheranno strani effetti. Nel post sopra ho dato un esempio di come abbandonare tali tentativi esaustivi - lasciare che i punti del gruppo siano più vicini a coppie tra loro sull'asse reale che agli elementi esterni al punto. Non bisognerebbe inventare qualcosa di molto non banale.
Esatto, inizialmente determiniamo la vicinanza di due punti, e poi cerchiamo di escludere la distanza che è grande - questa è la domanda, come facciamo a determinare se la distanza è grande o no? È qui che l'algoritmo ha fallito - quando la distanza sembra essere un ordine di grandezza maggiore.
Non l'ha scritto - conta prima le differenze. Poi tutto il resto.
Testare un tale algoritmo per filtrare i dati prima dell'elaborazione:
1. Somma i due delta in sequenza e moltiplica il valore per due
2. Trova il valore medio della serie numerica risultante
3. Crea una nuova serie numerica se il valore è inferiore al valore medio
4. Ripetere i punti 2-3 fino a quando la serie numerica è inferiore alla metà della serie originale
5. Dopo il filtraggio, facciamo già il calcolo secondo l'algoritmo di cui sopra
Ho provato diverse figure - ho ottenuto una versione plausibile, sarei felice di sentire commenti critici.
Quindi hai contato le differenze nella colonna "Delta", cosa suggerisci di fare dopo?
Perché stai girando in tondo? È stato scritto qui da molto tempo ormai
Qui dichiari "Il tratto più lungo è quando la serie originale è sotto la media", ma questo, come lo capisco, è un difetto del mio algoritmo, dopo il quale è stata presa la decisione di fare un filtro - l'ho fatto e ora l'algoritmo non diventa così palesemente stupido quando i numeri differiscono significativamente l'uno dall'altro.
Qual è lo svantaggio?
Il filtro non sostituisce l'algoritmo. Il filtro è un'aggiunta all'algoritmo.
Qual è lo svantaggio?
Il filtro non sostituisce l'algoritmo. Il filtro è un'aggiunta all'algoritmo.
Non so quale sia lo svantaggio - forse non lo vedo ancora.
Penso che dovrei provare a codificarlo ora - potete aiutarmi se ho difficoltà?
Non so quale sia il lato negativo - forse non lo vedo ancora.
Penso di dover cercare di codificarlo ora - potete aiutarmi se ho difficoltà?
perché ogni volta che scopro che sto pensando la cosa sbagliata, sto pensando la cosa sbagliata...
Ho iniziato a sviluppare un algoritmo - ora sto facendo un filtro. È sorta una difficoltà nel sincronizzare le due colonne "Numero" e "Delta".
Idee su come eliminare l'imprecisione sarebbero benvenute:
//| Test_FindOblast.mq4 |
//| Copyright 2017, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link "https://www.mql5.com"
#property version "1.00"
#property strict
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
int massivSize=19; //размер массива
double Digit[19]=
{
10,
20,
30,
40,
50,
51,
52,
53,
54,
60,
70,
80,
120,
150,
190,
210,
223,
232,
250,
260
};
double summDelta[19-1];
int N=massivSize-1;//Количество оставшихся цифровых значений
double avrMass=0;//Среднее значение массива дельт
//-Фильтр
//1. Суммируем последовательно две дельты и умножаем значение на два
for(int i=1;i<massivSize;i++)
{
summDelta[i-1]=((Digit[i]-Digit[i-1])+(Digit[i+1]-Digit[i]))*2;
}
for(int i=0;i<massivSize-1;i++) printf("summDelta[%d] = %G",i,summDelta[i]);
//2. Находим среднее значение получившегося числового ряда
//3. Составляем новый числовой ряд, если значение меньше среднего значения
//4. Повторяем пункт 2-3 пока числовой ряд не будет меньше половины первоначального ряда
for(int Z=0;N>massivSize/2;Z++)
{
int SizeMass=ArraySize(summDelta);//Узнаем размер массива
avrMass=iMAOnArray(summDelta,0,SizeMass,0,0,0);
Print("Среднее значение получившегося числового ряда",Z,"=",avrMass);
for(int i=0;i<SizeMass;i++)
{
if(summDelta[i]>avrMass)
{
summDelta[i]=0;
Digit[i]=0;
N--;
}
}
Print("N=",N);
ArraySort(summDelta,WHOLE_ARRAY,0,MODE_DESCEND);
ArraySort(Digit,WHOLE_ARRAY,0,MODE_DESCEND);
if(N!=0)
{
ArrayResize(summDelta,N,0);
for(int i=0;i<N;i++) printf("summDelta[%d] = %G",i,summDelta[i]);
ArrayResize(Digit,N+1,0);
for(int i=0;i<N+1;i++) printf("Digit[%d] = %G",i,Digit[i]);
}
else
{
for(int i=0;i<N;i++) printf("summDelta[%d] = %G",i,summDelta[i]);
for(int i=0;i<N+1;i++) printf("Digit[%d] = %G",i,Digit[i]);
return;
}
}
int SizeMass=ArraySize(summDelta);//Узнаем размер массива
avrMass=iMAOnArray(summDelta,0,SizeMass,0,0,0);
Print("Среднее значение получившегося числового ряда=",avrMass);
//-Основной алгоритм
//1. Находим разницу между числами - это как раз их близость друг от друга.
//2. Если число меньше среднего значения дельт, получившихся из п.1, то - 1, а если нет - 0.
//3. Если значение из п.2 равно 1, то суммируем значение с предыдущим итогом, если нет - 0.
//4. Находим максимальное значение из пункта 3.
//5. Определяем диапазон - находим значение из пункта 4 и ищем вверх из пункта 3 число с нулевым значением, потом увеличиваем найденное число на единицу.
//Таким образом мы получаем диапазон чисел, плотность которых наибольшая по отношению к другим.
}
//+------------------------------------------------------------------+