Komplex számok a programozásban

Láttuk, hogy a komplex számok RLC körök váltakozóáramú viselkedésének leírásánál fontos szerephez jutnak. Jelen szócikk azt vizsgálja, mely programnyelveken hogyan lehet komplex számokkal számításokat csinálni.

C

Nyelvi szinten a c99 szabványtól támogatva van.

<source lang="C">

1. include <stdio.h>
2. include <complex.h>

void kiir(const char *s, float complex a) {

   printf("%s: %f + %fj\n", s, creal(a), cimag(a) );

}

int main() {

   float complex a, b;

   a = 5 + 3i; // de akár 5 + 3j vagy 5 + 3*I alakban is megadható.
   b = 3 + 2i;

   // creal(a), cimag(a) - lásd kiír függvényben.

   kiir("a: ", a);
   kiir("b: ", b);

   // vektorhossz; cabs: double, cabsf: float, cabsl: long double
   printf("cabs(a): %f\n", cabs(a) );
   // fázis; carg: double, cargf: float, cargl: long double
   printf("carg(a): %f\n", carg(a) ); // radiánban

   kiir("a+b: ", a + b);
   kiir("a*b: ", a * b);
   kiir("a/b: ", a / b);

   return 0;

} </source>

Ha régebbi, például ansi C-t vagy C90 szabványt ismerő fordító esetén a nyelvi támogatás hiányában például az alábbi komplex számokat kezelő függvényekkel tudunk számolni:

<source lang="c">

1. include <math.h>

typedef struct _complex {

   float real;
   float imag;

} Complex;

Complex cadd(Complex a, Complex b) {

   Complex res;
   res.real = a.real + b.real;
   res.imag = a.imag + b.imag;
   return res;

}

Complex cmul(Complex a, Complex b) {

   Complex res;
   res.real = a.real * b.real - a.imag * b.imag;
   res.imag = a.real * b.imag + b.real * a.imag;
   return res;

}

// (a.real + a.imag) / (b.real + b.imag) // ---> szorozzuk a nevező konjugáltjával, azaz (b.real - b.imag) értékkel Complex cdiv(Complex a, Complex b) {

   Complex res, tmp;
   tmp.real = b.real * b.real + b.imag * b.imag; // keresztszorzatok kiesnek
   res.real = (a.real * b.real + a.imag * b.imag)/tmp.real;
   res.imag = (a.imag * b.real - a.real * b.imag)/tmp.real;
   return res;

}

float magnitude(Complex a) {

   return sqrt(a.real*a.real + a.imag * a.imag);

}

float phase(Complex a) {

   return atan2(a.imag, a.real);

} </source>

C#

A C# nagyrészben támogatja a komplex aritmetikát. Sajnos inicializáláskor az a = 5 + 3i formátumot nem fogadja el, így kizárólag konstruktorhívással lehet változót deklarálni.

apt-get install libmono-system-numerics4.0-cil
mcs -r:System.Numerics complex_teszt.cs

<source lang="csharp"> using System; using System.Numerics;

public class Example {

  public static void Main() {
     Complex a = new Complex(5, 3);
     Complex b = new Complex(3, 2);
     Complex r;

     Console.WriteLine(a.ToString());
     Console.WriteLine(b.ToString());

     Console.WriteLine(a.Real);
     Console.WriteLine(a.Imaginary);

     Console.WriteLine(Complex.Abs(a));
     Console.WriteLine(a.Magnitude); // Abs másképpen
     Console.WriteLine(a.Phase);

     r = a + b;
     Console.WriteLine(r.ToString());

     r = a * b;
     Console.WriteLine(r.ToString());

     r = a / b;
     Console.WriteLine(r.ToString());
  }

} </source>

Go

Szintén nyelvi elemekkel támogatja a komplex számokat.

<source lang="go"> package main

import "fmt" import "math/cmplx"

func main() {

   var a = 5 + 3i;
   var b = 3 + 2i;

   fmt.Printf("a.re: %v\n", real(a));
   fmt.Printf("a.im: %v\n", imag(a));

   fmt.Printf("a: %v\n", a);
   fmt.Printf("b: %v\n", b);

   fmt.Printf("Magnit: %v\n", cmplx.Abs(a));
   fmt.Printf("Phase: %v\n", cmplx.Phase(a));
   var magnit, phase = cmplx.Polar(a)
   fmt.Printf("Polar: %v %v\n", magnit, phase);

   fmt.Printf("a+b: %v\n", a+b);
   fmt.Printf("a*b: %v\n", a*b);
   fmt.Printf("a/b: %v\n", a/b);

} </source>

