A GNU Octave programozási nyelv

Adattípusok

Az Octave minden verziójában vannak beépített típusok, mint a valós és komplex számok, mátrixok, karakter stringek és adatstruktúrák. Ugyanakkor új speciális adattípusokat is definiálhatunk rövid C++ kódok segítségével. Egyes rendszereken az Octave futása közben dinamikusan is lehet új adattípusokat betölteni, anélkül, hogy újra kellene fordítani az Octave-ot. Ez a mechanizmus egyenlõre nem dokumentált; az Octave `src` könyvtárában található `ov.h` és `ops.h` alapján írhatunk új adattípusokat.

Octave-ban nem kell megadni a változók típusát, azok típusát a program futása során, a nekik megfeleltetett konstans objektum típusa határozza meg. Egy programon belül ugyanaz a változó (ugyanolyan nevû) akár többféle típusú is lehet, mindig az utolsó neki megfeleltetett érték (konstans objektum) típusa határozza meg az aktuális típusát.

Beépített függvény: typeinfo (kifejezés)
A kifejezés típusának nevét adja vissza, stringként. Ha a kifejezést elhagyjuk, a felhasználható adattípusok listáját kapjuk meg, string-tömbként.

Beépített adattípusok

Numerikus objektumok

A beépített numerikus objektumok a valós és komplex számok, valamint a mátrixok. Minden beépített numerikus adattípus kétszeres pontosságú számként van eltárolva. Azon rendszereken, amelyek az IEEE lebegõpontos formátumot használják, kb. 2.2251e-308 és 1.7977e+308 közötti értékek tárolhatóak, a relatív pontosság körülbelül 2.2204e-16. A mátrix objektumok bármekkora méretûek lehetnek és dinamikusan átméretezhetõek.

1.1 Egyszerû numerikus típusok

Egy numerikus konstans legegyszerûbb formája a skalár — egy szám, amely lehet egész, tizedes tört, exponenciális alakban írt szám vagy komplex szám. Példa numerikus konstansokra, amelyeknek ugyanaz az érteke:

105 1.05e+2 1050e-1

Egy komplex konstans specifikációja lehet (mind ekvivalensek):

3+4i 3.0+4.0i 0.3e1+40e-1i

Az imaginárius rész esetében a szám és az i betû között nem lehet szóköz, különben a fordító hibát jelez. Az i helyett használható a vele ekvivalens j, I, valamint J jelölés is.

1.2 Mátrixok

Mátrixokat nagyon egyszerûen lehet definiálni az Octave-ban, a rendszer automatikusan eldönti a mátrix méretét (a sorokat pontosvesszõvel kell lezárni), így ezt nem kell explicit megadni. Például az a=[1, 2; 3, 4] kifejezés a következõ mátrixot eredményezi:

a = [ 1 2 3 4 ]

A mátrixok elemei tetszõleges kifejezések lehetnek, feltéve, hogy az egyes részek kiértékelése után a dimenziónak értelme van. Például a feljebb definiált mátrixra, a b=[a, a] kifejezés a következõ mátrixot eredményezi:

b = [ 1 2 1 2 3 4 3 4 ]

A c=[a,1] kifejezésre viszont hibaüzenetet kapunk.

Egy mátrix kifejezést határoló szögletes zárójeleken belül a szövegkörnyezettõl függõen kerül meghatározásra, hogy a szóköz és újsor karakterek elhagyhatóak, vagy az elemeket és sorokat elválasztó jelekként kell kezelni õket. Pl. ez a kifejezés helyes:

a = [ 1 2 3 4 ]

Az ilyen használat azonban lehetséges hibaforrásként is szolgál, például az [ 1 - 1 ] kifejezésben a `-` jel bináris operátort jelent, a kifejezés értéke 0, viszont az [ 1 -1 ] megadásban a `-` jel unáris operátorként szolgál, és az eredmény egy [ 1, -1 ] vektor lesz.

Hasonlóan, a [ sin (pi) ] a kiértékeléskor [ sin, (pi) ]-t ad, amire a sinus függvény paraméter nélküli hívása miatti hibát kapunk. Ez kivédhetõ, ha nem írunk szóközt, vagy a kérdéses kifejezést zárójelbe tesszük.

