Accueil > > > SNIPPET $ICALC : CALCUL COMPLEXE
SNIPPET $ICALC : CALCUL COMPLEXE
Information sur la source
Description
$calc permet de calculer des expressions réelles uniquement ce qui limite le champ d'action pour des applications graphiques par exemple ... Après avoir vu maints bidouillages pour simuler des complexes , en avoir fait moi même , voici ce snippet permettant de réaliser des calculs complexes sous mirc (il utilise $calc seulement pour les calculs élémentaires)
Source
- /*
- $Icalc(expr.) -> calcul d'une expression mathématique complexe
- Entrée : expression pouvant contenir :
- - des nombres complexes sous la forme a+ib (ce qui inclut les expressions qu'on calcule avec $calc , modulo une entrée "valide" , certains remplacements tordus de $calc en particulier ne sont pas gérés > renvoient 0)
- - a|b , qui signifie "(a+ib)" (et non "a+ib"...) comme ils sont traités en interne
- Lors d'erreurs, l'alias renvoie un résultat (intermédiaire ou final) égal à 0, ce qui correspond au choix (très) discutable fait dans $calc
- Exemple : calcul de 2 * (1-i)
- //Echo -a › $Icalc(2 * (1-i))
- -> renvoie 2|-2
- //Echo -a › $Icalc(2|0 * (1-i))
- -> renvoie 2|-2
- //Echo -a › $Icalc(2|0*1|-1)
- -> renvoie 2|-2
- //Echo -a › $Icalc(2|0*1|-1).n
- -> "natural" , même si c'est assez peu manipulable... -> renvoie 2-2i
- //Echo -a › $Icalc(2*1|-1).exp
- -> "exponentiel" , retourne le résultat sous la forme Module|Argument -> renvoie 2.828427|-0.785398
- //Echo -a › $Icalc(2*1|-1).arg
- -> "argument" , retourne l'argument du résultat dans l'intervalle ]-Pi;Pi] -> renvoie -0.785398
- //Echo -a › $Icalc(2*1|-1).mod
- -> "module" , retourne le module résultat -> renvoie 2.828427
- Le parsing s'effectue a priori comme $calc , en suivant les règles usuelles de priorité (ordre : ^,%,* et /,+ et -)
- /itest <expr.> permet de dénicher des bugs sur des expressions REELLES (premier résultat : parsing avec $Icalc , deuxième $calc(expr.)) , si vous en trouvez n'hésitez pas , même si j'ai réussi à me convaincre qu'il y en avait certainement peu :
- Ex : /itest 9*1000-5*(.1456 -(1-5*(2+9*-7-90)*-2334.546))-0.1164*2+4*9.
- */
-
- Alias Icalc {
- if (!$isid) return
- if ($prop == t) { var %s $1 }
- else {
- if $2 { echo -s * Too many parameters: $Icalc | return 0 }
- var %s = $replace($1,$chr(32),,++,+,--,+,-+,-,+-,-)
- ;erreurs de parenthèses : comme $calc
- if ($count(%s,$chr(40)) > $count(%s,$chr(41))) { return 0 }
- if ($count(%s,$chr(40)) < $count(%s,$chr(41))) { var %i 1,%s2 | while ($count(%s2,$chr(40)) >= $count(%s2,$chr(41))) { inc %i | %s2 = $left(%s,%i) } | %s = $left(%s2,-1) }
- ;retrait des parenthèses et vérification : nombres et opérateurs enchevêtrés comme il faut
- if !$regex($remove(%s,$chr(40),$chr(41)),/^((-|\+)?[0-9i.|]+[-+*/^%])*(-|\+)?[0-9i.|]+$/i) { return 0 }
- ;remplacement des opérateurs , élimination des "+" inutiles (début d'expression notamment) , formatage a > a|0 et ib ou bi > 0|b
- var %mask /([0-9i).])([-+*/^%])/g , %x = $regsub(%s,%mask,\1;o\2;,%s) , %x = $regsub($replace(%s,$chr(40),$chr(40) $+ ;,$chr(41),; $+ $chr(41)),/([-0-9.]+i|i[-0-9.]+)/gi,i0|\1,%s) , %mask /(^|;)([-0-9.]+)(;|$)/g , %x = $regsub(%s,%mask,\1\2|0\3,%s) , %s = $replace($+(;,%s,;),;;,;,;i;,;0|1;,|-i;,|-1;,i,)
- ;remplacement des parenthèses dans l'ordre (de l'intérieur à l'extérieur)
- var %m /\(([^()]+)\)/
- while $regex(%s,%m) { %s = $replace(%s,$+($chr(40),$regml(1),$chr(41)),$Icalc-($regml(1))) }
- }
- ;on a des expressions sans parenthèse , on calcul en respectant les priorités des opérateurs ( ^ , % , *|/ , +|- )
- var %op \^;%;(?:\*|\/);(?:\+|-) , %i 1
- while $gettok(%op,%i,59) {
- var %m = /(;([^;]+);o( $+ $v1 $+ );([^;]+);)/
- while $regex(%s,%m) {
- %s = $replace(%s,$regml(1),$+(;,$Icalc--($regml(2),$regml(4),$regml(3)),;)) }
- inc %i
- }
- %s = $remove(%s,;)
- if ($gettok(%s,3,124) != $null) { return 0 }
- if ($prop == n) { return $replace($+($1,+,$2,i),+-,-) }
- if ($prop == exp) { return $Itr(%s) }
- if ($prop == arg) { return $Iarg(%s) }
- if ($prop == mod) { return $Imod(%s) }
- return %s
- }
- ;récurrence (remplacement des parenthèses , déjà traitées ($prop -> t)
- Alias -l Icalc- return $Icalc($1).t
- ;opérations (vues les erreurs d'arrondis grossières de $calc on ne passe pas à la forme exponentielle pour les calculs de puissances)
- Alias -l Icalc-- {
- tokenize 124 $+($1,$chr(124),$2,$chr(124),$3)
- if ($5 == ^) { if ($4) || ((- isin $3) && (!$1) && (!$2)) { return 0|0 } | var %m = $iif(- isin $3,1/,1*) , %3 = $remove($3,-) | return $iif($2,$iif(. isin %3,0|0,$iif(%3,$Icalc(%m $Iexpo($+($1,$chr(124),$2),%3)),1|0)),$calc($1 ^ $3) $+ |0) }
- if ($5 == %) { if ($2) || (!$3) || ($4) { return 0|0 } | return $calc($1 % $3) $+ |0 }
- if ($5 == *) { return $+($calc($1 * $3 - $2 * $4),$chr(124),$calc($1 * $4 + $2 * $3)) }
- if ($5 == /) { var %q $calc($3 ^ 2 + $4 ^ 2) | return $+($calc(($1 * $3 + $2 * $4) / %q),$chr(124),$calc(($2 * $3 - $1 * $4) / %q)) }
- if ($5 == +) { return $calc($1 + $3) $+ $chr(124) $+ $calc($2 + $4) }
- if ($5 == -) { return $calc($1 - $3) $+ $chr(124) $+ $calc($2 - $4) }
- }
- ;module
- Alias Imod { tokenize 124 $1 | return $sqrt($calc($1 ^ 2 + $2 ^ 2)) }
- ;argument
- Alias Iarg { tokenize 124 $1 | var %m $sqrt($calc($1 ^ 2 + $2 ^ 2)) | return $iif(!%m,0,$+($iif(- isin $2,-),$acos($calc($1 / %m)))) }
- ;a + i b -> |z| exp(i teta)
- Alias Itr { tokenize 124 $1 | var %m $sqrt($calc($1 ^ 2 + $2 ^ 2)) | return $iif(!%m,0|0,$+(%m,$chr(124),$iif(- isin $2,-),$acos($calc($1 / %m)))) }
- ;|z| exp(i teta) -> a + i b
- Alias Itr2 { tokenize 124 $1 | return $iif(- isin $1,0|0,$calc($1 * $cos($2)) $+ $chr(124) $+ $calc($1 * $sin($2))) }
- ;exponentielle complexe (utile pour les rotations ...) > exemple $iexp($pi / 2)
- Alias Iexp { return $cos($calc($1)) $+ $chr(124) $+ $sin($calc($1)) }
- ;"exponentiation rapide"
- Alias -l Iexpo return $iif($2 == 1, $1 , $iif(2 // $2, $Icalc($Iexpo2($1,$calc($2 /2)) * $Iexpo2($1,$calc($2 /2))) , $Icalc($1 * $Iexpo2($1,$calc(($2 -1)/2)) * $Iexpo2($1,$calc(($2 -1)/2)))))
- ;un jour mirc supportera les appels récursifs ... en attendant :
- Alias -l Iexpo2 return $Iexpo($1,$2)
- ;tests REELS
- Alias Itest { echo -a › $1- $str($chr(160),10) ¬ Résultats : $Icalc($1-) • $calc($1-) }
/*
$Icalc(expr.) -> calcul d'une expression mathématique complexe
Entrée : expression pouvant contenir :
- des nombres complexes sous la forme a+ib (ce qui inclut les expressions qu'on calcule avec $calc , modulo une entrée "valide" , certains remplacements tordus de $calc en particulier ne sont pas gérés > renvoient 0)
- a|b , qui signifie "(a+ib)" (et non "a+ib"...) comme ils sont traités en interne
Lors d'erreurs, l'alias renvoie un résultat (intermédiaire ou final) égal à 0, ce qui correspond au choix (très) discutable fait dans $calc
Exemple : calcul de 2 * (1-i)
//Echo -a › $Icalc(2 * (1-i))
-> renvoie 2|-2
//Echo -a › $Icalc(2|0 * (1-i))
-> renvoie 2|-2
//Echo -a › $Icalc(2|0*1|-1)
-> renvoie 2|-2
//Echo -a › $Icalc(2|0*1|-1).n
-> "natural" , même si c'est assez peu manipulable... -> renvoie 2-2i
//Echo -a › $Icalc(2*1|-1).exp
-> "exponentiel" , retourne le résultat sous la forme Module|Argument -> renvoie 2.828427|-0.785398
//Echo -a › $Icalc(2*1|-1).arg
-> "argument" , retourne l'argument du résultat dans l'intervalle ]-Pi;Pi] -> renvoie -0.785398
//Echo -a › $Icalc(2*1|-1).mod
-> "module" , retourne le module résultat -> renvoie 2.828427
Le parsing s'effectue a priori comme $calc , en suivant les règles usuelles de priorité (ordre : ^,%,* et /,+ et -)
/itest <expr.> permet de dénicher des bugs sur des expressions REELLES (premier résultat : parsing avec $Icalc , deuxième $calc(expr.)) , si vous en trouvez n'hésitez pas , même si j'ai réussi à me convaincre qu'il y en avait certainement peu :
Ex : /itest 9*1000-5*(.1456 -(1-5*(2+9*-7-90)*-2334.546))-0.1164*2+4*9.
*/
Alias Icalc {
if (!$isid) return
if ($prop == t) { var %s $1 }
else {
if $2 { echo -s * Too many parameters: $Icalc | return 0 }
var %s = $replace($1,$chr(32),,++,+,--,+,-+,-,+-,-)
;erreurs de parenthèses : comme $calc
if ($count(%s,$chr(40)) > $count(%s,$chr(41))) { return 0 }
if ($count(%s,$chr(40)) < $count(%s,$chr(41))) { var %i 1,%s2 | while ($count(%s2,$chr(40)) >= $count(%s2,$chr(41))) { inc %i | %s2 = $left(%s,%i) } | %s = $left(%s2,-1) }
;retrait des parenthèses et vérification : nombres et opérateurs enchevêtrés comme il faut
if !$regex($remove(%s,$chr(40),$chr(41)),/^((-|\+)?[0-9i.|]+[-+*/^%])*(-|\+)?[0-9i.|]+$/i) { return 0 }
;remplacement des opérateurs , élimination des "+" inutiles (début d'expression notamment) , formatage a > a|0 et ib ou bi > 0|b
var %mask /([0-9i).])([-+*/^%])/g , %x = $regsub(%s,%mask,\1;o\2;,%s) , %x = $regsub($replace(%s,$chr(40),$chr(40) $+ ;,$chr(41),; $+ $chr(41)),/([-0-9.]+i|i[-0-9.]+)/gi,i0|\1,%s) , %mask /(^|;)([-0-9.]+)(;|$)/g , %x = $regsub(%s,%mask,\1\2|0\3,%s) , %s = $replace($+(;,%s,;),;;,;,;i;,;0|1;,|-i;,|-1;,i,)
;remplacement des parenthèses dans l'ordre (de l'intérieur à l'extérieur)
var %m /\(([^()]+)\)/
while $regex(%s,%m) { %s = $replace(%s,$+($chr(40),$regml(1),$chr(41)),$Icalc-($regml(1))) }
}
;on a des expressions sans parenthèse , on calcul en respectant les priorités des opérateurs ( ^ , % , *|/ , +|- )
var %op \^;%;(?:\*|\/);(?:\+|-) , %i 1
while $gettok(%op,%i,59) {
var %m = /(;([^;]+);o( $+ $v1 $+ );([^;]+);)/
while $regex(%s,%m) {
%s = $replace(%s,$regml(1),$+(;,$Icalc--($regml(2),$regml(4),$regml(3)),;)) }
inc %i
}
%s = $remove(%s,;)
if ($gettok(%s,3,124) != $null) { return 0 }
if ($prop == n) { return $replace($+($1,+,$2,i),+-,-) }
if ($prop == exp) { return $Itr(%s) }
if ($prop == arg) { return $Iarg(%s) }
if ($prop == mod) { return $Imod(%s) }
return %s
}
;récurrence (remplacement des parenthèses , déjà traitées ($prop -> t)
Alias -l Icalc- return $Icalc($1).t
;opérations (vues les erreurs d'arrondis grossières de $calc on ne passe pas à la forme exponentielle pour les calculs de puissances)
Alias -l Icalc-- {
tokenize 124 $+($1,$chr(124),$2,$chr(124),$3)
if ($5 == ^) { if ($4) || ((- isin $3) && (!$1) && (!$2)) { return 0|0 } | var %m = $iif(- isin $3,1/,1*) , %3 = $remove($3,-) | return $iif($2,$iif(. isin %3,0|0,$iif(%3,$Icalc(%m $Iexpo($+($1,$chr(124),$2),%3)),1|0)),$calc($1 ^ $3) $+ |0) }
if ($5 == %) { if ($2) || (!$3) || ($4) { return 0|0 } | return $calc($1 % $3) $+ |0 }
if ($5 == *) { return $+($calc($1 * $3 - $2 * $4),$chr(124),$calc($1 * $4 + $2 * $3)) }
if ($5 == /) { var %q $calc($3 ^ 2 + $4 ^ 2) | return $+($calc(($1 * $3 + $2 * $4) / %q),$chr(124),$calc(($2 * $3 - $1 * $4) / %q)) }
if ($5 == +) { return $calc($1 + $3) $+ $chr(124) $+ $calc($2 + $4) }
if ($5 == -) { return $calc($1 - $3) $+ $chr(124) $+ $calc($2 - $4) }
}
;module
Alias Imod { tokenize 124 $1 | return $sqrt($calc($1 ^ 2 + $2 ^ 2)) }
;argument
Alias Iarg { tokenize 124 $1 | var %m $sqrt($calc($1 ^ 2 + $2 ^ 2)) | return $iif(!%m,0,$+($iif(- isin $2,-),$acos($calc($1 / %m)))) }
;a + i b -> |z| exp(i teta)
Alias Itr { tokenize 124 $1 | var %m $sqrt($calc($1 ^ 2 + $2 ^ 2)) | return $iif(!%m,0|0,$+(%m,$chr(124),$iif(- isin $2,-),$acos($calc($1 / %m)))) }
;|z| exp(i teta) -> a + i b
Alias Itr2 { tokenize 124 $1 | return $iif(- isin $1,0|0,$calc($1 * $cos($2)) $+ $chr(124) $+ $calc($1 * $sin($2))) }
;exponentielle complexe (utile pour les rotations ...) > exemple $iexp($pi / 2)
Alias Iexp { return $cos($calc($1)) $+ $chr(124) $+ $sin($calc($1)) }
;"exponentiation rapide"
Alias -l Iexpo return $iif($2 == 1, $1 , $iif(2 // $2, $Icalc($Iexpo2($1,$calc($2 /2)) * $Iexpo2($1,$calc($2 /2))) , $Icalc($1 * $Iexpo2($1,$calc(($2 -1)/2)) * $Iexpo2($1,$calc(($2 -1)/2)))))
;un jour mirc supportera les appels récursifs ... en attendant :
Alias -l Iexpo2 return $Iexpo($1,$2)
;tests REELS
Alias Itest { echo -a › $1- $str($chr(160),10) ¬ Résultats : $Icalc($1-) • $calc($1-) }
Conclusion
Installation : Clic droit sur la source , Copier , puis allez dans l'éditeur de remotes de mirc et de nouveau clic droit : Coller . Pour vous en servir vous pouvez d'abord tester les exemples de l'en-tête du remote ...
Je suis ouvert à toute remarque en particulier optimisation/bugs/améliorations Je m'excuse d'avance , non de l'utilité de ces aliases qui n'est pas à démontrer en ce qui me concerne (c'est suffisant) mais du fait que le code soit assez illisible vu l'utilisation outrancière des expressions régulières ... je le poste surtout pour connaître les bugs en fait et si ca intéresse certains ^^"
Historique
- 18 août 2004 03:45:41 :
- Faute de frappe dans l'en tête : Exemple : calcul de 2 * (1-i) et non (1+i)
- 19 août 2004 02:13:02 :
- Améliration des puissances : exponentiation rapide
Sources du même auteur
GEOTOOLS : GESTION D'UN UWORLDGEOTOOLS : GESTION D'UN UWORLDToujours dans la catégorie "je sors des remotes de mes cartons" : ce script a quelques temps déjà, il date de l'époque où je sévissais sur Entrechat e...
FRACTALES EN PICWINSFRACTALES EN PICWINSDisclaimer:
*** Ce code est donné à titre anecdotique : mIRC ne fournit pas les perfs obligatoires pour faire des fractales plus évoluées, mais bon, ...
ASPIRATEUR DE GALERIES INTERNETASPIRATEUR DE GALERIES INTERNET Hi,
Cette idée trotte depuis un bail dans ma tête..
Marre de télécharger une par une les images d'une galerie ?
Pourquoi pas faire quelques socke...
SCANNER MULTIFONCTIONSSCANNER MULTIFONCTIONSScanner multifonctions : clones, ircops, badnicks.
Resizable, en treeview, intégre un réglage des hosts ignorés et des badnicks à détecter. (certains...
QUOTEUR (MDX)QUOTEUR (MDX) Tout d'abord mes excuse à Sin_Of_Hell qui vient de poster un quoteur ici même, le mien est différent puisqu'utilisant pas mal mdx.dll.
Sinon, c'est u...
Sources de la même categorie
Commentaires et avis
|
Derniers Blogs
TECHDAYS PARIS 2010 : LA BI DANS SHAREPOINT 2010TECHDAYS PARIS 2010 : LA BI DANS SHAREPOINT 2010 par ROMELARD Fabrice
Animé par: Vincent Bellet et Baptiste Giraudier La BI dans SharePoint 2010, Les nouveaux services d'application dans SP2010 et SQL Server Reporting services 2008 R2. La BI dans SharePoint est généralisée pour tous afin de permettre à tous les coll...
Cliquez pour lire la suite de l'article par ROMELARD Fabrice TECHDAYS PARIS 2010 : PLAN DE MIGRATION VERS SHAREPOINT 2010TECHDAYS PARIS 2010 : PLAN DE MIGRATION VERS SHAREPOINT 2010 par ROMELARD Fabrice
Animé par: Arnault Nouvel et Antoine Dongois Le processus à prendre : Apprendre (découvrir la plateforme) Préparer (documenter l'historique et choisir la méthode de MAJ) Test (Test de MAJ) Implémenter (Effectuer la MAJ) Valid...
Cliquez pour lire la suite de l'article par ROMELARD Fabrice TECHDAYS PARIS 2010 : LA PLEINIèRE DU SECOND JOURTECHDAYS PARIS 2010 : LA PLEINIèRE DU SECOND JOUR par ROMELARD Fabrice
Après un retour sur l'histoire des TechDays de Paris et le fait que ce soit le plus gros event MS au monde (du fait de sa gratuité), le président de MS France (Eric Boustoullier) a fait une présentation de la vision Microsoft pour les années à venir...
Cliquez pour lire la suite de l'article par ROMELARD Fabrice
Forum
RE : ON RAWMODERE : ON RAWMODE par WorldDMT
Cliquez pour lire la suite par WorldDMT AVERTISSMENT ET KIKKAVERTISSMENT ET KIKK par mouhcine951990
Cliquez pour lire la suite par mouhcine951990
Logiciels
DB-MAIN (9.1.0)DB-MAIN (9.1.0)DB-MAIN is a data-modeling and data-architecture tool. It is designed to help developers and anal... Cliquez pour télécharger DB-MAIN Xilisoft DPG Convertisseur (5.1.37.0120)XILISOFT DPG CONVERTISSEUR (5.1.37.0120)Xilisoft DPG Convertisseur offre aux fans de Nintendo DS une bonne solution leur permettant de dé... Cliquez pour télécharger Xilisoft DPG Convertisseur GraphicsGale (2.01.01)GRAPHICSGALE (2.01.01)GraphicsGale est un logiciel de PixelArt avec de nombreuse fonctionnalités permettant de réalisé ... Cliquez pour télécharger GraphicsGale Architecte 3D (Platinum 2010)ARCHITECTE 3D (PLATINUM 2010)Architecte 3D Platinium vous permet de concevoir facilement les plans votre future maison, de l'é... Cliquez pour télécharger Architecte 3D TeamViewer 5 (TeamViewer 5)TEAMVIEWER 5 (TEAMVIEWER 5)Dépanner un ami,expliquer une manipulation devient un jeu d'enfant.
Prise en main d'un autre ord... Cliquez pour télécharger TeamViewer 5
|