Teh­tä­vä:
Lo­ga­rit­mit

Ly­hyt Math­Check-oh­je (uu­teen vä­li­leh­teen)

Lo­ga­rit­mi on mää­ri­tel­ty vain po­si­tii­vi­sil­le lu­vuil­le. Po­si­tii­vi­sen lu­vun `a` `b`-kan­tai­nen lo­ga­rit­mi eli `log_b a` on se lu­ku `x`, jol­le `b^x = a`. Kun `0 < b < 1` tai `b > 1`, on ole­mas­sa täs­mäl­leen yk­si täl­lai­nen `x`.

Mää­ri­tel­mäs­tä seu­raa tär­keä kaa­va:

`log_b b^x = x`

Jat­kos­sa ole­tam­me, et­tä kan­ta­lu­ku `b > 1`. Lo­ga­rit­mit sai­si toi­mi­maan myös kun `0 < b < 1`, mut­ta si­tä tar­vi­taan har­voin ja sen kans­sa asia muut­tui­si mo­ni­mut­kai­sem­mak­si, jo­ten kä­sit­te­lem­me vain lo­ga­rit­me­ja `log_b a`, mis­sä `a > 0` ja `b > 1`.

Pal­jon­ko ovat seu­raa­vat lo­ga­rit­mit? ok_text Oi­kein! hide_expr only_no_yes_on f_nodes 1 log 10000 =
`log_10 10000 =` tai

ok_text Oi­kein! hide_expr only_no_yes_on f_nodes 1 2 = `log_5 25 =` tai

ok_text Oi­kein! hide_expr only_no_yes_on f_nodes 2 -3 = `log_3 (1/27) =` tai

ok_text Oi­kein! hide_expr only_no_yes_on f_nodes 1 0 = `log_123 1 =` tai

Ih­mi­sil­le hel­poim­pia ovat 10-kan­tai­set lo­ga­rit­mit. Lo­ga­rit­mien mer­kin­tä­ta­vois­sa esiin­tyy vaih­te­lua. Math­Checkis­sä `x`:n 10-kan­tai­nen lo­ga­rit­mi mer­ki­tään log x. Lu­vun 100…0 10-kan­tai­nen lo­ga­rit­mi on nol­lien mää­rä lu­vus­sa. Lu­vun 0.00…01 10-kan­tai­nen lo­ga­rit­mi on nol­lien mää­rän vas­ta­lu­ku (mu­kaan lu­kien de­si­maa­li­pis­teen edel­lä ole­va nol­la).

Pal­jon­ko ovat seu­raa­vat? ok_text Oi­kein! only_no_yes_on f_nodes 1 log 100000 =
`log 100000 =` tai

ok_text Oi­kein! only_no_yes_on f_nodes 1 log 10 = `log 10 =` tai

ok_text Oi­kein! only_no_yes_on f_nodes 2 log 0.001 = `log 0.001 =` tai

Jos `x >= 1`, niin `x`:n nu­me­roi­den mää­rä il­man etu­nol­lia ja de­si­maa­li­osaa voi­daan il­mais­ta `log x`:n avul­la. Kir­joi­ta kaa­va­na! Alas­päin pyö­ris­tys lä­him­pään ko­ko­nais­lu­kuun saa­daan Math­Checkis­sä floor() ja ylös­päin ceil(). ok_text Oi­kein! hide_expr f_nodes 5 |_log x_|+1 =
`x`:n nu­me­roi­den mää­rä =
tai

Lu­vun 10-kan­tai­nen lo­ga­rit­mi pyö­ris­tet­ty­nä alas­päin lä­him­pään ko­ko­nais­lu­kuun saa­daan hel­pol­la pääs­sä­las­kul­la edel­lä ole­van kaa­van avul­la. Pe­riaa­te yleis­tyy myös yk­kös­tä pie­nem­piin lu­kui­hin. Las­ke seu­raa­vat. only_no_yes_on ok_text Oi­kein! f_nodes 1 |_ log 2019 _| =
`|__ log 2019 __| =` tai

