Tietokonepalsta: Matemaattisten symbolien käsittelyä

Symbolien käsittelyä tietokonealgebrasysteemillä - Käyttöliittymät ja matematiikkaa verkossa - Käytön perusteita - Ladontateknisiä huomioita - Maple laskimena - Polynomeja ja muita lausekkeita - Grafiikkaa - Yhtälöitä - Derivaatat - Integrointi - Symbolien hallintaa - Ohjelmointi - Esimerkkiprojektina kelluva lieriö - Ratkaisutyöarkin LATEX-muunnos hieman lyhenneltynä - Loppumietteitä - Viitteet

Jouni Seppänen aloitti Solmun numerossa 1/1998-1999 palstan, jossa käsitellään matematiikan ja tietotekniikan yhteyksiä. Pyrkimyksemme on saada tälle palstalle lisää aktiviteettia. Hyvin luonteva ja ajankohtainen aihepiiri tietotekniikan ja matematiikan yhteistyön alalla on symbolilaskenta, jota usein kutsutaan myös nimellä tietokonealgebra. Puhumme tässä kirjoituksessa lyhyyden vuoksi useimmiten symboliohjelmista. Kyseessä on niin laaja aihepiiri, että siitä riittää kerrottavaa montakin palstallista. Toivon, että tämä aihe kirvoittaa muitakin kirjoittajia näppäimistön äärelle.

Pyrin valottamaan joitakin symbolilaskennan perusajatuksia ja erityisesti lukion matematiikkaan liittyviä esimerkkejä. Joissakin kohdissa saattaa tulla vastaan jokunen koulukurssiin kuulumaton asia, mutta lukija voi huoletta sivuuttaa hänelle vieraat käsitteet kokonaisuuden siitä kärsimättä. Loppuhuipennuksena oleva esimerkiprojektikaan ei mene olennaisesti lukion suppean oppimäärän yli.

Keskityn tällä kertaa Maple-ohjelmaan.

Symbolien käsittelyä tietokonealgebrasysteemillä

Tietokoneen englanninkielinen nimi "computer" viittaa laskemiseen. Siihen tehtäväänhän tietokone alunperin kehitettiin. Tällä on totuttu tarkoittamaan laskentaa numeroilla, tarkemmin sanoen liukuluvuilla, eli desimaaliluvuilla, joiden esitystarkkuus on tyypillisesti noin 16 numeroa.

Laskentaan tietokoneella on myös toinen näkökulma, josta käytetään nimityksiä symbolilaskenta, symbolinen ja algebrallinen laskenta, tietokonealgebra ym. Lyhyesti sanottuna tällä tarkoitetaan laskentaa symboleilla, jotka edustavat matemaattisia olioita.

Tällaisten ohjelmistojen lyhyt kehityshistoria on hyvä esimerkki eri tieteen ja tekniikan alojen yhteistyön hedelmällisyydestä. Pohjatyöhön tarvittiin matemaatikoiden, fyysikoiden ja tekoälytutkijoiden yhteisiä ponnisteluja, joita on tehty 1950-luvulta alkaen. Erityisesti MIT:n eli Massachusetts Institute of Technology:n symbolilaskentaryhmän työn tuloksena syntynyt, tekoälykielellä Lisp ohjelmoitu Macsyma oli eräs 1960-luvun lopun ohjelmistoihme. Systeemi on edelleenkin käytössä. Noihin aikoihin ja vielä 1980-luvun lopulle saakka vakava este symboliohjelmien laajamittaiselle käytölle oli erityisesti suuri muistin tarve. Viime vuosina tämä este on käytännöllisesti katsoen poistunut ja etevimmätkin tietokonealgebrasysteemit ovat tulleet tavallisen kotikoneen käyttäjän ulottuville.

Nykyiset symbolilaskentaohjelmat on yleensä kirjoitettu C-kielellä ja niissä on kehittynyt graafinen käyttöliittymä, jonka ansiosta voidaan yhdistää käyttäjäystävällisellä tavalla symbolinen, numeerinen ja grafiikkaa sisältävä matemaattinen toiminta, mistä lopputuloksena voidaan muokata tyylikäs matemaattinen dokumentti.

Yleiskäyttöisistä symboliohjelmista suosituimmat lienevät nykyisin Mathematica ja Maple. Lisäksi erityisesti koulumaailmaa kiinnostava ohjelma on Derive, joka alunperin suunniteltiin pieniin koneympäristöihin. Nykyisin suuri osa Derive-ohjelmistoa toimii jopa TI-92-laskimessa (Texas Instruments 1995).

Maple ja Mathematica ovat periaatteessa keskenään samankaltaisia ohjelmia. Niissä molemmissa on valtavan matemaattisen tietämyksen lisäksi edellä kuvatunlainen pitkälle kehittynyt graafinen käyttöliittymä. Lisäksi kumpaankin systeemiin kuuluu täydellinen ohjemointikieli, joten ne ovat käyttäjän laajennettavissa. Niissä on samankaltainen perusfilosofia, jonka oppiminen antaa käyttäjälle suuren vapauden toteuttaa mitä erilaisimpia matemaattisia ideoita.

Käyttöliittymät ja matematiikka verkossa

Maplen käyttöliittymänä on työarkki ("worksheet"), joka näyttää matemaattiset kaavat oikeassa asussaan ja jolle myös grafiikka tulostuu.

Työarkissa on hyvät editointiominaisuudet, sitä voidaan käyttää matemaattisen työn dokumentointiin ja se voidaan joko osina tai kokonaisuutena muuntaa erilaisiin muotoihin. Tässä kirjoituksessa hyödynnämme erityisesti muunnoksia L^ATEX- ja HTML-muotoihin. Maplen uusimmassa versiossa V.5.1 voidaan työarkki ladata Maple-istuntoon suoraan verkosta antamalla kyseinen www-URL.

Molemmissa systeemeissä on myös kattava avustusjärjestelmä.

Sekä Maplen että Mathematican uusissa tai lähiaikoina julkistettavissa versioissa on MathML- tai OpenMath-muotoinen tulostus. Nämä tulevat olemaan WWW-selainten tukemia matematiikan esitysmuotoja verkossa.

Kerään kirjoitukseen liittyvät WWW-linkit sivulle http://www.math.hut.fi/~apiola/solmu/. Sieltä ovat myös saatavissa kaikki kirjoituksessa esiintyvät työarkit. Suunnittelen harjoittavani jonkinasteista ylläpitoa sivustolle ja erityisen mieluusti sijoitan sinne lukijoiden lähettämiä lisäyksiä, ehdotuksia, korjauksia, ratkaisutyöarkkeja, mielipiteitä ym.

Otan mielelläni vastaan palautetta osoitteella heikki.apiola@hut.fi .

Käytön perusteita

Maple käynnistetään suoraan ikonista tai esim. komennolla maple tai xmaple järjestelmästä riippuen.

