ajout de subcommandes à la commande string

[djkenny]

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

[MenzAgitat]

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à.

[djkenny]

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

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

[djkenny]

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

[MenzAgitat]

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

Mes tests disent le contraire :

[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

[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

[djkenny]

[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

[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

[MenzAgitat]

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.

[djkenny]

effectivement avec une variable le resultat change trés legerement

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

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 :x

édit: bizarrement avec un string vide j obtient le résultat inverse

[djkenny]

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

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

[BdS]

Je bave quand je vois votre niveau dans ce langage !

[djkenny]

après quelques test complémentaire jai décidé d utiliser string equal

tcl

proc ::tcl::string::empty string {
        ::tcl::string::equal $string ""
}

[ZarTek]

Je bave quand je vois votre niveau dans ce langage !

Ouais assez sympa, j'ai appris pas mal de chose en quelque postes ^^

[djkenny]

salut,

la dernière version