diszkrét matematika 5. eloadásmgyongyi/diszkretmat/5_szamtart.pdfdiszkrét matematika 5. el®adás...

Diszkrét matematika5. el®adás

MÁRTON Gyöngyvé[email protected]

Sapientia Egyetem,Matematika-Informatika TanszékMarosvásárhely, Románia

2020, ®szi félév

MÁRTON Gyöngyvér 2020, Diszkrét matematika

Mir®l volt szó az elmúlt el®adáson?

állománykezelés, bevezet® fogalmak

számtartományok: racionális számok

racionális számok irreducibilis alakja

legnagyobb közös osztó algoritmusa - iteratív, rekurzív változatok

racionális számok sorozatba rendezése - két módszer


Mir®l lesz szó?

Python alapfogalmak: függvények, paraméterátadás, a decimal modul

lánctörtek: a racionális számok lánctört jegyei

számtartományok: irracionális számok

"híresebb" irracionális számok (√2, π, e, φ) értéke

számtartományok: valós számok

a sin, log függvények, a k-ik gyök meghatározása

számtartományok: komplex számok

másodfokú egyenlet komplex gyökei

m¶veletek komplex számokkal: szorzat, hatványozás, stb

fraktálok: Mandelbrot, Julia


Függvények, paraméterátadás Pythonban

def foF1():

db = 0

segedF1(db)

print (db)

def segedF1(x):

x += 10

>>> foF1()

0

A foF1 függvényben nem látjuk, hogy a segedF1 függvényben megváltoztattuka paraméter értékét.


Függvények, paraméterátadás Pythonban

def foF2():

db = 0

db = segedF2(db)

print (db)

def segedF2(x):

x += 10

return x

>>> foF2()

10

A foF2 függvényben látjuk, hogy a segedF2 függvényben megváltoztattuk aparaméter értékét.


Lánctörtek (Continued fraction)

A lánctört egy emeletes tört, amely kétféle alakban is megadható, ahol a kétalak átalakítható egymásba:

a0 +b1

a1 +b2

a2 +b3

a3 +b4

. . .

d0 +1

d1 +1

d2 +1

d3 +1

. . .

A második alakot egyszer¶ lánctörtnek, a [d0, d1, d2, d3, . . . ] számsorozatot,pedig a lánctört jegyeinek hívjuk.

Ha a [d0, d1, d2, d3, . . . ] számsorozat véges számú elemet tartalmaz, akkorvéges lánctörtr®l beszélünk.

A racionális számok mindegyike felírható egyszer¶, véges lánctört alakba.


Lánctörtek, példa

Ha meg akarjuk határozni azx

yracionális szám lánctörtjét, akkor

