\documentclass[a4paper,11pt]{book}

\usepackage{t1enc}
\usepackage[latin2]{inputenc}
\usepackage[magyar]{babel}
\usepackage{alltt}
\usepackage{hhline}
\usepackage{amssymb}
\usepackage{graphics}
\makeindex
\selectlanguage{magyar}


\title{A versenyúszók nyújtó-lazító gyakorlatai a speciális képzés során}
\author{Felvégi Péter András\\petschy@avalon.aut.bme.hu}
\date{2000. március}

\begin{document}
%%%\maketitle

\setlength{\parindent}{2em}
\newcommand{\el}{\vskip 12pt }
\newcommand{\pt}{\hspace*{4em}}
\newcommand{\px}{\hspace*{0.5em}}

\newcommand{\kw}[1]{#1}
\newcommand{\vw}[1]{#1}
\newcommand{\fn}[3]{\setlength{\parindent}{0em}\textbf{#1}\emph{#2}
                    \setlength{\parindent}{2em}\\#3}
\newcommand{\fx}[2]{\setlength{\parindent}{0em}\textbf{#1}\emph{#2}
                    \setlength{\parindent}{2em}}
\newcommand{\np}[1]{\setlength{\parindent}{0em}#1\setlength{\parindent}{2em}}
\newcommand{\ec}[1]{\item\emph{#1}}
%\lefthyphenmin=32
%\righthyphenmin=32
\newcommand{\draft}{\vskip 100pt}

\chapter{Bevezetés}
A computeralgebra fogalmának tisztázása érdekében a computeralgebrában
előforduló számításokat a numerikus számításokkal hasonlítjuk össze.
Mindegyiket egy számítógép segíti, vannak azonban alapvető különbségek,
melyeket most részletesebben is bemutatunk.
\section{Numerikus számítások}
Numerikus számítások esetén egy matematikai problémát közelítőleg
oldunk meg, a számítási lépések \textit{számokkal} történnek. Ezek a
számok intern \textit{tizedes\-tört-alak\-ban} vannak tárolva, így az
aritmetikai operációk gyorsan kivitelez\-he\-tőek. Ezen megjelenítésnek
megvan azonban az a hátránya, hogy sem a számítások, sem az eredmények
nem pontosak, hisz többek közt a kerekítések miatt is hiba lép fel. A
numerikus algoritmusokat általában úgy állítják össze, hogy minél
hamarabb adjanak közelítő eredményt. Gyakran a közelítés az egyetlen
lehetőség egy matematikai probléma megoldására, ha nem létezik zárt
alakú, pontos megoldás. Ezen kívül hasznosak még a közelítőmegoldások
olyan esetekben, mikor pontos végeredményre nincs is szükségünk (pl. a
vizualizálásnál). \section{Computeralgebra} A számokkal történő
numerikus számításokkal ellentétben a computeralgebra esetén
\textit{szimbolikus} számításokat végzünk, [Hec 93] alapján
\textit{"matematikai objektumokkal való számolásokról"} van szó. Egy
objektum lehet például egy szám, de egy polinóm, egy egyenlet, egy
kifejezés vagy egy formula, egy függvény, egy csoport, egy győrű vagy
egy másik tetszőleges matematikai objektum is. A számokkal történő
szimbolikus számítások \textit{pontosak}, szemben a numerikus
számításokkal, mivel itt intern tetszőleges hosszúságú egész és
racionális számok megjelenítése syerepel. Ezt a számítást a
computeralgebrában \textit{szimbolikus}, vagy másnéven
\textit{algebrai} számításnak nevezzük. [Hec 93]-ban a következő
definíciót találjuk rá: \begin{enumerate} \item A "szimbolikus" jelző
azt jelenti, hogy a cél a megoldás lehetőleg zárt formulájának
megtalálása, jó (azaz egyszerű), szimbolikus megjelenítésben. \item Az
"algebrai" jelző a \textit{pontos} számításra utal, ellentétben a
tizedesjegy-aritmetikára jellemző közelítőmegoldással. \end{enumerate}
A computeralgebrát néha "szimbolikus manipulációnak" vagy
"formulamanipulációnak" is nevezik, mivel formulákkal és szimbolumokkal
történik a számolás. Példa erre a szimbolikus integrálás vagy a
differenciálás, mint

\[\int
x~dx=\frac{x^2}{2},\qquad\int_1^4x~dx=\frac{15}{2},\qquad\frac{d}{dx}ln
~ln~x=\frac{1}{x~ln~x}\]

\noindent
vagy egyenletek szimbolikus megoldásainak kiszámítása. Erre
példa az \(x^4+px^2+1=0\) \textit{x} ismeretlenes, \textit{p}
paraméteres egyenlet, melynek megoldási halmaza:
\[\left\{\pm\frac{\sqrt{2}\sqrt{-p-\sqrt{p^2-4}}}{2},\\\pm\frac{\sqrt{2}\sqrt{-
+\sqrt{p^2-4}}}{2}\right\}\] Egy pontos megoldás szimbolikus
kiszámí\-tá\-sá\-hoz szinte mindig több számolási időre és memóriára
van szükség, mint a numerikus megoldás kiszámí\-tá\-sá\-hoz. A
szimbolikus eredmény azonban pontos, általánosabb és legtöbbször
további információt ad a problémához és annak megoldásához. Tekintsük
például a fenti megoldási formulát, mely tetszőleges \textit{p}
paraméter esetén megadja az egyenlet megoldását: megmutatja a
\textit{p}-től való függőséget. Így például megtudhatjuk, hogy az
eredmény hogyan változik a paraméter változása esetén.

\noindent
Speciális felhasználás esetén érdemes kombinálni a szimbolikus és a
numerikus módszert. Vannak a computeralgebrában például olyan
algoritmusok, melyek a hardware hatékony tizedestört-aritmetikájából
profitálnak. Másrészt viszont ésszerű egy numerikus problémát
szimbolikusra egyszerű\-sí\-te\-ni, mielőtt a tényleges approximatív
algoritmust alkalmazzuk. \section{Computeralgebra-rendszerek
tulajdonságai} Az ismert computeralgebra-rendszerek többsége
interaktívan felhasználandó programcsomag: a felhasználó megad egy sor
formulát és parancsot a rendszernek, melyet aztán a rendszer feldolgoz
(vagy másnéven \textit{kiértékel}). Végül a rendszer visszaad egy
választ, melyet tovább manipulálhatunk.

\noindent
A pontos szimbolikus számításokon kívül a legtöbb computeralgebra-rendszer az
eredményt numerikusan is képes approximálni. Ekkor a felhasználó
tetszőlegesen megadhatja, hogy hány tizedesjegy pontossággal szeretné a
megol\-dást megkapni. \textsf{MuPAD} esetén ez a \texttt{DIGITS}
globális változó segítségével történik. Így például az egyszerű
\texttt{DIGITS:=100} parancssal elérhetjük, hogy a \textsf{MuPAD} 100
tizedesjegyre kerekítve adja meg az eredményt. Persze az ilyen
számításokhoz több számolási idő és memória szükséges, mint a hardware
tizedesjegy-aritmetikájának használatához.

\noindent
A modern computeralgebra-rendszerek ezen kívül plusszba még
egy hatalmas \ programnyelvvel\footnote{A \textsf{MuPAD}
programnyelvének szintaxisa a Pascaléhoz hasonló. Az objektumorientált
programozásnak létezik egy koncepciója.} is rendelkeznek és olyan
eszközöket nyújtanak, melyek lehetővé teszik a matematikai adatok
vizuális megjelenítését és animációját. Sok rendszer a nyomdakész
dokumentumok (úgynevezett \textit{Notebooks} vagy \textit{Worksheets})
előkészítését is lehetővé teszi. A \textsf{MuPAD}-ban is létezik egy
Notebook-koncepció, mellyel azonban ezen bevezetésben nem foglalkozunk.
E könyv célja, hogy bevezetésül szolgáljon a \textsf{MuPAD} matematikai
képessé\-gei\-nek használatához.

\section{Létező rendszerek} Sok computeralgebra-rendszer létezik, ezek
közül néhányat kereskedelmileg forgalmaznak, míg mások ingyen
hozzáférhetőek.

\noindent
Az úgynevezett \textit{special purpose} rendszerek speciális matematikai
problémák kezelését segítik. Így létezik például a \textit{Schoonship} rendszer
a nagyenergiájú fizikai problémákhoz, \textit{DELiA} a
differenciálegyenletekhez, \textit{PARI} a \ számel\-mé\-let\footnote{A
MuPAD ezen rendszer részeit intern alkalmazza.} alkalmazásához és
\textit{GAP} a csoportelméleti problémákhoz.

\noindent
Ezek mellett létezik még az úgynevezett \textit{general purpose}
computeralgebre-rendszer. Ide tartozik az 1980 óta kifejlesztett és
kifejezetten kisszámítógépre szánt \textit{Derive} és \textit{Math
Plus} illetve a \textit{Math
View} (korábban \textit{Theorist}), melyet 1990 óta fejlesztenek és
mely részletesen kidolgozott felhasználói felülettel rendelkezik,
aminek matematikai képességei azonban korlátozottak. Ezeken kívül
létezik még a \textit{Macsyma} és \textit{Reduce} rendszer, melyeket
1965 óta fejlesztenek és LISP programozásúak. A modern rendszereket,
mint \textit{Mathematica} és \textit{Maple}, körülbelül 1980 óta
fejlesztik és C-ben programozták. A \textit{Mathematica} volt az első
olyan rendszer, mely felhasználóbarát felülettel rendelkezett. Meg kell
még említeni az \textit{Axiom}-ot, melyet szintén 1980-óta
fejlesztenek. Az eddig említett rendszerekkel ellentétben ax Axiom egy
teljes tipizált nyelvvel rendelkezik és csak speciális matematikai
kontextusban engedélyezi a számításokat. Mindezen rendszerek közül a
\textsf{MuPAD} a legfiatalabb: 1990-óta fejlesztik a Paderborni
Egyetemen és megpróbálják összekapcsolni a különböző elődök erősségeit
a modern, egyéni koncepciókkal. \section{\textsf{MuPAD}} A
computeralgebre-rendszer eddig említett tulajdonságai mellett a MuPAD
rendelkezik még a következő képességekkel:  \begin{itemize} \item A
\textsf{MuPAD} az objektumorientált programozáshoz nyújt koncepciót.
Saját adattípusokat definiálhatunk és szinte minden meglévő operátort
és függvényt alkalmazhatunk rajtuk. \item A \textsf{MuPAD} egy
interaktív forráskód-debaggart bocsájt a rendelkezésünkre. \item A
modulkoncepcióval C-ben vagy C++-ban írt programokat hozzáfűz\-het\-jük
a \textsf{MuPAD}-maghoz. \end{itemize} A \textsf{MuPAD} szíve az
úgynevezett \textit{mag}, mely hatékonysági és gyorsasági szempontok
miatt főleg C-be és részben C++-ba van implentálva. Ez a mag pedig a
következő alapvető részekből áll: \newenvironment{Aitemize}
{\renewcommand{\labelitemi}{\textbf{-}}\begin{itemize}} {\end{itemize}}
\begin{Aitemize} \item Az úgynevezett \textit{Parser} elolvassa a
rendszernek megadott adatokat és ellenőrzi szintaxisukat. A hibátlan
inputot a Parser átírja \textsf{MuPAD} adattípusra. \item Az
úgynevezett \textit{kiértékelő} (angolul evaluator) kiértékeli az
inputokat és leegyszerűsíti az eredményeket. Ez a folyamat a
\textsf{MuPAD}-ban pontosan van definiálva és ezzel később még
részletesen foglalkozunk. \item A memóriakezelő a felelős a
\textsf{MuPAD}-objektumok intern kezeléséért. \item Egyes gyakran
alkalmazott algoritmusok, mint például az aritmetikai függvények,
hatékonysági és gyorsasági okokból \textit{magfüggvényként} a C szinten
vannak implentálva. \end{Aitemize} A magban van a
\textsf{MuPAD}-programnyelv is definiálva. E nyelv segítségével vannak
a \textsf{MuPAD}-hoz tartozó programkönyvtárak implentálva, melyek a
rendszer matematikai képességeit tartalmazzák. 

\noindent
Emellett a \textsf{MuPAD} kényelmes felhasználói felülettel is
rendelkezik az úgynevezett \textit{Notebooks} vagy ábrák
létrehozásakor és a \textsf{MuPAD}-nyelveken írt programok
debuggolásakor. A \textsf{MuPAD}-sógúrendszernek
hypertextfunkcionalitása van. Navigálhatunk a dokumentumokban, de
egérkattintással példákat is kiszámíttathatunk a rendszerrel. A
\textsf{MuPAD}-rendszer főösszetevőit az 1.1-es ábra
szemlélteti.
\chapter{Első lépések a \textsf{MuPAD}-dal} A
computeralgebra-rendszereket, mint a \textsf{MuPAD}, gyakran interaktív
módon hasz\-nál\-juk, azaz megadjuk a rendszernek az utasításokat, mint
például két szám szorzását és várunk amíg a MuPAD kiszámolja az
eredményt és kiírja a képernyőre. Futó számolás közben nem adhatunk be
több adatot, de a számítást bármikor megszakíthatjuk.

\noindent
A \textsf{MuPAD}/program meghívásával elkezd futni a program. A
megnyitás függ a felhasznált operációs-rendszertől és az alkalmazott
\textsf{MuPAD}/verziótól. Itt az \textsf{MuPAD} installálásának
leírásában szereplő információkra támaszkodhatunk. A \textsf{MuPAD}
rendelkezésünkre bocsájt egy súgórendszert, melytől a program futása
közben is kaphatunk felvilágosítást a rendszerfüggvényekről, azok 
szintaxisairól és egyebekről. A \textsf{MuPAD}-súgó használatát a
következő bekezdésben ismertetjük. A súgóoldalak megnyitása lesz
legalábbis eleinte a a legfontosabb rendszerparancs, melyet a kezdő
alkalmaz. Ezt követi egy bekezdés, mely a \textsf{MuPAD}-ot, mint
"Zsebszámológépet" mutatja be: a számokkal való számítást. Ez a
legegyszerűbb és legintuitívabb része e leírásnak. Ezután bemutatunk
néhány szimbolikus számítást szolgáló rendszerfüggvényt. Ez a fejezet
nem túl szisztematikus: igazából csak egy első benyomást kíván adni a
rendszer szimbolikus képességeiről.


\noindent A program elindítása után \textsf{MuPAD}-nyelven
megadjuk a parancsot. A rendszer ekkor input-módban található,
azaz vár az inputra, ha a \textsf{MuPAD}-prompt megjelent. Windows
illetve Macintosh esetén ez a prompt a \textbullet jel, UNIX esetén
$>>$. Ezután a példákon való illusztrálás esetén a Unix-promtot
hasz\-nál\-juk. A
<RETURN>-billentyű vagy a
<SHIFT>+<RETURN>-kombináció megnyomásával (Windows és UNIX esetén)
befejezzük az inputot és a \textsf{MuPAD} kiértékeli a megadott
parancsot. Macintosh esetén a parancs teljesítése érdekében az
<ENTER>-billentyűt kell megnyomni, a <RETURN>-billentyű alkalmazása itt
csak sorváltást eredményez és a \textsf{MuPAD} továbbra is input
állapotban található. A \textsf{MuPAD} 1.4 változatáig minden parancsot
pontosvesszővel vagy kettősponttal kell lezárnunk, mielőtt a
<RETURN>/<ENTER>-billentyű segítségével kiértékeltetjük a maggal.
Későbbi verziók ilyen lezárási jelek nélkül is kiértékelik a
helyes szintaxisú parancsokat <RETURN>/<ENTER> után.

\noindent
Ha a
\begin{alltt}>> sin(3.141);\end{alltt} parancsot <RETURN> illetve
<ENTER> követi, a képernyőn a következő eredmény jelenik meg:
\begin{alltt} 0.0005926535551 \end{alltt} Itt a 3.141 szinuszának
értékét kerestük, eredményül a közelítő szinusz-értéket tizedestört
alakban kaptuk meg, ahogy azt egy zsebszámológép is kijelezte volna.

\noindent
Ha a pontosvessző helyett kettősponttal zárunk le egy parancsot, akkor
a \textsf{MuPAD} elvégzi ezt ugyan, a képernyőn azonban nem jelenik meg
az eredmény. Így lényegtelen részeredményeknek nem kell megjelenniük a
képernyőn. Egy sorban több parancsot is megadhatunk. Pontosvessző vagy
kettőspont útján kell őket egymástól elválasztani:

\noindent
\begin{alltt}
>> diff(sin(x^2), x); int(last(1), x);

           2

  2 x cos(x )

       2

  sin(x ) \end{alltt}

\noindent Ekkor \verb/x^2/\ x négyzetét jelöli, a diff
illetve int \textsf{MuPAD}-függvények pedig a "differenciálás" és
"integrálás" matematikai műveleteket végzik (7. fejezet). A last(1)
meghívása az utolsó kifejezésre vonatkozik (most tehát sin($x^2$)
deriváltjára). A last-tal kapcsolatos mechanizmust a 12. fejezetben
mutatjuk be.

\noindent
A következő példánál csak a második parancs eredménye fog megjelenni a
képernyőn, mivel a kettőspont használatával elnyomtuk a az első parancs
eredményének kijelzését:

\begin{alltt}
\verb/>> egyenletek:= {x + y = 1, x - y = 1}: solve(egyenletek)/\\
\end{alltt}

\noindent
Itt az \texttt{egyenletek} megnevezéshez egy két egyenletből álló
halmazt rendelünk. A \texttt{solve(egyenletek)} (angol: to
solve=megoldani) parancs adja az eredményt. Az egyenletmegoldó
leírásáról a 8. fejezet szól.

\noindent 
Ha egy hiányos parancsot (ahol pl. lefelejtettük a pontosvesszőt)
akarunk a <RETURN>-billentyű megnyomása által a \textsf{MuPAD}-dal
kiértékeltetni, akkor a képernyőn egy másfajta prompt jelenik meg. E
megváltozott prompt UNIX esetén \verb/&>/\ alakú, Macintosh esetén egy
\verb/*/\, Windows esetén pedig nem jelenik meg promtjel. Ez jelzi,
hogy a parancs még nem teljes. Amint a következő sorban kiegészítettük
a parancsot, pontosvesszővel vagy kettősponttal lezártuk és elküldtük,
a rendszer kiértékeli:

\noindent
\begin{alltt}
>>solve (sin(x) = 1, x);

  \{ / PI  5 PI   3 PI     \verb/\/ \}
  \{ | --, ---, - ---, ... | \}
  \{ \verb/\/\ 2    2      2       / \}
\end{alltt}

\noindent
A \texttt{quit} kulcsszó meghívásával kilépünk a
\textsf{MuPAD}-programból:

\noindent
\begin{alltt}
>>quit
\end{alltt}

\section{Magyarázatok és a súgó} Ha Ön nem tudja, hogy hogyan néz ki
egy \textsf{MuPAD}-parancs helyes szintaxisa, akkor a szükséges
információt rögtön a futó program közben beszerezheti a
súgórendszertől. Az \texttt{info} függvény segítségével sok
\textsf{MuPAD}-művelet esetén kaphatunk egy rövid angol magyarázatot:

\noindent
\begin{alltt}
>> info(solve);

  solve -- solve equations and inequations [try ?solve for options]
  
>> info(ln);

  ln -- the natural logarithm
\end{alltt}

\noindent
Részletesebb információt az adott függvény súgóoldalán találunk. Ezt
\texttt{help("műveletnév")} útján hívhatjuk meg. Itt a nevet idézőjel
közé kell tenni, mivel a \texttt{help}-függvény a jelsorozatokat
inputnak tekinti, melyeket a \textsf{MuPAD} " segítségével képez
(fejezet 4.12). A help rövidítésére szolgál a ? operátor, mely esetén
nincs szükség az idézőjelekre:

\noindent
\begin{alltt}
>> ?solve
\end{alltt}

\noindent
Az 1.4 verziónál a súgót előhívó ? parancs egyike azon kevés
kivételeknek, melyek esetén nincs szükség pontosvesszőre vagy
kettőspontra a \ lezáráshoz\footnote{Kivétel még a \textsf{MuPAD}
elhagyását szolgáló \texttt{quit}-parancs és a \textsf{MuPAD} futása
közben az operációs-rendszernek szánt parancsokat megadó ! szimbólum
(fejezet 14.4)}. A \textsf{MuPAD} súgóoldalai a felhasznált verziótól
függően különböző képpen jelenhetnek meg. A következő példa egy
ASCII-formátumú súgóoldal esetén mutatja be, hogy a ?solve parancsra
milyen választ ad a \textsf{MuPAD} terminálverziója:
\begin{alltt}
solve -- általános megoldás

   Szintaxis:

   solve( equ , indet )
   solve( sys , unk <, MaxDegree=n> <, BackSubstitution=b> )
   solve( object )

   Paraméter:

   equ -- egyenlet vagy kifejezés
   indet -- határozatlan
   sys -- egyenletek halmaza
   unk -- határozatlanok halmaza
   n -- nemnegatív egész szám
   b -- TRUE vagy FALSE
   object -- domainelem 

   Áttölthető:

   equ , sys , object

   Leírás:

   A solve( equ, indet ) megoldja az indet határozatlanú equ egyenletet és
   visszaadja a megoldások egy halmazát. ...
\end{alltt}

\noindent
Az output többi részét most helyhiány miatt nem ismertetjük. A 2.1 ábra
a megfelelő hypertext-dokumentum egy részletét mutatja, mely grafikus
felület használata során jelenik meg. Erről a grafikus súgóoldalról
egérkattintással juthatunk el a rendelkezésre álló függvények
listájához, az indexekhez vagy a kézikönyv tartalomjegyzékéhez. A
sugórendszert úgynevezett hypertext-rendszerként valósították meg. Az
aktív kulcsszavak alá vannak húzva vagy be vannak keretezve. Ha
rákattintunk, további magyarázatokat kapunk a kifejezéssel
kapcsolatban. Mindegyik oldalon van néhány általános elágazási
lehetőség, pl.előre vagy hátralapozhatunk, a következő fejezetre vagy a
tartalomjegyzékre ugorhatunk. Macintosh esetén ezek a navigációs
lehetőségek a súgó-menüben találhatóak. A súgóoldalon található
példákat automatikusan átvihetjük a \textsf{MuPAD} inputablakába, ha a
megfelelő, aláhúzott vagy bekeretezett promptra kattintunk.

\textbf{Feladat 2.1:} Nézzen utána a \texttt{diff}
\textsf{MuPAD}-differenciálás alkalmazásmódjainak! Számítsa ki
sin(x\textasciicircum 2) ötödik deriváltját!

\section{Számítás számokkal} A \textsf{MuPAD}-ot úgy használhatjuk
számolások esetén, akár egy zsebszámológépet. A következő parancs egy
racionális számot ad eredményül:\\

\begin{alltt}
>> 1 + 5/2; \end{alltt}

  7/2\\


\noindent
Láthatjuk, hogy a \textsf{MuPAD} egész és racionális számokkal való
számítások esetén pontos eredményt ad (szemben a kerekített
tizedestörtekkel):

\begin{alltt}
>> (1 + (5/2*3))/(1/7 + 7/9)^2;\\

  67473/6728
\end{alltt}
\noindent
A \verb/^/ szimbólum a hatványozást jelöli. A \textsf{MuPAD} nagyon
nagy számokkal is hatékonyan tud számolni. A kiszámítandó szám
nagyságának valójában csak a számítógép rendelkezésre álló memória
szabhat határt. Így például az 1234-es szám 123. hatványa:

\begin{alltt}
>> 1234^123; \end{alltt}

\noindent
a következő meglehetősen nagy számot adja:

17051580621272704287505972762062628265430231311106829047052961932218391
383486800747136630671706059857264159231455434590057058967067149970908610
25399048465147931356173055636999395010462203568202735575775507008323844
44147778396026387067604268570040400328704248063968069686558786501669938
38833888319804591599428453724146018094297177261076285952434068010144185
9766279838067203567299104

Az alaparitmetikán kívül még egy sor \textsf{MuPAD}-függvény áll a
rendelkezésünkre, melyekkel számításokat végezhetünk. Egy egyszerű
példa az \textit{n} természetes szám faktorizációja
$n!=1\cdot 2\cdot...\cdot n$, amit egyszerűen a matematikai jelölésével
lekérhetünk:

\begin{alltt}
>>100!;
\end{alltt}

93326215443944152681699238856266700490715968264381621468592963895217599
93229915608941463976156518286253697920827223758251185210916864000000000
00000000000000

\noindent
Az \texttt{isprime} segítségével nézhetjük meg egy természetes szám esetén, hogy
prímszám-e: ez a művelet végeredményként vagy TRUE-t (igaz) vagy
FALSE-t (hamis) ír ki. Az \texttt{ifactor} (angol: integer factorization)
segítségével megkapjuk az adott szám prímtényezős alakját:

\begin{alltt}
>> isprime(123456789);

  FALSE

>> ifactor(123456789);

  [1, 3, 2, 3607, 1, 3803, 1]
\end{alltt}

\noindent
Az ifactor által visszaadott lista értelmezéséhez lásd a megfelelő
súgóoldalt: ?ifactor. 123456789 = +$1\cdot3^2\cdot3607^1\cdot3803^1$. Ennél szugesztívebb formájú
eredményt ad a \texttt{Factor} művelet, mely éppúgy faktorizálja a szimbolikus
kifejezéseket, mint a számokat:

\begin{alltt}
>>Factor(123456789);

   2
  3  3607 3803
\end{alltt}

\noindent
Nézzük most a $\sqrt{56}$ "kiszámításának" esetét! Itt szembentaláljuk
magunkat a problémával, hogy ez a szám irracionális volta miatt nem
állítható elő pontosan törtek segítségével. Így egy "számításnak" csak
egy \textsl{lehetőség szerint egyszerű}, pontos megjelenítés lehet a célja.
\subsection{Pontos számítások}
Megpróbáljuk példák útján elmagyarázni az előbb felvetett problémát,a
pontos megjelenítés nehézségét. Ha a $\sqrt{56}$-t az \texttt{sqrt}
(angol: square root=négyzet\-gyök) parancssal adjuk meg a rendszernek,
akkor a \textsf{MuPAD} a következő eredményt szolgáltatja:

\begin{alltt}
>> sqrt(56);

      1/2
  2 14
\end{alltt}

\noindent
Az eredmény a $\sqrt{56}$-t a pontos $2\cdot14^{1/2}$ értékre egyszerűsíti, ahol
\textsf{MuPAD} esetén $14^{1/2}$ az $x^2=14$ egyenlet pozitív megoldásait
jelenti. Valóban ez az eredmény legegyszerűbb pontos megadása. Vegyük
figyelembe, hogy a \textsf{MuPAD} egy olyan objektumnak tekinti a $14^{1/2}$
kifejezést, mely rendelkezik bizonyos tulajdonságokkal (lényegében
azzal, hogy a 14 négyzete egyszerüsíthető).Ilyen szimbólumokkal való számolás esetén ez automatikusan
végbemegy. Például:

\begin{alltt}
>> sqrt(14)^4;

  196
\end{alltt}

\noindent
További példaként szolgáljon a következő határérték pontos kiszámítása:
\[e=\lim_{n\to\infty}\left(1+\frac{1}{n}\right)^n\]
A \texttt{limit} függvény határértéket számol, az \texttt{infinity} pedig a \textsf{MuPAD}-ban a "végtelent" jelöli:

\begin{alltt}
>> limit((1+1/n)^n,n=infiniti);

  exp(1)
\end{alltt}

\noindent
Itt az \texttt{exp} a \ hatványozásfüggvényt\footnote{Az E szimbólum
ugyanezt az objektumot jelöli a \textsf{MuPAD}-ban, azaz a természetes
alapú logaritmus alapját (E = exp (1) = 2.71828..).} jelöli. Az
\textit{e} számot az \texttt{exp(1)} szimbólum jeleníti meg pontosan,
ahol a \textsf{MuPAD} rendelkezik az ezen objektumhoz szükséges
számítási szabályokkal. Így például a természetes alapú ln logaritmusra
a következőt kapjuk:

\begin{alltt}
>> ln(exp(1)^2)

  2
\end{alltt}

\noindent
További pontos számításokkal még e bevezetés során is fogunk
találkozni.  
\subsection{Numerikus közelítések}
A pontos számolások mellett a \textsf{MuPAD} lehetővé teszi a numerikus
közelítéssel való számolást is. Ha például Ön a $\sqrt{56}$
tizedestörtalakjának közelítő értékét szeretné megkapni, akkor
használja a \texttt{float} (angol: floating point number=tizedestört)
függvényt!
Ez a függvény kiszámítja az argumentum értékének úgynevezett
\textit{tizedestörtalakját}:

\begin{alltt}
>> float(sqrt(56));

  7.483314773
\end{alltt}
\noindent
A közelítés pontossága a DIGITS globális változó értékétől, a numerikus
számolások tizedesjegy-számától függ. Az előre beállított standardérték
a 10:

\begin{alltt}
>> DIGITS;float(67473/6728);

  10

  10.02868608
\end{alltt}
\noindent
A DIGITS-hez hasonló globális változók befolyásolják a \textsf{MuPAD}
viselkedését, ezeket környezetváltozóknak is \
nevezzük\footnote{Különösen figyelnünk kell, ha ugyanezt a számítást
különböző DIGITS értékekkel végezzük. A \textsf{MuPAD}-ban egyes
komplexebb numerikus algoritmusok a "remember" opcióval vannak
implentálva, aminek következtében ezen algoritmusok korábbi
eredményekből származnak (fejezet 18.8). Ez pontatlan numerikus
eredményeket okozhat, melyeket kevésbé pontos számolás útján kaptunk.
Kérdéses esetben a DIGITS meghívása előtt érdemes újrainstallálni a
\textsf{MuPAD}-programot a \texttt{reset()} segítségével (fejezet
14.3), amivel kitöröljük a \textsf{MuPAD} memóriáját}. A \textsf{MuPAD}
1.4 verziójába implentállt összes környezetváltozó listája megtalálható
a \textsf{MuPAD}-rövidreferencia [Oev 98] "Környezetváltozók" című
fejezetében. A DIGITS változó bármely tetszőleges, 1 és $2^{32}-1$
közötti egész értéket felvehet:

\begin{alltt}
>> DIGITS:= 100: float(67473/6728); DIGITS:= 10:
\end{alltt}

10.02868608799048751486325802615933412604042806183115338882282996432818
73721759809750297265160523186

\noindent
A következő számítások előtt a DIGITS értékét visszavettük 10-re. Ezt
az \texttt{unassign(DIGITS)} parancs segítségével is elvégezhetjük. Ha a számok
\textit{egyikét} tizedestörtlakban adjuk meg, akkor a \textsf{MuPAD} mindig
autómatikusan közelítő értéket számol számokkal való aritmetikai
operációk esetén:

\begin{alltt}
>> (1.0 + (5/2*3))/(1/7 + 7/9)^2;

  10.02868608
\end{alltt}

\noindent
Figyeljünk azonban arra, hogy a következő két parancsra

\begin{alltt}
>>2/3*sin(2), 0.6666666666 sin(2);
\end{alltt}

\noindent
egyik esetben \textit{sem} kapjuk meg a sin(2) közelítő értékét, mivel sin(2)
nem egy szám, hanem egy kifejezés, mely a sin(2) (pontos) értékét jelöli:
\begin{alltt}

  2 sin(2)
  --------, 0.6666666666 sin(2)
     3
\end{alltt}

\noindent A két érték egymástól vesszővel történő
elválasztása egy speciális adattípust, úgynevezett \textit{sor}-t
eredményez, melyről részletesebben a 4.6 fejezetben írunk. Ahhoz, hogy
a fenti esetben tizedestörtalakú eredményt kapjunk, ismét a
\texttt{float} függvényt kell \ alkalmaznunk\footnote{Figyelje meg a
két utolsó számjegyet. A második parancs egy kicsit pontatlan eredményt
ad, mivel a 0.666... már eleve közelítése a 2/3-nak és ez a hiba a
végeredményre is kihat.}:

\begin{alltt}
>> float(2/3*sin(2)), 0.6666666666*float(sin(2));

  0.6061982845, 0.6061982844
\end{alltt}

\noindent
A legtöbb \textsf{MuPAD}-függvény, mint ahogy az \texttt{sqrt}, a trigonometrikus
függvények, a hatványozás vagy a logaritmus is, automatikusan numerikus
eredményt ad, ha az argumentuma tizedestörtalakú szám:

\begin{alltt}
>> sqrt(56.0), sin(3.14);

  7.483314773, 0.001592652916
\end{alltt}

\noindent
A $\pi$ és \textit{e} konstansokkal, melyeket PI illetve E = exp(1)
jelenít meg, \textsf{MuPAD}-ban \textit{pontosan} számolhatunk:

\begin{alltt}
>> cos(PI), ln(E);

  -1, 1
\end{alltt}

\noindent
Ha szeretnénk, a \texttt{float} művelettel itt is megkaphatjuk a
konstansok egy numerikus approximációját:

\begin{alltt}
>> DIGITS:= 100: float(PI); float(E); unassign(DIGITS):

 
  3.141592653589793238462643383279502884197169399375105820974944592307816
  406286208998628034825342117068
  
 
  2.718281828459045235360287471352662497757247093699995957496696762772407
  6630353547594571382178525166427
\end{alltt}

\noindent
\textbf{Feladat 2.2:} Adja meg a $\sqrt{27}$-4$\sqrt{3}$ és a cos($\pi$/8)
pontos értékét! Számítsa ki öt tizedesjegy pontossággal a numerikus
közelítéseket!

\subsection{Komplex számok} Az imaginárius $\sqrt{-1}$ imaginárius
egységet a \textsf{MuPAD}-ban  az I szimbolizálja:

\begin{alltt}
>> I^2;

  -1
\end{alltt}

\noindent
\textsf{MuPAD} esetén is a szokásos módon, x+yI alakban adhatjuk meg a
komplex számokat, ahol a valós illetve az imaginárius rész (x illetve
y) egészszámok vagy racionális számok vagy tizedestörtek is lehetnek:

\begin{alltt}
>> (1 + 2*I)*(4 + I), (1/2 + I)*(0.1 + I/2)\textasciicircum 3, (1 + I)/(1 - I);
  
  2 + 9 I, 0.073 - 0.129 I, I
\end{alltt}

A számolási operációk eredményét nem mindig valós és imaginárius
részekre bontott alakban kapjuk meg, ha a számértékek mellett
\texttt{sqrt(2)}-hez hasonló szimbolikus kifejezéseket alkalmazunk:

\begin{alltt}
>> 1/(sqrt(2) + I);

      1

  --------

   1/2

  2    + I
  
\end{alltt}



\noindent
A \texttt{rectform} (angol: rectangular form) függvény azonban a valós és imaginárius részekre
bontást eredményezi:

\noindent
\begin{alltt}
>> rectform(1/(sqrt(2) + I));

   1/2

  2

  ---- + (-1/3) I

   3
\end{alltt}

\noindent A Re illetve Im függvények segítségével
megkaphatjuk egy x+yI komplex szám valós x illetve imaginárius y
részét. A komplex szám x-yI konjugáltját a \texttt{conjugate}
függvénnyel számíthatjuk ki. Az abszolútértéket ($|x+yI| =
\sqrt{x^2+y^2}$) az \texttt{abs} \textsf{MuPAD}-függvény adja:

\begin{alltt}
>> Re(1/(sqrt(2) + I)), Im(1/(sqrt(2) + I)), abs(1/(sqrt(2) + I));

   1/2         1/2

  2           3

  ----, -1/3, ----

   3           3

>>conjugate(1/(sqrt(2) + I)), rectform(conjugate(1/(sqrt(2) + I)));

             1/2

     1      2

  --------, ---- + (1/3) I

   1/2       3

  2    - I
\end{alltt}
\end{document}

























