only_no_yes_on ok_text Oi­kein! f_nodes 2 |_ log 0.00623 _| = `|__ log 0.00623 __| =` tai

Lo­ga­rit­mit muut­ta­vat ker­to­las­kun yh­teen­las­kuk­si täl­lä ta­val­la:

`log_b xy = log_b x + log_b y`

`log 3.14159` on li­ki­main 0.4971. Las­ke seu­raa­vat pääs­sä­si. Il­mai­se vas­taus li­kiar­vo­na si­ten, et­tä de­si­maa­li­pis­teen jäl­keen on ta­san nel­jä de­si­maa­lia. ok_text Oi­kein! only_no_yes_on hide_expr f_nodes 1 /*Vih­je: 31.4159 = 10 · 3.14159*/ 1.4971 =
`log 31.4159 ~~` tai

ok_text Oi­kein! /*Vih­je: 314.159 = 100 · 3.14159*/ only_no_yes_on hide_expr f_nodes 1 2.4971 = `log 314.159 ~~` tai

ok_text Oi­kein! /*Vih­je: 3141.59 = 1000 · 3.14159*/ only_no_yes_on hide_expr f_nodes 1 3.4971 = `log 3141.59 ~~` tai

ok_text Oi­kein! /*Vih­je: 0.314159 = 0.1 · 3.14159*/ only_no_yes_on hide_expr f_nodes 2 -0.5029 = `log 0.314159 ~~` tai

ok_text Oi­kein! /*Vih­je: 0.0314159 = 0.01 · 3.14159*/ only_no_yes_on hide_expr f_nodes 2 -1.5029 = `log 0.0314159 ~~` tai

`log_2 250` on li­ki­main 7.97. Las­ke seu­raa­vat pääs­sä­si. Il­mai­se vas­taus li­kiar­vo­na si­ten, et­tä de­si­maa­li­pis­teen jäl­keen on ta­san kak­si de­si­maa­lia. ok_text Oi­kein! only_no_yes_on hide_expr f_nodes 1 /*Vih­je: 1000 = 2 · 2 · 250*/ 9.97 =
`log_2 1000 ~~` tai

ok_text Oi­kein! /*Vih­je: `125 = 250/2`*/ only_no_yes_on hide_expr f_nodes 1 6.97 = `log_2 125 ~~` tai

Nyt joh­dam­me edel­lä ol­leen kaa­van ta­pauk­ses­sa `b = 10`. Ol­koot `x` ja `y` po­si­tii­vi­sia. So­vel­ta­mal­la 10-kan­tai­sen lo­ga­rit­min mää­ri­tel­mää saam­me `10^(log xy) =` ok_text Oi­kein! f_nodes 3 assume x > 0 /\ y > 0; 10^(log x y) = .
tai

So­vel­ta­mal­la mää­ri­tel­mää uu­del­leen, täl­lä ker­taa `x`:ään erik­seen ja `y`:hyn erik­seen, saam­me (lai­ta `x`:n osuus va­sem­mal­le ja `y`:n oi­keal­le) ok_text Oi­kein! hide_expr f_top_opr ^ f_nodes 4 assume x > 0 /\ y > 0; 10^(log x) =
`xy =` · end_of_answer ok_text Oi­kein! arithmetic hide_expr f_top_opr ^ f_nodes 4 assume x > 0 /\ y > 0; 10^(log y) = .
tai

Po­tens­si­las­ku­opis­ta muis­tam­me kaa­van, jo­ta voi so­vel­taa lau­sek­kei­siin muo­toa `a^b a^c`. Sil­lä saam­me jat­ket­tua muo­toon = ok_text Oi­kein! hide_expr f_nodes 7 assume x > 0 /\ y > 0; 10^(log x) * 10^(log y)= .
tai

