Egyéb matematikai műveletek

Megismerkedtünk már néhány művelettel számokon. Ezek a következők voltak:

float number1 = 12, number2 = 5;
         
float summa = number1 + number2;          // Összeadás  (12 + 5 = 17)
float difference = number1 - number2;     // Kivonás    (12 - 5 = 7)
float product = number1 * number2;        // Szorzás    (12 * 5 = 60)
float quotient = number1 / number2;       // Osztás     (12 / 5 = 2.4)
float modulo = number1 % number2;         // Maradék    (12 % 5 = 2)

Ezen műveleteket úgynevezett operátorok segítségével végeztük el. A fenti esetben minden operátornak van kettő bemenete (operandusok) és egy kimenete (visszatérés).

Ez azt jelenti, hogy gondolhatunk egy műveletre, mint egy gépre, amibe nem látunk bele. Pár értéket bedobunk és valami logika alapján kiköp magából egy újabb értéket.

Fontos , hogy a bemenetek típusa definiálta milyen lesz a kimenet típusa, sőt volt olyan eset is, mikor magát az elvégzendő műveltet is. Gondoljunk csak a plusz (+) operátorra, ami más-más műveletet hajtott végre attól függően, hogy milyen típusú operandusai voltak:

int + int → int (összeadás)

float + float → float (összeadás)

int + float → float (összeadás)

string + string → string (összefűzés)

string + int → string (összefűzés)

Még sok minden mást is végre lehet hajtania számokon, ám a fent felsorolt műveletek azok, amik a lehető leggyorsabban elvégezhetők bármilyen hardveren.

Annyira alapvető műveletek ezek, hogy a C# nyelv egyszerű és könnyen olvasható leírási módot kínál arra, hogy végrehajtjuk őket. Ezeket ismertük eddig meg.

A többi művelet egy kicsikét máshogy fog kinézni, ezeket úgy nevezett függvények segítségével fogjuk elvégezni. A programozási függvény fogalom nagyon szoros összefüggésben van, a matematikából megszokott függvénnyel: Bizonyos bemenetek alapján visszaad egy kimenetet. Általánosan itt fogunk tanulni ezen függvényekről: Metódusok, függvények. Most azonban nézzük meg a legfontosabb már előre elkészített matematikai függvényeket.

Az abszolút érték és előjel függvény

Vegyük a következő kódot:

int   abs1 = Math.Abs(-13);       // Abszolút érték (13)
float abs2 = Math.Abs(-15.5f);    // Abszolút érték (15.5f)

Ez a művelet egy szám abszolútértékét fogja kiszámolni.

Absolute value / Abszolútérték

Az abszolútérték egy szám nullától való távolsága a számegyenesen. Ezt kicsit pongyolábban úgy is leírhatjuk, hogy minden pozitív számnak az abszolútértéke önmaga és minden negatív számnak az abszolútértékét úgy kapjuk meg, hogy elhagyjuk a minusz jelet.

A Math egy osztály, ami sok matematikai függvényt tartalmaz. (Az osztályról később bővebben)

A Math -on belüli különböző függvényeket a pont (.)operátorral érjük el. Ha a Visual Studio-ban vagy bármi más IDE-ben egyszerűen leírjuk a Math osztálynevet és egy . operátort, akkor a kódszerkesztő felajánlja a lehetséges függvényeket, amiket használhatunk.

Egy függvénynek van…

• meghatározott számú és típusú bemenete és
• pontosan egy darab meghatározott típusú kimenete.

A bemeneteket mindig a függvény neve után zárójelben kell megadni.

Az abszolútérték például egy olyan függvény ami pontosan 1 darab bemenettel rendelkezik. Több verziója is létezik az Abs-nak és a bemenet típusától függő, hogy melyik fut le.

int   abs1 = Math.Abs(-13);       // Bemenet típusa: int     Kimenet típusa: int
float abs2 = Math.Abs(-15.5f);    // Bemenet típusa: float   Kimenet típusa: float

Az előjel művelet vagy Sign függvény mindig 1-es vagy -1-es értékkel tér vissza attól függően, hogy a bemenete pozitív vagy negatív szám volt.

Nézzük meg a következő két műveletet:

Az abszolútérték függvénynek is van int és float változata is, ahol a kimenet típusa megegyezik a bemenetével.

Figyeljük meg, hogy egy szám abszolútértékét és előjel értékét szorozva megkapjuk az eredeti számot.

float f; 
... // Valami értéket kap f
float f2 = Math.Abs(f) * Math.Sign(f);

// f bizotsab egyenlő f2-vel

Most nézzünk meg egy pár egyéb matematikai függvényt a Math osztályból.

Kerekítő függvények

Math.Round(1.45f);       // Egészre kerekít. A visszatérés (kimenet) típusa flota.
Math.Ceiling(1.13);      // Felfelé kerekít egészre
Math.Floor(77.99);       // Lefelé kerekít egészre

// Ezek a műveletek csak double  (64 bites floating point) típuson működnek.

Hatványozás és gyökvonás

Math.Pow(4, 3);  // Hatványozás függvény.   Eredmény: 4 a 3-dikon = 4 * 4 * 4 = 64
Math.Sqrt(16);   // Négyzetgyök függvény.   Eredmény: 4

A Hatványozás (Pow - Power) függvénynek float alapot és kitevőt is meg lehet adni:

Math.Pow(1.1f, 3.4f);  // Hatványozás függvény.

Ha nem négyzetgyököt, hanem egyéb gyököt szeretnél számítani felhasználhatod a következő matematikai azonosságot:

Ebből kiindulva így vonhatunk (nem csak négyzet gyököt) gyököt:

Math.Pow(a, 1f/b);  // Az eredmény: b-edik gyöke a-nak.

// Például:
Math.Pow(25, 1f/2);  // Az eredmény: 5  (25 négyzetgyöke)   (5 * 5 = 25)
Math.Pow(27, 1f/3);  // Az eredmény: 3  (27 köbgyöke)       (3 * 3 * 3 = 27)
Math.Pow(16, 1f/4);  // Az eredmény: 2  (16 negyedik gyöke) (2 * 2 * 2 * 2 = 16)

Erre amúgy igen ritkán van szükség. A négyzetgyök általában elég.

Minimum és maximum keresés

Ennél sokkal több függvény van a Math osztályban, nyugodtan nézz utána, mik ezek!