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