Discussion :

[NewUserDelphi]

Bonjour

J ai une fonction qui parcours chaque point d une série d'un chart et le compare avec l’intégralité des points suivants et calcule la différence entre eux pour ne conserver que la plus grande.
C est très lent.
J ai un peu optimisé en n'effectuant le calcul que si le nouveau point est plus petit que le point de référence mais c est encore très lent.

Comment optimiser cela, si c est possible ?

Est-ce que je gagnerais en vitesse si je copiais toutes les valeurs que je souhaite comparer dans un tableau ?

Etant donné que je souhaite comparer après chaque nouvelle valeur, puis-je utiliser une Tcollection d objet avec un objet avec ayant seule propriété double ou existe t il l'équivalent d'une tstringlist pour double ?

Ma question est peut être incongrue mais je débute et ayant découvert les objets et Tcollection (je ne maîtrise pas totalement, je découvre), j'ai tendance à croire que c est la panacée et les coller à toutes les sauces...

Merci pour vos conseils.

[Paul TOTH]

il faudrait voir si la lecture d'une valeur est lente ou pas, ce qui permet de répondre ta question...mais à priori un tableau de valeurs serait sans doute plus rapide d'accès

après il y a peut-être moyen de trier la valeurs par ordre de grandeur, ce qui permet de suite de savoir quelles valeurs sont plus grandes

[exyacc]

t'as combien de points (environ) ?
100? 100000?

[NewUserDelphi]

@exyacc :
en fait je teste des operations sur des graphiques de bourse.
j en ai en moyenne 120.000 par an

donc comme j ai 15 ans de côtes je peux 'théoriquement' afficher jusqu'à 1.800.000

je procède par tranches de 10000 mais l objectif final serait de tout traiter...

@Paul TOTH:

Question de débutant mais pour savoir si la lecture est lente ou pas je mesure la diff en millisecondes entre avant et apres la lecture d'une donnée, c est ça ?
Et je compare à la lecture de la même donnée dans un objet ?
Je ne peux pas trier les données car elle sont chrono datées.

Question subsidiaire :
La rapidité de traitement dépend t elle de la structure de l objet ?

[Paul TOTH]

@exyacc :
en fait je teste des operations sur des graphiques de bourse.
j en ai en moyenne 120.000 par an

donc comme j ai 15 ans de côtes je peux 'théoriquement' afficher jusqu'à 1.800.000

je procède par tranches de 10000 mais l objectif final serait de tout traiter...

@Paul TOTH:

Question de débutant mais pour savoir si la lecture est lente ou pas je mesure la diff en millisecondes entre avant et apres la lecture d'une donnée, c est ça ?

Et je compare à la lecture de la même donnée dans un objet ?

prend plutôt une boucle qui lit 1000 valeurs histoire d'avoir quelque chose de plus précis

Je ne peux pas trier les données car elle sont chrono datées.

euh...et alors ? si tu as des objets avec un membre Date et un membre Valeur, tu peux les trier suivant la date ou suivant la valeur, vu que tu cherches des données plus grandes, le tri par valeur me semple plus indiqué.

mais c'est peut-être ton approche qui n'est pas bonne...est-ce que ce code ne donne pas le même résultat ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
var
  min: Single;
  max: Single;
  index: Integer;
begin
  min := List[List.Count - 1].Value;
  max := min;
  for index := List.count - 1 downto 0 do
  begin
    if List[Index].Value < Min then
      Min := List[Index].Value;
    if List[Index].Value > Max then
      Max := List[Index].Value;
    list[Index].distance := Max(Abs(List.value - Min), Abs(List.Value - Max));
  end;
end;

Question subsidiaire :
La rapidité de traitement dépend t elle de la structure de l objet ?

[NewUserDelphi]

Mon approche ne serait pas la bonne ? Même si j avais pu en douter, et ce ne fut pas le cas, les resultats parlent d'eux même :

@Paul TOTH Debut 17/01/2019 17:55:04 Fin 17/01/2019 17:55:04
@Moi MEME Debut 17/01/2019 17:55:04 Fin 17/01/2019 17:55:15

Sur 1.000.000 d’occurrences le résultat est sans appel ! MERCI

