PureBasic

Forums PureBasic
Nous sommes le Mer 19/Juin/2019 10:39

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 16 messages ]  Aller à la page 1, 2  Suivante
Auteur Message
 Sujet du message: Nombres Complexes Opérateurs
MessagePosté: Mer 28/Fév/2018 10:28 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 555
Bonjour à tous
^^ ==> signifie puissance
Les nombres complexes sont très utilisés en électricité, dans les transformées de Fourier, on verra que "i" fait parti des nombre que l'on voit le plus souvent avec : 1, e, pi et bien sur le "0" : la formule préférée des mathématiciens : e^^(i*pi)+1=0

Voici quelques opérateurs sur les nombres complexes.
Mais avant de rentrer dans le détail voyons ce que représente i^^i= ?
ou Log(-5) logarithme d’un nombre négatif
i^^i i imaginaire à la puissance i = ? Petit problème posé par ma petite fille que j’ai résolu assez facilement
Je donnerai la solution plus loin.

Mais voulant vérifier le résultat obtenu j’ai pensé aux macros de guimauve celui-ci ne traite que les imaginaires de type algébrique (z=a+ib) et il manque dans ces opérateurs la puissance de z^^w avec z et w complexes
Aucune présentation ne m’a satisfait c’est pourquoi je vous propose cette étude informatique.

Les nombres complexes peuvent être représentés sous 3 formats différents :
1) Algébrique Z=a+ib avec i^^2=-1 ou comme l’exprime les anglo-saxons i= -1^^(0 ;5) ce qui n’est pas accepté par les mathématiciens Français car une racine carré a toujours 2 racines + ou - alors que i est unique.

2) Trigonométrique Z=Rho(cos(phi)+i*sin(phi))
Rho est le module et Phi est l’argument ou angle par rapport à l’axe 0,X

3) Exponentielle Z=rho e^^(i phi) avec la remarquable relation d’Euler
Rho*e^^(i*phi)= Rho(cos(phi)+i*sin(phi)) ce qui nous permet d’écrire Cos(phi)+isin(phi)=e^^(i phi)
Et avec phi=pi alors e^^(i pi)= cos(pi)+isin(pi)) =cos(pi)=-1 présentée e^^(i pi)+1=0
Ou e, i, pi, 1, et 0 sont représentés dans la même équation.

Voici les modules avec les opérations d’addition de soustraction de multiplication de division opérateurs classiques sur les nombre complexes J’ai ajouté la puissance le log() le sinus le cosinus la tangente sur les nombre complexes.

Le premier pb rencontré c’est la représentation des nombre complexes sous 3 formes différentes qui peuvent être réduites à 2 formes seulement en effet la forme trigo et la forme exponentielle utilise en commun rho comme module et phi comme argument ou angle.
Donc sous forme algébrique a et b en flottant double précision et
en trigo. ou en exponentielle Rho pour module et phi pour argument ou angle
pour les différencier il nous faut un indicateur précisant si le complexe est en représentation algébrique ou pas

D’autre part comme je désirais passer le résultat de l’opération le plus précis possible j’ai utilisé le flottant double précision type *.d et comme sortie l’adresse du résultat de structure ci dessous

Code:
STRUCTURE COMP_ALG
  REEL.D
  IMAGIN.D
endstructure   
STRUCTURE COMP_TRIG
  RHO.D
  PHI.D
EndStructure
STRUCTURE Comp
  StructureUnion
    VALD.d[1]
    COMPA.COMP_ALG
    COMPT.COMP_TRIG
  EndStructureUnion
  structureunion
    typ.s{1}
    Type.s{2}
  endstructureunion
endstructure 


Pour plus de compréhension j’ai distingué les formes algébriques et trigo_expo mais ces trois formes peuvent être confondues puisque l’indicateur Typ permet de les différencier
J’ai donc réduit le nombre de modules à un par opération. Ce module a été réalisé de façon la plus simple possible pour réaliser l’opération qui lui est liée
Ainsi l’addition et la soustraction est réalisé avec les entrées en format algébrique le résultat aussi
La multiplication et la division est réalisée avec les entrées en exponentielle ce qui permet une réalisation plus facile
La puissance est réalisée avec la première entré en exponentielle la 2em entrée en Algébrique et la sortie en trigo même résultat que la forme exponentielle Rho*e^^(i*phi)= Rho(cos(phi)+i*sin(phi))
Remarquons que chaque procédure est caractérisée par le format des 2 entrées et le format de la sortie

La caractéristique de chaque module est interne au module et est représentée par E1_E2_S.type\typeg="TAT" par exemple pour le module de la puissance. Ce terme est très lié avec l’algo utilisé Il ne peut être modifié sans modifier l’algo lui-même.

Maintenant il faut préciser au module sous quelle forme les 2 entrées lui sont fournies et sous quelle forme le résultat doit nous être fourni.
La conversion se fera automatiquement quelque-soit le format présenté.

Remarques importantes
J’ai réalisé les quatre opérations de bases que sont l’addition la soustraction la multiplication, la division et la puissance où toutes ces opérations ont 2 entrées complexes et une sortie
Or parmi ses 5 opérateurs 2 sont commutatifs A+B = B+A et A*B = B*A les 3 autres ne le sont pas
A-B <> B-A sauf pour A=B et A/B <> B/A sauf pour |A| = |B| et pow(Z,W) <> pow(W,Z) sauf pour W=Z
Or partant de ces remarques si l’un des termes d’entrée n’est pas un complexe (il peut être un Réel ou un imaginaire pur) il nous faudrait en combinant (Complexe Imaginaire Réel) 3^^2 =9 procédures pour chaque opérateur non commutatifs et 9*3 =27 pour les 3 opérateurs et pour les opérateurs commutatifs 6 cas pour 1 opérateur et pour les 2 opérateurs 12 procédures. Il nous faudrait au total 39 procédures pour couvrir tous les cas pour les 5 opérateurs de base ceci n’est pas envisageable il nous faut trouver une solution plus élégante
Il suffit de convertir un Réel ou un imaginaire en complexe
Si l’on désire avoir un nombre réel R par exemple
nous pouvons posez Z=R+0i avec la définition du prg *Z.comp=Def_comp_Alg(R,0)
Si l’on désire avoir un imaginaire pure I par exemple
nous pouvons poser W=0+Ii avec la définition du prg *W.comp=Def_comp_Alg(O,I)
Ensuite on peut utiliser un opérateur défini dans le programme
Cette méthode nous permet de limiter les procédures à 5 au lieu de 39


Remarques :
J’ai un problème sur les 3 opérateurs suivant arcsinus arccosinus et arc tangente en effet je ne comprend pas pourquoi dans le cycle w1=arctang(tang(z)) ou w1 devrait être égale à z alors que les cycles suivants
w2= arctang(tang(w1)) et w3= arctang(tang(w2)) donnent w1=w2=w3 ce qui est tout à fait normal
Il en de même pour les arcsin et arccos avec une petite remarque c’est que dans l’algo de ses 2 opérateurs il y a une équation du 2em degré donc chaque arcsin ou arccos doit avoir 2 solutions !!!!!
Avez-vous une solution ?


Et maintenant avant de vous présenter le prg voici un peut de théorie pour expliquer les algorithmes utilisés

http://dl.free.fr/qA5SznhWd
Image
Image




A+

_________________
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.


Dernière édition par PAPIPP le Jeu 01/Mar/2018 14:15, édité 3 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mer 28/Fév/2018 10:30 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 555
Voici le prg
le tout dépasse les 60Ko

Code:
;;****************************************************************************************************************
;; Si l’on désire avoir un nombre réel R par exemple 
;; nous pouvons posez Z=R+0i avec la définition du prg *Z.comp=Def_comp_Alg(R,0) avec R=5.8 par exemple
;; Si l’on désire avoir un imaginaire pure I par exemple
;; nous pouvons poser W=0+Ii avec la définition du prg *W.comp=Def_comp_Alg(O,I) avec i=8.28 par exemple
;; Ensuite on peut utiliser un opérateur défini ci_dessous
;;****************************************************************************************************************

structure Type
  StructureUnion
    typeg.s{3}
    Typet.s{1}[3]    ;;;;; A pour algébrique  T pour trigonométrique ou exponentielle (Le 1er entrée 1 le 2em entrée 2 le 3em sortie)
  EndStructureUnion
endstructure 
STRUCTURE COMP_ALG
  REEL.D
  IMAGIN.D
endstructure   
STRUCTURE COMP_TRIG
  RHO.D
  PHI.D
EndStructure
STRUCTURE Comp
  StructureUnion
    VALD.d[1]
    COMPA.COMP_ALG
    COMPT.COMP_TRIG
  EndStructureUnion
  structureunion
    typ.s{1}
    Type.s{2}
  endstructureunion
endstructure 
;;;************ Initialisation des constantes en nombres complexe  ***************
proceduredll init_Comp ()  ;;;; procedure à utliser en cas de compilation des dll
  EnableExplicit
   global DERNIERE.s,*_Z_p1_0.Comp, *_Z_0_P1.Comp, *_Z_p1_P1.Comp, *_Z_p1_m1.Comp, *_Z_m1_0.Comp, *_Z_0_m1.Comp,*_Z_m1_P1.Comp,*_Z_m1_m1.Comp
  ;;***** definition de Z= 1 + 0i   
  *_Z_p1_0.Comp=AllocateMemory(18)
  *_Z_p1_0.Comp\COMPA\REEL=1 : *_Z_p1_0\COMPA\IMAGIN=0 : *_Z_p1_0\typ="A"
  ;;***** definition de Z= -1 + 0i
  *_Z_m1_0.Comp=AllocateMemory(18)
  *_Z_m1_0.Comp\COMPA\REEL=-1 : *_Z_m1_0\COMPA\IMAGIN=0 : *_Z_m1_0\typ="A"
  ;;***** definition de Z= 0 + i
  *_Z_0_P1.Comp=AllocateMemory(18)
  *_Z_0_P1.Comp\COMPA\REEL=0 : *_Z_0_P1\COMPA\IMAGIN=1 : *_Z_0_P1\typ="A"
  ;;***** definition de Z= 0  -i
  *_Z_0_m1.Comp=AllocateMemory(18)
  *_Z_0_m1.Comp\COMPA\REEL=0 : *_Z_0_m1\COMPA\IMAGIN=-1 : *_Z_0_m1\typ="A"
  ;;***** definition de Z= 1 + i
  *_Z_p1_P1.Comp=AllocateMemory(18)
  *_Z_p1_P1.Comp\COMPA\REEL=1 : *_Z_p1_P1\COMPA\IMAGIN=1 :*_Z_p1_P1\typ="A"
  ;;***** definition de Z= 1  -i
  *_Z_p1_m1.Comp=AllocateMemory(18)
  *_Z_p1_m1.Comp\COMPA\REEL=1 :*_Z_p1_m1\COMPA\IMAGIN=-1 : *_Z_p1_m1\typ="A"
  ;;***** definition de Z= -1 + i
  *_Z_m1_P1.Comp=AllocateMemory(18)
  *_Z_m1_P1.Comp\COMPA\REEL=-1 : *_Z_m1_P1\COMPA\IMAGIN=1 : *_Z_m1_P1\typ="A"
  ;;***** definition de Z= -1  -i
  *_Z_m1_m1.Comp=AllocateMemory(18)
  *_Z_m1_m1.Comp\COMPA\REEL=-1 :*_Z_m1_m1\COMPA\IMAGIN=-1 :  *_Z_m1_m1\typ="A"
  DisableExplicit