To­dis­tim­me juu­ri, et­tä `10^(log x y) = 10^(log x + log y)`. Jos yh­tä­suu­ril­le teh­dään sa­ma asia, niin saa­daan yh­tä­suu­ret lop­pu­tu­lok­set. Ot­ta­mal­la tä­män kaa­van mo­lem­mil­ta puo­lil­ta 10-kan­tai­nen lo­ga­rit­mi saa­daan

`log 10^(log x y) = log 10^(log x + log y)`

Lä­hel­lä tä­män teh­tä­vän al­kua ol­leel­la kaa­val­la täs­tä saa­daan
ok_text Oi­kein! hide_expr f_top_opr log f_nodes 4 assume x > 0 /\ y > 0; log x y= = end_of_answer arithmetic hide_expr f_top_opr + f_nodes 5 assume x > 0 /\ y > 0; log x + log y= . tai

Sa­ma päät­te­ly toi­mii muil­le­kin yk­kös­tä suu­rem­mil­le kan­ta­lu­vuil­le kuin 10. Sik­si, jos `x > 0`, `y > 0` ja `b > 1`, niin `log_b x y``=``log_b x + log_b y`.

Seu­raa­va tär­keä kaa­va on

`log_b x^y = y log_b x`

Kun `y` on po­si­tii­vi­nen ko­ko­nais­lu­ku, tä­mä saa­daan hel­pos­ti seu­raa­vas­ti:

`log_b x^n`
`=``log_b x x cdots x`
`=``log_b x + log_b x + ... + log_b x`
`=``n log_b x` ,

mis­sä kum­pi­kin tois­to ta­pah­tuu `n` ker­taa. Tä­mä päät­te­ly kan­nat­taa muis­taa, sil­lä sen avul­la kaa­va on help­po pa­laut­taa mie­leen. Tä­mä päät­te­ly ei kui­ten­kaan ole ylei­ses­sä ta­pauk­ses­sa pä­te­vä.

Sik­si — voi ei! — joh­dam­me kaa­van ylei­ses­sä ta­pauk­ses­sa `x > 0` ja `y > 0`, mut­ta (tur­han kir­joit­ta­mi­sen vä­hen­tä­mi­sek­si) vain 10-kan­tai­sel­le lo­ga­rit­mil­le `log` (siis `b=10`). Muis­tat­han, et­tä täl­lä kurs­sil­la ta­voit­tee­na on op­pia päät­te­ly­tai­toa. Ota vaik­ka kup­pi kah­via tai la­si ap­pel­sii­ni­me­hua en­nen kuin jat­kat. Jos ker­ta kaik­kiaan tun­tuu mah­dot­to­mal­ta, niin hyp­pää seu­raa­vaan vaa­ka­vii­vaan.

To­dis­tam­me en­sin, et­tä `10^(log x^y)``=``10^(y log x)`.

So­vel­ta­mal­la 10-kan­tai­sen lo­ga­rit­min mää­ri­tel­mää saam­me
`10^(log x^y) =` ok_text Oi­kein! f_nodes 3 assume x > 0 /\ y > 0; 10^(log x^y) = . tai

Joh­da al­la ole­vas­sa ik­ku­nas­sa `10^(y log x) = x^y`. So­vel­la en­sin ker­to­las­kun vaih­dan­nai­suut­ta eli `ab = ba`, sit­ten jo­tain po­tens­si­las­ku­kaa­vaa ja lo­puk­si lo­ga­rit­min mää­ri­tel­mää. ok_text Oi­kein! f_nodes 3 assume x > 0 /\ y > 0;
10^(y log x) = = = .
tai

Saim­me to­dis­tet­tua `10^(log x^y)``=``x^y``=``10^(y log x)`. Ot­ta­mal­la mo­lem­mil­ta reu­noil­ta 10-kan­tai­nen lo­ga­rit­mi saa­daan
ok_text Oi­kein! f_nodes 4 assume x > 0 /\ y > 0; hide_expr log x^y = = end_of_answer arithmetic f_nodes 4 assume x > 0 /\ y > 0; hide_expr y log x = . tai

Tä­mä päät­te­ly toi­mii muil­le­kin yk­kös­tä suu­rem­mil­le kan­ta­lu­vuil­le `b` kuin 10.

