User Tools

Site Tools


29.1 Complex numbers

Even if the use of complex numbers is not part of everyday arithmetic with numbers, complex numbers are the first choice for certain applications in electrical engineering or quantum physics. A look at this page provides valuable information and basic knowledge.the Complex (gb.complex) class implements complex numbers. The following arithmetic operators and functions are supported in this number range: +, -, *, /, ^, =, <> and Abs(), whereby the absolute value of a complex number is also called the modulus. A complex number represents a pointer in the complex number plane. Perpendicular to the real number line with the unit 1 is the imaginary number line in the centre of the plane. The complex number is usually written as z = a +bi =. Where i is the imaginary unit i, for which i² = -1, a is the real part and b is the imaginary part.

If a real number in Gambas is immediately followed by an “i” or “I”, it is assumed to be a complex number (constant). In this case, the gb.complex component is loaded automatically and adds a new complex class to the interpreter. An 'i' or 'I' alone as a complex number without a real part is recognised as an invalid identifier! Therefore, always write 1i for i. The notation with the capital letter I is obviously specific to Gambas.

29.1.1 Properties

The Complex class has two properties:

PropertyData typeDescription
RealFloatSets or returns the real part of a complex number.
ImagFloatSets or returns the imaginary part of a complex number.

Table : Properties of the Complex class

29.1.2 Methods

The Complex class has a static method and several other methods, the description of which can be found in the next table, paying attention to the different return types:

MethodReturn typeDescription
Abs2()FloatSets or returns the root of the absolute value of a complex number.
Arg()FloatReturns the argument - in radians - of a complex number. This refers to the angle between the pointer representing the complex number in the number plane and the positive real axis.
Conj()ComplexReturns the conjugate complex number zc to an existing complex number z.
Copy()ComplexReturns a copy of a complex number.
Inv()ComplexReturns the inverse complex number of a complex number.
ToString([Local As Boolean ])StringConverts a complex number into a string. If the value of the boolean variable Local is TRUE, then the localised number is output; in Germany with the comma as the decimal separator. If the value of the Boolean variable Local is FALSE, a string is returned that can be evaluated with the 'Eval' function.

Table : Methods of the Complex class

Method Complex.Polar()

The static method Complex.Polar ( [ Abs As Float, Arg As Float ] ) As Complex returns a complex number. The data of the pointer (amount Abs and angle Arg (radian measure) against the positive real axis), which represents the complex number in the complex number plane, are used as arguments.

29.1.3 Generating complex numbers

There are several ways to create complex numbers:

  • Using the (static) method Polar( [ Abs As Float, Arg As Float ] ).
  • Use of the Conj(), Inv() and Copy() methods. Pay attention to the necessary brackets!
  • Use of the Complex( [ Real As Float, Imag As Float ] ) function. Use it to create a new complex number from its real and imaginary parts. If the real or imaginary part is not specified, it is assumed to be zero.
  • Conversion of a character string from a suitable (input) component into a complex number.

Example of the use of the Polar(..), Conj(), Inv(), Copy(), Complex(..) and ToString(..) methods:

Dim cZ1, cZ2 As Complex
 cZ1 = Complex(4, -3)
 cZ2 = Complex.Polar(4.66, Pi / 3)
 Print cZ1 + cZ2		' Sum of 2 complex numbers Z1 and Z2
 Print cZ1 - cZ2		' Difference of 2 complex numbers Z1 and Z2
 Print cZ1 * cZ2		' Product of 2 complex numbers Z1 and Z2
 Print cZ1 ^ 3		        ' 3rd power of the complex number Z1
 Print Abs(cZ1)		        ' Absolute value of the complex number Z1
 Print cZ1.Abs2()		' Square of the absolute value of the complex number Z1