Komentoja voidaan ruveta kirjoittamaan riville, jonka alussa on Maple-kehote . Jokainen komento vaatii loppumerkin, joko puolipisteen (;) tai kaksoispisteen (:).

Valaisen perusperiaatteita joukolla kommentoituja esimerkki-istuntoja. Pyrin esitykseen, joka antaisi mielikuvan joistakin ohjelman käyttömahdollisuuksista ja voisi olla kiinnostava sellaisillekin lukijoille, joilla ei ole ohjelmaa käytössään (ainakaan vielä).

Esimerkki-istunnot perustuvat Maplen versioon V.5.1 ja ne on tehty suurimmaksi osaksi LINUX-järjestelmässä. Ne toimivat aivan samalla tavoin muissa UNIX-järjestelmissä sekä WINDOWS- ja MACINTOSH-ympäristöissä. Työarkit ovat järjestelmästä riippumattomia, ts. jossain ympäristössä aloitettua työtä voi ongelmitta jatkaa toisessa.

Ladontateknisiä huomioita

Näillä ei ole mitään tekemistä kirjoituksen sisällön kanssa, mutta kenties ne ovat jollekin lukijalle kiinnostavia. Sinänsä olisi varmaan paikallaan saada Solmuun kirjoitus matemaattisesta tekstinkäsittelystä L^ATEX-ohjelmalla.

Esimerkit on tuotettu muuntamalla Maple-työskentelyn tuloksena syntyneet työarkit L^ATEX-muotoon osittain suoraan työarkin FILE-valikon EXPORT $\to$ LATEX-valinnalla, osittain muuntamalla yksittäiset kaavat Maplen latex-komennolla ja tekemällä hiukan käsityötä editorilla.

Kuvat on siepattu ruudulta UNIX-työkalulla nimeltään xv. Tämän ohjelman tuottama Postscript ei vastaa työarkin tarkkuutta. Siksi lehden sivulla olevien kuvien laatu on todellisuutta huonompi.

Maple laskimena

Käytän sanontoja komento ja funktio kutakuinkin synonyymeinä. Funktio-nimitystä käytän erityisesti matemaattisten operaatioiden yhteydessä.

Aloitan aritmeettisella työarkilla, jossa silmiinpistävää on tarkka rationaalilaskenta täydennettynä irrationaalilukuja esittävillä symboleilla.

> 70!;
119785716699698917960727837216890987364589381425464258575553628646280095827\
    89845319680000000000000000

> 6^130;
144431708923714697282341921957287977256854489558705240134406338415596406037\
    318860947517804001179467776

Maple laskee tarkoilla kokonais- ja rationaalilukuarvoilla. Laskentatarkkuutta rajoittaa vain käytettävissä oleva muisti.

> 70!/6^130;

$${\frac { 4380414169927950381453352896018734057670342713921685... ...734793686199713952913070338335607038938965023384939698061312}}$$

Osoittajan ja nimittäjän pituuksien perusteella näemme, että Maple supistaa automaattisesti yhteiset tekijät.

Komennolla evalf saadaan liukulukulikiarvo (f-kirjain sanan evalf lopussa viittaa termiim "floating point").
Edellisen komennon tulokseen viitataan %-merkillä.

> evalf(%);
          .08293588547

Liukulukulikiarvon laskentatarkkuuden oletuksena on 10 numeroa. Tarkkuutta voidaan muuttaa antamalla se komennon toiseksi argumentiksi.

Maple tuntee matemaattisia vakioita, kuten $\pi$, jonka merkkinä on Pi.

> evalf(Pi,60);
         3.14159265358979323846264338327950288419716939937510582097494

Imaginaariyksikölle on varattu kirjain I, sensijaan Neperin luvulle ei ole varattu omaa merkkiä, vaan se lasketaan eksponenttifunktion avulla pisteessä x=1.

> evalf(exp(1),50);
              2.7182818284590452353602874713526624977572470937000

Käytämme hyväksemme Maplen yhtälörakennetta tulostaaksemme matemaattisen identiteetin. Vasemmalla puolella käytämme sitaatteja, mikä estää arvon laskemisen.

> 'sin(Pi/2)'=sin(Pi/2);

$$\sin \pi/2 = 1$$

Funktiolla seq on kätevää muodostaa erilaisia jonoja.

> seq(2^i,i=0..15);

1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768

Funktio ithprime on esimerkki Maplen lukuisista voimakkaista matemaattisista funktioista. Sen nimi viittaa englanninkieliseen sanaan "i^th prime", eli i:s alkuluku. Niinpä lukija arvannee, mitä tässä tapahtuu:

> seq(ithprime(i),i=10..25);

29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

Ei ole vaikeaa antaa ohjelmalle liian suurta tehtävää:

> seq(ithprime(i),i=1..10^6);
Error, object too large

Polynomeja ja muita lausekkeita

Aivan kuin missä tahansa ohjelmointikielessä, voimme ottaa käyttöön muuttujia, joille sijoitamme arvoja. Sijoittamismerkkinä on . Symboliohjelman tapauksessa arvot voivat olla myös symboleja tai symboleista koostuvia lausekkeita.

Merkittävä symboliohjelman ominaisuus on kyky sieventää lausekkeita. Tähän on monia komentoja. Yleiskomento on simplify. Tavallisesti käyttäjällä on mielessään jokin muoto, johon hän pyrkii. Silloin on syytä käyttää esim. auki kertovaa komentoa expand, tekijöihin jakoa yrittävää factor, yhteen keräävää combine jne. Komentoihin voidaan liittää monia lisätarkentimia.

Annamme muutaman esimerkin lukuisista sievennyskomennoista ja niiden lukuisista lisätarkentimista. Kannattaa suorittaa avustuskomento ?simplify kattavan esittelyn saamiseksi. Aihetta on käsitelty kaikissa viitteissämme, mainittakoon [2][I.4, ss. 103-111], [6][Luku 10]. Perusteellisin esitys on Heckin kirjassa [4] .

> p:=(x-1)^4;

$$p:= \left (x-1\right )^{4}$$

> expand(p);

$${x}^{4}-4\,{x}^{3}+6\,{x}^{2}-4\,x+1$$

> q:=x^4+2*x^3-12*x^2-40*x-32;
> factor(q);

$$q:= {x}^{4}+2\,{x}^{3}-12\,{x}^{2}-40\,x-32$$

$$\left (x-4\right )\left (x+2\right )^{3}$$

Sievennyskomennot säilyttävät lausekkeen matemaattisesti identtisenä, joten niiden avulla saadaan kätevästi yhtälökaavoja alla olevaan tyyliin.

> exp(x*ln(y))=simplify(exp(x*ln(y)));

$${e^{x\ln (y)}}={y}^{x}$$

> sin(x)^2+cos(x)^2=simplify(sin(x)^2+cos(x)^2);

$$\left (\sin(x)\right )^{2}+\left (\cos(x)\right )^{2}=1$$

