ajout de subcommandes à la commande string
#1
j'ai trouvé le moyen d'ajouter des subcommandes à string
j ai donc créé un petit package contenant 4 commandes supplémentaire

- string empty <string> : retourne 1 si string=="" sinon retourne 0
Code :
% string empty ""
1

- string xchang <string> <index1> <index2> : échange les 2 indexes
Code :
% string xchang abcdef 1 end
afcdeb

- string randomize <string> : mélange string de façon aléatoire
Code :
% string randomize abcdef
dfecba

- string sort ?-option value ...? <string> : utilise la commande lsort de façon a classer string dans l'ordre désiré (en fonction des options spécifié)
(cf man lsort pour plus d info sur les options)
Code :
% string sort -dictionary dfecba
abcdef
% string sort -dictionary -decreasing dfecba
fedcba


bien entendu les subcommandes de base de string restent actives

si vous avez des idées de subcommandes que je pourrais ajouter
Absent
  Répondre   Avertir
#2
Bonne idée.

Quelques idées/questions en vrac :

Y'a-t-il une raison particulière à utiliser set string plutôt que return $string ?
__________
Pour une librairie de ce genre, la rapidité d'exécution est cruciale et quelques optimisations seraient les bienvenues. Même si ça n'a l'air de rien, quelques µs gagnées sur une proc exécutée plusieurs fois par seconde peuvent avoir un effet sensible.
Voici à quoi je fais allusion :
tcl
expr {$string==""}


pour tester une condition impliquant une string, eq et ne sont plus rapides que == et != (et inversement pour tester une équivalence numérique), donc :
tcl
expr {$string eq ""}


__________
tcl
set string [string replace $string $index2 $index2 $tmp]
set string [string replace $string $index1 $index1 $tmp2]


deviendrait
tcl
return [::tcl::string::replace [::tcl::string::replace $string $index2 $index2 $tmp] $index1 $index1 $tmp2]


On économise ainsi quelques instructions.
A noter aussi que ::tcl::string::replace s'exécute plus rapidement que string replace car ça épargne à l'interpréteur la peine de devoir localiser le namespace.
Même chose pour les string length qui deviendront des ::tcl::string::length et les string empty qui deviendront des ::tcl::string::empty.
__________
tcl
set j [expr {int(rand()*$len)}]
set string [string xchang $string $i $j]


pourrait s'écrire
tcl
set string [::tcl::string::xchang $string $i [expr {int(rand()*$len)}]]


et d'autres cas similaires ci et là.
  Répondre   Avertir
#3
Citation :Y'a-t-il une raison particulière à utiliser set string plutôt que return $string ?
et bien set est la syntaxe par défaut de tcl sachant que $ est un raccourci vers set "return $string" est équivalent a "return [set string]"

sinon == ou eq on un temps d'exécution strictement identique

Citation :TCL :
set string [string replace $string $index2 $index2 $tmp]
set string [string replace $string $index1 $index1 $tmp2]
deviendrait
TCL :
return [::tcl::string::replace [::tcl::string::replace $string $index2 $index2 $tmp] $index1 $index1 $tmp2]
On économise ainsi quelques instructions.
A noter aussi que ::tcl::string::replace s'exécute plus rapidement que string replace car ça épargne à l'interpréteur la peine de devoir localiser le namespace.
Même chose pour les string length qui deviendront des ::tcl::string::length et les string empty qui deviendront des ::tcl::string::empty.

j'aime bien garder un code claire d'où l utilisation de 2 lignes.
Par contre pour l'utilisation du path complet ca pourrait être une bonne idée, il y a un gain de 2us / 50us en moyenne
Absent
  Répondre   Avertir
#4
voila j ai modifié les path,
sur un "string randomize 0123456789" le gain de performance est proche des 80% (à cause de la boucle surement)
je ne pensais pas qu'on y gagnerai autant
Absent
  Répondre   Avertir
#5
djkenny a écrit :sinon == ou eq on un temps d'exécution strictement identique
Mes tests disent le contraire :
Citation :[01:12:48] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:48] <Boole> Tcl: 0.235 microseconds per iteration
[01:12:49] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:50] <Boole> Tcl: 0.234 microseconds per iteration
[01:12:51] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:51] <Boole> Tcl: 0.25 microseconds per iteration
[01:12:52] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:52] <Boole> Tcl: 0.234 microseconds per iteration
Citation :[01:12:57] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:12:58] <Boole> Tcl: 0.265 microseconds per iteration
[01:12:59] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:12:59] <Boole> Tcl: 0.265 microseconds per iteration
[01:13:00] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:13:00] <Boole> Tcl: 0.265 microseconds per iteration
[01:14:03] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:14:04] <Boole> Tcl: 0.265 microseconds per iteration
[01:14:05] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:14:06] <Boole> Tcl: 0.265 microseconds per iteration
  Répondre   Avertir
#6
Citation :[01:22] <+Dj_KennY> &tcl time {expr {1 == 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5838 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 == 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.569 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 == 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5818 microseconds per iteration
Citation :[01:22] <+Dj_KennY> &tcl time {expr {1 eq 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5579 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 eq 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5868 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 eq 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.575 microseconds per iteration
Absent
  Répondre   Avertir
#7
Dans mon test, il était question d'une string non-numérique, refais le test avec la même pour que les résultats soient comparables.
  Répondre   Avertir
#8
effectivement avec une variable le resultat change trés legerement

Citation :avec eq
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.04944 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.08395 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.04519 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.05083 microseconds per iteration
Citation :avec ==
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.12794 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.14497 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.12121 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.11631 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.1471 microseconds per iteration
mais bon la différence se compte en nano secondes Mad

édit: bizarrement avec un string vide j obtient le résultat inverse
Absent
  Répondre   Avertir
#9
Citation :avec ==
% time {::tcl::string::empty ""} 100000
1.88144 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.86438 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.89402 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.86838 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.87231 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.87639 microseconds per iteration

% time {::tcl::string::empty aaa} 100000
2.14479 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.1215 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.12854 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.12112 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.13864 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.12714 microseconds per iteration

Citation :avec eq
% time {::tcl::string::empty ""} 100000
1.97091 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.98191 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.99542 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.97693 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.96448 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.98486 microseconds per iteration

% time {::tcl::string::empty aaa} 100000
1.90619 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.90897 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.91097 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.90607 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.93027 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.90746 microseconds per iteration
Absent
  Répondre   Avertir
#10
Je bave quand je vois votre niveau dans ce langage !
  Répondre   Avertir
#11
après quelques test complémentaire jai décidé d utiliser string equal
tcl
proc ::tcl::string::empty string {
        ::tcl::string::equal $string ""
}


Absent
  Répondre   Avertir
#12
BdS a écrit :Je bave quand je vois votre niveau dans ce langage !

Ouais assez sympa, j'ai appris pas mal de chose en quelque postes ^^
  Répondre   Avertir
#13
salut,

la dernière version
Absent
  Répondre   Avertir


Atteindre :


Utilisateur(s) parcourant ce sujet : 1 visiteur(s)