J'utilisais deux boucles imbriquées

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
for I := 0 to Barres.Count - 1 do
  begin
    for J := I + 1 to Barres.Count - 1 do
    begin
      if Barres[J].Value < Barres[I].Value then
      begin
        Diff := Abs(Barres[J].Value - Barres[I].Value);
        if Diff > MaxiAbs then
          MaxiAbs := Diff;
 
      end;
    end;
  end;

Je crois que c est bien l exemple de ce qui différencie un pro d'un amateur pas encore éclairé.

[anapurna]

salut

sans vouloir me mêler de se qui ne me regarde pas
je pense que tu avait une grosse erreur dans ton code ... tu risque un débordement à la fin de ta boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for I := 0 to Barres.Count - 2 do
  begin
    for J := I + 1 to Barres.Count - 1 do
    begin
      if Barres[J].Value < Barres[I].Value then
      begin
        Diff := Abs(Barres[J].Value - Barres[I].Value);
        if Diff > MaxiAbs then
          MaxiAbs := Diff;
 
      end;
    end;
  end;

ensuite comme le dis paul l'utilisation d’éléments triée aurait été plus simple
tu prenais le premier et le dernier et le tour était joué
après le calcul de distance me parais bien curieux et pas cohérent
quel est l’intérêt de calculer la distance pour chaque valeur de cette manière
surtout si tes données ne sont pas trie par valeur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
var
  amin: Single;
  amax: Single;
  index: Integer;
begin
  amin := List[List.Count - 1].Value;
  amax := min;
  Count  := List.count - 1
  Mid     :=  Count div 2 
  if  odd(Count) Then // le cas d'un nombre d’éléments paire
  begin
    aMin := Min(aMin,List[Mid].Value ) 
    aMax := Max(aMax,List[Mid].Value ) 
  end;
 
  for index := count - 1 downto Mid do
  begin
    if List[Index].Value < aMin  or List[Index-Mid].Value <aMin  then
      if  List[Index].Value < List[Index-Mid].Value  then 
        aMin := List[Index].Value 
     else 
        aMin := List[Index-Mid].Value 
 
    if List[Index].Value > aMax  or List[Index-Mid].Value > aMax  then
      if  List[Index].Value > List[Index-Mid].Value  then 
        aMin := List[Index].Value 
     else 
        aMin := List[Index-Mid].Value 
 
  end;
  distance := Abs( aMax - aMin);
end;

[NewUserDelphi]

@anapurna

tu risque un débordement à la fin de ta boucle

Je debute et je ne comprends pas comment cela est possible dans la mesure ou les boucles sont 'finies'.

le calcul de distance me parais bien curieux et pas cohérent
quel est l’intérêt de calculer la distance pour chaque valeur de cette manière
surtout si tes données ne sont pas trie par valeur

Je cherche à calculer la chute maxi pour une action au fil du temps, c est à dire à trier les valeurs d'une série ordonnées dans le temps.

ex : un cours est à 100, il monte à 120, redescends à 80, remonte à 300, redescends à 150 , remonte à 800 etc

Là ce que je cherche à trouver c est la période ou le cours passe de 300 à 150, soit -150 qui n'implique ni le plus haut ni le plus bas du graphique.
C est la plus grande différence négative entre tous les couples possibles.

C est pour cela que je teste tous les couples possible pour ne retenir que celui qui présente la plus grande différence négative et pas la plus grande différence 'absolue' entre les valeurs extrêmes d'un graphique.

C est vrai qu'en utilisant le code fourni et en stockant dans une variable les 'dates' quand la différence est la plus grande, j y parviens.

Je n ai pas encore le réflexe 'tri' mais boucle. Une résurgence du basic amstrad je crois ;-)

[SergioMaster]

Bonjour,

j en ai en moyenne 120.000 par an... j'ai 15 ans de côtes
Je cherche à calculer la chute maxi pour une action au fil du temps, c est à dire à trier les valeurs d'une série ordonnées dans le temps.
ex : un cours est à 100, il monte à 120, redescends à 80, remonte à 300, redescends à 150 , remonte à 800 etc

Avec toutes ces données vous n'avez pas pensé à utiliser un SGBD !? ne serait-ce "que" SQLite permet,
avec un peu de SQL de faire ce que vous cherchez à calculer se fait sans problème

