Tehtävä 1

lauseke = x y/(x^2 + y^2);

lauseke /. {x -> 2,  y -> 3}

lauseke /. {x -> -5,  y -> Pi}

N[lauseke /. {x -> 2,  y -> 3}, 50]

N[lauseke /. {x -> -5,  y -> Pi}, 
      50]

Tehtävä 2

yhtaloa = 168 x == 195

ratkaisua = Solve[yhtaloa, x]

yhtaloa /. ratkaisua

yhtalob = x^2 - 2 x - 4 == 0

ratkaisub = Solve[yhtalob, x]

yhtalob /. ratkaisub // Simplify

Tässä kuten muutamissa myöhemmissäkin kohdissa tulee kummallisia $MaxExtraPrecision-virheilmoituksia. Oikeastaan tällaisia ei pitäisi tulla, koska juurilausekkeiden sieventäminen on puhtaasti algebrallista eikä siinä pitäisi laskentatarkkuudella olla merkitystä. Tarkempaa tietoa Help Browserista hakusanoilla $MaxExtraPrecision ja $MaxExtraPrecision::meprec. Hämäräksi kuitenkin jää, miksi Mathematica tässä kohden antaa tällaisia ilmoituksia.

yhtaloc = x^3 - x^2 + x - 21 == 0

ratkaisuc = Solve[yhtaloc, x]

yhtaloc /. ratkaisuc // Simplify

yhtalod = (a - b) x^2 + a x + b == 
        0

ratkaisud = Solve[yhtalod, x]

yhtalod /. ratkaisud // Simplify

Tehtävä 3

ratkaisu = Solve[a x^2 + b x + c == 0, x]

{ratk1, ratk2} = 
      x /. ratkaisu

tulos = 
      ratk1^2 + ratk1 ratk2 + ratk2^2 // Simplify

ratkaisu /. {a -> 2, b -> 3, 
        c -> 4}

tulos /. {a -> 2, b -> 3, c -> 4}

Tehtävä 4

ratkaisu = 
      Solve[{3 x - 2 y == 1, 4 x + 5 y == 2}, {x, 
          y}]

Tehävä 5

Plot[{Log[x^2 + 1], Sqrt[x + 1]}, {x, -0.99, 
          10}];

Plot[{Log[x^2 + 1], Sqrt[x + 1]}, {x, 10, 
          100}];

Näyttäisi tulevan 3 juurta. Enempää ei ole, sillä funktiot ovat suurillan x:n arvoilla likimain 2 ln x ja (Sqrt[x]). Logaritmi taas kasvaa hitaammin kuin mikä tahansa positiivinen potenssi. Täsmällisempi analyysi derivaatoilla!

FindRoot[
      Log[x^2 + 1] == Sqrt[x + 1], {x, -0.9}]

FindRoot[Log[x^2 + 1] == Sqrt[x + 1], {x, 2}]

FindRoot[Log[x^2 + 1] == Sqrt[x + 1], {x, 50}]

Tehtävä 6

Needs["Graphics`ImplicitPlot`"]

ImplicitPlot[{Exp[x] + Sin[y] == 0, 
        x^6 - x y + y^6 == 4}, {x, -2, 2}, {y, -2, 
        2}]

Siis 2 juurta näyttää ainakin löytyvän. Määrätään ne. Itse asiassa muita ratkaisuja ei voi olla, sillä jos x>0, niin ensimmäisellä yhtälöllä ei ole ratkaisua ja jos Abs(x)>2, niin toisella yhtälöllä ei ole ratkaisua, kuten tarkemmalla analyysilla voidaan osoittaa.

FindRoot[{Exp[x] + Sin[y] == 0, 
        x^6 - x y + y^6 == 4}, {x, 
        0}, {y, -1.5}]

FindRoot[{Exp[x] + Sin[y] == 
          0, x^6 - x y + y^6 == 
          4}, {x, -1.5}, {y, -0.5}]

Tehtävä 7

p = x^3 - 2 x - 5

ratkaisu = Solve[p == 0, x]

p == 0 /. ratkaisu // Simplify

Ei siis sieventynyt.

p /. ratkaisu // Simplify

Ei taida sieventyä. Otetaan edellisestä likiarvo:

p /. ratkaisu // N

Numeerinen ratkaisu:

numratk = NSolve[p == 0, x]

p == 0 /. numratk

p /. numratk

Tehtävä 8

ratkaisu = 
      Solve[Abs[x - 1] + Abs[x - 3] == 3, x]

Siis varoitus, että joku ratkaisu voi puuttua. Piirretään kuvaaja.

Plot[{Abs[x - 1] + Abs[x - 3] - 3}, {x, -10, 
        10}]

Siis kaikki ratkaisut löytyivät, kun käytetään hyväksi tietoa, että kuvaaja paloittain suora.

Tietenkin voitaisiin poistaa itseisarvomerkit (myös määrittelyalueista väittämättä) ja ratkaista saadut yhtälöparit ja lopuksi testata mitkä ratkaisuista toteuttavat alkuperäisen yhtälön. Voisimme myös suorittaa neliöön korotuksen ja ratkaista saadun yhtälön ja sitten tarkastaa, ovatko saadut ratkaisut alkuperäisen yhtälön ratkaisuja.

Tehtävä 9

likiarvo = (n + 1/2) Log[n] - n  + 
        Log[Sqrt[2 Pi]]

virhe = Log[n!] - likiarvo

suhtvirhe = virhe/Log[n!]

virhe /. {n -> 10} // N

virhe /. {n -> 100} // N

virhe /. {n -> 1000} // N

suhtvirhe /. {n -> 10} // N

suhtvirhe /. {n -> 100} // N

suhtvirhe /. {n -> 1000} // N

Tehtävä 10

Needs["Graphics`ImplicitPlot`"]

yht1 = 
      16 x^2 + 9 y^2 + 24 x y - 170 x + 310 y - 465 == 
        0

yht2 = 
      5 x^2 + 8 y^2 + 4 x y - 32 x - 56 y + 80 == 
        0

ImplicitPlot[{yht1, yht2}, {x, -2, 7}, {y, 0, 
        7}]

Haetaan kuvaajan perusteella leikkauspisteille likiarvoja. Kuvaajan perusteella toinen käyristä on ellipsi, joten ratkaisuja ei ole piirtoalueen ulkopuolella; eli niitä on 2.

FindRoot[{yht1, yht2}, {x, 0}, {y, 2}]

FindRoot[{yht1, yht2}, {x, 5}, {y, 2}]

Yritetään sitten ratkaista tarkasti. Tulee hankalan näköinen vastaus.

Solve[{yht1, yht2}, {x, y}]

Lasketaan likiarvot, jolloin nähdään, että reaaliset ratkaisut ovat samoja kuin edellä.

% // N

Myös NSolve toimisi:

NSolve[{yht1, yht2}, {x, y}]