> 4*cos(x)^3=combine(4*cos(x)^3);

$$4\,\left (\cos(x)\right )^{3}=\cos(3\,x)+3\,\cos(x)$$

Trigonometrisille lausekkeille combine lausuu $\sin$:n ja $\cos$:n potenssit moninkertaisten kulmien avulla, kun taas expand tekee päinvastoin.

Huomautamme, että samoja lausekkeita ei tarvitse kirjoittaa kahteen kertaan, vaan voimme käyttää työarkin leikkaus/liimaus-toimintoja samalla tavoin kuin WINDOWS-, MACINTOSH- tai XWINDOW-ympäristöissä yleensäkin tehdään. Tämä koskee myös tuloksena saatavia (sinisiä) matemaattisia kaavoja, joita voidaan osina tai kokonaisina siirtää suoraan (punaiselle) syöteriville.

Grafiikkaa

Maplessa on suuri joukko monipuolisia komentoja matemaattiseen visualisointiin.

Perustavin komento on plot, jonka käyttö on yksinkertaisimmillaan muotoa

> plot(lauseke,x=a..b);

Esimerkiksi:

> plot(sin(x)*exp(-x),x=0..2*Pi);

tuottaa oheisen kuvan (Kuva 1) työarkille.

Kuva 1: Esimerkki plot-komennon käytöstä.

Osa grafiikkafunktioista on erikseen ladattavassa pakkauksessa plots. Otamme tässä esimerkin funktion animate käytöstä. Näemme, että matemaattisten animaatioiden tekeminen käy hyvin vaivattomasti. Jäljempänä olevissa esimerkeissämme tulee käyttöön muutama muu plots-pakkauksen funktio.

Haluamme tehdä animaation, joka havainnollistaa monomifunktioiden xⁿ käyttäytymistä välillä [-1,1], kun parametriä n vaihdellaan.

with(plots):   # Ladataan plots-pakkaus. ?plots antaa funktiolistauksen.
animate(x^n,x=-1..1,n=1..20,frames=20);

Tulokseksi saamme kuvan, joka hiirellä aktivoitaessa saa ympärilleen animaatiovalikon.

Työarkki voidaan tulostaa HTML-muodossa, jolloin animaatiot saadaan verkkoon eläviksi. Tässä ei saada kaikkia työarkin mahdollisuuksia, kuten animaation suoritusta askel kerrallaan, suunnan vaihtoa, hidastuksia/nopeutuksia ym. Ne lukijat, joilla on Maple käytössään, voivat ladata työarkin Mapleen, kokeilla ja muunnella esimerkkiä.

Grafiikkafunktioilla on suuri joukko kuvan asua sääteleviä valitsimia, jotka voidaan aktivoida suoraan hiirellä grafiikkavalikoista tai antaa piirtokomennon tarkentimina. Näitä voidaan kysellä esimerkiksi tyyliin ?plot tai ?plot,options. Jäljempänä esiintyvissä esimerkeissä varustan piirtokomennot asianmukaisilla tarkentimilla komentopohjaisesti. Tästä on se etu, että komennot voidaan ajaa uudelleen ja tuloksena on täsmälleen samanlaiset kuvat.

Pakkauksen plots lisäksi Maple sisältää muitakin grafiikkakirjastoja, kuten esimerkiksi plottools, geometry ja geometry3d. Lisäksi stats-pakkaus sisältää joukon tilastolliseen kuvaamiseen sopivia piirtofunktioita. Hyviä esimerkkejä grafiikkakirjastojen käytöstä on mm. kirjassa [6].

Yhtälöitä

Yhtälö ilmaistaan siis muodossa vasen=oikea. Yhtäsuuruusmerkkiä ei pidä sekoittaa sijoitusmerkkiin . Toisen asteen yhtälö ei tuota vaikeuksia.

> solve(x^2-x=5,x);

$${\frac{1}{2}}+{\frac{1}{2}}\,\sqrt {21}, {\frac{1}{2}}-{\frac{1}{2}}\,\sqrt {21}$$

Yhtälöryhmä ilmaistaan joukkona. Jos ratkaistavana olisi systeemi

$$\begin{cases} 2x+3y+z=1 \\ x-y-z=4 \\ 3x+7z=5, \end{cases}$$

kirjoittaisimme

> yhtsys:={2*x+3*y+z=1,x-y-z=4,3*x+7*z=5}:
> solve(yhtsys,{x,y,z});

$$\left \{x={\frac {101}{41}},z=-{\frac {14}{41}},y=-{\frac {49}{41}} \right \}$$

Yllä ratkaisimme lineaarisen systeemin. Epälineaarisia yhtälöitä ja systeemejä voidaan vain harvoin ratkaista tarkassa symbolisessa muodossa.

Kun halutaan numeerista ratkaisua, liitetään f-kirjain solve-sanan eteen (vrt. evalf edellä). Numeeriselle ratkaisijalle täytyy yleensä antaa alkuarvaus, jonka selvittämiseen voidaan käyttää grafiikkaa, numeerisia kokeiluja tai esim. fysikaalista perustetta.

Otetaan ratkaistavaksi yhtälöpari

$$\begin{cases} x^2+y^2=10 \\ x^y=2 \end{cases}$$

Lähtöarvon keksimiseksi piirrämme kuvan (Kuva 2) komennolla implicitplot, joka soveltuu "implisiittisessä muodossa" annettuihin, tyyppiä f(x,y)=c olevien yhtälöiden kuvaajien piirtoon. Lataamme ensin lisäpakkauksen plots.

> with(plots):
> implicitplot({x^2+y^2=10,x^y=2},x=0..3.4,y=-3.4..3.4);

Kuva 2: Esimerkki implicitplot-komennon käytöstä.

Kun osoitamme hiirellä kuvaan ja erityisesti asetamme osoittimen leikkauspisteen kohdalle (hiirikäden tarkkuudella), näemme vasemmassa yläkulmassa koordinaatit . Voimme antaa tämän alkupisteeksi numeeriselle ratkaisijalle

> fsolve({x^2+y^2=10,x^y=2},{x=1.23,y=2.88});

$$\left \{x= 1.270433346, y= 2.895858960 \right \}$$

Havaitsemme, että hiirikäsi ei ollut kovin tarkka. Samalla tavoin voisimme määrittää kaksi muuta kuvassa näkyvää ratkaisupistettä.

Derivaatat

Derivointi on symboliohjelmien varhaisia riemuvoittoja. Itse asiassa lausekkeiden sievennys on vaikeampi tehtävä ja vasta kehittyneet, syvällistä algebrakoneistoa käyttävät sievennysalgoritmit ovat tehneet näistä käyttökelpoisia työvälineitä.

Symboliohjelmat osaavat suuren joukon derivoimissääntöjä, joiden turvin derivointi sujuu nopeasti ja luotettavasti. Maplessa lausekkeen derivointi tapahtuu komennolla