'-- Angle between the pointer of Z1 and the positive real axis (in radians)
 Print cZ1.Arg() & String.Chr(8596) & Deg(cZ1.Arg() + 2 * Pi) & "°"		
 Print cZ1.Conj()		' Conjugates complex number to Z1
 Print cZ1.Copy()		' Copy of the complex number Z1 as a new complex number
 Print cZ1.Inv()		' Inverse complex number to Z1
 Print cZ1.Real		        ' Real part of complex numbers Z1
 Print cZ1.Imag		        ' Imaginary part of the complex numbers Z1
 Print cZ2.ToString(True)       ' Conversion from Z2 to a string (localised - comma as decimal separator for DE)
 Print cZ2.ToString()           ' Conversion from Z2 to a string 
 Print Complex(-cZ1.Real,-cZ1.Imag) ' Complex number from the inverted real and imaginary part of Z1

These are the outputs in the console of the Gambas IDE:

[1] 6,33+1,03567838163548i
[2] 1,67-7,03567838163548i
[3] 21,4270351449065+9,15271352654193i
[4] -44-117i
[5] 5
[6] 25
[7] -0.64350110879328 ↔ 323.130102354156°
[8] 4+3i
[9] 4-3i
[10] 0,16+0,12i
[11] 4
[12] -3
[13] 2,33+4,03567838163548i
[14] 2.33+4.03567838163548i
[15] -4+3i

29.1.4 Examples

The following examples are tried and tested and provide an initial insight into working with complex numbers. You can find the tried and tested projects in the download area. Example 1 - Solutions of quadratic equations in normal form

A classic example is the calculation of the solutions of a quadratic equation in the general form a-x²+b-x+c = 0. This is first transformed into the normal form x²+p-x+q = 0 in order to make the Vieta test for the two solutions x1 and x2 with x1+x2 = -p and x1-x2 = q simple. You then determine their solution diversity using the discriminant D with D = (p²/4-q) and arrive at exactly 3 distinguishable cases:

1st case: D > 0 → 2 different real solutions or
2nd case: D = 0 → 2 equal real solutions (double solution) or
3rd case: D < 0 → 2 conjugate complex solutions.

Depending on the value of the discriminant D, you must then calculate exactly 2 solutions; either the two real or the two complex solutions. By using the class gb.complex, you can quickly implement the above approach. Here is an excerpt from the source code used:

Public Function Calculate(fP As Float, fQ As Float) As Variant[] 
  Dim fDiskriminante As Float = 0 
  Dim fX1, fX2 As Float
  Dim fXC1, fXC2 As Complex 
  fDiskriminante = (fP * fP) / 4 - fQ 
  Select Sgn(fDiskriminante) 
    Case 1 '-- D>0
       fX1 = - fP / 2 - Sqr(fDiskriminante) 
       fX2 = - fP / 2 + Sqr(fDiskriminante) 
       Return [fX1, fX2] 
    Case 0 '-- D=0
       fX1 = - fP / 2 
       fX2 = fX1 
       Return [fX1, fX2] 
    Case Else '-- D<0
       fXC1 = Complex(- fP / 2, - Sqr(- fDiskriminante)) 
       fXC2 = fXC1.Conj() 
       Return [fXC1, fXC2] 
  End Select 
Public Sub btnQG_Click() 
  Dim vElement As Variant 
  Dim iCount As Integer = 1 
' Randomize 
' For Each vElement In Calculate(Rnd(-2, 2), Rnd(-9, 9)) '-- Random values for the parameters
  For Each vElement In Calculate(-4, 13) 
    Print "x" & Str(iCount) & " = " & vElement 
    Inc iCount 
' Alternative: 
' Print "x1 = " & Calculate(-4, 13)[0] 
' Print "x2 = " & Calculate(-4, 13)[1] 

The solutions of the quadratic equation x²-4-x+13 = 0 are two conjugate complex numbers:

  x1 = 2-3i , x2 = 2+3i Example 2 - Use of a custom function IsComplex(..)

