Complex Number

Share your advanced PureBasic knowledge/code with the community.
Post Reply
User avatar
Guimauve
Enthusiast
Enthusiast
Posts: 742
Joined: Wed Oct 22, 2003 2:51 am
Location: Canada

Complex Number

Post by Guimauve »

Hello everyone,

Today I release a "Complex number" type and library (A mix of Macros and procedures)
(Sorry for the French comment...)

I need this for alternative electric current and vibration analysis.

Code: Select all

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Nom du projet : Lib Nombre Complex
; Nom du Fichier : Lib_Complex_Number.pb
; Version du Fichier : 1.0.1
; Programmation : OK
; Programmé par : Guimauve
; Date : 10-10-2009
; Mise à jour : 11-10-2009
; Codé avec PureBasic V4.40 BETA 4
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Déclaration de la Structure <<<<<

Structure Complex
  
  X.d
  Y.d
  
EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les observateurs <<<<<

Macro GetComplexX(ComplexA)
  
  ComplexA\X
  
EndMacro

Macro GetComplexY(ComplexA)
  
  ComplexA\Y
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les mutateurs <<<<<

Macro SetComplexX(ComplexA, P_X)
  
  GetComplexX(ComplexA) = P_X
  
EndMacro

Macro SetComplexY(ComplexA, P_Y)
  
  GetComplexY(ComplexA) = P_Y
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Update <<<<<

Macro UpdateComplex(ComplexA, P_X, P_Y)
  
  SetComplexX(ComplexA, P_X)
  SetComplexY(ComplexA, P_Y)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Reset <<<<<

Macro ResetComplex(ComplexA)
  
  SetComplexX(ComplexA, 0)
  SetComplexY(ComplexA, 0)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Copy : A = Source : B = Destination <<<<<

Macro CopyComplex(ComplexA, ComplexB)
  
  SetComplexX(ComplexB, GetComplexX(ComplexA))
  SetComplexY(ComplexB, GetComplexY(ComplexA))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Compare <<<<<

Macro CompareComplex(ComplexA, ComplexB)
  
  CompareMemory(ComplexA, ComplexB, SizeOf(Complex))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Swap <<<<<

Macro SwapComplex(ComplexA, ComplexB)
  
  Swap GetComplexX(ComplexA), GetComplexX(ComplexB)
  Swap GetComplexY(ComplexA), GetComplexY(ComplexB)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Plus : R = A + B <<<<<

Macro PlusComplex(ComplexR, ComplexA, ComplexB)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) + GetComplexX(ComplexB))
  SetComplexY(ComplexR, GetComplexY(ComplexA) + GetComplexY(ComplexB))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Minus : R = A - B <<<<<

Macro MinusComplex(ComplexR, ComplexA, ComplexB)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) - GetComplexX(ComplexB))
  SetComplexY(ComplexR, GetComplexY(ComplexA) - GetComplexY(ComplexB))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur ProductByScalar : R = A * Scalar <<<<<

Macro ProductByScalarComplex(ComplexR, ComplexA, Scalar)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) * Scalar)
  SetComplexY(ComplexR, GetComplexY(ComplexA) * Scalar)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur DivideByScalar : R = A / Scalar <<<<<

Macro DivideByScalarComplex(ComplexR, ComplexA, Scalar)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) / Scalar)
  SetComplexY(ComplexR, GetComplexY(ComplexA) / Scalar)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Zero <<<<<

Macro ZeroComplex(ComplexA)
  
  SetComplexX(ComplexA, 0)
  SetComplexY(ComplexA, 0)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Macro de déboguage <<<<<

Macro DebugComplex(ComplexA)
  
  Debug GetComplexX(ComplexA)
  Debug GetComplexY(ComplexA)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Macro de Formatage <<<<<

Macro FormatComplex(ComplexA, Decimal = 3)
  
  StrD(GetComplexX(ComplexA), Decimal) + " + " + StrD(GetComplexY(ComplexA), Decimal) + "i"
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Product : R = A * B <<<<<