> diff(lauseke,muuttuja(jono));

Derivoinnin tulosta on tavallisesti syytä sieventää, usein päästään hyvään tulokseen yleissieventäjällä simplify, mutta tilanteesta riippuen kannattaa tietysti soveltaa erityisempiä, kuten tässä teemme. Saattaapa käydä niinkin, että simplify mutkistaa lauseketta, kuten kohta esitettävässä esimerkissä tapahtuu.

> f:=x^3*exp(x)*cos(x);df:=diff(f,x);

$$f:= {x}^{3}{e^{x}}\cos(x)$$

$$df:=3\,{x}^{2}{e^{x}}\cos(x)+{x}^{3}{e^{x}}\cos(x)-{x}^{3}{e^{x}}\sin(x)$$

> factor(df);

$$-{x}^{2}{e^{x}}\left (-3\,\cos(x)-x\cos(x)+x\sin(x)\right )$$

> collect(%,cos(x));

$$\left (3\,{x}^{2}{e^{x}}+{x}^{3}{e^{x}}\right )\cos(x)-{x}^{3}{e^{x}} \sin(x)$$

Kokeillaan hieman mutkikkaampaa, muodostetaan x^xx:n kolmas derivaatta. Korkeammat derivaatat saadaan toistamalla dervoimismuuttujaa.

> diff(x^(x^x),x,x,x);

${x}^{{x}^{x}}\left ({x}^{x}\left (\ln (x)+1\right )\ln (x)+{\frac {{x} ^{x}}{x... ...{x}}\left ({x}^{x}\left (\ln (x)+1 \right )\ln (x)+{\frac {{x}^{x}}{x}}\right )$

$\left ({x}^{x}\left (\ln ( x)+1\right )^{2}\ln (x)+{\frac {{x}^{x}\ln (x)}{x}}+... ...rac {{x}^{x} \left (\ln (x)+1\right )}{x}}- {\frac {{x}^{x}}{{x}^{2}}}\right )+$

${x}^{ {x}^{x}}\left ({x}^{x}\left (\ln (x)+1\right )^{3}\ln (x)+3\,{\frac {{ x}... ...^{x}\left (\ln (x)+1\right )}{ {x}^{2}}}+2\,{\frac {{x}^{x}}{{x}^{3}}}\right )$

Huomaamme, että varsin yksinkertaiset operaatiot voivat johtaa massiivisiin lausekkeisiin, joita ei enää ole mahdollista hallita ilman tietokonealgebraohjelmaa. Tässä tapauksessa simplify-komento antaisi vielä pitemmän lausekkeen tulokseksi.

Symboliohjelma suorittaa derivoinnin tuntemiensa sääntöjen ja kaavojen nojalla. Tällaisia ovat esimerkiksi summan ja tulon derivoimissäännöt ja potenssin derivoimiskaava.

Komento diff ei kerro mitään derivaatasta sellaisissa pisteissä, joissa kaavoja tai sääntöjä ei voida soveltaa. Käyttäjän tulee itse olla selvillä kaavojen pätevyysalueesta. Ohjelmaa voidaan monin tavoin hyödyntää myös tilanteissa, joissa pelkät säännöt eivät toimi.

Otamme pienen esimerkki-istunnon, jossa määrittelemme yleisen erotusosamääräfunktion eros. Siinä jätetään f ja xvapaiksi symboleiksi (ohjelmointitermein sanottuna globaaleiksi muuttujiksi) ja otetaan vain x:n lisäys h argumentiksi. Esittelemme funktiomääritysasiat "virallisesti" vasta ohjelmointia koskevassa kohdassa. Esimerkkifunktiona käytämme kaikkein tutuinta ei-derivoituvaa funktiota, itseisarvoa, jonka määrittelemme paloittain komennolla piecewise. (Emme käytä Maplen sisäänrakennettua abs-funktiota.)

> eros:=h->(f(x+h)-f(x))/h;

$$\textrm{eros}:= h\mapsto {\frac {f(x+h)-f(x)}{h}}$$

> f:=x->piecewise(x<0,-x,x>0,x);

$$f:= x\mapsto % \begin{cases} -x , x<0 \\ x, x>0 \end{cases}$$

Tutkitaan derivoituvuutta pisteessä x=0.

> x:=0:

Tutkimme erotusosamäärän vasemman- ja oikeanpuoleisia raja-arvoja,

> limit(eros(h),h=0,left);
> limit(eros(h),h=0,right);

-1

1

Koska ne ovat erisuuret, ei funktiollamme ole derivaattaa 0:ssa.

Käsittelimme tahallamme triviaalin esimerkin. Usein on viisasta aloittaa tapauksella, jonka ratkaisu tunnetaan. Oikeasti kiinnostavan tapauksen suhteen tarvitsee tässä tapauksessa vain muuttaa funktion f määrittely ja tarkastelupisteestä riippuen sijoituslause     > x:=0;

Numeeriset ja graafiset kokeilut erotusosamäärällä ja niiden opetukset niin derivaattakäsitteen kuin numeeristen ilmiöiden suhteen voisivat olla seuraavan kirjoituksen aihepiiriä.

Tässä on sopiva paikka korostaa sitä, että symboliohjelman käyttö on ihmisen ja ohjelman välistä vuorovaikutusta, eikä suinkaan mekaanista nappien painelemista. Olennaisena välineenä ratkaisuprosessissa on edelleenkin myös kynä ja paperi.

Integrointi

Integrointi sujuu käyttäjän kannalta yhtä helposti, mutta se on huomattavasti vaikeampi tehtävä ohjelmalle. Tavallisten integrointisääntöjen lisäksi Maple sisältää varsin syvällistä matemaattista koneistoa hyödyntävän ns. Rischin algoritmin. Maple osaa myös suuren joukon ns. erikoisfunktioita, mistä syystä osa matemaattisen tradition mahdottomiksi julistamista integraaleista on myös symbolisesti laskettavissa. Joka tapauksessa integroinnin suhteen tilanne on aivan vastaava kuin edellä esiteltyjen epälineaaristen yhtälöiden kohdalla. Valtaosa todellisissa sovellutuksissa vastaan tulevista integraaleista on laskettava numeerista approksimaatiota käyttäen.

Integraalifunktio saadaan komennolla int(lauseke,muuttuja); Määrätty integraali lasketaan liittämällä rajat mukaan tyyliin int(lauseke,muuttuja=a..b); Käytämme edellä esiteltyä yhtälötyyliä, missä estämme vasemman puolen laskennan jälleen sitaateilla.

> 'int(1+x+x^3+sin(x),x)'=int(1+x+x^3+sin(x),x);

$$\int \!1+x+{x}^{3}+\sin(x)\,{dx}=x+1/2\,{x}^{2}+1/4\,{x}^{4}-\cos(x)$$

Maple ei liitä mukaan integroimisvakiota. Määrätty integraali saadaan tähän tapaan:

> 'int(1+x+x^3+sin(x),x=2..3)'=int(1+x+x^3+sin(x),x=2..3);

$$\int _{2}^{3}\!1+x+{x}^{3}+\sin(x)\,{dx}={\frac {79}{4}}-\cos(3)+\cos(2)$$

Seuraavaksi otetaan hieman vaikeampi.

 
> 'int(1/(1+x^3),x)' = int(1/(1+x^3),x);

$$\int \!\left (1+{x}^{3}\right )^{-1}\,{dx}=1/3\,\ln (1+x)-1/6... ...1)+1/3\,\sqrt {3}\arctan(1/3\,\left (2\,x-1\right )\sqrt {3})$$

