Nombres Complexes Opérateurs

PAPIPP · Message par **PAPIPP** » mer. 28/févr./2018 10:28

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 : Tout sélectionner

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

A+

PAPIPP · Message par **PAPIPP** » mer. 28/févr./2018 10:30

Voici le prg
le tout dépasse les 60Ko

Code : Tout sélectionner

;;****************************************************************************************************************
;; 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+

Micoute · Message par **Micoute** » mer. 28/févr./2018 14:55

Très intéressant, merci pour le partage.

PAPIPP · Message par **PAPIPP** » sam. 03/mars/2018 16:06

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+

falsam · Message par **falsam** » sam. 03/mars/2018 16:23

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 .

djes · Message par **djes** » sam. 03/mars/2018 17:11

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 !

Ar-S · Message par **Ar-S** » sam. 03/mars/2018 17:39

Un boulot de fou qui dépasse de loin mon amour des maths.
Merci

Kwai chang caine · Message par **Kwai chang caine** » mar. 06/mars/2018 10:03

Falsam a écrit :Les maths en s'amusant

Pour moi c'est deux mots qui ne pourront jamais figurer dans la même phrase

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

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

à moins bien sûr que ce soit le besoin qui motive ce travail

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

Les seules appréciations de ma part, qui vont beaucoup te faire avancer dans tes formules, pourraient être
Oooooooh !!! C'est beau !!!! Super !!! Incroyable !!!

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

Zorro · Message par **Zorro** » mar. 06/mars/2018 11:03

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

"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"

Kwai chang caine · Message par **Kwai chang caine** » mar. 06/mars/2018 16:40

Je dirais même plus, les math en s'amusant c'est "antipodique", voir même antipathique

PAPIPP · Message par **PAPIPP** » ven. 09/mars/2018 10:52

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.

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

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+

Ollivier · Message par **Ollivier** » sam. 10/mars/2018 13:22

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.

PAPIPP · Message par **PAPIPP** » mer. 21/mars/2018 8:59

Bonjour à tous

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

https://www.microsoft.com/fr-fr/downloa ... x?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+

zaphod_b · Message par **zaphod_b** » mer. 21/mars/2018 9:31

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.

PAPIPP · Message par **PAPIPP** » mer. 21/mars/2018 9:55

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+

PureBasic

Nombres Complexes Opérateurs

Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs

Re: Nombres Complexes Opérateurs