Version imprimable
Grow c'est une méthode Privée, faut lire le source ... ;)
Sinon Affiché les 1500 itérations ne sert à rien la dernière suffit, ... c'est ce que je fait, car j'ai dans la 30aine de variante, sans compter les appels d'Explode avec tous les cas que j'ai pu trouvé pour mes tests, ...
A ShaiLeTroll :
... oui mais ça suffit uniquement pour faire un test de vitesse avec 1000 fois la même ligne de test, mais si on veut accumuler dans le tableau A les Splits sur 1000 lignes toutes différentes l'une de l'autre on ne retrouverait que le résultat du dernier appel à ExplodeLazyPChar ... raison pour laquelle je pensais qu'il y aurait une astuce pour accumuler l'ensemble dans une StringList.:DCitation:
Sinon Affiché les 1500 itérations ne sert à rien la dernière suffit
L'accumulation fausse le test, car tu ne teste plus la fonction, mais la fonction plus de l'accumulation, ...
mais pour l'accumulation sans mesure de temps, tu peux mettre
après chaque appel ...Code:for i:=Low(A) to High(A) do RichEdit1.lines.Add(A[i]);
Sinon, je ne teste qu'avec qu'une ListBox, c'est le composant dont les TStrings sont les plus proche de la TStringList et ne font aucune modification de contenu comme le TMemo ou le TRichEdit ...
A ShaiLeTroll :... c'est effectivement une façon de voir les choses, par contre si l'objectif global est d'accumuler je préfère faire porter les test de vitesse sur l'ensemble splittage+accumulation, et c'est d'ailleurs ce que fait ma version d'ExplodeLazy où, n'ayant pas trouvé dans un 1er temps l'unité "Types" à ajouter dans les USES pour le TStringDynArray, j'ai simplement remplacé le TStringDynArray par une StringList alimentée par Add.Citation:
L'accumulation fausse le test, car tu ne teste plus la fonction, mais la fonction plus de l'accumulation
... effectivement en accumulant après chaque appel c'est une parade qui permet d'accumuler dans n'importe quel conteneur de lignes.Citation:
A propos de ExplodeLazyPChar :
mais pour l'accumulation sans mesure de temps, tu peux mettre for i:=Low(A) to High(A) do RichEdit1.lines.Add(A[i]);après chaque appel ...
Nouvelle fonction de splittage : Voiçi une variante améliorée d'ExplodeGG où tous les mots splittés sont séparés par des #13#10 et accumulés à la volée dans un MemoryStream :... Temps d'Execution d'ExplodeGGMS sur [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] découpé sur ; répété 1000 fois avec splittage ET accumulation dans le MémoryStream : 1,12 ms avec Pentium III à 1,13 Ghz.Code:
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
... pas mécontent du résultat, si ça peut rendre service à qqu'un.:D
Juste comme çà, la fonction n'explode rien, mais fait un simple ReplaceString et copie le résultat dans un TStream, donc le réel explode est fait par le LoadFromStream ... pour moi, cette fonction ne propose pas le même résultat c'est à dire un tableau/liste contenant les chaines séparés que l'on peut parcourir facilement.
Comparer les temps sur une fonction qui ne fait pas le même résultat n'a pas de sens ...
Il est vrai l'acculumation du résultat d'un explode (pas la version Lazy) peut servir pour l'affichage d'un csv dans une grille par exemple ... sinon je vois rien d'autres ...
Salut Gilbert,
Je rejoins un peu ce que dit ShailLeTroll car en fait pour moi c'est vraiment le fait d'avoir le résultat dans une List qui m'interesse.
Amicalement,
Bruno
A ShaiLeTroll :
... peu importe, l'essentiel est que ça marche bien, et comme le Stream contient bien la totalité des chaines séparées on peut les charger à souhait dans une StringList si on veut pouvoir les parcourir facilement et qu'on n'a pas besoin de les visualiser, ou bien si on veut les accumuler dans un contrôle de visualisation au prix du ralentissement correspondant on peut les envoyer dans une ListBox, un Memo ou un RichEdit. Pour ma part je considère qu'une chaîne est splittée dès lors que les séparateurs y sont remplacés par des #13#10 qui découpent cette chaîne en des mini-chaînes, que ces mini-chaînes soient à l'intérieur d'un Stream ou d'autre chose. Bon, j'ai utilisé un MemoryStream, j'aurais aussi bien pu faire avec un TStringStream, mais comme le MemoryStream fonctionne tout aussi bien j'ai pris celui-ci ... si ça me prend j'essayerai avec un TStringStream un prochain jour.
:D
P.S : En fait LoadFromStream n'explode rien du tout il ne fait que transmettre au destinataire ce qui a été explodé-splitté au préalable par la fonction et si on donne à LoadFromStream un stream non splitté ce n'est certainement pas LoadFromStream qui fera les splits à la place de la fonction.
Et pour ce qui est des temps d'exécution il est exact qu'ils nont de sens que si on compare des fonctions qui renvoient les mêmes résultats ce qui nécessiterait de modifier ExplodeLazy par exemple de sorte qu'elle renvoie la totalité des splits qu'elle produit dans un boucle d'appel et non seulement ceux du dernier appel car l'objectif n'est pas de splitter pour splitter mais de récupérer la totalité des splits ce qui nécessite bien entendu que ce soit ExplodeLazy qui engrange tous les splits dans le même tableau ou alors c'est dans la boucle d'appel qu'il faut, après chaque appel, transférer les résultats partiels dans un tableau annexe ce qui prend bien entendu un temps non pris en compte dans le score affiché et dans les comparaisons.
Salut Bruno,
Comme ton message s'est intercalé devant le mien pendant que je le rédigais et qu'en même temps j'ai fait autre chose, je pense que ma réponse à ta remarque se trouve dans ma réponse à ShaiLeTroll : Si tu veux le résultat dans une List :
... et le tour est joué.:DCode:
2
3
4
5... for i:=1 to 1000 do ExplodeGGMS(ligTests,MS,';'); MS.Position:=0; SL := tStringList.create; SL.LoadFromStream(MS);
:mouarf: j'etais justement en train de composer un message qui faisait cela
A Bruno13,
Salut Bruno,
Vérification faite, le remplacement du TMemoryStream par un TStringStream aboutit à peu près à des temps d'exécution identiques.
La principale différence avec TStringStream est de pouvoir récupérer la totalité des splits soit par ReadString soit par LoadFromStream :
... mais pour les reste c'est kif-kif.Code:
2
3
4
5
6
7SL := tStringList.create SS.Position:=0; SL.Text:=SS.ReadString(SS.size); // ou bien : SS.Position:=0; SL.LoadFromStream(SS);
Autre vérification faite avec une variante de la fonction ExplodeGGMS où au lieu de splitter sur un seul séparateur le test de splittage portait sur la vérification de présence de 10 séparateurs le temps d'exécution a seulement été multiplié par deux.:D
Salut Gilbert,
Je vais tester cela d'ici peu. Je te tiens informé. Là je bloque sur la qualité du resultat que j'obtiens avec ma détection de Concept. hum pas évident du tout :roll: :(
Salut Bruno,
... je suppose que tu fais allusion au BrainStorming de l'autre dicussion : effectivement c'est pas évident et en plusieurs langues ça l'est encore moins, mais wait and see il y aura peut-être des idées. J'ai cherché sur Google avec bi-gramme tri-gramme et n-gramme on y trouve une floppée de théories mais je n'ai pas trouvé de trucs bien concrets qui aboutiraient à un résultat indiscutable.;)Citation:
Là je bloque sur la qualité du resultat que j'obtiens avec ma détection de Concept. hum pas évident du tout
Pour les n-grammes, c'est pour la détection de la langue ? Pour ça ce que tu m'as fourni est largement suffisant, je reste sur 5 langues et j'ai un résultat plus que satisfaisant donc je passe à la suite... au fameux BrainStorming ;)
Il n'y a pas de "Pour ma part", splitté c'est découpé en morceaux un ensemble, et remplacer un caracètère par une série de caractère ne sera jamais un split mais un remplacement, et je confirme le VRAI explode est fait par le LoadFromStream qui utilise comme caractère de séparation le #10 ou le #13 et le #0Citation:
Envoyé par Gilbert Geyer
La Fonction Explode n'a qu'un seul but, on lui donne une entrée chaine et cela ressort un tableau de chaine, ensuite, tu peux utiliser mon wrapper, car j'avais déjà pensé au besoin d'accumulation ou au fait que mes collègues préfèrent manipuler des TStringList que des Array ...
voir le code de Classes.pasCode:
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
tu notteras SetTextStr ressemble très nettement à un explode en PChar ... SetString étant l'équivalent du SetLength+Move ...Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Bonjour ShaiLeTroll,
... wouais ? sauf que lorsque je sauve les résultats du splittage sur le disque et que j'ouvre le fichier avec un Editeur Hexa je n'y trouve que des 0D0A c'est à dire #13#10 comme séparateurs !!! et nulle part aucun #0 ! Pas convaincant l'histoire du #0 ajouté comme séparateur. Ce n'est pas parceque le SetTextStr teste la présence éventuelle d'un #0 qu'il le rajoute comme séparateur. Et LoadFromStream laisse passer comme le facteur toute chaine spllittée ou non splittée.Citation:
LoadFromStream qui utilise comme caractère de séparation le #10 ou le #13 et le #0
Mais dans tout ça, l'essentiel c'est que ça marche, non ?
Pour ce qui est de la function ExplodeLazyToStrings qui répond au besoin d'accumulation je testerai demain mais je m'attends à obtenir le même temps d'exécution qu'avec ma variante la function ExplodeLazySL(const S: string; var SL: TStringList; Separator: Char): Integer où la TStringList SL remplace directement le tableau 'A' qui n'accumulait que les splits du dernier appel et celle-ci met 13 à 18,42 ms avec la chaine de tests répétée 1000 fois (Pentium III 1,13 Ghz)
J'ai deux autres variantes d'ExplodeLazy où j'ai conservé le tableau 'A' mais modifié les setLength et les indices pour tenir compte de Lg0:=High(A)+1; longueur initiale du tableau au moment de l'appel pour y accumuler tous les splits résultant de la série d'appels par boucle, mais les deux versions (avec ou sans PChar) conduisent à des temps d'exécution de l'ordre de 160 ms ... ce qui une fois de plus confirme l'intérêt et la vélocité des StringList.:D
oui, c'était un "et" dans le sens qu'il gère le #0, suffisait de lire le code "(P^ in [#0, #10, #13]) ", tu chippote !:roll:
Sinon, pour le Tableau, bien sur, l'allocation sans prévision (ce que fait la TStringList avec sa méthode privée Grow) est très lente, et toute la lenteur de l'accumulation est l'agrandissement de la mémoire au fur et à mesure, le parcours des chaines est à coté insignifiant ...
... au final la StringList est plus dynamique que les tableaux-dits-dynamiques,Citation:
Sinon, pour le Tableau, bien sur, l'allocation sans prévision (ce que fait la TStringList avec sa méthode privée Grow) est très lente, et toute la lenteur de l'accumulation est l'agrandissement de la mémoire au fur et à mesure, le parcours des chaines est à coté insignifiant
... et les Streams sont encore plus dynamiques que les StringList.
... peut on vraiment faire de la micro-informatique sans chipoter, alors qu'au moindre oubli d'un point ou d'une virgule la machine nous envoie ballader? :mouarf:Citation:
tu chippote !
La TStringList est un Tableau Dynamique !
Mais elle apporte une gestion intelligente de la mémoire (voir Capacity) puisqu'il y a une allocation prévisionnelle par lot ... et c'est justement pour ce que dans Explode, je compte le nombre de séparateur pour allouer le tableau en une seule fois, le gain est énorme ...
Pour le Stream,
si c'est à base de THandleStream c'est du Fichier, pipe, socket ... limitation habituelle, temps d'execution dépendant bcp des conditions systèmes, des DD, du réseau, ...
si c'est à base de TMemoryStream c'est du pointeur, donc gestion mémoire standard, et finalement, tout dépend de la taille pré-alloué, ... comme dans ton exemple tu écrit dans le stream une seule fois, cela gagne du temps car une seule allocation
si c'est à base de TStringStream, c'est une string qui est derrière donc aucun intérêt pour Exploder ...
Voilà, c'est très simple ...
tu devrais essayer les Pointers, tu comprendrais mieux ces Objets et comment fonctionne la mémoire ... consulte donc l'unité Classes.pas, tu devrais y trouver l'implementation de la StringList et autres ... j'y ai appris bcp de choses ...
Bonjour ShaiLeTroll
1)... oui oui, tu l'avais déjà souligné dans une autre discussion. En fait quand j'ai dit "au final la StringList est plus dynamique que les tableaux-dits-dynamiques" c'était surtout un jeu de mots en faveur des StringList.Citation:
La TStringList est un Tableau Dynamique !
... dommage qu'il n'ait pas été prévu d'allocation prévisionnelle par lot pour les tableaux-dits-dynamiques cela les aurait mis sur un pied d'égalité avec TStringList.
2)... pourtant ma variante avec TStringStream est tout aussi rapide que celle avec TMemoryStream et de plus elle permet de récupérer le résultat de trois manières différentes ce qui est également intéressant :Citation:
si c'est à base de TStringStream, c'est une string qui est derrière donc aucun intérêt pour Exploder
3) Tests avec la function ExplodeLazyToStrings(const S: string; L: TStrings; Separator: Char; DoClear: Boolean = True): Integer : je n'ai pas pu faire de tests car elle encapsule Explode(S, A, Separator) et celle-ci utilise des IfThen qui n'existent pas sous Delphi-5.Code:
2
3
4
5
6SL := tStringList.create; SS.Position:=0; 1) SL.Text:=SS.ReadString(SS.size); // et en jouant avec SS.Position et ReadString(count) on peut même faire une extraction sélective dans le cas de splits de même longueur 2) SL.Text:=SS.DataString; ou 3) SL.LoadFromStream(SS);
Par contre je trouve dommage d'encapsuler celle-ci derrière le paramètre Separator: Char qui est restrictif alors qu'Explode permet des splits-multiséparateurs.
Je préfère plutôt une version de ExplodeLazy qui n'encapsule pas Explode() mais dans laquelle le out A: Types.TStringDynArray est directement remplacé par var SL : TStringList et qui rend superflue l'existence d'ExplodeLazyToStrings puisque l'ExplodeLazy mono-séparateur ainsi modifiée réalise l'accumulation tout aussi bien directement et en se passant des SetLength-ralentisseurs.
Et pour ce qui est d'encapsuler Explode() pour l'accumulation je verrais donc mieux l'existence d'une function ExplodeToStrings(const S: string; L: TStrings; Separator: string; DoClear: Boolean = True): Integer
Cela formerait un ensemble plus cohérent.
4)... ok je la consulterai à l'occasion puisque tu dis y avoir appris bcp de chosesCitation:
consulte donc l'unité Classes.pas, tu devrais y trouver l'implementation de la StringList et autres ... j'y ai appris bcp de choses
... j'hésite toujours un peu à tripatouiller dans les fichiers des dossiers de Delphi pour éviter d'y mettre le désordre.
A+:D