Code SQL :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT ACTION,MAX(COURS)-MIN(COURS) FROM HISTORIQUEACTIONS GROUP BY ACTION

Cerise sur le gâteau le SQL permettant d'utiliser des clauses restrictives (WHERE) vous auriez la possibilité de cibler des périodes

Code SQL :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT ACTION,MAX(COURS)-MIN(COURS) FROM HISTORIQUEACTIONS WHERE DATE_COURS BETWEEN :DateDebut AND :DateFin GROUP BY ACTION

ci-dessus une requête paramétrée utilisable avec Delphi pour passer les bornes de dates

[NewUserDelphi]

Avec toutes ces données vous n'avez pas pensé à utiliser un SGBD !?

Oui, bien sur... mais pas pour ça J'y avais songé pour stocker la liste des opérations..

Je vais donc essayer avec Firedac/sqlite et une table en mememoire.

En fait je lis un fichier assez large (ce qui est très lent car j ai par exemple pour les années 2017 et 2018 145.000.000 de lignes qui correspondent chacune à un mouvement de prix)
j'effectue des opérations (achat ou vente) et mets le bilan sur un chart puis parcours ce dernier pour mes calculs.

Je peux très bien remplacer le chart par une bdd. Plus j y pense plus ça me semble évident.

Mais j'arrive tout de même pour cette période à un peu plus d'1.000.000 d'opérations.

Je testerais ça la semaine prochaine.

Merci

[tourlourou]

Il me semble que le besoin n'avait pas été bien exposé jusqu'ici.

Il suffit donc de parcourir la liste de cours dans l'ordre chronologique en comparant au cours précédent et au sens de variation :
+ si le cours a baissé alors qu'il baissait déjà, on l'ignore
+ si le cours a baissé alors qu'il augmentait, on mémorise le point précédent comme plus récent maximum
+ si le cours a augmenté alors qu'il augmentait déjà, on l'ignore
+ si le cours a augmenté alors qu'il baissait, c'est la fin fin d'une baisse et on teste le point précédent :
- si sa différence avec le plus récent maximum est plus petite que le record, on l'ignore
- si sa différence avec le plus récent maximum est plus grande que le record, on mémorise ce nouveau record.

Sauf erreur, un seul parcours de la liste suffit, à condition de mémoriser les points d'intérêts et le sens de variation.

[SergioMaster]

Je vais donc essayer avec Firedac/sqlite et une table en mememoire.

mais pourquoi une table en mémoire ?

En fait je lis un fichier assez large

Sous quelle forme ce fichier ?

[NewUserDelphi]

mais pourquoi une table en mémoire ?

Peut être un fantasme de débutant mais je me dis qu en mémoire ce sera plus rapide...
Comme je me dis que l'acces à un fichier sur un SSD ce sera plus rapide que sur un disque dur mécanique...


Le fichier est un .csv
Des lignes de max 60 caractères séparés par une virgule que je décompose avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
sl_Temp := Tstringlist.Create;
  sl_Temp.Delimiter := ',';
  sl_Temp.DelimitedText := Lignelue;

[SergioMaster]

Bonjour,

transférer le fichier vers une table d'une base de données SQLite (ou un autre SGBD) serait la première étape à réaliser.
Vous pourrez alors découvrir la puissance du SQL.

Pour moi avec 1.800.000 lignes c'est aberrant d'être resté sous la forme CSV , surtout que vous avez certainement une structure de donnée relativement simple
votre ligne est je pense à peu près construite comme ça :

Action,date_cours,cours

ce qui se schématiserai en gros avec une SGBD ainsi :
Table ACTION (Numero autoincrémenté ?,Nom )
clé primaire Numero
index nom unique
Table Cours (id unique autoincrémenté,numero_action,date_cours,cours)
Clé primaire id
relation numero_action table Action(numero)
index date_cours (ordre descendant) ?