Tutuin esimerkki yllä mainitusta "mahdottomaksi julistetusta" integraalista johtaa normaalijakautumaan liittyvään erf-funktioon.

> int(exp(-t^2),t=0..x)'=int(exp(-t^2),t=0..x);

$$\int _{0}^{x}\!{e^{-{t}^{2}}}\,{dt}=1/2\,\textrm{erf}(x)\sqrt {\pi }$$

Seuraavasta Maple ei ymmärrettävästikään selviä, missä tapauksessa se palauttaa annetun tehtävän sellaisenaan.

> int(sin(1/x^3),x=1..2);

$$\int _{1}^{2}\!\sin({x}^{-3}){dx}$$

Numeeriseen integrointiin siirrytään liittämällä eteen vanha tuttavamme evalf.

> evalf(Int(sin(1/x^3),x=1..2));

.3548334332

Jääköön Maple-kirjoista luettavaksi, miksi tässä Int on suositeltavampi kuin int .

Symbolien hallintaa ja periaatteita

Otetaan lähtökohdaksi jokin matemaattinen kaava, vaikkapa korkolaskukaava.

Otamme käyttöön muuttujan r, jolle sijoitamme arvoksi koron kaavan, missä symboleille K (pääoma), p (korkoprosentti) ja t (aika) ei ole annettu mitään arvoja.

> r:=K*p*t/100;

$$r:={\frac {1}{100}}\,Kpt$$

Jos annamme muuttujille arvoja, muuttuu edellä määritelty muuttuja rvastaavasti.

> K:=10225: p:=3: t:=1/12:
> r;

$${\frac {409}{16}}$$

Annamme muuttujalle p uuden symbolisen arvon q ja poistamme t:ltä arvon. Arvon poistaminen, eli muuttujan vapauttaminen saadaan aikaan sijoittamalla muuttujalle arvoksi sen nimi varustettuna laskennan estävillä sitaateilla.

> p:=q: t:='t':
> r;

$${\frac {409}{4}}\,qt$$

Lopuksi vapautamme kaikki muuttujat ja katsomme, mikä arvo muuttujallamme r on.

> K:='K': p:='p': t:='t':
> r;

$${\frac {1}{100}}\,Kpt$$

Pääsimme näin takaisin peruskaavaan, josta lähdimme liikkeelle.

Tässä on tärkeää suorittaa juuri mainitussa järjestyksessä, siis kirjoitamme yleisen kaavan ensin ja sijoittelemme vasta sen jälkeen muuttujille arvoja. Jos tekisimme päinvastaisessa järjestyksessä, niin kyseisen muuttujan arvo kiinnittyisi kaavassa ja sitä ei voitaisi enää jälkeenpäin muuttaa. Otetaan pieni jatkoesimerkki tästä.

> restart:
> p:=5:
> r:=K*p*t/100;
                            r := 1/20 K t
> p:=6:
> r;

                               1/20 K t

Ilmiö johtuu ns. täysevaluaatiosta "full evaluation". Aina, kun muuttujalle sijoitetaan jokin arvo, joka sisältää symboleja, niin symbolien arvot lasketaan ensin, nämä arvot saattavat puolestaan sisältää symboleja, jotka puolestaan lasketaan jne. Lopuksi tuo "täysin evaluoitu" arvo sijoitetaan ao. muuttujalle.

Otamme vielä toisen esimerkin, napakoordinaattimuunnoksen. Koordinaatiston piste (x,y) määräytyy antamalla pisteestä (x,y)origoon piirretyn "napasäteen" ja positiivisen x-akselin välinen kulma $\varphi$ ja pisteen etäisyys origosta, r.

Suorakulmaiset koordinaatit saadaan näiden avulla kaavoista

$$\begin{cases} x=r\cos \varphi \\ y=r\sin \varphi \end{cases}$$

Kirjoitamme ensin muunnoskaavat

> restart:
> x:=r*cos(phi):
> y:=r*sin(phi):

Olkoot pisteen napakoordinaatit r=1, $\varphi=\pi/4$. Muunnoskaavoista näemme, että $x=y=1/\sqrt{2}$ .

Koska syötimme muunnoskaavat Maplelle, voimme kysyä sen mielipidettä yksinkertaisesti kirjoittamalla muuttujien nimet:

> r:=1: phi:=Pi/4:
> x, y;

$${\frac{1}{\sqrt{2}}},{\frac{1}{\sqrt{2}}}$$

Voimme näin antaa r:lle ja $\varphi$:lle mitä arvoja tahansa, muuttujiin x ja y ilmestyvät automaattisesti vastaavat xy-koordinaatit.

Tätä olisi houkuttelevaa kehitellä hiukan eteenpäin sopivaa ohjausrakennetta käyttäen ja kuvilla havainnollistaen, mutta jätetään se lukijalle ja ryhdytään sensijaan esittelemään ohjausrakenteita ja ohjelmointia.

Sitä ennen kertaamme vielä yhteenvetona, että etenimme yleisestä erityiseen. Kirjoitimme ensin yleisen kaavan ja vasta sen jälkeen annoimme kaavassa esiintyville muuttujille arvoja. Huomautamme, että numeerisen ohjelman tapauksessa näin ei voida menetellä, koska se ei suostu käsittelemään muuttujaa, jolla ei ole numeerista arvoa.

Ohjelmointi

Maple on myös täydellinen ohjelmointikieli, jolla voidaan määritellä omia funktioita eli proseduureja. Käyttäjä, joka ei halua varsinaisesti kirjoittaa ohjelmia, voi tehdä symboliohjelmalla hyvin paljon puhtaasti vuorovaikutteisesti. Omien matemaattisten funktioiden kirjoittamiseen kannattaa kuitenkin totuttautua, muuten käyttötapa muodostuu tarpeettoman köyhäksi. Tällä tarkoitan kohta esitettävällä "nuolityylillä" kirjoitettuja pikku funktioita. Niiden kirjoittamista en tässä pidä varsinaisena ohjelmointina.

Enemmän symboliohjelmaa käyttävä henkilö tuntee kyllä usein tarvetta laajentaa systeemiä jollakin omalla ohjelmallaan. Vaikka Maplessa on tuhansia funktioita, niin aina tulee vastaan tilanteita, joissa käyttäjä haluaisi jotain muuta, tai sitten hän ohjelmoi nopeammin kuin etsii erilaisista kirjastoista, WWW-sivuilta ym.