endprocedure
procedure controle(*comp1.comp,*comp2.comp)
  if *comp1=0
    messagerequester("ATTENTION","La première entrée  *COMP1 n'a pas la structure comp requise FIN du PRG")
    end
  endif 
  if *comp2=0
    messagerequester("ATTENTION","La deuxième entée *COMP2 n'a pas la structure comp requise FIN du PRG")
    end
  endif 
endprocedure 
proceduredll.D MOD_Comp(*COMP1.Comp) ;;;; module |Z|
  EnableExplicit
;   controle(*comp1,*comp1)
  if *comp1\typ="A"
    procedurereturn sqr((*comp1\COMPA\REEL * *comp1\COMPA\REEL)+(*comp1\COMPA\IMAGIN * *comp1\COMPA\IMAGIN))
  else
    procedurereturn *comp1\COMPT\RHO
  endif 
  DisableExplicit
endprocedure
proceduredll.D ARG_Comp(*COMP1.Comp)  ;;;;  arg Z  angle avec 0x
  EnableExplicit
;   controle(*comp1,*comp1)
  if *comp1\typ="A"
    procedurereturn atan2(*comp1\COMPA\REEL,*comp1\COMPA\IMAGIN)
  else
    procedurereturn *comp1\COMPT\PHI
  endif 
  DisableExplicit
endprocedure
;;; par défaut entré 1 et 2  format en algébrique et sortie format en algébrique
; proceduredll.l CONVERSION_ALG_TRIG(*COMP1.Comp,typ$="T")
proceduredll.l CONV_COMP_TriEx(*COMP1.Comp)
  EnableExplicit
  controle(*comp1,*comp1)
  define R.D,I.D,*COMP10.Comp,message$
  *COmp10.Comp =AllocateMemory(18)
  if ucase(*comp1\typ)="A"
    *comp10.Comp\COMPT\RHO=mod_comp(*comp1)
    *comp10.Comp\COMPT\PHI=arg_comp(*comp1)
    *comp10\Type= "T"
  Else
    CopyMemory(*COMP1,*COMP10,18)
  endif 
  ;;; forme rho(cos(phi)+isin(phi))=rho*e^^(i*phi)  ===> Formule d'Euler
  procedurereturn *COMP10
  DisableExplicit
EndProcedure
proceduredll.l CONV_COMP_ALG(*COMP1.Comp)
  EnableExplicit
  controle(*comp1,*comp1)
  define Rho.D,Phi.D,COMP1.Comp,*COMP10.Comp,message$
  *COmp10.Comp =AllocateMemory(18)
  if ucase(*comp1\typ)="T" or  ucase(*comp1\typ)="E" or ucase(*comp1\typ)="D" or ucase(*comp1\typ)="P" 
    ;;; forme rho(cos(phi)+isin(phi))
    *comp10\COMPA\REEL=*comp1\COMPt\RHO*cos(*comp1\COMPt\PHI)
    *comp10\COMPA\IMAGIN=*comp1\COMPt\RHO*sin(*comp1\COMPt\PHI)
    *comp10\typ= "A"
  Else
    CopyMemory(*COMP1,*COMP10,18)
  endif 
  procedurereturn *COMP10
  DisableExplicit
EndProcedure

proceduredll.l Choix_Comp_Entree_1(*COMP1.Comp,*E1_E2_S.type)
  EnableExplicit
;   controle(*comp1,*comp1)
  define *comp10.Comp
  *comp10=AllocateMemory(18)
  ;;; Remarque l'entrée N° 2 peut être absente avec (0_ ) procédure avec une seule entrée exemple LOG_Comp()
  if *E1_E2_S\Typet[0]="A" or *E1_E2_S\Typet[0]= "T";;;;
    if *COMP1\typ="A"
      if *E1_E2_S\Typet[0]="T";;; procédure entrée en Trigo et entrée fournie en Algébrique
        *COMP10.Comp=CONV_COMP_TriEx(*COMP1)
        ;         *COMP10\typ="T"
      Else
        CopyMemory(*COMP1, *COMP10,18)
        ;         *COMP10\typ="A"
      endif
    Else
      if *E1_E2_S\Typet[0]="A";;; procédure entrée en Algébrique  et entrée fournie en Trigo
        *COMP10=CONV_COMP_ALG(*COMP1)
        ;         *COMP10\typ="A"
      else
        CopyMemory(*COMP1, *COMP10,18)
        ;         *COMP10\typ="T"
      endif
    endif
  Else
    ;;;; ************ ici entrée n'est pas conforme *****************
    MessageRequester("ATTENTION"," Type Algébrique ou Trigo_expo="+StrD(*comp1\COMPA\REEL,3)+" "+strd(*comp1\COMPA\IMAGIN,3)+" i  type="+*comp1\Type)
  endif
  procedurereturn *COMP10
  DisableExplicit
endprocedure 
proceduredll.l Choix_Comp_Entree_2(*COMP2.Comp,*E1_E2_S.type)
  EnableExplicit
;   controle(*comp2,*comp2)
  define *comp20.Comp
  *comp20=AllocateMemory(18)
  ;;; Remarque l'entrée N° 2 peut être absente avec (0_ ) procédure avec une seule entrée exemple LOG_Comp()
  if *E1_E2_S\Typet[1]="A" or *E1_E2_S\Typet[1]= "T";;;;
    if *COMP2\typ="A"
      if *E1_E2_S\Typet[1]="T";;; procédure entrée en Trigo et entrée fournie en Algébrique
        *COMP20=CONV_COMP_TriEx(*COMP2)
        ;         *COMP20\typ="T"
      Elseif *E1_E2_S\Typet[1]="A"
        CopyMemory(*COMP2, *COMP20,18)
        ;         *COMP20\typ="A"
      endif
    Else;;;;; Ici *comp2\typ="T"
      if *E1_E2_S\Typet[1]="A";;; procédure entrée en Algébrique  et entrée fournie en Trigo
        *COMP20=CONV_COMP_ALG(*COMP2)
        ;         *COMP20\typ="A"
      else    ;;;; IF E1_E2_S\Typet[1]="T"
        CopyMemory(*COMP2, *COMP20,18)
        ;         *COMP20\typ="T"
      endif
    endif
  else
    ;;;; ************ ici entrée n'est pas conforme *****************
    MessageRequester("ATTENTION"," Type Algébrique ou Trigo_expo="+StrD(*comp2\COMPA\REEL,3)+" "+strd(*comp2\COMPA\IMAGIN,3)+" i  type="+*comp2\Type)
  endif; 
  procedurereturn *COMP20
  DisableExplicit
endprocedure 

proceduredll.l Choix_Comp_Sortie(*Result2.Comp,*E1_E2_S.type,TYP$="")
  EnableExplicit
;   controle(*Result2,*Result2)
 
  define *Result.Comp
  if len(typ$)>0 and (left(typ$,1)="A" or left(typ$,1)="T")
    *E1_E2_s\Typet[2]=Typ$
  endif 
  *result.Comp=AllocateMemory(18)
  if *result2\typ="A"
    if *E1_E2_S\Typet[2]="T"
      *RESULT.Comp=CONV_COMP_TriEx(*result2)
    Else
      CopyMemory(*RESULT2,*result,18)
    endif
  Else
    if *E1_E2_S\Typet[2]="A"
      *RESULT.Comp=CONV_COMP_ALG(*result2)
    else
      CopyMemory(*RESULT2,*result,18)
    endif
  endif
  procedurereturn *Result
  DisableExplicit
EndProcedure


proceduredll.l Def_Comp_Alg ( reel.D, imagin.D)
  EnableExplicit
  define E1_E2_S.type\typeg="A0A",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp
  E1_E2_S.type\typeg="A0A"
  define *resul2.Comp,*result.Comp
  ;   *Result.Comp =AllocateMemory(18)
  *Result2.Comp =AllocateMemory(18)
  *Result2\COMPA\REEL=REEL
  *Result2\COMPA\IMAGIN=IMAGIN
  *Result2\typ="A"
  ;   *result.Comp=Choix_Comp_Sortie(*Result2.Comp,@E1_E2_S.type,TYP$)
  ; ;   choix_typ_sortie
  ;   *result\typ=typ$
  ;   freememory(*result2)
  procedurereturn *Result2
  DisableExplicit
