Diciamo che hai un file di input con molte voci come queste:
date, ticker, open, high, low, close, <and some other values>
E si desidera eseguire una routine di corrispondenza del modello sulle voci (righe) in quel file, usando ad esempio un motivo a candela. (Vedi, Doji) E quel modello può apparire in qualsiasi intervallo di tempo uniforme (lasciare t = 1s, 5s, 10s, 1d, 7d, 2w, 2y, e così via ...).
Supponiamo che una routine di abbinamento di pattern possa prendere un numero arbitrario di righe per eseguire un'analisi e contenere un numero arbitrario di sotto-schemi. In altre parole, alcuni pattern potrebbero richiedere 4 voci per operare su altri, potrebbero richiedere più o meno.
Supponiamo anche che la routine (possa) successivamente debba trovare e classificare gli estremi (massimi e minimi locali e globali come pure i punti di flesso) per il ticker su un intervallo chiuso, ad esempio, si potrebbe dire che una funzione cubica ( x ^ 3) ha il extrema sull'intervallo [-1, 1]. (Vedi link)
Dato che non conosco le dimensioni del file di input alla lettura? Quale sarebbe la scelta più naturale in termini di struttura dei dati? Che dire di un'interfaccia che è conforme a un oggetto Ticker contenente una riga di dati a una raccolta di Ticker in modo che un motivo arbitrario possa essere applicato ai dati. Ad esempio, supponiamo di avere un pattern che richiede n elementi per formare una corrispondenza, ho bisogno di applicare il pattern a quegli elementi e quindi analizzare ciascuno di quei blocchi.
Qual è la prima cosa che ti viene in mente?
Ho scelto una lista circolare circolare doppiamente collegata che ha i seguenti metodi:
push_front()
push_back()
pop_front()
pop_back()
[] //overloaded, can be used with negative parameters
Ma quella struttura di dati sembra molto maldestra, dal momento che stanno succedendo così tante cose, devo fare una copia profonda della struttura dei dati prima di eseguire un'analisi su di essa.
Quindi, non so se ho fatto la mia domanda in modo chiaro - ma i punti principali sono:
- Che tipo di strutture dati devono essere considerate quando si analizzano i punti dati sequenziali per conformarsi a un modello che NON richiede accesso casuale?
- Che tipo di strutture dati dovrebbero essere considerate quando si classificano gli estremi di un insieme di punti dati?
Aggiornamento
Ecco il ciclo principale dell'analizzatore per il mio programma (in alcuni pseudocodi che è un poliglotta di poche lingue)
data = new circular_linkedList()
// in my case, data is a circular linked list of elements.
foreach(element in dataFeed) {
data.push_front(element)
}
step_value = Pattern.numberRequiredElementsForMatch()
buffer = new circular_linkedList()
// at this point, you'll have a circular linked list
// where pop_back() will return the oldest entry and
// entry, and pop_front() will return the newest
// initialize the buffer
for(value in range(step_value()) {
buffer.push_back(data.pop_back())
// fill a buffer with the number of
// values required for a match.
// so now buffer will contain
// [elementk, ... , elementk+n]
// where buffer[0] < ... < buffer[n]
}
do {
last = buffer[len(buffer)]
...
first = buffer[0]
Pattern.match(first, ... , last)
buffer.pop_front() // remove the first element
buffer.push_back(data.pop_back()) //add another element to the back
} while (!data.isEmpty())
...
Ad ogni modo, è un'idea di base di quello che sto succedendo. Il problema è che, ora che lo sto facendo, devo ripetere il ciclo per applicare un altro pattern. (le dimensioni del buffer differiscono) Sembra proprio inefficiente farlo. Inoltre, cosa succede quando non ci sono più dati nel buffer e non è equamente divisibile per il numero di elementi necessari a una partita?