Snippet $icalc : calcul complexe

Commenter

Contenu du snippet

$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 / Exemple : 


/*
$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 ^^"

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_PaDa)