A transzponálást jelentõ aposztróf karakter szintén okozhat nem várt hibát; legyen a=1. Ekkor az [ 1 a' ] kifejezés helyes, azonban az [ 1 a ' ] kifejezésre hiba keletkezik, hiszen ha nem így lenne, akkor nem lehetne értelmezni az [ a 'valami' ] kifejezést. Az egyértelmûség miatt ezért célszerû, ha a sorok és oszlopok elválasztására a vesszõt és a pontosvesszõt használjuk.

Beépített függvény: zeros (méret)
Egy megadott méretû, 0-mátrixot hoz létre. Ha csak egy méretet adunk meg, akkor egy négyzetes mátrix, különben a megadott sor-, és oszlopszámú mátrix jön létre.

Beépített függvény: ones (méret)
Egy megadott méretû, 1-esekbõl álló mátrixot hoz létre.

Beépített függvény: eye (méret)
Egy megadott méretû identitásmátrixot ad meg.

1.3 Üres mátrixok

Egy mátrixnak egy, vagy mindkét dimenziója lehet nulla is. Ha adott s egy skalár, M(kxl) egy k x l -es mátrix, valamint [](mxn) egy m x n -es üres mátrix úgy, hogy m, n, vagy mindkettõ értéke nulla, akkor a következõ mûveletek definiáltak:

s * [](mxn) = [](mxn) * s = [](mxn) [](mxn) + [](mxn) = [](mxn) [](0xm) * M(mxn) = [](0xn) M(mxn) * [](nx0) = [](mx0) [](mx0) * [](0xn) = 0(mxn)

Egy n x m -es üres mátrixot a zeros(n,m) kifejezéssel lehet létrehozni (n, m, vagy mindkettõ értéke nulla kell, hogy legyen), valamint egy 0 x 0 -s mátrix jelölésére a [] kifejezés is használható.

1.4 Sorozatok

A sorozatok egy kényelmes lehetõséget biztosítanak vektorok definiálására. Egy sorozat kifejezést egy értékhármas határoz meg: a sor elsõ elemének értéke, egy opcionális érték az elemek közti növekményre, valamint a felsõ határt megadó érték, amelyet a sor elemei nem léphetnek túl. Ezen értékeket egymástól kettõsponttal választjuk el, és bármilyen aritmetikai kifejezést vagy függvényhívást tartalmazhatnak. Ha a növekményt nem írjuk ki, azt 1-nek veszi. Pl. az 1 : 5 a következõ értékhalmazt definiálja:

[ 1, 2, 3, 4, 5 ]

Az 1 : 3 : 5 sorozat pedig a következõt:

[ 1, 4 ]

Annak ellenére, hogy egy sorozat konstans egy sorvektort határoz meg, az Octave nem konvertálja vektorrá, csak akkor, amikor ez szükségessé válik. Ezért anélkül használhatunk egy `1 : 10000` sorozatot, hogy lefoglalnánk hozzá 80,000 byte memóriát (egy tipikus 32 bites gépen).

Érdemes megjegyezni, hogy a felsõ (negatív lépésköz esetén az alsó) határ nincs mindig benne az értékhalmazban, valamint a lebegõpontos értékekkel definiált sorokban a elõfordulhatnak meglepõ eredmények, mivel az Octave lebegõpontos aritmetikát használ a sorban lévõ értékek kiszámítására. Ha fontos, hogy a végpont is benne legyen az értékhalmazban, és az elemek száma ismert, akkor célszerûbb a linspace függvény használata. Ez a függvény viszont nem sorozatot, hanem mátrixot ad vissza.

1.5 Logikai értékek

Két beépített logikai változó van, ezek a false, és a true. Azokban a kifejezésekben, ahol logikai változóra van szükség, az alábbi implicit konverziók érvényesek:
skalár0              false
nem 0          true

mátrix, sorozatüres           false
van 0 eleme    false
nincs 0 eleme  true

stringüres           false
nem üres       true

Ugyanakkor egy logikai változó implicit konvertálódik skalárrá, ha ez szükséges — a false-ból 0, a true-ból 1 lesz.

1.6 Beépített konstansok

NAhiányzó érték. Két hiányzó érték nem egyenlõ, és nem hasonlítható össze. NaNnem szám. Két NaN nem egyenlõ, és nem hasonlítható össze. Ez az értéke a 0/0, az Inf-Inf, valamint a NaN-nal végzett mûveleteknek. Infvégtelen. Két végtelen szám egyenlõ, és minden más értéknél nagyobb, kivéve az NA-t, és a NaN-t. -Infnegatív végtelen. Két negatív végtelen szám egyenlõ, és minden más értéknél kisebb.

