SNIPPET $ICALC : CALCUL COMPLEXE

/*
$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-) }

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