PureBasic Forums - English

Posted: **Sun Oct 11, 2009 4:26 pm**

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

Posted: **Mon Oct 12, 2009 9:03 am**

thanks could be useful

Posted: **Mon Oct 12, 2009 9:15 pm**

A tiny update

ProductByScalar --> Added
DivideByScalar --> Added

Regards
Guimauve

Posted: **Sat Aug 13, 2016 1:13 am**

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

Posted: **Sat Aug 13, 2016 7:40 am**

for my need.

What's all this may need?

Posted: **Sat Aug 13, 2016 11:33 am**

Calculations of inductive and capacitive voltages and flow, angle power calculation, etc ...
Maybe.

Posted: **Sat Aug 13, 2016 4:32 pm**

@StarBootics

Thank you.

Posted: **Mon Aug 15, 2016 4:01 pm**

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

you may want think about using them.

Posted: **Sun Nov 06, 2016 3:24 am**

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.

PureBasic Forums - English

Complex Number

Complex Number

Re: Complex Number

Re: Complex Number

Re: Complex Number

Re: Complex Number

Re: Complex Number

Re: Complex Number

Re: Complex Number

Re: Complex Number