For the interactive input of a complex number, you can read a string from a suitable input component - such as a TextBox. Before converting String “ Complex number, it is advantageous to check whether the character string read in matches the pattern a+bi, where a and b are real numbers. You can use the IsComlex(string) function to check whether the character string read in is a complex number a+bi. If successful, you can use the new syntax (→ If sInput MATCH sPattern Then) of the gb.pcre class:

Public Function IsComplex(sInput As String) As Boolean
  Dim sPattern As String
  sInput = Trim(sInput)
  If sInput = "0-0i" Or sInput = "0+0i" Then Return False '-- Dealing with special cases ...
  sPattern = "^([-+]?[0-9]+(,[0-9]+)?)[-+][0-9]+(,[0-9]+)?[i]$"
  If sInput Match sPattern Then
     Return True
    Return False

It is advantageous if you use an input alphabet as the set of permitted input characters, as it reduces possible incorrect entries:

Public Sub txbInputComplex1_KeyPress()
Public Sub CheckInput(sAllowed As String) ' Idea by Charles Guerin + Benoît Minisini
  Dim iAllow As Integer = 0
  If Key.Code = Key.Left Then iAllow = 1
  If Key.Code = Key.Right Then iAllow = 1
  If Key.Code = Key.BackSpace Then iAllow = 1 
  If Key.Code = Key.Delete Then iAllow = 1
  If Key.Code = Key.End Then iAllow = 1
  If Key.Code = Key.Home Then iAllow = 1
  If txbInputComplex1.Text And (Key.Code = Key.Enter Or Key.Code = Key.Return) Then iAllow = 1
  If Key.Text And (InStr(sAllowed, Key.Text) > 0) Then iAllow = 1
  If iAllow = 0 Then Stop Event  

The conversion String ” Complex number is carried out with the function ValComplex(sInput As String), which returns a complex number as the function value if sInput can be interpreted as a complex number:

Public Function ValComplex(sInput As String) As Complex
  Dim complexNumber As Complex
  Dim iCount As Integer
  Dim sReal, sImaginary As String
  sInput = Trim(sInput)  
  For iCount = Len(sInput) To 1 Step -1 '-- Inverted iteration
      If (Mid(sInput, iCount, 1) = "+") Or (Mid(sInput, iCount, 1) = "-") Then            
         sReal = Left(sInput, iCount - 1)          
         sImaginary = Mid(sInput, iCount, Len(sInput) - iCount)       
         complexNumber = Complex(Val(sReal), Val(sImaginary))        
         Return complexNumber

With the two functions presented, you can check whether a character string read in formally represents a complex number a+bi and then convert the valid character string into a complex number and save it in a suitable variable as required. Example 3 - Calculating with complex numbers


Figure Test program for calculating with complex numbers

The following source code excerpt shows you the use of the two functions IsComplex(..) and ValComplex(..) in two variants:

Public Sub btnConvert_Click()  
  If txbInputComplex1.Text Then 
     If IsComplex(txbInputComplex1.Text) = True Then
        txbOutputComplex.Text = ValComplex(txbInputComplex1.Text).ToString(True)
        Message.Error("The input string cannot be interpreted as a complex number!")

Here is a variant of the above source code snippet in which the IsComplex(..) function is not used. Instead, the Try statement from the Gambas error management is used to catch errors. This is certain to occur if the input string cannot be interpreted as a complex number:

Public Sub btnConvert_Click()  
  If txbInputComplex1.Text Then 
     Try txbOutputComplex.Text = ValComplex(txbInputComplex1.Text).ToString(True)
         If Error Then
            Message.Error("The input string cannot be interpreted as a complex number!")

The complete project 'Complex' can be found in the following download area.


Chapter & Projects


The website uses a temporary session cookie. This technically necessary cookie is deleted when the browser is closed. You can find information on cookies in our privacy policy.
k29/k29.1/start.txt · Last modified: 17.02.2024 by emma

Page Tools