String objektumok

Octave-ban a karakter-stringek idézõjelek (") vagy aposztróf jelek (') közé írt karaktersorozatokból állnak. Az Octave a stringeket karaktertömbökként tárolja, így minden indexelõ mûvelet, amelyeket mátrixok esetében használhatunk, stringeknél is alkalmazhatóak. Pl. a 'labda' és a "labda" kifejezések ugyanazt a stringet jelölik, melynek tartalma 'labda'. Stringeket összefûzhetünk, a tömbök definiálására szolgáló jelöléseket használva: pl. a [ 'pottyos', 'labda' ] kifejezés a 'pottyoslabda' tartalmú stringet adja vissza. Octave-ban a stringek bármilyen hosszúak lehetnek.

Mivel az aposztóf jel használatos egy mátrix transzponáltjának jelölésére, és az idézõjelnek nincs más jelentése, ezért célszerûbb ezt használni a stringek jelölésére. Néhány karakter nem írható le közvetlenül egy string kifejezésben. Ezeket a karaktereket escape szekvenciákkal — backslash-el (\) kezdõdõ karakter szekvenciákkal — lehet leírni.

Ha idézõjel karaktert akarunk írni egy idézõjelek között definiált stringben, és mivel egy egyszerû idézõjel lezárná a stringet, ezért a \" escape szekvenciát kell használni, hogy elérjük a kívánt hatást. A szekvenciák hasonlóak a C nyelvben használtakhoz, Octave-ban a következõket használhatjuk:

Adatstruktúrák

Az Octave-ban lehetõség van arra, hogy az adatokat adatstruktúrákba szervezzük. A jelenlegi implementáció egy asszociatív tömböt használ, melynek szintaxisa olyan, mint a C-beli adatstruktúráké. A struktúrák elemei bármilyen típusúak lehetnek. Pl. adottak a következõ kifejezések:

x.a = 1 x.b = [1, 2; 3, 4] x.c = "string"

Ezek egy háromelemû struktúrát hoznak létre:

x = { a = 1 b = 1 2 3 4 c = string }

A struktúrák egymásba ágyazhatóak.

Az Octave a kiírás során a struktúra elemeit bármilyen sorrendben megjelenítheti. Ha beágyazott struktúrát kívánunk kiíratni, akkor ez csak meghatározott szintig történik meg. Például:

octave:1> a.b.c.d.e = 1; octave:2> a a = { b = { c = { d: 1x1 struct } } }
Így elõzve meg a hosszú és zavaró kimenetet mélyen egybeágyazott struktúra esetén.

Beépített változó: struct_levels_to_print
A struct_levels_to_print beépített változó beállításával definiálhatjuk hány szintig történjen a megjelenítés. Az alapértelmezett érték: 2.

A függvények struktúrákat is visszaadhatnak. Például a következõ függvény elkülöníti a mátrix valós és komplex részét, és egy struktúra két mezõjében tárolja el.

octave:1> function y = f (x) > y.re = real (x); > y.im = imag (x); > endfunction

Az alábbi beépített fügvények használhatóak, hogy információt nyerjünk a struktúrákról:
isstruct(expr) Visszatérési értéke 1, amennyiben az expr kifejezés értéke struktúra.
fieldnames(struct) Egy sztringeket tartalmazó cella tömböt ad vissza, melynek elemei a struktúra mezõinek nevei. Hiba, ha az argumentum nem struktúra!
isfield(expr, name) Visszatérési értéke igaz, ha az expr kifejezés struktúra és van name nevû eleme. Az elsõ argumentum kötelezõen struktúra, míg a második sztring típusú kell legyen!

Konténerek

4.1 Listák

Beépített függvények listák kezelésére:

list(a1, a2, ...)
Új lista létrehozása, melynek elemei a megadott argumentumok lesznek: a1, a2, ....

nth(list, n)
A list n-edik elemét adja vissza.

append(list, a1, a2, ...)
Új lista létrehozása. A list listához fûzi hozzá a megadott, a1, a2, ... argumentumokat. Ha az argumentumok maguk is listák, akkor elemeik egyesével lesznek hozzákapcsolva a list-hez. Például:

x = list (1, 2); y = list (3, 4); append (x, y);
eredménye az alábi lista: `(1 2 3 4)', nem pedig egy három elemû lista, mint: `(1 2 (3 4))'.

reverse(list)
Egy új listát ad vissza, mely a list elemeit tartalmazza fordított sorrendben.

splice(list_1, offset, length, list_2)
A list_1 elemeit helyettesíti az offset-tõl kezdõdõen length hosszan a list_2 elemeivel. Ha a lenght érték nincs megadva, akkor a helyettesítés az offset-tõl kezdõdõen a lista végéig érvényes. Speciális eset, ha az offset eggyel nagyobb, mint a list_1 hossza és a length értéke 0. Ekkor a splice ekvivalens az append(list_1, list_2) mûvelet végrehajtásával.

islist(x)
Nem nulla elemmel tér vissza, ha x lista típusú.

4.2 Cella tömbök

A cella tömbök esetén alkalmazható beépített függvények:

cell(x)
cell(n,m)
Új cella tömb létrehozása. Ha egy skaláris argumentummal lett hívva, akkor a cell egy az argumentum által meghatározott dimenziójú négyzetes cella tömböt hoz létre. Ha az alkalmazás során két skaláris típusú argumentummal hívva, a cell ezen számokat a sorok és oszlopok értékének veszi. Az elõbbi érvényes, ha az argumentum egy két elemû vektor.

cellstr(string)
A string sztring elemeibõl hoz létre egy cella tömböt.

iscell(x)
Visszatérési értéke igaz, ha x cella tömb. Ellenben, hamis.

A beépített típusok mûveletei

Numerikus objektumok mûveletei

1.1 Aritmetikai operátorok

A következõ aritmetikai mûveletek használhatóak skalárokon és mátrixokon:

x + y
Összeadás. Ha mindkét operandus mátrix, akkor a dimenzióiknak meg kell egyezniük. Ha az egyik skalár, akkor az értéke hozzáadódik a másik operandus összes eleméhez.

x - y
Kivonás. Ha mindkét operandus mátrix, akkor a dimenzióiknak meg kell egyezniük.

x * y
Szorzás. Ha mindkét operandus mátrix, akkor x oszlopainak száma meg kell hogy egyezzen y soraival.

x .* y
Elemenkénti szorzás. Ha mindkét operandus mátrix, akkor a dimenzióiknak meg kell egyezniük.

x / y
Jobb oldali (mátrix)osztás.

x ./ y
Elemenkénti jobb oldali osztás. Ha mindkét operandus mátrix, akkor a dimenzióiknak meg kell egyezniük.

x \ y
Bal oldali (mátrix)osztás.

x .\ y
Elemenkénti bal oldali osztás. Az y minden elemét elosztja x megfelelõ elemével.

x ^ y
Hatványozás. A ^ jel helyett ** is írható.

x .^ y
Elemenkénti hatványozás.

x'
Transzponált konjugáltja. Valós mátrix esetében ez megegyezik a transzponálttal.

x.'
Transzponált.

Ezek mellett használhatóak a C-ben megszokott x++, --x, x^=2, stb. formák is.

1.2 Összehasonlító operátorok

Ha a két összehasonlítandó operandus közül az egyik skalár, a másik pedig mátrix, akkor a mátrix összes eleme összehasonlítódik a skalárral, és az eredmény egy logikai mátrix lesz, az eredeti mátrix méretének megfelelõen.

x < y
Igaz, ha x kisebb y-nál.

x <= y
Igaz, ha x kisebb, vagy egyenlõ mint y.

x == y
Igaz, ha x és y egyenlõek.

x >= y
Igaz, ha x nagyobb, vagy egyenlõ mint y.

x > y
Igaz, ha x nagyobb, mind y.

x != y
Igaz, ha x nem egyenlõ y-nal. A != helyett írható ~=, vagy <> is.

1.3 Logikai mûveletek

A logikai mûveleteknek két fajtája van. Az egyik csoport az egyszerû logikai mûveletek:

x && y
logikai és

x || y
logikai vagy

Ezeknek a mûveleteknek az operandusai logikai értékek, és az eredmény is logikai érték. Az eredmény kiszámításához lusta kiértékelést használ, ezért következõ kifejezés nem változtatja meg a értékét:

a=0 false && ++a

A másik csoportba tartoznak az elemenkénti logikai mûveletek:

x & y
logikai és

x | y
logikai vagy

! x
logikai nem (a ! jel helyett ~ is írható)

xor(x, y)
logikai kizáró vagy

Ezeknek a mûveleteknek az operandusai skalárok és mátrixok lehetnek. Ha mindkét operandus mátrix, akkor a dimenzióiknak meg kell egyezniük. Ezek az operátorok szigorú kiértékelés szerintiek, vagyis az x és y részkifejezést is kiszámolja, mielõtt kiértékeli a kifejezést. Ezért a b értéke akkor is növekszik, ha a hamis:

a & ++b

Mátrixokra a kiértékelés elemenként történik, a következõ kifejezés egy 2x2-es egységmátrixot ad:

[1, 0; 1, 1] & [1, 1; 0, 1]

Ha az egyik operandus skalár, a másik pedig mátrix, akkor az eredemény egy, az eredetivel megegyezõ méretû logikai mátrix lesz úgy, hogy a logikai kifejezés kiértékelése minden elemre megtörténik.

1.4 Index kifejezések

Egy mátrix vagy vektor elemeit index kifejezésekkel érhetjük el. Az indexek lehetnek skalárok, vektorok, sorozatok, vagy a teljes sort vagy oszlopot jelentõ ':' operátor. Vektoroknál egy, mátrixoknál két indexet kell írnunk.

Legyen a = [1, 2; 3, 4]. Ekkor a következõ kifejezések ekvivalensek, és az a mátrix elsõ sorát adják vissza:

a(1, [1,2]) a(1, 1:2) a(1, :)

1.5 Értékadó kifejezések

Az értékadás egy olyan kifejezés, ami egy változónak új értéket ad. Például a z=1 kifejezésben z változóhoz 1-et rendeltünk. A értékadás végrehajtása után a z változó értéke 1 lesz, bármi is volt az értéke azelõtt. Az = jelet értékadás opererátornak nevezzük.

A legtöbb operátornak (összeadás, konkatenáció, stb.) nincs más hatása azon kívül, hogy kiszámít egy értéket. Ha ezt az értéket figyelmen kívül hagyjuk, akkor fölösleges az operátort használni. Ellenben az értékadás operátor azon kívül, hogy visszaad egy értéket, megváltoztatja egy változó értékét is. Ezt a tulajdonságot mellékhatásnak nevezzük.

Az értékadás bal oldali operandusa változó kell, hogy legyen. Ez lehet mátrix egy eleme, vagy egy megfelelõ függvény használata esetén visszatérési változók listája is. A jobb oldali operandus bármilyen kifejezés lehet, ennek az értéke eltárolódik a megadott változóban, mátrixelemben, vagy változók listájában.

Egy indexelt mátrixhoz hozzárendelt skalár a mátrix összes hivatkozott eleméhez ezt a skalár értéket rendeli. Ha az a mátrixnak legalább két oszlopa van, akkor a következõ értékadás a második oszlop összes eleméhez 5-öt rendel:

a(:, 2) = 5

Egy mátrix soraihoz vagy oszlopaihoz üres mátrixot rendelve törölhetõek az adott sorok és oszlopok. A következõ kifejezés törli az a márix második és negyedik sorát:

a([2,4], :) = []

Az értékadás egyúttal kifejezés is, tehát értéket ad vissza. A z=1 kifejezés értéke 1, ezért helyes a következõ többszörös értékadás, ami x, y, és z értékét 0-ra állítja:

x = y = z = 0

1.6 Inkrementálás

Az inkrementálási mûveletek növeli vagy csökkentik 1-gyel a változó értékét. Egy változó inkrementálásához a '++', decrementálásához a '--' operátor áll rendelkezésre. Ezek segítségével növelhetõ a változó mielõtt felvenné illetve miután felvette az értékét. Az elõbbi a pre-inkrementálás, az utóbbi pedig a post-inkrementálás mûvelete.

Martix és vektor argumentumok esetén az inkrementálás illetve dekrementálási operátorok az operandusok minden elemére hatásal vannak. Jelenleg a nyelv nem kínál lehetõséget az index-kifejezések inkrementálására.

Például a v(4)++ kifejezéstõl azt várnánk, hogy a v vektor negyedik elemének értékét növeli 1-gyel, de helyette ez fordítási hibát eredményez. Ezt az Octave újabb verzióiban próbálják majd meg orvosolni.

1.7 Operátorok precedenciája
^ ** .^ .** hatványozás
++ --
+ -
! ~
növelés, csökkentés
pozitivitás, negativitás
logikai nem
' .' transzponálás
* / \ .* ./ .\ szorzás, osztás
+ - összeadás, kivonás
: kettõspont
< <= == >= > != ~= <> relációk
& elemenkénti logikai és
| elemenkénti logikai vagy
&& logikai és
|| logikai vagy
= értékadás (jobbról balra asszociatív)
; , kifejezés-szeparátorok
1.8 Predikátumok a numerikus objektumokhoz
A numerikus objektumokat a következõ logikai függvényekkel vizsgálhatjuk:

isnumeric (x)
igaz, ha x numerikus objektum

isreal (x)
igaz, ha x valós

iscomplex (x)
igaz, ha x komplex

ismatrix (x)
igaz, ha x nem üres mátrix, vagy sorozat

isvector (x)
igaz, ha x mátrix, és legalább az egyik dimenziója 1

issquare (x)
x dimenziója, ha x négyzetes mátrix, különben 0

isscalar (x)
igaz, ha x skalár

isbool (x)
igaz, ha x logikai érték

isna (x)
igaz, ha x hiányzó érték

isnan (x)
igaz, ha x NaN

isinf (x)
igaz, ha x pozitív vagy negatív végtelen

String objektumok mûveletei

2.1 Konstrukciós mûveletek
blanks (n)
n darab szóközt ad vissza char (x)
az x ASCII-kódú karaktert adja vissza int2str (n)
az n egész számot stringgé konvertálja num2str (x,p)
az x valós számot stringgé konvertálja, p jegy pontossággal com2str (x)
az x komplex számot stringgé konvertálja strcat (s1,s2,...)
összefûzi az s1, s2, ... stringeket
2.2 Keresés és törlés

deblank (s)
levágja az s string végérõl a szóközöket, és a nul karaktereket

findstr (s,t,b)
az s és t stringek közül a hosszabbikban megkeresi a rövidebbet, és visszaadja a találatok kezdõpozícióit. A b egy logikai változó, igaz érték esetén a találatok között lehet átfedés, hamis esetén nem. A harmadik argumentumot nem szükséges megadni, alapértelmezés szerint igaz.

index (s,t)
megadja a t string elsõ elõfordulását az s stringben. Ha t nem szerepel az s-ben, akkor 0-t ad vissza.

rindex (s,t)
a t string utolsó elõfordulását adja meg az s stringben

substr (s,x,y)
az s stringbõl az x pozíciótól kezdve y karaktert ad vissza. Ha a harmadik argumentumot nem adjuk meg, akkor az x pozíció utáni karaktereket adja vissza. Ha x negatív, akkor ez a string vége elõtti x-edik karaktert jelöli.

strrep (s,x,y)
az s stringben az x string összes elõfordulását az y stringre cseréli

2.3 String konverziók

hex2dec (s)
az s stringben tárolt hexadecimális számot adja vissza decimális egész számként. Nem értelmezhetõ karakterek esetén az eredmény NaN lesz.

dec2bin (n)
az n egész szám bináris alakját adja vissza stringként

dec2hex (n)
az n egész szám hexadecimális alakját adja vissza stringként

dec2base (n,b)
az n egész számot b számrendszerbeli alakját adja vissza stringként. Ha b string, akkor a szám b hosszának megfelelõ alapú számrendszerre konvertálódik, az egyes jegyeket pedig a megfelelõ karakterrel írja ki.

base2dec (s,b)
az s stringben tárolt b számrendszerbeli számot adja vissza decimális egészként. Ha b string, akkor a benne lévõ karakterek jelentik a b hosszának megfelelõ számrendszer számjegyeit.

str2num (s)
az s stringben tárolt számot konvertálja skalárrá

toascii (s)
az s stringben tárolt szöveg karaktereinek ASCII-kódjaiból álló mátrixot adja vissza

tolower (s)
az s stringben lévõ nagybetûket kisbetûvé alakítja

toupper (s)
az s stringben lévõ kisbetûket nagybetûvé alakítja