Macro ProductComplex(ComplexR, ComplexA, ComplexB)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) * GetComplexX(ComplexB) - GetComplexY(ComplexA) * GetComplexY(ComplexB))
  SetComplexY(ComplexR, GetComplexX(ComplexA) * GetComplexY(ComplexB) + GetComplexY(ComplexA) * GetComplexX(ComplexB))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Square <<<<<

Macro SquareComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) * GetComplexX(ComplexA) - GetComplexY(ComplexA) * GetComplexY(ComplexA))
  SetComplexY(ComplexR, GetComplexX(ComplexA) * GetComplexY(ComplexA) * 2.0)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur SumSquare <<<<<

Macro SumSquareComplex(ComplexA)
  
  (GetComplexX(ComplexA) * GetComplexX(ComplexA) + GetComplexY(ComplexA) * GetComplexY(ComplexA))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Magnitude <<<<<

Macro MagnitudeComplex(ComplexA)
  
  Sqr(SumSquareComplex(ComplexA))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Sinus <<<<<

Macro SinusComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, Sin(GetComplexX(ComplexA)) * CosH(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, Cos(GetComplexX(ComplexA)) * SinH(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Cosinus <<<<<

Macro CosinusComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, Cos(GetComplexX(ComplexA)) * CosH(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, -Sin(GetComplexX(ComplexA)) * SinH(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Sinus Hyperbolique <<<<<

Macro SinusHyperbolicComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, SinH(GetComplexX(ComplexA)) * Cos(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, CosH(GetComplexX(ComplexA)) * Sin(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Cosinus Hyperbolique <<<<<

Macro CosinusHyperbolicComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, CosH(GetComplexX(ComplexA)) * Cos(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, SinH(GetComplexX(ComplexA)) * Sin(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Ln <<<<<

Macro LnComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, Log((GetComplexX(ComplexA) * GetComplexX(ComplexA)) + (GetComplexY(ComplexA) * GetComplexY(ComplexA))) / 2.0)
  SetComplexY(ComplexR, (2 * ATan(GetComplexY(ComplexA) / (Sqr(GetComplexX(ComplexA) * GetComplexX(ComplexA) + GetComplexY(ComplexA) * GetComplexY(ComplexA))+GetComplexX(ComplexA)))))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Divide : R = A / B <<<<<

Procedure DivideComplex(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
  
  ComplexModulus.d = GetComplexX(*ComplexB) * GetComplexX(*ComplexB) + GetComplexY(*ComplexB) * GetComplexY(*ComplexB)
  
  SetComplexX(*ComplexR, (GetComplexX(*ComplexA) * GetComplexX(*ComplexB) + GetComplexY(*ComplexA) * GetComplexY(*ComplexB)) / ComplexModulus)
  SetComplexY(*ComplexR, (GetComplexX(*ComplexA) * GetComplexY(*ComplexB) - GetComplexY(*ComplexA) * GetComplexX(*ComplexB)) / ComplexModulus)
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Tangeante <<<<<

Procedure TangentComplex(*ComplexR.Complex, *ComplexA.Complex)
  
  SinusComplex(ComplexSin.Complex, *ComplexA)
  CosinusComplex(ComplexCos.Complex, *ComplexA)
  DivideComplex(*ComplexR.Complex, ComplexSin, ComplexCos)
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Tangeante Hyperbolique <<<<<

Procedure TangentHyperbolicComplex(*ComplexR.Complex, *ComplexA.Complex)
  
  SinusHyperbolicComplex(ComplexSinH.Complex, *ComplexA)
  CosinusHyperbolicComplex(ComplexCosH.Complex, *ComplexA)
  DivideComplex(*ComplexR.Complex, ComplexSinH, ComplexCosH)
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Exponential <<<<<

Procedure ExponentialComplex(*ComplexR.Complex, *ComplexA.Complex)
  
  ComplexEx.d = Pow(2.71828182846, GetComplexX(*ComplexA))
  
  SetComplexX(*ComplexR, ComplexEx * Cos(GetComplexY(*ComplexA)))
  SetComplexY(*ComplexR, ComplexEx * Sin(GetComplexY(*ComplexA)))
  
EndProcedure

;/ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
;/ <<<<< ATTENTION - CODE D'ESSAI - ATTENTION <<<<<
;/ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Nombre complexe originaux"

UpdateComplex(ComplexA.Complex, 5, 3)
UpdateComplex(ComplexB.Complex, 3, 5)

Debug FormatComplex(ComplexA)
Debug FormatComplex(ComplexB)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test d'addition de nombre complexe"

PlusComplex(PlusComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(PlusComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de soustraction de nombre complexe"

MinusComplex(MinusComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(MinusComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Produit par un scalaire de nombre complexe"

ProductByScalarComplex(ProdByScalarComplexR.Complex, ComplexA, 5)
Debug FormatComplex(ProdByScalarComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Division par un scalaire de nombre complexe"

DivideByScalarComplex(DividByScalarComplexR.Complex, ComplexA, 5)
Debug FormatComplex(DividByScalarComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de multiplication de nombre complexe"

ProductComplex(ProdComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(ProdComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de division de nombre complexe"

DivideComplex(DividComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(DividComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Square de nombre complexe --> A²"

SquareComplex(SqrComplexR.Complex, ComplexA)
Debug FormatComplex(SqrComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de e^(A) de nombre complexe"

ExponentialComplex(ExpComplexR.Complex, ComplexA)
Debug FormatComplex(ExpComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Sin(A) de nombre complexe"

SinusComplex(SinComplexR.Complex, ComplexA)
Debug FormatComplex(SinComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Cos(A) de nombre complexe"

CosinusComplex(CosComplexR.Complex, ComplexA)
Debug FormatComplex(CosComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Tan(A) de nombre complexe"

TangentComplex(TanComplexR.Complex, ComplexA)
Debug FormatComplex(TanComplexR, 6)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de SinH(A) de nombre complexe"

SinusHyperbolicComplex(SinHComplexR.Complex, ComplexA)
Debug FormatComplex(SinHComplexR, 4)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de CosH(A) de nombre complexe"

CosinusHyperbolicComplex(CosHComplexR.Complex, ComplexA)
Debug FormatComplex(CosHComplexR, 4)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de TanH(A) de nombre complexe"

TangentHyperbolicComplex(TanHComplexR.Complex, ComplexA)
Debug FormatComplex(TanHComplexR, 6)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Ln de nombre complexe"

LnComplex(LnComplexR.Complex, ComplexA)
Debug FormatComplex(LnComplexR, 5)

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< FIN DU FICHIER <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<
You probably need these 2 macros too :

Code: Select all

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Sinus Hyperbolique <<<<<

Macro SinH(Angle)
  
   ((Pow(2.71828182846, Angle) - Pow(2.71828182846, -Angle)) / 2)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Cosinus Hyperbolique <<<<<

Macro CosH(Angle)
  
   ((Pow(2.71828182846, Angle) + Pow(2.71828182846, -Angle)) / 2)
  
EndMacro
Best regards
Guimauve
Last edited by Guimauve on Mon Oct 12, 2009 9:14 pm, edited 1 time in total.
Top
User avatar
idle
Always Here
Always Here
Posts: 5836
Joined: Fri Sep 21, 2007 5:52 am
Location: New Zealand

Re: Complex Number

Post by idle »

thanks could be useful
Top
User avatar
Guimauve
Enthusiast
Enthusiast
Posts: 742
Joined: Wed Oct 22, 2003 2:51 am
Location: Canada

Re: Complex Number

Post by Guimauve »

A tiny update

ProductByScalar --> Added
DivideByScalar --> Added

Regards
Guimauve
Top
User avatar
StarBootics
Addict
Addict
Posts: 1006
Joined: Sun Jul 07, 2013 11:35 am
Location: Canada

Re: Complex Number

Post by StarBootics »

Hello everyone,

Sorry to revive this old topic but I convert it into a module for my need.

Best regards
StarBootics

Code: Select all

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Project name : Complex Number - Module
; File Name : Complex - Module.pb
; File version: 1.0.0
; Programming : OK
; Programmed by : StarBootics
; Date : 12-08-2016
; Last Update : 12-08-2016
; PureBasic code : V5.50
; Platform : Windows, Linux, MacOS X
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; This code was originally created by Guimauve
; to manipulate Complex Number.
;
; I deserve credit only to convert the original 
; code into a Module.
;
; This code is free to be use where ever you like 
; but you use it at your own risk.
;
; The author can in no way be held responsible 
; for data loss, damage or other annoying 
; situations that may occur.
;
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

DeclareModule Complex
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< Déclaration de la Structure <<<<<
  
  Structure Complex
    
    Real.d
    Imaginary.d
    
  EndStructure
  
  Declare.d GetReal(*ComplexA.Complex)
  Declare.d GetImaginary(*ComplexA.Complex)
  Declare SetReal(*ComplexA.Complex, P_Real.d)
  Declare SetImaginary(*ComplexA.Complex, P_Imaginary.d)
  Declare Update(*ComplexA.Complex, P_Real.d, P_Imaginary.d)
  Declare Reset(*ComplexA.Complex)
  Declare Equal(*ComplexA.Complex, *ComplexB.Complex)
  Declare Plus(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
  Declare Minus(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
  Declare Product(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
  Declare Divide(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
  Declare Zero(*ComplexA.Complex)
  Declare ProductByScalar(*ComplexR.Complex, *ComplexA.Complex, P_Scalar.d)
  Declare DivideByScalar(*ComplexR.Complex, *ComplexA.Complex, P_Scalar.d)
  Declare Copy(*ComplexA.Complex, *ComplexB.Complex)
  Declare Compare(*ComplexA.Complex, *ComplexB.Complex)
  Declare Swapping(*ComplexA.Complex, *ComplexB.Complex)
  Declare ReadComplex(FileID.l, *ComplexA.Complex)
  Declare WriteComplex(FileID.l, *ComplexA.Complex)
  Declare.s Format(*ComplexA.Complex, Decimal = 3)
  Declare Square(*ComplexR.Complex, *ComplexA.Complex)
  Declare Exponential(*ComplexR.Complex, *ComplexA.Complex)
  Declare Sinus(*ComplexR.Complex, *ComplexA.Complex)
  Declare Cosinus(*ComplexR.Complex, *ComplexA.Complex)
  Declare Tangent(*ComplexR.Complex, *ComplexA.Complex)
  Declare SinusHyperbolic(*ComplexR.Complex, *ComplexA.Complex)
  Declare CosinusHyperbolic(*ComplexR.Complex, *ComplexA.Complex)
  Declare TangentHyperbolic(*ComplexR.Complex, *ComplexA.Complex)
  Declare Ln(*ComplexR.Complex, *ComplexA.Complex)
  
EndDeclareModule

Module Complex
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< Les observateurs <<<<<
  
  Procedure.d GetReal(*ComplexA.Complex)
    
    ProcedureReturn *ComplexA\Real
  EndProcedure
  
  Procedure.d GetImaginary(*ComplexA.Complex)
    
    ProcedureReturn *ComplexA\Imaginary
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< Les mutateurs <<<<<
  
  Procedure SetReal(*ComplexA.Complex, P_Real.d)
    
    *ComplexA\Real = P_Real
    
  EndProcedure
  
  Procedure SetImaginary(*ComplexA.Complex, P_Imaginary.d)
    
    *ComplexA\Imaginary = P_Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Update <<<<<
  
  Procedure Update(*ComplexA.Complex, P_Real.d, P_Imaginary.d)
    
    *ComplexA\Real = P_Real
    *ComplexA\Imaginary = P_Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Reset <<<<<
  
  Procedure Reset(*ComplexA.Complex)
    
    *ComplexA\Real = 0.0
    *ComplexA\Imaginary = 0.0
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Equal : A = B <<<<<
  
  Procedure Equal(*ComplexA.Complex, *ComplexB.Complex)
    
    *ComplexA\Real = *ComplexB\Real
    *ComplexA\Imaginary = *ComplexB\Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Plus : R = A + B <<<<<
  
  Procedure Plus(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
    
    *ComplexR\Real = *ComplexA\Real + *ComplexB\Real
    *ComplexR\Imaginary = *ComplexA\Imaginary + *ComplexB\Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Minus : R = A - B <<<<<
  
  Procedure Minus(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
    
    *ComplexR\Real = *ComplexA\Real - *ComplexB\Real
    *ComplexR\Imaginary = *ComplexA\Imaginary - *ComplexB\Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Product : R = A * B <<<<<
  
  Procedure Product(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
    
    *ComplexR\Real = *ComplexA\Real * *ComplexB\Real - *ComplexA\Imaginary * *ComplexB\Imaginary
    *ComplexR\Imaginary = *ComplexA\Real * *ComplexB\Imaginary + *ComplexA\Imaginary * *ComplexB\Real
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Divide : R = A / B <<<<<
  
  Procedure Divide(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
    
    ComplexModulus.d = *ComplexB\Real * *ComplexB\Real + *ComplexB\Imaginary * *ComplexB\Imaginary
    
    If ComplexModulus <> 0.0
      *ComplexR\Real = (*ComplexA\Real * *ComplexB\Real + *ComplexA\Imaginary * *ComplexB\Imaginary) / ComplexModulus
      *ComplexR\Imaginary = (*ComplexA\Real * *ComplexB\Imaginary - *ComplexA\Imaginary * *ComplexB\Real) / ComplexModulus
    EndIf
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Zero <<<<<
  
  Procedure Zero(*ComplexA.Complex)
    
    *ComplexA = 0.0
    *ComplexA = 0.0
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur ProductByScalar : R = A * Scalar <<<<<
  
  Procedure ProductByScalar(*ComplexR.Complex, *ComplexA.Complex, P_Scalar.d)
    
    *ComplexR\Real = *ComplexA\Real * P_Scalar
    *ComplexR\Imaginary = *ComplexA\Imaginary * P_Scalar
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur DivideByScalar : R = A / Scalar <<<<<
  
  Procedure DivideByScalar(*ComplexR.Complex, *ComplexA.Complex, P_Scalar.d)
    
    *ComplexR\Real = *ComplexA\Real / P_Scalar
    *ComplexR\Imaginary = *ComplexA\Imaginary / P_Scalar
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Copy : A = Source : B = Destination <<<<<
  
  Procedure Copy(*ComplexA.Complex, *ComplexB.Complex)
    
    *ComplexB\Real = *ComplexA\Real
    *ComplexB\Imaginary = *ComplexA\Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Compare <<<<<
  
  Procedure Compare(*ComplexA.Complex, *ComplexB.Complex)
    
    If *ComplexA\Real <> *ComplexB\Real
      ProcedureReturn #False
    EndIf
    
    If *ComplexA\Imaginary <> *ComplexB\Imaginary
      ProcedureReturn #False
    EndIf
    
    ProcedureReturn #True
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Swapping <<<<<
  
  Procedure Swapping(*ComplexA.Complex, *ComplexB.Complex)
    
    Swap *ComplexA\Real, *ComplexB\Real
    Swap *ComplexA\Imaginary, *ComplexB\Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< Lecture sur fichier Binaire <<<<<
  
  Procedure ReadComplex(FileID.l, *ComplexA.Complex)
    
    *ComplexA\Real = ReadDouble(FileID)
    *ComplexA\Imaginary = ReadDouble(FileID)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< Écriture sur fichier Binaire <<<<<
  
  Procedure WriteComplex(FileID.l, *ComplexA.Complex)
    
    WriteDouble(FileID, *ComplexA\Real)
    WriteDouble(FileID, *ComplexA\Imaginary)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< Opérateur de Formatage <<<<<
  
  Procedure.s Format(*ComplexA.Complex, Decimal = 3)
    
    ProcedureReturn StrD(*ComplexA\Real, Decimal) + " + " + StrD(*ComplexA\Imaginary, Decimal) + "i"
  EndProcedure 
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Square <<<<<
  
  Procedure Square(*ComplexR.Complex, *ComplexA.Complex)
    
    *ComplexR\Real = *ComplexA\Real * *ComplexA\Real - *ComplexA\Imaginary * *ComplexA\Imaginary
    *ComplexR\Imaginary = 2.0 * *ComplexA\Real * *ComplexA\Imaginary
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Exponential <<<<<
  
  Procedure Exponential(*ComplexR.Complex, *ComplexA.Complex)
    
    ComplexEx.d = Pow(#E, *ComplexA\Real)
    
    *ComplexR\Real = ComplexEx * Cos(*ComplexA\Imaginary)
    *ComplexR\Imaginary = ComplexEx * Sin(*ComplexA\Imaginary)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Sinus <<<<<
  
  Procedure Sinus(*ComplexR.Complex, *ComplexA.Complex)
    
    *ComplexR\Real = Sin(*ComplexA\Real) * CosH(*ComplexA\Imaginary)
    *ComplexR\Imaginary = Cos(*ComplexA\Real) * SinH(*ComplexA\Imaginary)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Cosinus <<<<<
  
  Procedure Cosinus(*ComplexR.Complex, *ComplexA.Complex)
    
    *ComplexR\Real = Cos(*ComplexA\Real) * CosH(*ComplexA\Imaginary)
    *ComplexR\Imaginary = -Sin(*ComplexA\Real) * SinH(*ComplexA\Imaginary)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Tangeante <<<<<
  
  Procedure Tangent(*ComplexR.Complex, *ComplexA.Complex)
    
    Sinus(ComplexSin.Complex, *ComplexA)
    Cosinus(ComplexCos.Complex, *ComplexA)
    Divide(*ComplexR, ComplexSin, ComplexCos)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Sinus Hyperbolique <<<<<
  
  Procedure SinusHyperbolic(*ComplexR.Complex, *ComplexA.Complex)
    
    *ComplexR\Real = SinH(*ComplexA\Real) * Cos(*ComplexA\Imaginary)
    *ComplexR\Imaginary = CosH(*ComplexA\Real) * Sin(*ComplexA\Imaginary)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Cosinus Hyperbolique <<<<<
  
  Procedure CosinusHyperbolic(*ComplexR.Complex, *ComplexA.Complex)
    
    *ComplexR\Real = CosH(*ComplexA\Real) * Cos(*ComplexA\Imaginary)
    *ComplexR\Imaginary = SinH(*ComplexA\Real) * Sin(*ComplexA\Imaginary)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Tangeante Hyperbolique <<<<<
  
  Procedure TangentHyperbolic(*ComplexR.Complex, *ComplexA.Complex)
    
    SinusHyperbolic(ComplexSinH.Complex, *ComplexA)
    CosinusHyperbolic(ComplexCosH.Complex, *ComplexA)
    Divide(*ComplexR, ComplexSinH, ComplexCosH)
    
  EndProcedure
  
  ; <<<<<<<<<<<<<<<<<<<<<<<<<<
  ; <<<<< L'opérateur Ln <<<<<
  
  Procedure Ln(*ComplexR.Complex, *ComplexA.Complex)
    
    *ComplexR\Real = Log((*ComplexA\Real * *ComplexA\Real) + (*ComplexA\Imaginary * *ComplexA\Imaginary)) / 2.0
    *ComplexR\Imaginary = (2.0 * ATan(*ComplexA\Imaginary / (Sqr(*ComplexA\Real * *ComplexA\Real + *ComplexA\Imaginary * *ComplexA\Imaginary) + *ComplexA\Real)))
    
  EndProcedure

EndModule

CompilerIf #PB_Compiler_IsMainFile
  
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Nombre complexe originaux"
  Debug ""
  
  Complex::Update(ComplexA.Complex::Complex, 5, 3)
  Complex::Update(ComplexB.Complex::Complex, 3, 5)
  
  Debug Complex::Format(ComplexA)
  Debug Complex::Format(ComplexB)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test d'addition de nombre complexe"
  Debug ""
  
  Complex::Plus(PlusComplexR.Complex::Complex, ComplexA, ComplexB)
  Debug Complex::Format(PlusComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de soustraction de nombre complexe"
  Debug ""
  
  Complex::Minus(MinusComplexR.Complex::Complex, ComplexA, ComplexB)
  Debug Complex::Format(MinusComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Produit par un scalaire de nombre complexe"
  Debug ""
  
  Complex::ProductByScalar(ProdByScalarComplexR.Complex::Complex, ComplexA, 5)
  Debug Complex::Format(ProdByScalarComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Division par un scalaire de nombre complexe"
  Debug ""
  
  Complex::DivideByScalar(DividByScalarComplexR.Complex::Complex, ComplexA, 5)
  Debug Complex::Format(DividByScalarComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de multiplication de nombre complexe"
  Debug ""
  
  Complex::Product(ProdComplexR.Complex::Complex, ComplexA, ComplexB)
  Debug Complex::Format(ProdComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de division de nombre complexe"
  Debug ""
  
  Complex::Divide(DividComplexR.Complex::Complex, ComplexA, ComplexB)
  Debug Complex::Format(DividComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Square de nombre complexe --> A²"
  Debug ""
  
  Complex::Square(SqrComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(SqrComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de e^(A) de nombre complexe"
  Debug ""
  
  Complex::Exponential(ExpComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(ExpComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Sin(A) de nombre complexe"
  Debug ""
  
  Complex::Sinus(SinComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(SinComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Cos(A) de nombre complexe"
  Debug ""
  
  Complex::Cosinus(CosComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(CosComplexR)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Tan(A) de nombre complexe"
  Debug ""
  
  Complex::Tangent(TanComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(TanComplexR, 6)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de SinH(A) de nombre complexe"
  Debug ""
  
  Complex::SinusHyperbolic(SinHComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(SinHComplexR, 4)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de CosH(A) de nombre complexe"
  Debug ""
  
  Complex::CosinusHyperbolic(CosHComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(CosHComplexR, 4)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de TanH(A) de nombre complexe"
  Debug ""
  
  Complex::TangentHyperbolic(TanHComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(TanHComplexR, 6)
  
  Debug ""
  Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
  Debug "; Test de Ln de nombre complexe"
  Debug ""
  
  Complex::Ln(LnComplexR.Complex::Complex, ComplexA)
  Debug Complex::Format(LnComplexR, 5)
  
CompilerEndIf

; <<<<<<<<<<<<<<<<<<<<<<<
; <<<<< END OF FILE <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<
The Stone Age did not end due to a shortage of stones !
Top
mestnyi
Addict
Addict
Posts: 1098
Joined: Mon Nov 25, 2013 6:41 am

Re: Complex Number

Post by mestnyi »

for my need.
What's all this may need?
Top
User avatar
mk-soft
Always Here
Always Here
Posts: 6202
Joined: Fri May 12, 2006 6:51 pm
Location: Germany

Re: Complex Number

Post by mk-soft »

Calculations of inductive and capacitive voltages and flow, angle power calculation, etc ...
Maybe.
My Projects ThreadToGUI / OOP-BaseClass / EventDesigner V3
PB v3.30 / v5.75 - OS Mac Mini OSX 10.xx - VM Window Pro / Linux Ubuntu
Downloads on my Webspace / OneDrive
Top
davido
Addict
Addict
Posts: 1890
Joined: Fri Nov 09, 2012 11:04 pm
Location: Uttoxeter, UK

Re: Complex Number

Post by davido »

@StarBootics

Thank you. :D
DE AA EB
Top
startup
Enthusiast
Enthusiast
Posts: 105
Joined: Wed Feb 25, 2015 5:55 pm

Re: Complex Number

Post by startup »

on complex number as a whole:
http://milesmathis.com/euclid.html

you may want think about using them.
Top
User avatar
Psychophanta
Always Here
Always Here
Posts: 5153
Joined: Wed Jun 11, 2003 9:33 pm
Location: Anare
Contact:
Contact Psychophanta

Re: Complex Number

Post by Psychophanta »

startup wrote:on complex number as a whole:
http://milesmathis.com/euclid.html

you may want think about using them.
Complex numbers and its operations is an algebra designed by Leonhard Euler in an attempt to solve some mechanical behaviours of the rotation dynamics, behaviour that today still is not solved nor understood.

Strange that the text of that link you posted does not mention anything of this.
http://www.zeitgeistmovie.com

while (world==business) world+=mafia;
Top
Post Reply

Return to “Tricks 'n' Tips”