meghatározzuk az x és y osztási egészrészét (//), illetve osztási maradékát (%),felülírjuk az x értékét y-al és az y értékét az osztási maradékkal, majdismételjük a m¶veletsort, amíg az x és y osztási maradéka nem lesz 0.

Az algoritmus a legnagyobb közös osztó algoritmusának gondolatmenetétköveti, amelynek során eltároljuk az osztási egészrészeket, ezek fogják képeznia lánctörtjegyeket.

Példa,6147

lánctört jegyeinek a meghatározása:

x y x//y x%y

61 47 1 1447 14 3 514 5 2 45 4 1 14 1 4 0



6147

= 1+1

3+1

2+1

1+1

4

6147

= 1+1

3+1

2+1

1+1

3+1

16147

lánctört jegyei: [1, 3, 2, 1, 4], vagy

6147

lánctört jegyei: [1, 3, 2, 1, 3, 1]

6147

tizedes alakja: 1.(2978723404255319148936170212765957446808510638)

Ha a lánctört utolsó jegye nem 1, akkor ez az x érték helyettesíthet® kéttovábbi értékkel: x − 1, 1. A két alak ekvivalens.



Alakítsuk át4111

-t lánctörtté, hat. meg a lánctört jegyeket, és a tizedes alakot:

4111

= 3+1

1+1

2+1

1+1

2

4111

= 3+1

1+1

2+1

1+1

1+1

14111

lánctört jegyei: [3, 1, 2, 1, 2], vagy

4111

lánctört jegyei: [3, 1, 2, 1, 1, 1]

4111

tizedes alakja: 3.(72)


Algoritmusok Pythonban

1. feladat

Határozzuk meg az xyracionális szám tizedes alakját és lánctört jegyeit.

def lanct(x, y):

tAlak = x / y

L = []

while True:

temp = x // y

L += [temp]

r = x % y

if r == 0: break

x = y

y = r

return (tAlak, L)

>>> lanct(41, 11)

(3.727272727272727, [3, 1, 2, 1, 2])

>>> lanct(89, 55)

(1.6181818181818182, [1, 1, 1, 1, 1, 1, 1, 1, 2])



Átírjuk a maradékos osztást:

def lanct1(x, y):

tAlak = x / y

L = []

while True:

temp = x // y

L += [temp]

r = x - temp * y

if r == 0: break

x = y

y = r

return (tAlak, L)

>>> lanct(61, 47)

(1.297872340425532, [1, 3, 2, 1, 4])



Ellen®rz® m¶veleteket vezetünk be:

def lanct2(x, y):

if not float(x).is_integer() or not float(y).is_integer():

print ('a bemenet nem egesz szam')

return

L = []

while True:

temp = x // y

L += [temp]

r = x - temp * y

if r == 0: break

x = y

y = r

return L

>>> lanct2(41, 11.2)

a bemenet nem egesz szam

>>> lanct2(41, 11.0)

[3, 1, 2, 1, 2]


A decimal modul

Próbáljuk ki az alábbi m¶veleteket:

>>> 0.1 + 0.1 - 0.2

0.0

>>> 0.1 + 0.1 + 0.1

0.30000000000000004

>>> 0.1 + 0.1 + 0.1 - 0.3

5.551115123125783e-17

A Python bevezeti a Decimal típust, amely pontosabb számolást tesz lehet®vé,a nem egész számok körében:


A decimal modul

A Decimal típus a decimal modulban van de�niálva, és a felhasználó általóhajtott pontossággal ábrázolja a lebeg®pontos (valós) számokat:

>>> from decimal import Decimal

>>> 1/3

0.3333333333333333

>>> Decimal(1/3)

Decimal('0.333333333333333314829616256247390992939472198486328125')

>>> Decimal('0.3')

Decimal('0.3')

>>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3)

Decimal('2.775557561565156540423631668E-17')

>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')

Decimal('0.0')


A decimal modul

A getcontext.prec() segítségével a tizedes jegyek számát adhatjuk meg.

>>> from decimal import getcontext

>>> x = Decimal(1)

>>> y = Decimal(3)

>>> getcontext().prec = 10

>>> x / y

Decimal('0.3333333333')


>>> x / y

Decimal('0.3333333333333333333333333')

Az int, a float, a string típusokból egyaránt létre lehet hozni Decimaltípusú értéket.


Irracionális számok

halmazjelölés: Q∗,azok a számok, melyek nem írhatóak fel két egész szám hányadosaként,azaz a végtelen, nem szakaszos tizedes törtek,

"híresebb" irracionális számok:√2 = 1.4142 . . . ,

π = 3.1415 . . . ,e = 2.7182 . . . ,

φ =1+√5

2= 1.6118 . . . , az aranyarány.

a számítástechnika az irracionális számok közelített értékét tudja kezelni

az irracionális számok végtelen lánctörtek

lánctörtek segítségével könnyedén meglehet határozni a közelített értéktízedesjegyeit


√n értéke

2. feladat

Határozzuk meg√n értékét lánctörtek segítségével.

A kiinduló képlet a következ®, ahol a értéke egy akármilyen szám lehet:

√n = a+

n − a2

a+√n

ha a = 1, akkor:√n = 1+

n − 1

2+n − 1

2+n − 1

2+n − 1

2+ . . .


√2 értéke

3. feladat

Határozzuk meg√2 értékét lánctörtek segítségével.

√2 = 1+

1

2+1

2+1

2+ . . .

def my_sqrt2_():

temp = 0

for x in range (0, 500):

temp = 1 / (2 + temp)

return 1 + temp

>>> my_sqrt2_()

1.4142135623730951

>>> 2 ** 0.5

1.4142135623730951


√2 értéke

Ha több tizedes jegyet szeretnénk, akkor Decimal típussal kell dolgoznunk,ahol a tizedesjegyek számát a getcontext segítségével adhatjuk meg.

from decimal import Decimal, getcontext

def my_sqrt2(p):