Annamme ohjelmointia välttelevälle lukijalle luvan lopettaa tämän kohdan lukemisen aloittaessamme Fibonacci-teemaa.

Edellä olemme käsitelleet matemaattisia funktioita yleensä lausekkeina. Derivaattakohdan lopulla käytimme esimerkissä myös oikeata funktiomääritystä, jonka esittelyn aika alkaa olla käsillä.

Jos kirjoitamme

> f:=x*sin(x);

voimme kohdistaa f:ään monenlaisia symbolisia operaatioita, kuten sievennys, derivointi, integrointi, kuvaajan piirtäminen ym. Sensijaan emme voi luontevalla tavalla laskea funktion arvoja eri pisteissä. Tämä johtuu siitä, että f ei ole Maplen kannalta funktio, vaan pelkästään symboleja sisältävä lauseke.

Maplessa on sinänsä hyvin hyödyllinen korvauskomento subs, jota voimme käyttää tyyliin

> fa:=subs(x=a,f);

Sen käyttö on kömpelöä, jos joudumme usein laskemaan arvoja eri pisteissä ja miltei toivotonta käsitellessämme yhdistettyjä funktioita.

Funktiomääritys saadaan aikaan normaalia matemaattista merkintätapaa muistuttavalla tyylillä:

> f:=x->x*sin(x);

Toisin sanottuna: Funktio on olio f, joka liittää annettuun argumentin arvoon x laskukaavan (yleisemmin laskenta-algoritmin) antaman yksikäsitteisen arvon f(x). Onkohan tuttua matematiikan tunnilta?

Nyt voimme käytellä funktiotamme aivan normaalin matematiikan käytännön mukaisesti tähän tapaan:

> f(a);

$$a\sin(a)$$

> f(exp(z)*cos(z));

$${e^{z}}\cos(z)\sin({e^{z}}\cos(z))$$

> seq(f(x),x=0..5);

$$0, \sin(1), 2\,\sin(2), 3\,\sin(3), 4\,\sin(4), 5\,\sin(5)$$

Argumentteja voi olla useita, jolloin on kyse usean muuttujan funktiosta. Määrittelemme esimerkiksi kahden muuttujan funktion.

> g:=(x,y)->sqrt(x^2+y^2);

$$g:=( {x,y} )\mapsto \sqrt {{x}^{2}+{y}^{2}}$$

Laskemme funktion arvon pisteessä (2,-1) .

> g(2,-1);

$$\sqrt {5}$$

Maple tarjoaa myös vaihtoehtoisen syntaksin funktioiden eli proseduurien määrittelyyn. Jos haluaisimme kirjoittaa edellisen yksinkertaisen ja kauniin määritelmän mutkikkaasti, kömpelösti ja rumasti, voisimme kirjoittaa myös näin:

   f:=proc(x)
   x*sin(x);
   end:

Proseduuri palauttaa viimeksi laskemansa arvon.

Tällainen perinteisen ohjelmointityylin näköinen syntaksi (jonka rumuutta hieman liioittelimme) on tarpeellinen monimutkaisempien ohjelmien tapauksessa. Palaamme asian havainnollistamiseksi Jouni Seppäsen kirjoituksen Fibonacci-teemaan. Näiden lukujen merkitys matematiikan ja sen sovellusten kannalta jää usein opiskelijoilta näkemättä. Kirjoituksemme yhteydessä ei ole mahdollisuutta korjata tätä asiantilaa. Todettakoon vain, että nuo luvut tarjoavat ainakin ohjelmoinnin opetukseen hyvin soveltuvan, helposti ohjelmoitavan algoritmin, jolla voidaan valaista monia näkökulmia niin algoritmien erilaisen toteutuksen, tehokkuuden, rekursion ym. suhteen. Näitä seikkojahan valotettiin monipuolisesti Jouni Seppäsen kirjoituksessa.

Kirjoitamme aluksi rekursiivisen funktion, jonka koodi samalla palauttaa lukijan mieleen Fibonaccin lukujen määritelmän.

Fib:=proc(n::nonnegint)
     option remember;
       if n=0 then 0
       elif n=1 then 1
       else Fib(n-1)+Fib(n-2) 
       fi
     end:

Lause "option remember" tallettaa lasketut arvot proseduurin ns. muistitauluun, jolloin laskettuja arvoja ei lasketa uudelleen.

Kyseessä on Jouni Seppäsen kirjoituksessa "naiiviksi Fibonacciksi" kutsuttu toteutus, jota on parannettu tuolla muistamispiirteellä.

Kokeillaan hieman rajoja.

> restart:
> Fib(1000);
Error, (in type/nonnegint) too many levels of recursion

Lasketaan vaiheittain, jotta voimme hyödyntää muistamisominaisuutta.

> Fib(300);
   222232244629420445529739893461909967206666939096499764990979600
> Fib(500): # Laskemme, mutta emme tulosta.
> Fib(700): # Laskemme, mutta emme tulosta. 
> Fib(1000);
434665576869374564356885276750406258025646605173717804024817290895\
    36555417949051890403879840079255169295922593080322634775209689\
    62323987332247116164299644090653318793829896964992851600370447\
    6137795166849228875

Nytpä onnistui.

Fibonacci-ohjelma ei ole kuitenkaan tyypillistä symboliohjelmointia, siinä ei näy muita Maplen erityisominaisuuksia kuin rajoittamaton kokonaislukulaskentatarkkuus.

Teemme vielä version, jossa tulee ainakin hiukan symbolinkäsittelymahdollisuuttakin mukaan. Yleistämme tilannetta niin, että jätämme myös alkuarvot käyttäjän valittaviksi parametreiksi, jotka voivat olla myös symbolisia. Annamme ohjelmamme palauttaa koko jonon alusta alkaen. Kirjoitamme tällä kertaa ei-rekursiivisesti.

    yFib:=proc(a,b,n::nonnegint)
    local luvut,i;
    luvut[0]:=a;luvut[1]:=b:
    for i from 1 to n-1 do
        luvut[i+1]:=luvut[i]+luvut[i-1]
                        od;
    seq(luvut[i],i=0..n);
    end:

Kutsu jonon $f_0, \ldots f_{10}$ muodostamiseksi olisi

> yFib(0,1,10);

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

Voimme kutsua funktiotamme myös symbolisilla lähtöarvoilla, jolloin Maple sieventää tuloksen suoraan muotoon, jossa jonon k:s alkio näkyy olevan f_k-1 a₀ + f_k a₁, missä f_k tarkoittaa Fibonacci-lukua, jonka indeksi on k.

> yFib(a[0],a[1],9);

$$a_{{0}}, a_{{1}}, a_{{1}}+a_{{0}}, 2\,a_{{1}}+a_{{0}}, 3\,a_{... ...}+8\,a_{{0}}, 21\,a_{{1}}+13\,a_{{0}}, 34\,a_{{1}}+21\,a_{{0}}$$