---

Toi­nen hy­vin pal­jon käy­tet­ty lo­ga­rit­mi on luon­nol­li­nen lo­ga­rit­mi. Si­tä mer­ki­tään mo­nin pai­koin (Math­Check mu­kaan lu­kien) ln, mut­ta va­li­tet­ta­vas­ti mm. mo­net oh­jel­moin­ti­kie­let käyt­tä­vät sil­le mer­kin­tää log, jo­ka meil­le tar­koit­taa 10-kan­tais­ta. Se­kaan­nuk­sen vaa­ra on siis il­mei­nen ja on pa­ras­ta ai­na tar­kas­taa, mi­tä `log` kul­loin­kin tar­koit­taa, ei­kä luot­taa sii­hen, et­tä se on ai­na 10-kan­tai­nen.

Luon­nol­li­sen lo­ga­rit­min kan­ta­lu­kua mer­ki­tään `e`. Sen ar­vo on li­ki­main 2.71828. Siis `ln x = log_e x`. Kun käy­te­tään `b`-kan­tais­ta lo­ga­rit­mia, mo­nes­sa kaa­vas­sa esiin­tyy `ln b`. Esi­mer­kik­si funk­tion `log_b x` de­ri­vaat­ta on `1/((ln b)x)`. Lo­ga­rit­min mää­ri­tel­mäs­tä seu­raa, et­tä `log_b b = 1` (kos­ka 1 on se lu­ku `x`, jol­le `b^x = b`), jo­ten `ln e = log_e e = 1`. Sik­si `d/dx ln x = 1/x`. Luon­nol­li­sel­la lo­ga­rit­mil­la `ln b` voi­daan siis kor­va­ta yk­kö­sel­lä tai jät­tää tar­peet­to­ma­na ko­ko­naan pois, jol­loin kaa­vois­ta tu­lee yk­sin­ker­tai­sem­pia kuin muil­la lo­ga­rit­meil­la. Sik­si tä­tä lo­ga­rit­mia kut­su­taan luon­nol­li­sek­si. Lu­vul­la `e` on myös mui­ta haus­ko­ja omi­nai­suuk­sia. Jos in­toa riit­tää, voit tu­tus­tua nii­hin Wi­ki­pe­dias­ta tai op­pi­kir­jois­ta, tai ky­sel­lä ka­ve­reil­ta.

Usein on hyö­dyl­lis­tä kye­tä muun­ta­maan muu lo­ga­rit­mi luon­nol­li­sek­si. Se on­nis­tuu kaa­val­la `log_b x = (ln x)/ln b`. Muun­na seu­raa­vat luon­nol­li­sik­si lo­ga­rit­meik­si: ok_text Oi­kein! hide_expr f_nodes 5 (ln x)/ln 2 =
`log_2 x =` tai

ok_text Oi­kein! hide_expr f_nodes 5 (ln c)/ln 6 = `log_6 c =` tai

ok_text Oi­kein! f_nodes 7 f_top_opr / log(a+b) = `log(a+b) =` tai

Tä­mä kaa­va on help­po joh­taa. Nyt­kin joh­dam­me sen vain 10-kan­tai­sel­le lo­ga­rit­mil­le. En­sin kor­vaa `x` lau­sek­keel­la `10^(log x)`. Sit­ten so­vel­la so­pi­vaa edel­lä ol­lut­ta kaa­vaa. Jos tar­vit­set ker­to­las­kua, niin käy­tä *. ok_text Oi­kein! f_nodes 5 f_top_opr * assume x > 0 /\ y > 0;
ln x = =
tai

Jos sait tä­män oi­kein, saa­daan ta­voi­tel­tu kaa­va `b`:n ar­vol­la 10 ja­ka­mal­la mo­lem­mat puo­let lau­sek­keel­la only_no_yes_on ok_text Oi­kein! hide_expr f_nodes 2 ln 10 = .
tai

Tä­mä riit­tä­köön täl­lä ker­taa.