getcontext().prec = p

temp = Decimal(0)

for x in range (0, 500):

temp = 1 / (2 + temp)

return 1 + temp

>>> my_sqrt2(30)

Decimal('1.41421356237309504880168872421')

>>> my_sqrt2(50)

Decimal('1.4142135623730950488016887242096980785696718753769')


A π szám

a kör kerületének és átmér®jének hányadosa az eukleidészi geometriában

más de�níciók is léteznek, melyek kihagyják a kört

irracionális és transzcendens szám (nincs olyan egész együtthatós polinomamelynek gyöke lenne)

A π értékének meghatározására több lánctört-képlet is ismert:

π =4

1+12

3+22

5+32

7+ . . .

π = 3+1

6+32

6+52

6+72

6+ . . .


A π szám

4. feladat

Határozzuk meg π értékét lánctörtek segítségével.

def my_pi(p):

getcontext().prec = p

temp = Decimal(0)

for x in range (1000, 0, -1):

a = x * x

b = 2 * x + 1

temp = a / (b + temp)

return 4 / (1 + temp)

>>> my_pi(100)

Decimal('3.1415926535897932384626433832795028841971693993751058209

74944592307816406286208998628034825342117067')


Az e szám

irracionális és transzcendens szám

többféleképpen lehet értelmezni:

e = limn→∞

(1+

1n

)n

.

e = 2+1

1+1

2+2

3+3

4+ . . .


A ϕ szám, aranymetszés, aranyarány (Golden Ratio)

két mennyiség, a, b, a > b az aranymetszés szerint aránylik egymáshoz, hafennáll:

ϕdef=

a

b=

a+ b

a

a ϕ meghatározása érdekében felírhatjuk:a+ b

a= 1+

1a

b

, azaz fennáll:

ϕ = 1+1ϕ⇔ ϕ2 = ϕ+ 1

megoldva a fenti egyenletet kapjuk, hogy

ϕ =1+√5

2= 1.61803 . . . és ϕ̂ =

1−√5

2= −0.61803 . . .

a ϕ irracionális szám



építészet: Parthenon homlokzatának arányértékei:

logok: Toyota, Mercedesz, stb.

Pentagramma (szabályos ötszög): piroszold

= zoldkek

= keklila

= ϕ

természet: napraforgó spirlajai



Kiindulva a ϕ = 1+1

ϕösszefüggésb®l, a ϕ értékét felírhatjuk a következ®képpen:

ϕ = 1+1

1+1

1+1

1+1

. . .



két egymás utáni Fibonacci szám arányaként is felírhatjuk a ϕ értékét

egy Fibonacci szám a Fibonacci számsorozat egy eleme

a Fibonacci számsorozat: 0, 1, 1, 2, 3, 5, 8, 13..., kiindulva a 0, 1 kezd®értékekb®l,

a következ® elemet az el®z® két elem összegéb®l kapjuk

Az n és m közötti, két egymásutáni Fibonacci számból képzett arányok meghatározása:

def fib_phi(n, m):

f1 = 0

f2 = 1

for i in range(2, m):

f = f1 + f2

if i >= n:

print("{0:4d} {1:5d} {2:5d} {3:10,.6f}".format(i, f, f2, f/f2))

f1 = f2

f2 = f

>>> fib_phi(10, 14)

10 55 34 1.617647

11 89 55 1.618182

12 144 89 1.617978

13 233 144 1.618056


Valós számok

a racionális és irracionális számok halmaza

halmazjelölés: R = Q ∪Q∗

egy szám egyszerre nem lehet racionális és irracionális is

a valós számokhoz hozzárendelhet®, egy mindkét irányban végtelenegyenes egy-egy pontja

kommutatívitás, asszociatívítás, disztributívítás

az egész számokkal ellentétben a valós számok halmaza nemmegszámlálható

a számítástechnikában nem valós mennyiségekkel dolgozunk, ezek egyközelít® értéke lesz eltárolva: lebeg®pontos ábrázolás


A sin(z) értéke

5. feladat

Határozzuk meg sin(z) értékét lánctörtek segítségével.

sin(z) =z

1+z2

2 · 3− z2 +2 · 3 · z2

4 · 5− z2 +4 · 5 · z2

6 · 7− z2 + . . .

def my_sin_(z):

getcontext().prec = 50

temp = Decimal(0)

for x in range (1000, 0, -2):

a = (x+2) * (x+3) - z*z

b = x * (x+1) * z * z

temp = b / (a + temp)

temp = z*z / (2*3-z*z + temp)

return z / (1 + temp)


A sin(z) értéke

>>> my_sin_(60)

Decimal('-0.30481062110221670562576204186131345751440565822218')

>>> import math

>>> math.sin(60)

-0.3048106211022167

>>> math.sqrt(3)/2

0.8660254037844386

Mi a probléma? Miért nem a helyes eredményt kapjuk?

>>> math.sin(60 * math.pi/180)

0.8660254037844386

>>> math.sin(math.radians(60))

0.8660254037844386

A paraméterként megadott értéket át kell alakítani radiánba:

>>> my_sin_(Decimal(math.radians(60)))

Decimal('0.86602540378443858934550903079182617193526553351420')


A sin(z) értéke

az átalakított kódsor:

from math import radians, pi

def my_sin(z):


#z = Decimal(z * pi/180)

z = Decimal(radians(z))

temp = Decimal(0)

for x in range (1000, 0, -2):

a = (x + 2) * (x + 3) - z * z

b = x * (x + 1) * z * z


temp = z * z / (2 * 3 - z * z + temp)


>>> my_sin(60)

Decimal('0.86602540378443858934550903079182617193526553351420')


Az ln(z) értéke

6. feladat

Határozzuk meg ln(z) értékét lánctörtek segítségével.

ln(1+ z) =z

1+12 · z

2+12 · z

3+22 · z

4+22 · z

5+32 · z6+ . . .

def my_ln(z):

z -= 1


temp = Decimal(0)

for x in range (1000, 0, -1):

t = (x + 1) // 2

a = x + 1

b = t * t * z



>>> my_ln(2)

Decimal('0.69314718055994530941723212145817656807550013436025')

>>> from math import log, e

>>> log(2, e)

0.6931471805599453


Az ln(z) értéke

A ln(z) értékének meghatározásához használhatóak a következ® összefüggésekis

ln (z) = (z − 1)− (z − 1)2

2+

(z − 1)3

3− (z − 1)4

4· · · =

∞∑n=1

(−1)n+1

n(z − 1)n

ln (z) = limn→∞

n · (z1/n − 1)

def my_ln_(z):


n = 10 ** 40

exp = Decimal(1) / n

return n * ( (z ** exp) - 1)

>>> my_ln_(2)

Decimal('0.693147180559945309400000000000000000000000000000000000000')


A√n értéke Newton féle módszerrel

7. feladat

Határozzuk meg√n értékét a Newton féle módszerrel.

x0 = 1

xi+1 =12·(xi +

n

xi

)from decimal import Decimal, getcontext

def my_sqrt_(n):


n = Decimal(n)

x0 = 1

while True:

xi = (x0 + n/x0) / 2

if xi == x0: return xi

x0 = xi


A k√n értéke Newton féle módszerrel

Általános esetben a k√n értéke:

xi+1 =1k

[(k − 1) · xi +

n

xk−1i

], ahol x0 = 1.

ha k = 2, akkor a négyzetgyök meghatározásának képletét kapjuk:

xi+1 =12·(xi +

n

xi

)a beépített ∗∗ operátorral is dolgozhatunk:

>>> 10 ** 0.5

3.1622776601683795

>>> from decimal import Decimal, getcontext


>>> 10 ** Decimal('0.5')

Decimal('3.16227766016837933199889354443271853371955513932521682685...')


Komplex számok

A komplex számok a valós számhalmaz egy olyan b®vítése, melyben negatív számok

esetén is értelmezett a gyökvonás, halmazjelölés: C.

három modell alapján is értelmezhet®: halmazelméleti, geometriai, algebrai

modell alapján

halmazelméleti modell: C = {(a, b)|a ∈ R, b ∈ R} , azaz a számhalmazt

rendezett számpárok alkotják, ahol az elemek valós számok,

imaginárius rész: az a komplex szám amelynek négyzete -1, jele az i

a komplex számok a+ b · i alakban írhatóak fel, ahol a valós rész, b imaginárius

egység

ha b = 0, akkor valós számot kapunk

a valós számok körében megismert m¶veleti tulajdonságok megmaradnak

additív semleges elem: z = 0+ 0 · imultiplikatív semleges elem: z = 1+ 0 · iadditív inverz elem: −z = −a− b · i ,multiplikatív inverz elem: 1/z = a/(a2 + b2)− b/(a2 + b2) · i , z 6= 0


M¶veletek komplex számokkal

M¶veleti szabályok:

a = a1 + a2 · iabs(a) =

√a21 + a22, a komplex szám "nagysága"

b = b1 + b2 · ia+ b = (a1 + b1) + (a2 + b2) · ia− b = (a1 − b1) + (a2 − b2) · ia · b = (a1 · b1 − a2 · b2) + (a2 · b1 + a1 · b2) · i

1b

=b1

(b21 + b22)− b2

(b21 + b22)· i

a

b= a · 1

b


Komplex számok Pythonban

>>> a = complex(2, 4)

>>> a.imag

4.0

>>> a.real

2.0

>>> abs(a)

4.47213595499958

>>> b = complex(1,10)

>>> a + b

(3 + 14j)

>>> a - b

(1 - 6j)

>>> a * b

(-38 + 24j)

>>> a / b

(0.4158415841584159 - 0.15841584158415842j)



8. feladat

Határozzuk meg egy másodfokú egyenlet gyökeit.

import math

def megyenlet2 (a, b, c):

if a == 0: return egyenlet(b, c)

delta = b*b - 4*a*c

if delta < 0:

valosR = -b / (2*a)

imagR = math.sqrt( abs (delta)) / (2 * a)

gy1 = complex(valosR, imagR)

gy2 = complex(valosR, -imagR)

return (gy1, gy2)

if delta == 0:

gy = -b/(2*a)

return (gy, gy)

if delta > 0:

gy1 = (-b + math.sqrt(delta)) / (2*a)

gy2 = (-b - math.sqrt(delta)) / (2*a)

return ( gy1, gy2 )


Két komplex szám szorzata

9. feladat

Határozzuk meg az a = a1 + a2i és b = b1 + b2i komplex számok szorzatát,

ahol alkalmazzuk, hogy a · b = (a1 · b1 − a2 · b2) + (a2 · b1 + a1 · b2)i

def szorzatC(a, b):

a1, a2 = a

b1, b2 = b

vResz = a1 * b1 - a2 * b2

iResz = a2 * b1 + a1 * b2

return (vResz, iResz)

>>> szorzatC((2.5, 5.4), (3.34, 101.5))

(-539.75, 271.786)

>>> a = complex(2.5, 5.4)

>>> b = complex(3.34, 101.5)

>>> a * b

(-539.75+271.786j)


Komplex számok hatványozása

10. feladat

Határozzuk meg an-t, ahol a = (a1, a2) az a1 + a2i komplex szám; alkalmazzuk

a gyorshatványozás algoritmusát.

def my_powC (a, n):

res = (1, 0)

while True:

if n % 2 == 1:

res = szorzatC(res, a)

if n == 1: break

a = szorzatC(a, a)

n = n // 2

return res

>>> my_powC((2.5, 5.4), 3)

(-203.07500000000002, -56.21400000000003)

>>> a = complex(2.5, 5.4)

>>> pow(a, 3)

(-203.07500000000002-56.21400000000003j)


Mandelbrot fraktál

Fraktálok: kiindulva egy komplex számból, egy iterációs folyamateredményeként a képerny®re kirajzolt pontok fraktál alakzatokathozhatnak létre

minél nagyobb az iteráció szám, annál jobb a kirajzolt kép min®sége

a Mandelbrot halmaz iterációs képlete:

z0 = czn+1 = (zn)

2 + c,

ahol a c komplex szám értékét a programozó állítja be

a Mandelbrot halmaz azokat a c komplex számokat fogja tartalmazni,amelyekre a zn sorozat nem tart a végtelenbe,

a zn sorozat nem tart a végtelenbe, ha az abszolútértéke kisebb vagyegyenl® lesz mint 2.



11. feladat

Határozzuk meg a Mandelbrot halmaz elemeit, azaz egy halmazbeli elem esetén

rajzoljunk #-t a képerny®re, másképp space-t.

def fMan():

L1 = [a*0.07 for a in range (-15, 16)]

L2 = [a*0.04 for a in range (-50, 26)]

for y in L1:

L = ""

for x in L2:

c = complex(x, y)

z = c

for i in range (40):

z = z ** 2 + c

if abs(z) > 2:

L += " "

break

if abs(z) <= 2: L += "#"

print (L)


Julia fraktál

12. feladat

Határozzuk meg a Julia halmaz elemeit.

A Julia halmaz iterációs képlete ugyanaz, mint a Mandelbrot halmazé, azzal akülönbséggel, hogy a c értéke itt konstans, legyen c = −1− 0.25i .def fJulia():

L1 = [a*0.07 for a in range (-15, 16)]

L2 = [a*0.04 for a in range (-40, 36)]

c = complex (-1, -0.25)

for y in L1:

L = ""

for x in L2:

z = complex(x, y)

for i in range (40):

z = z ** 2 + c

if abs(z) > 2:

L += " "

break

if abs(z) <= 2: L += "#"

print (L)


Megjegyzések

az L1, L2 intervallumokat módosíthatjuk, a kirajzolt alakzat nagyobb lesz:

L1 = [a*0.05 for a in range (-20, 21)]

L2 = [a*0.02 for a in range (-80, 31)]

a gra�kus megjelenítéshez használjuk a pygmae csomagot (lehet mást is):http://www.pygame.org/download.shtml

a gra�kus megjelenítés forrása:http://fractalart.gallery/mandelbrot-set-in-python-pygame


Mandelbrot fraktál, gra�kus megjelenítés

from pygame.locals import *

import pygame

def mainMa():

width, height = 600, 600

screen = pygame.display.set_mode((width,height),DOUBLEBUF)

xaxis = width / 1.5

yaxis = height / 2

scale = 190

iterations = 40

for iy in range(height):

for ix in range(width):

c = complex((ix - xaxis)/scale, (iy - yaxis)/scale)

z = c


Mandelbrot fraktál, gra�kus megjelenítés

for i in range(iterations):

z = z**2 + c

if abs(z) > 2:

color = (255, 255, 255)

break #end for

if abs(z) <= 2:

color = (0, 0, 0)

screen.set_at((ix, iy), color)

screen.set_at((ix, height - iy), color) #end for, for

pygame.display.update()

while True:

event = pygame.event.poll()

if (event.type == QUIT or

(event.type == KEYDOWN and event.key == K_ESCAPE)):

break #end def

mainMa()

pygame.quit()


Mandelbrot fraktál


Julia fraktál, gra�kus megjelenítés

from pygame.locals import *

import pygame

def mainJu():

width, height = 600, 600

screen = pygame.display.set_mode((width,height),DOUBLEBUF)

xaxis = width / 2

yaxis = height / 2

scale = 170

iterations = 40

c = complex (0, -0.8)

for iy in range(height):

for ix in range(width):

z = complex((ix - xaxis)/scale, (iy - yaxis)/scale)

for i in range(iterations):

z = z**2 + c

if abs(z) > 2.0:

color = (i%16, i%16*8, i%16*16)

break #end for


Julia fraktál, gra�kus megjelenítés

if abs(z) <= 2:

color = (0, 0, 0)

screen.set_at((ix, iy), color)

screen.set_at((width, height), color) #end for, for

pygame.display.update()

while True:

event = pygame.event.poll()

if (event.type == QUIT or

(event.type == KEYDOWN and event.key == K_ESCAPE)):

break #end def

mainJu()

pygame.quit()


Julia fraktál

c = complex (0, -0.8)

if abs(z) > 2.0:

color = (i%16, i%16*8, i%16*16)

break

if abs(z) <= 2:

color = (0, 0, 0)


Julia fraktál

c = complex (-0.824, -0.17711)

if abs(z) > 2.0:

v = 765*i /40

if v > 510:

color = (255, 255, v%255)

elif v > 255:

color = (255, v%255, 0)

else:

color = (v%255, 0, 0)

if abs(z) <= 2:

color = (0, 0, 0)


Julia fraktál

További c értékek a Julia fraktálhoz:

c = complex (0.285, 0.013)c = complex (-0.295, -0.55)c = complex (-0.63, -0.407)c = complex (-0.624, 0.435)c = complex (-1, -0.25)c = complex (-1, -0)


diszkrét matematika 5. eloadásmgyongyi/diszkretmat/5_szamtart.pdfdiszkrét matematika 5. el®adás...

Documents