Tällainen käyttötapa voi olla hyödyllinen monissa yhteyksissä ohjelmakoodin toimintaa selviteltäessä.

Enemmän matematiikkaa ja symbolisia operaatioita sisältävien ohjelmien suhteen viittaamme kirjan [2] lukuun 5 ja muihin viitteinä oleviin Maple-kirjoihin. Erityisesti Maple-ohjelmoinnille omistettu kirja on [7] .

Huomautamme, että Maplen tulkkausluonteesta johtuen ohjauslauseita voidaan käyttää myös Maple-istunnossa suoraan. Jos todella haluaisimme vain saada käsiimme alkupään Fibonacci-lukuja vaikkapa 50 kpl, riittäisi kirjoittaa

  > f[0]:=0: f[1]:=1;
  > for i from 2 to 50 do f[i]:=f[i-1]+f[i-2] od:

Esimerkkiprojektina kelluva lieriö

Lopuksi esitämme tehtävän, joka voisi olla vaikkapa pienen projektityön aiheena. Tehtävään sisältyvä matematiikka rajoittuu aika vähiin, lukion suppea oppimäärä on riittävä. Ainoa vakava lukion kurssin ylittävä kohta on epälineaarisen yhtälön ratkaiseminen, mutta se voidaan jättää Maple-ohjelman huoleksi.

Tehtävä. Miten syvällä vedessä kelluu alumiiniputki, jonka säde R=60 cm ja vaipan paksuus d=1 cm ? Putki tarkoittaa onttoa sylinteriä, joka on päistään suljettu ohuilla "painottomilla" levyillä. Alumiinin tiheys $\rho=2.7$ g/cm³.

Ratkaisu. Ideana on, että sylinterin veden alla olevan osan kokoisen vesimäärän paino antaa Arkhimedeen lain mukaisen nostevoiman, joka pitää tasapainossa sylinterirenkaan painon. Jälkimmäisen saamme kertomalla tiheydellä (ja g:llä) sisäkkäisten sylinterien tilavuuksien erotuksen.

Kuva 3: Sylinteri vedessä

Nostevoiman saamme kertomalla sylinterin pohjaympyrän vedenalaisen segmentin pinta-alan sylinterin pituudella (ja g:llä).

Kuvassa (Kuva 3) olemme valinneet koordinaatiston origoksi pohjaympyrän keskipisteen ja merkitsemme vedenpinnan ja x-akselin välistä pystysuoraa etäisyyttä y:llä siten, että pidämme y:tä positiivisena, jos veden pinta on x-akselin alapuolella, vastakkaisessa tapauksessa negatiivisena.

Keskuskulmaa $2 \alpha$ vastaavan kolmion pinta-ala $=y\sqrt{R^2-y^2}$. Jos y otetaan positiivisena alaspäin ja negatiivisena ylöspäin, kuten sovimme, saadaan segmentin ala kaikissa tapauksissa kaavalla

$${\frac{2\alpha}{2 \pi}}\pi R^2 - y\sqrt{R^2-y^2}.$$

Ratkaisutyöarkki on HTML:ksi muunnettuna kokonaisuudessaan luettavissa viitteestä http://www.math.hut.fi/~apiola/solmu/sylinteri.html . Oikea Maple-työarkki on saatavissa WWW-sivulta http://www.math.hut.fi/~apiola/solmu/sylinteri.mws .

Ratkaisutyöarkin L^ATEX-muunnos hieman lyhenneltynä

Piirrämme kuvan, jossa näkyy putki ja veden pinta. Piirretään ensin sylinteri. Tähän voidaan käyttää plots-pakkauksen plot3d-funkitota, jolla saadaan yleinen parametrimuotoinen pinta piirretyksi. (Tämä menee hieman yli koulukurssin, mutta nyt on pääasia, että saadaan kuva tavalla tai toisella aikaan.)

 
> with(plots):
> x:=t: y:=cos(theta): z:=sin(theta):
> X:=t: Y:=1.2*cos(theta): Z:=1.2*sin(theta):

Muodostamme 1-säteisen sylinterin [x,y,z] ja 1.2-säteisen [X,Y,Z], joiden akselina on x-akseli. Jos kiinnitetään t, saadaan ympyrä tasossa x=t, sylinteripinta muodostuu, kun annetaan t:n vaihdella. Piirrämme eri mitoilla, liioittelemme havainnollisuuden vuoksi putken paksuutta.

> sisasylinteri:=plot3d([x,y,z],t=-2..2,theta=0..2*Pi,axes=none,grid=[2,
> 50],scaling=constrained,orientation=[20,60],style=patchnogrid,...):
> ulkosylinteri:=plot3d([X,Y,Z],t=-2..2,theta=0..2*Pi,axes=none,grid=[2,
> 50],scaling=constrained,style=patchnogrid,shading=zgreyscale):
> vesi:=plot3d(1/3,xx=-4..2,yy=-2.5..2.5,shading=zgreyscale):
> display({sisasylinteri,ulkosylinteri,vesi});

Kuva 4: Pohjaympyrän ja vedenalaisen segmentin alan laskenta.

> x:='x': y:='y': z:='z':

Käytämme ainakin y:tä vapaana symbolina, joten se täytyy vapauttaa edellisestä arvostaan.

Nosteen laskemiseksi tarvitsemme vedenalaisen lieriösegmentin tilavuuden, jota varten laskemme ulkolieriön pohjasegmentin pinta-alan. Piirretään pohjaympyrä ja vedenpinta. Annamme komennot, mutta jätämme kuvan näyttämättä, koska samanlainen kuva oli jo edellä.

> restart: with(plots):
> R:=30: x:=R*cos(theta): y:=R*sin(theta):
> ympyra:=plot([x,y,theta=0..2*Pi]):
> t1:=-Pi/6: t2:=Pi+Pi/6: x1:=R*cos(t1): y1:=R*sin(t1): x2:=R*cos(t2):
> y2:=R*sin(t2): kolmio:=plot([[0,0],[x1,y1],[x2,y2],[0,0]]):
> vesi:=plot(y1,xaks=-40..40,color=blue):
> mittaviiva:=plot([[32,y1],[32,0]],color=black):
> y:='y': yteksti:=textplot([33.5,-7.5,"y"]):
> alteksti:=textplot([3,-5,"a"]):
> display({kolmio,ympyra,vesi,mittaviiva,yteksti,alteksti});

Jos ympyrä ei näytä ympyrältä, kannattaa näpäyttää kuvavalikon -painiketta.

Olemme käyttäneet monia muuttujia, nyt on syytä aloittaa puhtaalta pöydältä.

> restart:
> kolmion_ala:=y*sqrt(R^2-y^2);

$$\textrm{kolmion\_ala} := y\sqrt {900-{y}^{2}}$$