EndProcedure
proceduredll.l Def_Comp_TriEx(Rho.D,Phi.D,Typ$="T")
  EnableExplicit
  define E1_E2_S.type\typeg="A0A",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp
  E1_E2_S.type\typeg="T0T"
  define *result2.Comp,type.s,*Result.Comp
  *Result2.Comp =AllocateMemory(20)
  *Result2\COMPT\RHO=Rho
  *Result2\COMPT\PHI=Phi
  Type=ucase(Typ$)
  select Typ$
    case "A" , "A "
      Messagerequester("ATTENTION", "Type=" + Type + "  incompatible avec le module Trigo_Expo"+#LF$+" T le remplace")
      *Result2\Type="T"
    case "T" , "T "
      *Result2\Type="T"
    case "TE", "E"
      *Result2\Type="TE"
    case "TD", "D"
      *Result2\Type="TD"
    case "TP", "P"
      *Result2\Type="TP"
    Default
      *Result2\Type="T"
  endselect
  ProcedureReturn  *Result2
  DisableExplicit
EndProcedure

proceduredll.s Form_Comp(*Comp1.Comp, Typ$="",Decimal = 3)
  EnableExplicit
;   controle(*comp1,*comp1)
  define *comp10.Comp ,sign$
  *comp10.Comp=AllocateMemory(18)
  *comp1\type=ucase(*comp1\type)
 
  TYP$=ucase(typ$)
  if typ$=""
    typ$=*comp1\Type
  endif
  select Typ$
    case "A" , "A ", "AL"
      Typ$="A"
    case "T" , "T ", "TR"
      Typ$="T"
    case "TE", "E"
      Typ$="TE"
    case "TD", "D"
      Typ$="TD"
    case "TP", "P"
      Typ$="TP"
    Default
      Typ$="A"
  endselect
  if left(typ$,1)="A"
    if *comp1\typ="T"
      *Comp10.Comp=CONV_COMP_ALG(*comp1)
    else
      CopyMemory(*COMP1,*comp10,18)
    endif
  Else
    if *comp1\typ="A"  and left(typ$,1)="T"
      *Comp10.Comp=CONV_COMP_TriEx(*comp1)
    else
      CopyMemory(*COMP1,*comp10,18)
      *comp10\Type=Typ$
    endif
  endif
  sign$=" + "
  if *comp10\COMPA\IMAGIN<0
    sign$=" "
  endif 
  select typ$
    case "A" ,"A "
      procedurereturn StrD(*COMP10\COMPA\REEL, Decimal) + sign$ + StrD(*COMP10\COMPA\IMAGIN, Decimal) + "i  "
    case "T" ,"T "
      ;       ProcedureReturn "Rho(cos(phi)+isin(phi))="+StrD(*COMP10\COMPT\RHO, Decimal) + "*(cos(" +StrD(*COMP10\COMPT\PHI, Decimal)+"+isin("+StrD(*COMP10\COMPT\PHI, Decimal)+")) phi "+derniere+" en Radian"
      ProcedureReturn StrD(*COMP10\COMPT\RHO, Decimal) + "*(cos(" +StrD(*COMP10\COMPT\PHI, Decimal) + sign$ + " isin("+StrD(*COMP10\COMPT\PHI, Decimal)+")) phi en Radian"
    case "TE", "E"
      ;       ProcedureReturn "Rho*e^^(i*phi)="+StrD(*COMP10\COMPT\RHO, Decimal) + " * "+ #e +" ^^(i*" +StrD(*COMP10\COMPT\PHI, Decimal) +")  phi "+derniere+"   en Radian"
      ProcedureReturn StrD(*COMP10\COMPT\RHO, Decimal) + "*"+ #e +" ^^("+sign$+"i*" +StrD(*COMP10\COMPT\PHI, Decimal) +")  phi en Radian"
    case "TD", "D"
      ;       procedurereturn "Rho(cos(phi)+isin(phi))="+StrD(*COMP10\COMPT\RHO, Decimal) + "*(cos("+StrD(*COMP10\COMPT\PHI*180/#pi, Decimal)+")+isin("+StrD(*COMP10\COMPT\PHI*180/#pi, Decimal)+")) phi "+derniere+" en  degé(s)"
      procedurereturn StrD(*COMP10\COMPT\RHO, Decimal) + "*(cos("+StrD(*COMP10\COMPT\PHI*180/#pi, Decimal)+ sign$ + ")+isin("+StrD(*COMP10\COMPT\PHI*180/#pi, Decimal)+")) phi en  degé(s)"
    case "TP", "P"
      procedurereturn StrD(*COMP10\COMPT\RHO, Decimal) + "*(cos(" +StrD(*COMP10\COMPT\PHI/#pi, Decimal) +"*PI)+isin("+StrD(*COMP10\COMPT\PHI/#pi, Decimal)+"*PI)) phi "+derniere+"  en  PI Radian"
    Default
      procedurereturn StrD(*COMP10\COMPA\REEL, Decimal) + sign$ + StrD(*COMP10\COMPA\IMAGIN, Decimal)+ sign$ + "i  Type="+*COMP10\typ
  endselect
  DisableExplicit
endprocedure 

proceduredll.l ADD_Comp(*COMP1.Comp,*COMP2.Comp,typ$="A")
  ;    proceduredll.l Add_ALG(*COMP1.Comp,*COMP2.Comp)
  EnableExplicit
  controle(*comp1,*comp2)
  derniere=""
  define E1_E2_S.type\typeg="AAA",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp
  E1_E2_S.type\typeg="AAA"
  *comp10=AllocateMemory(18)
  *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  *COMP20=Choix_Comp_Entree_2(*COMP2.Comp,@E1_E2_S.type)
 
  *result2\COMPA\REEL=*comp10\COMPA\REEL+*comp20\COMPA\REEL
  *result2\COMPA\IMAGIN=*COMP10\COMPA\IMAGIN+*comp20\COMPA\IMAGIN
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*comp20)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
endprocedure
proceduredll.l SOUS_Comp(*COMP1.Comp,*COMP2.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp2)
  define E1_E2_S.type\typeg="AAA",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp
  E1_E2_S.type\typeg="AAA"
  *comp10=AllocateMemory(18)
  *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  *COMP20=Choix_Comp_Entree_2(*COMP2.Comp,@E1_E2_S.type)
 
  ;   choix_typ_entree
  *RESULT2.Comp\COMPA\REEL=*comp10\COMPA\REEL-*comp20\COMPA\REEL
  *RESULT2\COMPA\IMAGIN=*COMP10\COMPA\IMAGIN-*comp20\COMPA\IMAGIN
  *result2\typ="A"
  ;   choix_typ_sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*comp20)
  freememory(*result2)
 
  procedurereturn *RESULT
  DisableExplicit
endprocedure
proceduredll.l MULT_Comp(*COMP1.Comp,*COMP2.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp2)
 
  ;   proceduredll.l MULT_TRIG(*COMP1.Comp,*COMP2.Comp)
  ;;;; format (Rho(Cos(PHI)+isin(PHI)*(Rho2(COS(PHI2)+isin(PHI2)) =Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle
  ;;; = Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle si RHO=RHO2=1 => equation d'Euler
  ;; cette équation sert à la démonstration de COS(A+B) et simultanément à la démonstration de  sin(A+B)
  derniere=""
  define E1_E2_S.type\typeg="TTT",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp
  E1_E2_S.type\typeg="TTT"
  *comp10=AllocateMemory(18)
  *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix_des_entrees
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  *COMP20=Choix_Comp_Entree_2(*COMP2.Comp,@E1_E2_S.type)
 
  *result2.Comp\COMPT\RHO=*comp10\COMPT\RHO * *comp20\COMPT\RHO
  *result2\COMPT\PHI=*comp10\COMPT\PHI + *comp20\COMPT\PHI
  *result2\typ="T"
 
  ;   choix_typ_sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*comp20)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
endprocedure 
proceduredll.l DIV_Comp(*COMP1.Comp,*COMP2.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp2)
 
  ;   proceduredll.l DIV_TRIG(*COMP1.Comp,*COMP2.Comp)
  ;;;; format (Rho(Cos(PHI)+isin(PHI)*(Rho2(COS(PHI2)+isin(PHI2)) =Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle
  ;;; = Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle si RHO=RHO2=1 => equation d'Euler
  ;; cette équation sert à la démonstration de COS(A+B) et simultanément à la démonstration de  sin(A+B)
  derniere=""
  define E1_E2_S.type\typeg="TTT",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp
  E1_E2_S.TYPE\typeg="TTT"
  *comp10=AllocateMemory(18)
  *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix_des_entrees
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  *COMP20=Choix_Comp_Entree_2(*COMP2.Comp,@E1_E2_S.type)
 
  ;   choix entree
  *result2.Comp\COMPT\RHO=*comp10\COMPT\RHO / *comp20\COMPT\RHO
  *result2\COMPT\PHI=*comp10\COMPT\PHI - *comp20\COMPT\PHI
  *result2\typ="T"
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*comp20)
  freememory(*result2)

  procedurereturn *RESULT
  DisableExplicit
endprocedure
; proceduredll.l DIVA_Comp(*COMP1.Comp,*COMP2.Comp,typ$="A")
;   EnableExplicit
;   controle(*comp1,*comp2)
;   
;   ;   proceduredll.l DIV_TRIG(*COMP1.Comp,*COMP2.Comp)
;   ;;;; format (Rho(Cos(PHI)+isin(PHI)*(Rho2(COS(PHI2)+isin(PHI2)) =Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle
;   ;;; = Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle si RHO=RHO2=1 => equation d'Euler
;   ;; cette équation sert à la démonstration de COS(A+B) et simultanément à la démonstration de  sin(A+B)
;   derniere=""
;   define E1_E2_S.type\typeg="AAA",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,COMP1.Comp,cOMP2.Comp,Z2.d
;   E1_E2_S.TYPE\typeg="AAA"
;   *comp10=AllocateMemory(18)
;   *comp20=AllocateMemory(18)
;   *result=AllocateMemory(18)
;   *result2=AllocateMemory(18)
;   
;   ;   choix_des_entrees
;   *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
;   *COMP20=Choix_Comp_Entree_2(*COMP2.Comp,@E1_E2_S.type)
;   
;   Z2.D=(*comp20\COMPA\REEL * *comp20\COMPA\REEL)+(*comp20\COMPA\IMAGIN * *comp20\COMPA\IMAGIN)
;   *result2\COMPA\REEL=(*comp10\COMPA\REEL * *comp20\COMPA\REEL)/Z2 + (*comp10\COMPA\IMAGIN * *comp20\COMPA\IMAGIN)/Z2
;   *result2\COMPA\IMAGIN=(*comp10\COMPA\IMAGIN * *comp20\COMPA\REEL)/Z2 - (*comp10\COMPA\REEL * *comp20\COMPA\IMAGIN)/Z2
;   *result2\typ="A"
;   
;   ;   choix sortie
;   *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
;   freememory(*comp10)
;   freememory(*comp20)
;   freememory(*result2)
;
;   procedurereturn *RESULT
;   DisableExplicit
; endprocedure


proceduredll.l Pow_Comp(*COMP1.Comp,*COMP2.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp2)
  derniere=""
  define  E1_E2_S.type\typeg="TAT",RHO1.D,PHI1.D,REEL2.D,IMAG2.D,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp
  E1_E2_S.type\typeg="TAT"
  *comp10=AllocateMemory(18)
  *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix_des_entrees
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  *COMP20=Choix_Comp_Entree_2(*COMP2.Comp,@E1_E2_S.type)
 
  ;;;; format (Rho(Cos(PHI)+isin(PHI)*(Rho2(COS(PHI2)+isin(PHI2)) =Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle
  ;;; = Rho*Rho2*e^^i(PHI+PHI2) => équivalence forme trigo et forme exponentielle si RHO=RHO2=1 => equation d'Euler
  ;; cette équation sert à la démonstration de COS(A+B) et simultanément à la démonstration de  sin(A+B)
  ;;; (rho*#e^^iphi)^^'c+id) => (rho^^c)*#e^^(-phi*d)* #e^^(phi*c+dlog(rho)== RHOx=rho^^c)*#e^^(-phi*d) et PHIx=(phi*c+dlog(rho) CQFD
  RHO1.D=*comp10\COMPT\RHO
  PHI1.D=*comp10\COMPT\PHI  ;;;;; donc forme (rho1*e^^iphi1)^^(reel2+i*imag2)
  REEL2.D=*COMP20\COMPA\REEL
  IMAG2.D=*COMP20\COMPA\IMAGIN
  *Result2.Comp\COMPT\RHO=pow(RHO1,REEL2)*pow(#e,-imag2*PHI1)
  *Result2\COMPT\PHI=(REEL2*PHI1)+(imag2*log(Rho1))
  *result2\typ="T"
 
  ;   choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$) 
  freememory(*comp10)
  freememory(*comp20)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
endprocedure


proceduredll.l    INV_Comp(*COMP1.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp1)
 
  define  E1_E2_S.type\typeg="T0T",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="T0T"
  ; ;;;;;  log(rho*e^^i*phi)=log(rho)+i*phi ==>passage d'un type Exponentiel à un type algébrique
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix entree
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *Result2.Comp\COMPT\RHO=1/*COMP10\COMPT\RHO
  *RESULT2\COMPT\PHI=-*comp10\COMPT\PHI
  *result2\typ="T"
 
  ;    choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
 
  procedurereturn *RESULT
  DisableExplicit
endprocedure 

proceduredll.l    LOG_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="T0A",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="T0A"
  ;  ;;;;  log(rho*e^^i*phi)=log(rho)+i*phi ==>passage d'un type Exponentiel à un type algébrique
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  ;;;;    si z=rho * e^^iphi alors  ==> log(z)= log(rho)+iphi
  ;   choix entree
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *Result2.Comp\COMPA\REEL=LOG(*COMP10\COMPT\RHO)
  *RESULT2\COMPA\IMAGIN=*comp10\COMPT\PHI
  *result2\typ="A"
 
  ;    choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
endprocedure 
proceduredll.l    COS_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  define *comp2.Comp
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix entree
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  ;;;;;    cos(a+ib)=cos(a)cos(ib)-sin(a)sin(ib)  => cos(a)cosh(b)-isin(a)sinh(b)
  ;;;;;   avec Cos(ib) = cosh(b)   et sin(ib)=isinh(b)
 
  *Result2.Comp\COMPA\REEL=COS(*COMP10\COMPA\REEL) * COSH(*comp10\COMPA\IMAGIN);;; avec COS(ib)=cosh(b)
  *Result2\COMPA\IMAGIN=-SIN(*COMP10\COMPA\REEL) * SINH(*comp10\COMPA\IMAGIN)  ;;;; avec sin(ib)=isinh(b)
  *result2\typ="A"
 
  ;    choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
endprocedure 
proceduredll.l    SIN_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  ;   define *comp2.Comp
  ;   *COMP2=AllocateMemory(8)
  ;   *comp10=AllocateMemory(18)
  ;   *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix entree
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  ;;;;;  sin(a+ib)=sin(a)cos(ib)+sin(ib)cos(a)
  ;;;;;   avec Cos(ib) = cosh(b)   et sin(ib)=isinh(b)
  *result2.Comp\COMPA\REEL=sin(*COMP10\COMPA\REEL) * COSH(*comp10\COMPA\IMAGIN);;; avec COS(ib)=cosh(b)
  *result2\COMPA\IMAGIN=COS(*COMP10\COMPA\REEL) * SINH(*comp10\COMPA\IMAGIN)   ;;;; avec sin(ib)=isinh(b)
  *result2\typ="A"
 
  ;    choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
 
  procedurereturn *RESULT
  DisableExplicit
endprocedure 
Procedure Swap_Comp(*COMP1.Comp,*COMP2.Comp)
  controle(*comp1,*comp2)
  Swap *COMP1,*COMP2
endprocedure
;
proceduredll.l    EXPO_Comp(*COMP1.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="T0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0T"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  ;;;  e^^z=e^^(a+ib)=e^^a*e^^ib forme générale de rho*e^^(iphi) avec rho=e^^a et phi=b
 
  *result2\COMPT\RHO=Pow(#e,*comp10\COMPA\REEL)
  *result2\COMPT\PHI=*comp10\COMPA\IMAGIN
  *result2\typ="T"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
proceduredll.l SinH_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *Result2\COMPA\REEL=SinH(*comp10\COMPA\REEL)*Cos(*comp10\COMPA\IMAGIN)
  *Result2\COMPA\IMAGIN=CosH(*comp10\COMPA\REEL)*Sin(*comp10\COMPA\IMAGIN)
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure


proceduredll.l CosH_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *Result2\COMPA\REEL=CosH(*comp10\COMPA\REEL)*Cos(*comp10\COMPA\IMAGIN)
  *Result2\COMPA\IMAGIN=SinH(*comp10\COMPA\REEL)*Sin(*comp10\COMPA\IMAGIN)
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
proceduredll.l Tan_Comp(*Comp1.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0T",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define *SIN.Comp,*COS.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.TYPE\typeg="A0T"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *SIN.Comp=AllocateMemory(18)
  *COS.Comp=AllocateMemory(18)
  *sin=sin_Comp(*Comp10)
  *Cos=Cos_Comp(*Comp10)
  ;;; ***************  il faut que *cos <>0  ****************
  *result2=DIV_Comp(*Sin,*cos)
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
Procedure TanH_Comp(*Comp1.Comp,typ$="T")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0T",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define *SINH.Comp,*COSH.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.TYPE\typeg="A0T"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *SINH.Comp=AllocateMemory(18)
  *COSH.Comp=AllocateMemory(18)
  *sinh=sinh_Comp(*Comp10)
  *Cosh=Cosh_Comp(*Comp10)
  *result2=DIV_Comp(*Sinh,*cosh)
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
;;*******************************************************************************************************
;;****  ces deux procedures sont ici pour le confort  de l'utilisateur mais ne sont pas necessaires *****
;;*******************************************************************************************************
;; Si l’on désire avoir un nombre réel R par exemple 
;; nous pouvons posez Z=R+0i avec la définition du prg *Z.comp=Def_comp_Alg(R,0)
;; Si l’on désire avoir un imaginaire pure I par exemple
;; nous pouvons poser W=0+Ii avec la définition du prg *W.comp=Def_comp_Alg(O,I)
;; Ensuite on peut utiliser un opérateur défini ci_dessus

proceduredll.l SQR_Comp(*COMP1.Comp,TYP$="T")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="T0T",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="T0T"
  ;   *COMP2=AllocateMemory(18) ;;;;;  log(rho*e^^i*phi)=log(rho)+i*phi ==>passage d'un type Exponentiel à un type algébrique
  *comp10=AllocateMemory(18)
  ;   *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix entree
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  *result2\COMPT\RHO=Sqr(*COMP10\COMPT\RHO)
  *result2\COMPT\PHI=*COMP10\COMPT\PHI/2
  *result2\typ="T"
 
  ;    choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  freememory(*result2)
 
  procedurereturn *RESULT
  DisableExplicit
endprocedure 
proceduredll.l CARRE_Comp(*COMP1.Comp,TYP$="T")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="T0T",*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="T0T"
  ;   *COMP2=AllocateMemory(18) ;;;;;  log(rho*e^^i*phi)=log(rho)+i*phi ==>passage d'un type Exponentiel à un type algébrique
  *comp10=AllocateMemory(18)
  ;   *comp20=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
 
  ;   choix entree
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  *result2\COMPT\RHO=*COMP10\COMPT\RHO * *COMP10\COMPT\RHO
  *result2\COMPT\PHI=*COMP10\COMPT\PHI * 2
  *result2\typ="T"
 
  ;    choix sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  freememory(*comp10)
  ;   freememory(*comp20)
  freememory(*result2)
 
  procedurereturn *RESULT
  DisableExplicit
endprocedure

proceduredll.l ASin_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define.comp *Z2,*UN_Z2,*rac_UN_Z2,*IZZZ, *iZ_rac_un_Z2,*log_IZ_rac_UN_Z2
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  ;;;;arcsin z=-ilog(iz+pow(1-Z*z,0.5));;;;; Attention après la racine il ya 2 réponses une + et l'autre -
  ;;;;arcsin z=-ilog(iz(+ ou -)pow(1-Z*z,0.5));;;;; Attention après la racine il ya 2 réponses une + et l'autre -
  ;;;;ARCcos z=-ilog(z+pow(z*z-1,0.5);;;; Attention après la racine il ya 2 réponses une + et l'autre -
  *Z2.Comp=AllocateMemory(18)
  *UN_Z2.Comp=AllocateMemory(18)
  *rac_UN_Z2.Comp=AllocateMemory(18)
  *IZZZ.Comp=AllocateMemory(18)
  *Z2.Comp=MULT_Comp(*comp10,*comp10)
  *UN_Z2.Comp=sous_Comp(*_Z_p1_0,*Z2)
  *rac_UN_Z2.Comp=SQR_Comp(*UN_Z2)
  ;;; *** Ci-dessous iZ avec z=a+ib ==> iZ=-b+ia ****
  *IZZZ.Comp\COMPA\REEL=-*comp10\COMPA\IMAGIN
  *IZZZ\COMPA\IMAGIN=*comp10\COMPA\REEL
  *IZZZ\typ="A"
  *iZ_rac_un_Z2.Comp=ADD_Comp(*IZZZ,*rac_UN_Z2)
  *log_IZ_rac_UN_Z2.Comp=Log_Comp(*iZ_rac_un_Z2)
  *result2\COMPA\REEL=*log_IZ_rac_UN_Z2\COMPA\IMAGIN
  *result2\COMPA\IMAGIN=-*log_IZ_rac_UN_Z2\COMPA\REEL
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  FreeMemory(*Z2)
  FreeMemory(*UN_Z2)
  FreeMemory(*rac_UN_Z2)
  FreeMemory(*IZZZ)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
proceduredll.l ASinm_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define.comp *Z2,*UN_Z2,*rac_UN_Z2,*IZZZ, *iZ_rac_un_Z2,*log_IZ_rac_UN_Z2n,*UN,*log_IZ_rac_UN_Z2
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(20)
  ;   *comp20=AllocateMemory(20)
  *result=AllocateMemory(20)
  *result2=AllocateMemory(20)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
  ;;;;arcsin z=-ilog(iz+pow(1-Z*z,0.5));;;;; Attention après la racine il ya 2 réponse une + et l'autre -
  ;;;;arcsin z=-ilog(iz(+ ou -)pow(1-Z*z,0.5));;;;; Attention après la racine il ya 2 réponse une + et l'autre -
 
  ;;;;ARCcos z=-ilog(z+pow(z*z-1,0.5)
 
  *Z2.Comp=AllocateMemory(18)
  *UN_Z2.Comp=AllocateMemory(18)
  *rac_UN_Z2.Comp=AllocateMemory(18)
  *IZZZ.Comp=AllocateMemory(18)
  *Z2.Comp=MULT_Comp(*comp10,*comp10)
  *UN.Comp=Def_Comp_Alg(1,0)
  *UN_Z2.Comp=sous_Comp(*UN,*Z2)
  *rac_UN_Z2.Comp=SQR_Comp(*UN_Z2)
  *rac_un_z2\COMPT\RHO*(-1)
  ;;; *** Ci-dessous iZ avec z=a+ib ==> iZ=-b+ia ****
  *IZZZ.Comp\COMPA\REEL=-*comp10\COMPA\IMAGIN
  *IZZZ\COMPA\IMAGIN=*comp10\COMPA\REEL
  *IZZZ\typ="A"
  *iZ_rac_un_Z2.Comp=ADD_Comp(*IZZZ,*rac_UN_Z2)
  *log_IZ_rac_UN_Z2.Comp=Log_Comp(*iZ_rac_un_Z2)
  *result2\COMPA\REEL=*log_IZ_rac_UN_Z2\COMPA\IMAGIN
  *result2\COMPA\IMAGIN=-*log_IZ_rac_UN_Z2\COMPA\REEL
  *result2\typ="A"
  ;   choix_typ_sortie
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  FreeMemory(*Z2)
  FreeMemory(*UN_Z2)
  FreeMemory(*rac_UN_Z2)
  FreeMemory(*IZZZ)
  freememory(*comp10)
  ;   freememory(*comp20)
  freememory(*result2)
 
  procedurereturn *RESULT
  DisableExplicit
EndProcedure

proceduredll.l ACos_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define.comp *Z2,*UN_Z2,*rac_UN_Z2,*IZZZ, *iZ_rac_un_Z2,*log_IZ_rac_UN_Z2,*Z2_UN
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  ;;;;arcsin z=-ilog(iz+pow(1-Z*z,0.5))
  ;;;;ARCcos z=-ilog(z+pow(z*z-1,0.5)
  *Z2.Comp=AllocateMemory(18)
  *UN_Z2.Comp=AllocateMemory(18)
  *rac_UN_Z2.Comp=AllocateMemory(18)
  *IZZZ.Comp=AllocateMemory(18)
  *Z2.Comp=MULT_Comp(*comp10,*comp10)
  *Z2_UN.Comp=sous_Comp(*Z2,*_Z_p1_0)
  *rac_UN_Z2.Comp=SQR_Comp(*Z2_UN);;;; doit être + ou - 
  *iZ_rac_un_Z2.Comp=ADD_Comp(*COMP10,*rac_UN_Z2);;; ici + mais peut être - avec sos_comp
  *log_IZ_rac_UN_Z2.Comp=Log_Comp(*iZ_rac_un_Z2)
  *result2\COMPA\REEL=-*log_IZ_rac_UN_Z2\COMPA\IMAGIN
  *result2\COMPA\IMAGIN=*log_IZ_rac_UN_Z2\COMPA\REEL
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  FreeMemory(*Z2)
  FreeMemory(*UN_Z2)
  FreeMemory(*rac_UN_Z2)
  FreeMemory(*IZZZ)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
proceduredll.l ACosm_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define.comp *Z2,*UN_Z2,*rac_UN_Z2,*IZZZ, *iZ_rac_un_Z2,*log_IZ_rac_UN_Z2,*Z2_UN
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  ;;;;arcsin z=-ilog(iz+pow(1-Z*z,0.5))
  ;;;;ARCcos z=-ilog(z+pow(z*z-1,0.5)
  *Z2.Comp=AllocateMemory(18)
  *UN_Z2.Comp=AllocateMemory(18)
  *rac_UN_Z2.Comp=AllocateMemory(18)
  *IZZZ.Comp=AllocateMemory(18)
  *Z2.Comp=MULT_Comp(*comp10,*comp10)
  *Z2_UN.Comp=sous_Comp(*Z2,*_Z_p1_0)
  *rac_UN_Z2.Comp=SQR_Comp(*Z2_UN)
  *iZ_rac_un_Z2.Comp=sous_Comp(*COMP10,*rac_UN_Z2);;;; ici - mais peut être +
  *log_IZ_rac_UN_Z2.Comp=Log_Comp(*iZ_rac_un_Z2)
  *result2\COMPA\REEL=-*log_IZ_rac_UN_Z2\COMPA\IMAGIN
  *result2\COMPA\IMAGIN=*log_IZ_rac_UN_Z2\COMPA\REEL
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  FreeMemory(*Z2)
  FreeMemory(*UN_Z2)
  FreeMemory(*rac_UN_Z2)
  FreeMemory(*IZZZ)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure

proceduredll.l Atan_Comp(*COMP1.Comp,typ$="A")
  EnableExplicit
  controle(*comp1,*comp1)
  define  E1_E2_S.type\typeg="A0A",COMP1.Comp,RESULT.Comp,*COMP10.Comp,*COMP20.Comp,*RESULT.Comp,*result2.Comp,*COMP2.Comp
  define.comp *Z_iz,*Z_1_miZ,*Z_1_piZ,*Z_logx1, *Z_divis
  derniere="+i2kPI  avec k=0,1,2,3,....N"
  E1_E2_S.type\typeg="A0A"
  *comp10=AllocateMemory(18)
  *result=AllocateMemory(18)
  *result2=AllocateMemory(18)
  *COMP10=Choix_Comp_Entree_1(*COMP1.Comp,@E1_E2_S.type)
 
  ;;;;arcsin z=-ilog(iz+pow(1-Z*z,0.5))
  ;;;;ARCcos z=-ilog(z+pow(z*z-1,0.5)
  ;;;; autre formule ARCTANG Z= log((1+iz)/1-iz)/(2i) demo par pp  ou -i*log((1+iz)/1-iz)/2
 
  *Z_iz.Comp=AllocateMemory(18)
  *Z_1_miZ.Comp=AllocateMemory(18)
  *Z_1_piZ.Comp=AllocateMemory(18)
  *Z_logx1.Comp=AllocateMemory(18)
  ;   *Z_logx2.Comp=AllocateMemory(18)
  *Z_divis.Comp=AllocateMemory(18)
 
  ;;;;; **** defition de iZ =i(a+ib)=ia-b
  ;   *Z_iz\COMPA\REEL=*comp10\COMPA\IMAGIN
  ;   *Z_iz\COMPA\IMAGIN=-*comp10\COMPA\REEL
  *Z_iz\COMPA\REEL=-*comp10\COMPA\IMAGIN
  *Z_iz\COMPA\IMAGIN=*comp10\COMPA\REEL
  *Z_iz\typ="A"
  *Z_1_miz=sous_Comp(*_Z_p1_0,*Z_iz)
  *Z_1_piz=add_Comp(*_Z_p1_0,*Z_iz)
 
  ;;;;**** definition de (1+iz)/(1-iz)
  *Z_divis=div_Comp(*Z_1_piz,*Z_1_miz)
  *Z_logx1=log_Comp(*Z_divis)
 
  ;;;; definition log(z)/(2i)
  *result2\COMPA\IMAGIN=*Z_logx1\COMPA\REEL/(-2)
  *result2\COMPA\REEL=*Z_logx1\COMPA\IMAGIN/(2)
  *result2\typ="A"
 
  *result.Comp=Choix_Comp_Sortie(*result2,E1_E2_S,typ$)
  FreeMemory(*Z_iz)
  FreeMemory(*Z_1_miz)
  FreeMemory(*Z_divis)
  FreeMemory(*Z_1_piz)
  freememory(*comp10)
  freememory(*result2)
  procedurereturn *RESULT
  DisableExplicit
EndProcedure
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Nombre complexe originaux
; 0.707 + 0.707i
; 0.819 + 0.583i
; 0.707 + 0.707i
; 0.958 + -0.498i

init_Comp ()
if OpenConsole("Essais sur les complexes")
;;; ******* libérer l'un des goto(s) suivants pour tester la partie concernée ****"
;   goto TEST_OP         ;;;; les opérations de base + - * / et pow
;   goto  test_sin_cos   ;;;; sin(z)*sin(z)+cos(z)*cos(z)=1
;   goto TEST_TANG_etc     ;;;; Cycles incompréhensibles avez vous une explication ???
PRINTN("********* Particularités avec les nombres complexes ***********")
;; recherche i^^i ou -i^^i ou i^^-i ou -i^^-i
printn("********** i^^i=0;2078...est un Réel *************")
*r_Z_0_P1.comp=pow_comp(*_Z_0_P1,*_Z_0_P1)
;
printn( form_comp(*_Z_0_p1)+form_comp(*_Z_0_p1)+"=i^^i="+form_comp(*r_Z_0_P1,"A")+"  "+form_comp(*r_Z_0_P1,"T"))
*r_Z_0_m1.comp=pow_comp(*_Z_0_m1,*_Z_0_P1)
Printn(" ")
printn("********** (O-i)^^i *************")

Printn(form_comp(*_Z_0_m1)+form_comp(*_Z_0_p1)+"=-i^^i="+ form_comp(*r_Z_0_m1,"A")+"  "+form_comp(*r_Z_0_m1,"T"))
*r_Z_0_mmi.comp=pow_comp(*_Z_0_P1,*_Z_0_m1)
Printn(" ")
printn("********** (O+i)^^-i *************")
Printn(form_comp(*_Z_0_p1)+form_comp(*_Z_0_m1)+"=i^^-i="+ form_comp(*r_Z_0_mmi,"A")+"  "+form_comp(*r_Z_0_mmi,"E"))
*r_Z_0_m_i.comp=pow_comp(*_Z_0_m1,*_Z_0_m1)
Printn(" ")
printn("********** (-i)^^-i *************")

Printn(form_comp(*_Z_0_m1)+form_comp(*_Z_0_m1)+" -i^^-i="+ form_comp(*r_Z_0_m_i,"A")+"  "+form_comp(*r_Z_0_m_i,"E"))
PRINTN(" ")
PRINTN( "****** Puissance *comp1^^*comp2 ************")
*comp10.Comp=Def_Comp_Alg(0,1)
*COMP11.Comp=Def_Comp_Alg(1,1)

*comp12.Comp=Pow_Comp(*comp10,*comp10)
PRINTN( "*comp1 ^^ *comp2=("+Form_Comp(*comp10,"A")+") ^^ ("+Form_Comp(*comp10,"A")+")="+Form_Comp(*comp12,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp12,"TP"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp12,"TE"))
PRINTN(" ")
PRINTN( "****** puissance (1+i) ^^ (1+i) *******")
*comp13.Comp=Pow_Comp(*comp11,*comp11)
PRINTN( "*comp1 ^^ *comp2=("+Form_Comp(*comp11,"A")+") ^^ ("+Form_Comp(*comp11,"A")+")="+Form_Comp(*comp13,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp13,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp13,"TP"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp13,"TE"))
PRINTN(" ")
PRINTN( "****** puissance (1+i) ^^ (0+i) *******")
*comp14.Comp=Pow_Comp(*comp11,*comp10)
PRINTN( "*comp1 ^^ *comp2=("+Form_Comp(*comp11,"A")+") ^^ ("+Form_Comp(*comp10,"A")+")="+Form_Comp(*comp14,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp14,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp14,"TP"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp14,"TE"))
PRINTN(" ")
PRINTN( "****** puissance (0+i) ^^ (1+i) *******")
*comp15.Comp=Pow_Comp(*comp10,*comp11)
PRINTN( "*comp1 ^^ *comp2=("+Form_Comp(*comp10,"A")+") ^^ ("+Form_Comp(*comp11,"A")+")="+Form_Comp(*comp15,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp15,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp15,"TP"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp15,"TE"))

PRINTN(" ")
PRINTN( "****** LOG népérien  LOG(*comp1) ************")
*COMP20.Comp=log_Comp(*comp10)
PRINTN( "log(*comp10)="+Form_Comp(*comp20,"A"))
PRINTN( "log(*comp10)="+Form_Comp(*comp20,"TP"))
PRINTN( "log(*comp10)="+Form_Comp(*comp20,"TE"))
*COMP21.Comp=log_Comp(*comp11)
PRINTN( "log(*comp11)="+Form_Comp(*comp21,"A"))
PRINTN( "log(*comp11)="+Form_Comp(*comp21,"TP"))
PRINTN( "log(*comp11)="+Form_Comp(*comp21,"TE"))
PRINTN(" ")
PRINTN( "****** Vérification LOG népérien  LOG(*comp11) par e^^log(*comp11)=*comp11 ************")
*comp22=expo_comp(*COMP21)
PRINTN(" *COMP11="+form_comp(*comp11)+" e^^log(*comp11)=comp11="+form_comp(*comp22,"A"))
PRINTN(" ")
PRINTN("********** particularités avec les nombres complexes ************")
PRINTN("****** Recherche de log(-a) ==> a=(acos(pi)+isin(pi)= ae^^ipi  *****" )
PRINTN("log(-a)=log(a) + i *pi")
PRINTN("recherche de log(-2) avec")
*comp1.comp=def_comp_alg(-2,0)
PRINTN( "*comp1="+form_comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
*log_1.comp=log_comp(*comp1)
LOG_1$=form_comp(*log_1,"E")
PRINTN( "log(-2)="+form_comp(*log_1,"A")+" // "+form_comp(*log_1,"E"))
*comp2.comp=mult_comp(*_z_m1_0,def_comp_alg(2,0))
printn("*comp2="+form_comp(*comp2,"A")+" // "+form_comp(*comp2,"T"))
*log_2.comp=log_comp(*comp2)
PRINTN( "log(*comp2)=log(-2)="+form_comp(*log_2,"A")+" // "+form_comp(*log_2,"E"))

goto FINFIN


TEST_TANG_etc:
PRINTN("******** Tests sur cycles arctang(tang(x)) ***************")
phi.d=#pi/8
; phi.d=0
rho.d=8
  Printn("********************************************************")
  printn("*********** Cycles arctangente(tangente(x)) ************")
  PRINTN("********************************************************")

for i=1 to 8
  phi1.d=phi * i
  *comp1.Comp=Def_Comp_TriEx(rho,phi1)
  ;   *comp1.Comp=Def_Comp_TriEx(phi1,rho)
  ;   *COMP2.comp=conv_comp_alg(*comp1)
  PRINTN(" Tang(*comp1="+Form_Comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
  *Tan.Comp=Tan_Comp(*comp1)
  *aTan.comp=aTan_comp(*Tan)
  *Tan2.comp=Tan_comp(*aTan)
  *aTan2.comp=aTan_comp(*Tan2)
  *Tan3.comp=Tan_comp(*aTan2)
  *aTan3.comp=aTan_comp(*Tan3)
 
  PRINTN( "*TAN ="+form_comp(*Tan,"A")+" // "+form_comp(*Tan,"E"))
  PRINTN( "*TAN2="+form_comp(*Tan2,"A")+" // "+form_comp(*Tan2,"E"))
  PRINTN( "*TAN3="+form_comp(*Tan3,"A")+" // "+form_comp(*Tan3,"E"))
  PRINTN( "*comp1 ="+form_comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
  PRINTN( "*ATAN ="+form_comp(*aTan,"A")+" // "+form_comp(*aTan,"E"))
  PRINTN( "*ATAN2="+form_comp(*aTan2,"A")+" // "+form_comp(*aTan2,"E"))
  PRINTN( "*ATAN3="+form_comp(*aTan3,"A")+" // "+form_comp(*aTan3,"E"))
  PRINTN( " ")
next
printn("***** Tapez sur une touche pour avoir les cycles  arcsin(sin(x)) *****")
input()
CloseConsole()
OpenConsole()

phi.d=#pi/8
; phi.d=0
rho.d=8
  Printn("********************************************************")
  printn("************** Cycles arcinus(sinus(x)) ****************")
  PRINTN("********************************************************")

for i=1 to 8
  phi1.d=phi * i
  *comp1.Comp=Def_Comp_TriEx(rho,phi1)
  ;   *comp1.Comp=Def_Comp_TriEx(phi1,rho)
  ;   *COMP2.comp=conv_comp_alg(*comp1)
  PRINTN( "sin(*comp1)="+Form_Comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
  *Sin.Comp=Sin_Comp(*comp1)
  *aSin.comp=aSinm_comp(*Sin)
  *Sin2.comp=Sin_comp(*aSin)
  *aSin2.comp=aSinm_comp(*Sin2)
  *Sin3.comp=Sin_comp(*aSin2)
  *aSin3.comp=aSinm_comp(*Sin3)
 
  PRINTN( "*Sin="+form_comp(*Sin,"A")+" // "+form_comp(*Sin,"E"))
  PRINTN( "*Sin2="+form_comp(*Sin2,"A")+" // "+form_comp(*Sin2,"E"))
  PRINTN( "*Sin3="+form_comp(*Sin3,"A")+" // "+form_comp(*Sin3,"E"))
  PRINTN( "*comp1="+Form_Comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
  PRINTN( "*aSin="+form_comp(*aSin,"A")+" // "+form_comp(*aSin,"E"))
  PRINTN( "*aSin2="+form_comp(*aSin2,"A")+" // "+form_comp(*aSin2,"E"))
  PRINTN( "*aSin3="+form_comp(*aSin3,"A")+" // "+form_comp(*aSin3,"E"))
  PRINTN( " ")
next

printn("***** Tapez sur une touche pour avoir les cycles  arccos(cos(x)) *****")
input()
CloseConsole()
OpenConsole()

phi.d=#pi/8
; phi.d=0
rho.d=8
  Printn("********************************************************")
  printn("************ Cycles arccosinus(cosinus(x)) *************")
  PRINTN("********************************************************")

for i=1 to 8
  phi1.d=phi * i
  *comp1.Comp=Def_Comp_TriEx(rho,phi1)
  ;   *comp1.Comp=Def_Comp_TriEx(phi1,rho)
  ;   *COMP2.comp=conv_comp_alg(*comp1)
  PRINTN( "*comp1="+Form_Comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
  *cos.Comp=cos_Comp(*comp1)
  *acos.comp=acos_comp(*cos)
  *cos2.comp=cos_comp(*acos)
  *acos2.comp=acos_comp(*cos2)
  *cos3.comp=cos_comp(*acos2)
  *acos3.comp=acos_comp(*cos3)
 
  PRINTN( "*cos="+form_comp(*cos,"A")+" // "+form_comp(*cos,"E"))
  PRINTN( "*cos2="+form_comp(*cos2,"A")+" // "+form_comp(*cos2,"E"))
  PRINTN( "*cos3="+form_comp(*cos3,"A")+" // "+form_comp(*cos3,"E"))
  PRINTN( "*comp1="+Form_Comp(*comp1,"A")+" // "+form_comp(*comp1,"E"))
  PRINTN( "*acos="+form_comp(*acos,"A")+" // "+form_comp(*acos,"E"))
  PRINTN( "*acos2="+form_comp(*acos2,"A")+" // "+form_comp(*acos2,"E"))
  PRINTN( "*acos3="+form_comp(*acos3,"A")+" // "+form_comp(*acos3,"E"))
  PRINTN( " ")
next

goto finfin

test_sin_cos:
printn("*****************************************************************")
printn("*********** test SIN_comp et cos_comp cohérence *****************")
printn("*****************************************************************")

phi.d=#pi/8
; phi.d=0
rho.d=1
for i=O to 8
  phi1.d=phi * i
  *comp1.Comp=Def_Comp_TriEx(rho*i,phi1)
  ;   *comp1.Comp=Def_Comp_TriEx(rho,phi1)
  *COMP2.comp=conv_comp_alg(*comp1)
  *comp3.comp=CONV_COMP_TriEx(*comp2)
  *comp4.comp=conv_comp_alg(*comp3)
  PRINTN("Format A=>*COMP1,*comp2,*comp3,*comp4="+form_comp(*comp1,"A")+" // "+form_comp(*comp2,"A")+" // "+form_comp(*comp3,"A")+" // "+form_comp(*comp4,"A"))
  PRINTN("Format T=>*COMP1,*comp2,*comp3,*comp4="+form_comp(*comp1,"T")+" // "+form_comp(*comp2,"T")+" // "+form_comp(*comp3,"T")+" // "+form_comp(*comp4,"T"))
  *sin.Comp=sin_Comp(*comp1)
  *cos.Comp=cos_Comp(*comp1)
  *cos_car.Comp=MULT_Comp(*cos,*cos)
  *sin_car.Comp=MULT_Comp(*sin,*sin)
  *cos_sin_car.Comp=add_Comp(*COS_car,*sin_car)
  PRINTN( "*comp1,cos*cos+sin*sin="+form_comp(*cos_sin_car,"A")+" // "+form_comp(*cos_sin_car,"T")+" // "+form_comp(*cos_sin_car,"E"))
  *sin.Comp=sin_Comp(*comp2)
  *cos.Comp=cos_Comp(*comp2)
  *cos_car.Comp=MULT_Comp(*cos,*cos)
  *sin_car.Comp=MULT_Comp(*sin,*sin)
  *cos_sin_car.Comp=add_Comp(*COS_car,*sin_car)
  PRINTN( "*comp2,cos*cos+sin*sin="+form_comp(*cos_sin_car,"A")+" // "+form_comp(*cos_sin_car,"T")+" // "+form_comp(*cos_sin_car,"E"))
  *sin.Comp=sin_Comp(*comp3)
  *cos.Comp=cos_Comp(*comp3)
  *cos_car.Comp=MULT_Comp(*cos,*cos)
  *sin_car.Comp=MULT_Comp(*sin,*sin)
  *cos_sin_car.Comp=add_Comp(*COS_car,*sin_car)
  PRINTN( "*comp3,cos*cos+sin*sin="+form_comp(*cos_sin_car,"A")+" // "+form_comp(*cos_sin_car,"T")+" // "+form_comp(*cos_sin_car,"E"))
  *sin.Comp=sin_Comp(*comp4)
  *cos.Comp=cos_Comp(*comp4)
  *cos_car.Comp=MULT_Comp(*cos,*cos)
  *sin_car.Comp=MULT_Comp(*sin,*sin)
  *cos_sin_car.Comp=add_Comp(*COS_car,*sin_car)
  PRINTN( "*comp4,cos*cos+sin*sin="+form_comp(*cos_sin_car,"A")+" // "+form_comp(*cos_sin_car,"T")+" // "+form_comp(*cos_sin_car,"E"))
  PRINTN( " ")
next
goto finfin
End

TEST_OP:
PRINTN( "****** tests sur les opérateurs complexes ************")
*comp1.Comp=Def_Comp_Alg(4,8) ;;;; format algébrique  a+ib ===ici a=4 et b=8
*comp2.Comp=Def_Comp_Alg(7,4) ;;;; format algébrique  a+ib ===ici a=7 et b=4

PRINTN( "*comp1="+Form_Comp(*comp1)+" *comp2="+ Form_Comp(*comp2))
PRINTN( "****** Addition *comp1+*comp2 ************")
*comp3.Comp=ADD_Comp(*comp1,*comp2)
PRINTN( "*comp1 + *comp2="+Form_Comp(*comp3))
PRINTN( "***** Vérification addition *comp3-*comp1=*comp2 *******")
*comp20.comp=sous_comp(*comp3,*comp1)
printn("*comp3-*comp1=*comp2="+form_comp(*comp20)+"="+form_comp(*comp2))
printn(" ")
PRINTN( "****** soustraction *comp1+*comp2 ************")
*comp4.Comp=sous_Comp(*comp1,*comp2)
PRINTN( "*comp1 - *comp2="+Form_Comp(*comp4))
PRINTN( "***** Vérification soustraction *comp3-*comp1=*comp2 *******")
*comp40.comp=Add_comp(*comp4,*comp2)
printn("*comp4+*comp2=*comp1="+form_comp(*comp40)+"="+form_comp(*comp1))
printn(" ")

PRINTN( "****** multiplication *comp1**comp2 ************")
; *comp1=Def_Comp_TriEx(6,#pi/3)
; *comp2=Def_Comp_TriEx(3,#pi/6)
PRINTN( "*comp1="+Form_Comp(*comp1,"A"))
PRINTN( "*comp2="+Form_Comp(*comp2,"A"))
*comp5.Comp=MULT_Comp(*comp1,*comp2)
PRINTN( "*comp1 * *comp2="+Form_Comp(*comp5,"A"))
PRINTN( "*comp1 * *comp2="+Form_Comp(*comp5,"TP"))
PRINTN( "*comp1 * *comp2="+Form_Comp(*comp5,"TE"))
PRINTN( "***** Vérification multiplication *comp5/*comp2=*comp1 *******")
*comp50.Comp=div_Comp(*comp5,*comp2)
PRINTN( "*comp50/*comp2="+Form_Comp(*comp50,"A")+"="+form_comp(*comp1))
printn(" ")

PRINTN( "****** division *comp1/*comp2 ************")
*comp6.Comp=DIV_Comp(*comp1,*comp2)
PRINTN( "*COMP1="+Form_Comp(*comp1,"A"))
PRINTN( "*COMP2="+Form_Comp(*comp2,"A"))
PRINTN( "*comp1 / *comp2="+Form_Comp(*comp6,"A"))
PRINTN( "*comp1 / *comp2="+Form_Comp(*comp6,"TP"))
PRINTN( "*comp1 / *comp2="+Form_Comp(*comp6,"TE"))
PRINTN( "***** Vérification Division *comp6 * *comp2=*comp1 *******")
*comp60.Comp=mult_Comp(*comp6,*comp2)
PRINTN( "*comp6 * *comp2="+Form_Comp(*comp60,"A")+"="+form_comp(*comp1))
printn(" ")

PRINTN( "****** Puissance *comp1^^*comp2 ************")
*comp7.comp=pow_comp(*comp1,*comp2)
PRINTN( "*COMP1="+Form_Comp(*comp1,"A"))
PRINTN( "*COMP2="+Form_Comp(*comp2,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp7,"A"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp7,"TP"))
PRINTN( "*comp1 ^^ *comp2="+Form_Comp(*comp7,"TE"))
PRINTN( "***** Vérification puissance *comp1 ^^ (-*comp2)=*comp70 *******")
printn("               *comp7 * *comp70=1 ")
*comp70.Comp=pow_comp(*comp1,mult_comp(*comp2,*_Z_m1_0))
*comp71.comp=mult_comp(*comp70, *comp7)
PRINTN( "*comp7 ^^ -*comp2="+Form_Comp(*comp71,"A")+"= 1")
printn(" ")
goto FINFIN
;
finfin:
printn(" TAPER SUR TOUCHE POUR FINIR")
input()
CloseConsole()
endif



A+

_________________
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.


Dernière édition par PAPIPP le Ven 02/Mar/2018 9:21, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mer 28/Fév/2018 14:55 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 02/Oct/2011 16:17
Messages: 2135
Localisation: 50200 Coutances
Très intéressant, merci pour le partage.

_________________
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce GT 640 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.62, 5.70 LTS
Un homme doit être poli, mais il doit aussi être libre !


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Sam 03/Mar/2018 16:06 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 555
Merci micoute.

Pour les autres lecteurs je vois que le sujet ne vous passionne pas beaucoup.
Serait-il trop simple ou parfaitement connu ?

1) Et si ce n’est pas le cas excusez moi d’avoir posté cette étude.

2) Si c’est le cas vous devez avoir une solution pour le Pb posé par tous les (arctangente arcsinus et arccosinus) qui me posent question.

Pour tester ces cas supprimez le commentaire de la ligne suivante du PRG :
;; goto TEST_TANG_etc ;;;; Cycles incompréhensibles avez vous une explication ???

Par exemple tang(Zdépart) = tang(Zcyclen) avec plusieurs cycles mais surtout si les tangentes sont égales et identiques les complexes Zdépart et Zcyclen sont différents avez-vous une explication ?

Il en de même pour les autres arcsinus et arccosinus !!!

Peut-être faut-il passer cette étude dans une rubrique plus adaptée !

A+

_________________
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Sam 03/Mar/2018 16:23 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 22/Aoû/2010 15:24
Messages: 6853
Localisation: IDF (Yvelines)
PAPIPP a écrit:
Pour les autres lecteurs je vois que le sujet ne vous passionne pas beaucoup.
Peut être qu'on préfère voir des choses plus funs.

Les maths en s'amusant (Code 2D ou 3D) serait un sujet surement plus passionnant.

Je pense que ce sujet serait mieux dans le forum discussion .

_________________

➽ Config PureBasic : i3, RAM 4Go, NVidia (1024 Mo), Windows 10 - PB 5.70 LTS
➽ Je papote aussi sur http://purebasic.chat & http://purebasic.chat/forum

➽ Sites personnels http://falsam.com & EasySprite.js

➽ Je ne réponds pas aux MP techniques


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Sam 03/Mar/2018 17:11 
Hors ligne
Avatar de l’utilisateur

Inscription: Ven 11/Fév/2005 17:34
Messages: 4210
Localisation: Arras, France
On n'a pas souvent l'usage des nombres complexes, mais je pense que je serai TRÈS content d'avoir de telles fonctions, en si grand nombre et aussi précises le moment venu.

Merci pour ce partage PAPIPP ! :)


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Sam 03/Mar/2018 17:39 
Hors ligne
Avatar de l’utilisateur

Inscription: Dim 09/Oct/2005 16:51
Messages: 8670
Un boulot de fou qui dépasse de loin mon amour des maths.
Merci

_________________
~~~~Règles du forum ~~~~
.: Ar-S :. Tour + portable W10 x64 PB 5.4x / 5.6x
LDV MULTIMEDIA : Dépannage informatique & mes Logiciels PB
RESIZER GOLD : Mon logiciel de redimensionnement par lot 100% PB


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mar 06/Mar/2018 10:03 
Hors ligne
Avatar de l’utilisateur

Inscription: Sam 23/Sep/2006 18:32
Messages: 6628
Localisation: Isere
Falsam a écrit:
Les maths en s'amusant
Pour moi c'est deux mots qui ne pourront jamais figurer dans la même phrase 8O

Papipp a écrit:
Pour les autres lecteurs je vois que le sujet ne vous passionne pas beaucoup.
Serait-il trop simple ou parfaitement connu ?
Mon bon Papipp, par correction pour l'auteur, je ne m'autorise même pas à avoir une pensée sur le sujet, lorsque l'on est monté neuronalement fin comme moi :oops:
Le titre me rappelle vaguement quelque chose, j'ai dû en entendre parler en 4e je crois....

Des sujets comme celui-ci n'ont aucun rapport avec la passion....bien qu'il en faille une certaine quantité pour faire ce genre de choses alors qu'on est plus à l'école :lol: à moins bien sûr que ce soit le besoin qui motive ce travail :wink:
Je le redit, mais devant ce genre de connaissances, je suis en admiration, je pourrais gober une mouche tellement ma bouche s'ouvre quand je vois ce genre d'image 8O

Image

Les seules appréciations de ma part, qui vont beaucoup te faire avancer dans tes formules, pourraient être
Oooooooh !!! C'est beau !!!! Super !!! Incroyable !!! 8O
Prooooout !!! serait au même rang de l'utilité :|

En mon nom, merci mille fois en tout cas, pour le lard aux cochons, et cette tentative de me faire apprécier mon ennemi de toujours
LA MATHEMATIQUE
Comme dirait notre ministre :wink:
Image

_________________
ImageLe bonheur est une route...
Pas une destination

PureBasic Forum Officiel - Site PureBasic


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mar 06/Mar/2018 11:03 
Hors ligne
Avatar de l’utilisateur

Inscription: Mar 31/Mai/2016 9:06
Messages: 1973
Kwai chang caine a écrit:
Les maths en s'amusant, Pour moi c'est deux mots qui ne pourront jamais figurer dans la même phrase 8O



"Les maths en s'amusant, Pour moi c'est deux mots qui ne pourront jamais figurer dans la même phrase "
ce qui en algorithmie peut s'optimiser par => "Les maths en s'amusant, c'est antinomique" :mrgreen:

_________________
Image
Image
Site: http://michel.dobro.free.fr/
Devise :"dis moi ce dont tu as besoin, je t'expliquerai comment t'en passer"


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mar 06/Mar/2018 16:40 
Hors ligne
Avatar de l’utilisateur

Inscription: Sam 23/Sep/2006 18:32
Messages: 6628
Localisation: Isere
:lol:
Je dirais même plus, les math en s'amusant c'est "antipodique", voir même antipathique :mrgreen:

_________________
ImageLe bonheur est une route...
Pas une destination

PureBasic Forum Officiel - Site PureBasic


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Ven 09/Mar/2018 10:52 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 555
Je ne veux pas polluer ce forum avec des opinions personnelles comme cela a été réalisé ci-dessus.
En effet mathématiques et amusements ne sont pas opposés pour tout le monde.
C’est donc une opinion personnelle et non un fait avéré.
On ne pourra que difficilement créer un oxymore avec ces deux termes.

Je vais donc être le plus factuel possible (informations vérifiables et opposables)

Plus de 85% des éducateurs de l’enseignement scolaire sont des littéraires.
Je connais des professeurs des écoles qui ne font pas de différence entre moyenne et pourcentage !!
Et d’autres qui doivent enseigner les fractions et qui ne savent pas additionner 2 fractions !!
C’est l’une des principales raisons de notre place dans l’enquête Pisa

La France affiche une peu glorieuse 26e place en sciences, le domaine majeur d'évaluation de la dernière étude internationale PISA, qui concerne les élèves de 15 ans de l'OCDE.

Citation:
Pour Luc Ferry, « les maths ne servent à rien dans la vie quotidienne »


Monsieur Ferry ancien ministre de l’éducation nationale est-il vexé de n'avoir pas su en son temps enrayer la dégringolade de la France ?

Cédric Villani médaille Fields (2010) est chargé de proposer des actions pour redresser la place peu enviable de la France dans les sciences.(il n’est pas encore ministre)
Il est chargé aussi d'une mission sur l'intelligence artificielle.

Citations

Citation:
Réconcilier les Français et les maths, la mission impossible du député Villani ? Abstraction mathématique et sens politique peuvent-ils faire bon ménage ?

VillaniCedric :En France, on s'est mis en tête que la culture était littéraire… Nous devons convaincre que les sciences font partie de la culture

VillaniCedric :"Il faut taper fort pour réconcilier les petits Français avec les maths. Pourtant, elles sont dans le sang de la France, notre histoire politique a été très influencée par les idées mathématiques."

VillaniCedric :"Le raisonnement déductif sert plutôt peu. Mais dans l'apprentissage des math, il y a aussi de l'expérimentation. Ce n'est pas le résultat mathématique qui sert dans la vie de tous les jours, c'est la démarche."

VillaniCedric : "Le plaisir de la découverte des maths dure plus longtemps que le plaisir sexuel. Je ne fais que reprendre la citation d'un grand mathématicien français, que vous pourrez découvrir dans mon livre."


Merci Monsieur Villani. La démarche, la méthode, une façon de penser, l'apprentissage de l'exhaustivité, la partition des possibles, autant de facteurs positifs pour une vie professionnelle et pour une société moderne ! Il n'y a pas de rhétorique en mathématiques.

Il y a plus d’informations dans la formule d’Euler e^^(i pi)+1=0 en moins de 10 caractères que dans certains texto(s) du président Trump de 140 caractères

A+

_________________
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Sam 10/Mar/2018 13:22 
Hors ligne

Inscription: Ven 29/Juin/2007 17:50
Messages: 3413
Bonjour PAPIPP,

je n'ai pas trop le temps pour cause de prise de bande passante cérébrale à durée non déterminée.

J'apprécie tes écrits, cependant, loin des personnes, il n'y a pas de "conflit" entre littérature et mathématique. Aussi l'un ne va pas sans l'autre.

C'est comme si tu pointais des personnes qui ne jureraient que par l'algèbre, contre d'autres qui ne jureraient que par la géométrie.

Un litre d'eau, c'est un litre d'eau, même si le litre, comme l'eau sont négligeables en maths. S'il n'y a pas d'eau à mesurer dans l'existence, il n'y a pas besoin de maths. Aussi, il n'y a pas de conscience en mathématiques : un litre d'eau ou un peuple, c'est pareil en maths. Or une science nécessite une conscience.

Voilà, c'était mon humble opinion. Je ne donnerai pas suite à une réponse de ta part à ce sujet pour te permettre une totale sérénité. Par contre, je découvre que tu as posé une question sur une irrégularité que tu constates en trigo. Alors quand j'aurai le temps, je crois que je tenterai un éclaircissement. Par intuition, je me risque à dire qu'il s'agit d'une omission de ta part. Mais une omission tout à fait honorable comme la conséquence d'un cumul important d'informations.

_________________
Juste la 4G pour Smartphone


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mer 21/Mar/2018 8:59 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 555
Bonjour à tous

Je viens de m’apercevoir que la calculatrice Microsoft Matematics en téléchargement gratuit ici :

https://www.microsoft.com/fr-fr/download/details.aspx?id=15702

Permet de contrôler les résultats sur les complexes.

Les résultats sur w=sin(z) suivi de Z1=asin(w) suivi de W1=sin(Z1) etc…
Et sur tw=tan(Z) suivi de TZ1=atan(tw) suivi de TW1=tan(TZ1) etc…


La calculatrice et le programme donnent les mêmes résultats.

Ceci ne m’explique toujours pas pourquoi on ne retombe pas sur les mêmes angles complexes que celui d'origine
Quelqu’un peut-il me donner une explication ?

A+

_________________
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mer 21/Mar/2018 9:31 
Hors ligne

Inscription: Mar 09/Déc/2014 20:02
Messages: 74
Salut,
Désolé, si je dis des bêtises, c'est très loin tout ça, vu que maintenant je suis tout vieux....
Je raisonne mieux avec du concret.

soit le complexe : z1=4-4i
forme trigo : [ r;alpha ]
r=sqr(4²+(-4²)=sqr(32)=4sqr(2)
cos(alpha)=4/(4sqr(2))=1/sqr(2)=sqr(2)/2
sin(alpha)=-4/(4sqr2)=-&/sqr(2)=-sqr(2)/2

soit le sin et cos de l'angle -pi/4 à 2pi près
alpha=-pi/4 à 2pi près

z1=[4sqr(2); -pi/4]

C hyper dur de faire de taper des expressions math dans le forum.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Nombres Complexes Opérateurs
MessagePosté: Mer 21/Mar/2018 9:55 
Hors ligne

Inscription: Sam 23/Fév/2008 17:58
Messages: 555
Merci zaphod_b

Non il n’y a pas d’erreur dans ta démonstration sur les réels.

Les angles sont toujours définis à 2k pi près avec k = 0,1,2,3, …etc

Mais sur les complexes quel est le modulo ?
sous la forme trigo rho(cos(phi)+isin(phi) peut-être phi+2K pi mais les résultats sous la forme trigo ne confirment pas cela.

Ps :

En effet c’est impossible d’écrire des fonctions mathématiques sur le forum.
C’est pourquoi j’ai utilisé soit un fichier word à télécharger soit une image JPEG du même texte.

A+

_________________
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 16 messages ]  Aller à la page 1, 2  Suivante

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages

Rechercher:
Aller à:  

 


Powered by phpBB © 2008 phpBB Group | Traduction par: phpBB-fr.com
subSilver+ theme by Canver Software, sponsor Sanal Modifiye