Java

Nyelvi elemként nem ismeri a komplex számokat, azonban számtalan komplex függvényeket tartalmazó osztály letölthető hozzá.

Javascript

Nyelvi elemként nem támogatja, azonban a komplex számokat kezelő függvénygyűjtemény itt található rá: http://mathjs.org/

Példa: http://mathjs.org/examples/complex_numbers.js.html

Lua

Nyelvi elemei nincsenek rá, komplex aritmetikát támogató függvény gyűjteményt innen lehet letölteni: http://lua-users.org/wiki/ComplexNumbers

Octave

Az Octave egy matematikai program, jól szkriptelhető, egyszerű a nyelvezete. Műszaki számításokra kifejezetten alkalmas. Amennyiben ;-vel zárjuk a sort, akkor annak a sornak az eredménye nem kerül ki a képernyőre.

A komplex számok nyelvi szinten vannak támogatva.

<source lang="octave">

1. !/usr/bin/octave

a = 5 + 3i b = 3 + 2i

disp "a: Real, imag:" re = real(a) im = imag(a)

disp "a: magnit, phase:" magnit = abs(a) phase = arg(a)

disp "a+b, a*b, a/b:" plusz = a+b szor = a*b per = a/b </source>

Perl

A PERL szintén nyelvi elemekkel segíti a komplex számokkal való számolást.

<source lang="perl">

1. !/usr/bin/perl

use Math::Complex;

$a = 5 + 3*i; $b = 3 + 2*i;

print Re($a), "\n"; print Im($a), "\n";

print $a, "\n"; print $b, "\n";

print abs($a), "\n"; print atan2(Im($a), Re($a)), "\n";

print $a+$b, "\n"; print $a*$b, "\n"; print $a/$b, "\n"; </source>

PHP

Alapból nincs támogatva, azonban a feltelepíthető a Complex csomag (jelenleg béta). Sajnos ezzel sem olyan kényelmes a komplex számokkal való számolás. Szerencsés lenne itt is nyelvi elemként beintegrálni.

pear install Math_Complex
# illetve ha nem települ fel, akkor:
pear install Math_Complex channel://pear.php.net/Math_Complex-0.8.6

Példa: https://github.com/pear/Math_Complex/blob/master/docs/examples/using_complexop.php

Próbáim során a ComplexOp problémás volt, így a Complex lett csak behívva, amiben még nincs összeadás, szorzás, osztás.

<source lang="php"> <?php require_once 'Math/Complex.php';

$a = new Math_Complex(5, 3); // a = 5 + 3j $b = new Math_Complex(3, 2); // b = 3 + 2j

echo "a: ", $a->toString(), "\n"; echo "b: ", $b->toString(), "\n";

echo "real(a): ", $a->getReal(), "\n"; echo "imag(a): ", $a->getIm(), "\n";

echo "magnit: ", $a->abs(), "\n"; echo "phase: ", $a->angle(), "\n";

// alábbi nekem a ComplexOp modul hibájával elszállt require_once 'Math/ComplexOp.php';

$r = Math_ComplexOp::add($a. $b); echo "a+b: ", $r->toString(), "\n";

$r = Math_ComplexOp::mult($a. $b); echo "a*b: ", $r->toString(), "\n";

$r = Math_ComplexOp::div($a. $b); echo "a/b: ", $r->toString(), "\n"; ?> </source>

Python

A komplex számok nyelvi szinten támogatva vannak.

<source lang="python">

1. !/usr/bin/python

import cmath

a = 5 + 3j b = 3 + 2j

print "real(a): ", a.real print "imag(a): ", a.imag

print "a:", a print "b:", b

print "abs:", abs(a) print "phase:", cmath.phase(a) print "polar:", cmath.polar(a)

print "a+b:", a+b print "a*b:", a*b print "a/b:", a/b </source>

Ruby

A Ruby szintén nyelvi szinten támogatja a komplex számokkal való műveleteket.

<source lang="ruby">

1. !/usr/bin/ruby

a = 5 + 3i b = 3 + 2i

print a.real print a.imag

print a print b

print a.abs() print a.phase() print a.polar()

print a+b print a*b print a/b </source>