Huom! Tässä muodostettiin merkillä varustettu ala.

> sektorin_ala:=(2*alpha)/(2*Pi)*Pi*R^2;

$$\textrm{sektorin\_ala} :=900\,\alpha$$

 
> segmentin_ala:=sektorin_ala-kolmion_ala;

$$\textrm{segmentin\_ala} := 900\,\alpha-y\sqrt {900-{y}^{2}}$$

> noste:=g*segmentin_ala*syl_pituus;

$$\textrm{noste} := g\left (900\,\alpha-y\sqrt {900-{y}^{2}}\right )\textrm{syl\_pituus}$$

> putken_tilavuus:=(Pi*R^2-Pi*(R-d)^2)*syl_pituus;

$$\textrm{putken\_tilavuus} := \left (900\,\pi -\pi \,\left (30-d\right )^{2}\right )\textrm{syl\_pituus}$$

> putken_paino:=simplify(rho*g*putken_tilavuus);

$$\textrm{putken\_paino} := -\rho\,g\pi \,d\left (-60+d\right )\textrm{syl\_pituus}$$

Muodostamme tasapainoehtoyhtälön.

> ehto:=noste=putken_paino;

$$\textrm{ehto} := g\left (900\,\alpha-y\sqrt {900-{y}^{2}}\rig... ...tuus}=- \rho\,g\pi \,d\left (-60+d\right )\textrm{syl\_pituus}$$

Maple ei suorita puolittain jakamista, ennenkuin vaadimme sitä:

> ehto:=ehto/(g*syl_pituus);

$$\textrm{ehto} := 900\,\alpha-y\sqrt {900-{y}^{2}}=-\rho\,\pi \,d\left (-60+d\right )$$

Yhtälön sieventäminen käy parhaiten muodostamalla vasemman puolen (lhs - left hand side) ja oikean puolen (rhs - right hand side) erotus.

> ehto:=simplify(rhs(ehto)-lhs(ehto))=0;

$$\textrm{ehto} := 60\,\rho\,\pi \,d-\rho\,\pi \,{d}^{2}-900\,\alpha+y\sqrt {900-{y}^{2}} =0$$

> alpha:=arccos(y/R);

$$\alpha:=\arccos(1/30\,y)$$

Tarkistetaanpa, miten Maple ymmärtää $\arccos$-funktion päähaaran. Kuva (jota emme tässä tulosta) näyttää, että se sopii juuri tarkoitukseemme.

> plot(arccos(x),x=-1..1);
> ehto;

$$60\,\rho\,\pi \,d-\rho\,\pi \,{d}^{2}-900\,\arccos(1/30\,y)+y\sqrt { 900-{y}^{2}}=0$$

Tässä vaiheessa otamme numeroarvot mukaan. Muistamme, että kun lausekkeessa esiintyville muuttujille annetaan arvoja, ne sijoittuvat automaattisesti lausekkeeseen. (Muistele korkoa ja napakoordinaatteja!)

> R:=30: d:=1: rho:=2.7:
> ehto;

$$159.3\,\pi -900\,\arccos(1/30\,y)+y\sqrt {900-{y}^{2}}=0$$

Edelleenkin näyttää jokseenkin kaamealta yhtälöltä. Vaan onpa meillä välineet sen selvittelyyn. Katsotaan ensin, miltä yhtälön vasemman puolen kuvaaja näyttää (Kuva 5), jotta saamme käsityksen ratkaisujen olemassaolosta, lukumäärästä ja sijainnista.

Kuva 5: Yhtälön vasemman puolen kuvaaja.

> F:=lhs(ehto);

$$F:=159.3\,\pi -900\,\arccos(1/30\,y)+y\sqrt {900-{y}^{2}}$$

> plot(F,y=0..30);

Annamme kuvasta katsomamme karkean likiarvon y=16 numeerisen ratkaisijan lähtöpisteeksi.

> yarvo:=fsolve(ehto,y=16);

yarvo := 16.01860140

> syvyys:=R-yarvo;

syvyys := 13.98139860

Piirrämme lopuksi putken ja vedenpinnan oikeilla arvoilla.

> X:=t: Y:=R*cos(theta): Z:=R*sin(theta): x:=t: y:=(R-d)*cos(theta):
> z:=(R-d)*sin(theta):

Piirtokomennot ovat periaatteessa aivan samat kuin ensimmäisessä kuvassa, siksi emme niitä näytä tämän enempää.

> display({sisasylinteri,ulkosylinteri,vesi});

Kuva 6: Sylinteri vedessä.

Huomaamme, että oikeilla mitoilla varustettuna sylinteri näyttää hyvin ohuelta, niinpä ei olekaan ihme, että se kelluu näin ylhäällä.

Loppumietteitä

Olemme nähneet joitakin symboliohjelman periaatteita ja mahdollisuuksia. Tämänkaltaisen ohjelman avulla rutiinioperaatioita voidaan siirtää koneelle ja antaa enemmän tilaa luovalle ajattelulle ja ideoinnille. Kehittynyt graafinen käyttöliittymä houkuttelee kirjoittamaan työstä viimeistellyn dokumentin ja antaa siten välineet projektiluonteisiin suorituksiin.

Koulumatematiikassakin voidaan ottaa nykyistä vaativampia ja siten kiinnostavampia tehtäviä eristämällä jokin ratkaisun osa "mustaksi laatikoksi", kuten edellä teimme epälineaarisen yhtälön ratkaisijan suhteen. Erillisenä projektina voitaisiin käsitellä käytetyn mustan laatikon toiminnan selvittelyä.

Toki on syytä muistaa, että myös käsin tapahtuva kaavojen sieventäminen ja niillä operoiminen on edelleenkin välttämätön taito, jota ohjelmalla ei voi korvata. Paras tulos ohjelman käytössä saavutetaan tietenkin siten, että ihminen panee myös koko luovan panoksensa peliin.

Rantasalmella elokuussa 1999

Heikki Apiola
Matematiikan laitos
Teknillinen korkeakoulu

Viitteet

1

G. Andersson.
Applied Mathematics with Maple.
Studentlitteratur, 1997.

2

H. Apiola.
Symbolista ja numeerista matematiikkaa Maple-ohjelmalla.
Otatieto, 1998.

3

K.M. Heal, M.L. Hensen, and K.M. Rickard.
Maple V Learning Guide.
Springer, 1996.

4

A. Heck.
Introduction to Maple.
Springer, 1996.
2nd edition.

5

R.B. Israel.
Calculus the Maple way.
Addison Wesley, 1996.

6

M. Kofler.
Maple An Introduction and Reference.
Addison Wesley, 1997.

7

M.B. Monagan, K.O. Geddes, K.M. Heal, G. Labahn, and S.M. Vorkoetter.
Maple V Programming Guide.
Springer, 1996.

Alkuun

Solmu 2/1999-2000
Viimeksi muutettu 24. marraskuuta 1999.