Et, non, avant même que vous posiez la question, vous ne dépasserez pas la capacité de la Base (qui, pour SQLite, sous certaines conditions, peut aller jusqu'à 140 To )

[NewUserDelphi]

Merci du conseils, je vais tester cela la semaine prochaine.

Mais malgré tout j ai une question surement pas très futée car pour remplir la bdd je dois parcourir mon fichier et faire des requtes ligne par ligne.
Alors comment est il possible que le temps de traitement d'insertion dans la base de données cumulé au temps de recherche de la chute maximale du prix soit plus rapide que cette seule recherche lors de la seule lecture du fichier .

J'ai malgré tout réussi à optimiser un peu le temps de lecture (10%) en utilisant un TStreamReader

[SergioMaster]

Bonjour

Mais malgré tout j' ai une question surement pas très futée car pour remplir la bdd je dois parcourir mon fichier et faire des requêtes ligne par ligne.

tel que je vois les choses, oui, il faut transférer les anciennes écritures (celles dans le fichier texte actuel) dans la BDD, mais les nouvelles écritures seraient inscrites ensuite directement dans cette BDD sans passer par la case fichier texte.

[anapurna]

salut

pour repondre a cette question

@anapurna

tu risque un débordement à la fin de ta boucle
Je debute et je ne comprends pas comment cela est possible dans la mesure ou les boucles sont 'finies'.

le faites qu'elles soient finis n'empeche pas le debordement
dans ton exemple le dernière boucle interne dépasse

j'ai d’ailleurs modifier ton code est signalé par du rouge ou le problème peut provenir
reprenons ton code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
  for I := 0 to Barres.Count - 1 do
  begin
    for J := I + 1 to Barres.Count - 1 do
    begin
       ...

peut s’écrire comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
  alength := Barres.Count - 1 ;
  for I := 0 to alength do
  begin
    for J := I + 1 to alength do
    begin
       ...

regarde bien ton incrément I quand il arrive a la valeur acount
la valeur J de vient alength+1 ... bin tu dépasse la longueur de ton tableau

voila pourquoi j'avais décrémenté la valeur max de i afin que les indices des boucles ne dépassent jamais l'intervalle de ta liste

pour reprendre ton code si je comprend bien tu recherche le point de rupture le plus grand
tu reprend deux a deux pour avoir l’écart maxi d'une journée sur l'autre
dans ce cas tu peut le faire avec 2 variables OldValue ,distMax global
et une variable local pour chaque boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
  Dist := 0;
  if OlDValue > ValueActuel Then 
    Dist := Abs(OlDValue-ValueActuel)
  else 
    if OlDValue > ValueActuel Then 
      Dist := Abs(ValueActuel-OlDValue);
 
  if distMax < Dist  Then 
    distMax := Dist;
 
  OlDValue := ValueActuel;

[NewUserDelphi]

Bonjour

Je ne sais pas si je poste au bon endroit...

Je me suis décidé à passer aux bases de données que je découvre pour simplifier le traitement mais je me trouve déjà confronté à un problème. En effet, le nombre de résultats retourné par une requête n est pas correcte dans mon appli alors que si je teste la même requête dans dans l’éditeur de requête tout fonctionne.

mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
qry.sql.Clear;
  qry.sql.add('Select * from Tb_Barres where signal <> 0');
  qry.Open();
 
  Memo1.Lines.add('Réponses ' + inttostr(qry.RowsAffected));

J ai crée la table avec DB_BROWSER_FOR_SQLITE

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

CREATE TABLE `Tb_Barres` ( `Id` INTEGER PRIMARY KEY AUTOINCREMENT, `Date_Open` INTEGER, `Open` REAL, `Low` REAL, `High` REAL, `Close` REAL, `Signal` INTEGER )

Qu'ai-je raté ?

Merci de votre aide.

[BuzzLeclaire]

Bonjour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
  Memo1.Lines.add('Réponses ' + inttostr(qry.RowsAffected));

Bonjour NewuserDelphi

RowsAffected retourne le nombre d’enregistrement touché(s) par un update/insert etc...

Je pense que tu recherche plutôt : Qry.RecordCount.Recordset Non ?

Tu pourrais le faire également directement dans ta requête... SELECT COUNT(*) FROM matable

[NewUserDelphi]

En fait j me suis expliqué comme une patate.
Quand je fais un count(), j ai le bon resultat,
Quand je boucle sur les résultats, il s affichent tous et non les 50 premiers

Mais impossible de récupérer le nombre de résultats que retourne la requête