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

Jos käy­tät Math­Checkiä en­sim­mäis­tä ker­taa, niin tee en­sin teh­tä­vä Yleis­tä Math­Checkis­tä. Jos et muual­ta löy­dä mi­ten jo­kin sym­bo­li kir­joi­te­taan, niin kat­so MathCheck Brief Instructions.

Mi­kä lo­ga­rit­mi on?

Ol­koon `b > 1`. 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`. On ole­mas­sa täs­mäl­leen yk­si täl­lai­nen `x`. (Jä­täm­me to­dis­ta­mat­ta, et­tä nii­tä on täs­mäl­leen yk­si, kos­ka to­dis­tus vei­si liian kauas pää­ai­hees­ta.) Siis

`b^(log_b a) = a` kun `a > 0` ja `b > 1`

Kun `a <= 0`, `b = 1` tai `b <= 0`, lo­ga­rit­mia ei ole mää­ri­tel­ty. Lo­ga­rit­mi on mää­ri­tel­ty kun `0 <``b < 1` ja `a > 0`, mut­ta si­tä tar­vi­taan har­voin ja sen kans­sa asia muut­tuu mo­ni­mut­kai­sem­mak­si. Sik­si täs­sä teh­tä­väs­sä kä­si­tel­lään vain ta­paus­ta, jos­sa kan­ta­lu­ku `b > 1`.

Tar­vit­sem­me jat­kos­sa muu­ta­maan ker­taan seu­raa­vaa tie­toa:

Jos `b > 0` ja `c` on mi­kä ta­han­sa reaa­li­lu­ku, niin `b^c > 0`.

Si­joit­ta­mal­la sa­nal­li­seen mää­ri­tel­mään `a`:n pai­kal­le `b^c` saa­daan, et­tä `log_b b^c` on se lu­ku `x`, jol­le `b^x = b^c`. Kos­ka edel­lä lu­vat­tiin, et­tä täl­lai­sia lu­ku­ja on vain yk­si, pä­tee `x = c`. Muis­tat­han vaa­ti­muk­sen `a > 0`! Nyt se tar­koit­taa, et­tä pi­tää pä­teä `b^c > 0`. Kun `b > 1` niin `b > 0`, jo­ten se pä­tee äs­ken si­ni­sel­lä to­de­tun no­jal­la.

Saim­me tär­keän kaa­van:

`log_b b^c = c` kun `b > 1`

Pal­jon­ko ovat seu­raa­vat lo­ga­rit­mit?

ok_text Oi­kein! arithmetic only_no_yes_on f_nodes 1 hide_expr 3 = `log_2 8 =` tai

ok_text Oi­kein! arithmetic only_no_yes_on f_nodes 1 hide_expr log 10000 = `log_10 10000 =` tai

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

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

ok_text Oi­kein! arithmetic only_no_yes_on f_nodes 1 hide_expr 1 = `log_b b =` tai

Ol­koot `a > 0` ja `b > 1`. Po­tens­si­las­kun sään­tö­jen mu­kaan `x^(-y) =``1/(x^y)` kun `x > 0`. Mik­si voim­me si­joit­taa `x`:n pai­kal­le `b`:n ja `y`:n pai­kal­le `log_b a`:n? Mie­ti en­sin it­se ja sit­ten kat­so vas­taus täs­täKos­ka ole­tim­me `b > 1`, pä­tee `b > 0`. Sik­si `x > 0` to­teu­tuu si­joi­tuk­ses­sa. Lu­vul­ta `y` ei vaa­di­ta mi­tään, jo­ten sen pai­kal­le saa si­joit­taa mi­tä ta­han­sa mää­ri­tel­tyä. Alus­sa teim­me ole­tuk­sen, jo­ka ta­kaa, et­tä `log_b a` on mää­ri­tel­ty..

Niin si­joit­ta­mal­la saa­daan `b^(-log_b a) =``1/(b^(log_b a))`. Edel­lä ol­leen kaa­van mu­kaan `b^(log_b a) =``a`. Näis­tä yh­des­sä saa­daan `b^(-log_b a) =``1/a`. Mää­ri­tel­män mu­kaan `log_b(1/a)` on se lu­ku `x`, jol­le `b^x =``1/a`. Ai­van äs­ken huo­ma­sim­me, et­tä `-log_b a` täyt­tää tä­män eh­don. Olem­me osoit­ta­neet seu­raa­van tär­keän kaa­van:

`log_b (1/a) = -log_b a` kun `a > 0` ja `b > 1`

Pal­jon­ko ovat seu­raa­vat lo­ga­rit­mit?

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

ok_text Oi­kein! arithmetic only_no_yes_on f_nodes 2 hide_expr -4 = `log_10 0.0001 =` tai

ok_text Oi­kein! arithmetic only_no_yes_on f_nodes 2 hide_expr -2 = `log_2 0.25 =` tai

Kym­men­kan­tai­set lo­ga­rit­mit

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 kym­men­kan­tai­nen lo­ga­rit­mi on nol­lien mää­rä lu­vus­sa. Lu­vun 0.00…01 kym­men­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! arithmetic f_nodes 1 only_no_yes_on log 100000 =
`log 100000 =` tai

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

ok_text Oi­kein! arithmetic f_nodes 2 only_no_yes_on 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() tai |_ _| ja ylös­päin ceil() tai |^ ^| . ok_text Oi­kein! arithmetic f_nodes 5 hide_expr |_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. ok_text Oi­kein! arithmetic f_nodes 1 only_no_yes_on |_ log 2019 _| =
`|__ log 2019 __| =` tai

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

10-kan­tai­set (ja muut­kin) lo­ga­rit­mit muut­ta­vat ker­to­las­kun yh­teen­las­kuk­si täl­lä ta­val­la:

`log xy = log x + log y`  , kun `x > 0` ja `y > 0`

`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. Vih­je314.159 = 100 · 3.14159, joten log 100 · 3.14159 = … ok_text Oi­kein! /*Vih­je: 31.4159 = 10 · 3.14159*/ arithmetic only_no_yes_on f_nodes 1 hide_expr 1.4971 =
`log 31.4159 ~~` tai

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

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

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

ok_text Oi­kein! /*Vih­je: 0.0314159 = 0.01 · 3.14159*/ arithmetic only_no_yes_on f_nodes 2 hide_expr -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! /*Vih­je: 1000 = 2 · 2 · 250*/ arithmetic only_no_yes_on f_nodes 1 hide_expr 9.97 =
`log_2 1000 ~~` tai

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

Lo­ga­rit­mien la­ke­ja

Tä­mä kaa­va, jo­hon edel­lä jo vii­tat­tiin­kin, on eh­kä tär­kein his­to­rial­li­nen syy lo­ga­rit­mien käyt­töön otol­le:

`log_b xy = log_b x + log_b y` kun `x > 0`, `y > 0` ja `b > 1`

Sen avul­la voi­tiin muut­taa työ­läät ker­to­las­kut vä­hem­män työ­läik­si yh­teen­las­kuik­si ja tau­lu­koi­den kat­so­mi­sik­si. (Ker­rot­ta­vien lo­ga­rit­mit et­sit­tiin tau­lu­kos­ta ja las­ket­tiin yh­teen. Lo­puk­si kat­sot­tiin tau­lu­kos­ta, min­kä lu­vun lo­ga­rit­mi saa­tu tu­los on.)

Joh­dam­me kaa­van ta­pauk­ses­sa `b = 10`. (Math­Check ei osaa kä­si­tel­lä yleis­tä kan­ta­lu­kua.)

Ol­koot `x` ja `y` po­si­tii­vi­sia. Sil­loin myös `xy` on po­si­tii­vi­nen. 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! arithmetic 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! arithmetic f_top_opr ^ f_nodes 4 assume x > 0 /\ y > 0; x =
`xy =` · end_of_answer ok_text Oi­kein! arithmetic f_top_opr ^ f_nodes 4 assume x > 0 /\ y > 0; 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
`xy =`ok_text Oi­kein! arithmetic f_nodes 7 f_ban * #*; assume x > 0 /\ y > 0; x y = .
tai

To­dis­tim­me juu­ri, et­tä `10^(log x y) =``xy =``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 reu­noil­ta 10-kan­tai­nen lo­ga­rit­mi saa­daan

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

Mik­si äs­kei­nen lo­ga­rit­min ot­to on sal­lit­tu? Vas­tausKau­ka­na edel­lä ole­va si­ni­nen lu­paus ker­too, et­tä `10^(log x y)` ja `10^(log x + log y)` ovat po­si­tii­vi­sia.

Lä­hel­lä tä­män teh­tä­vän al­kua ol­leel­la tär­keäl­lä kaa­val­la täs­tä saa­daan
ok_text Oi­kein! arithmetic f_top_opr log f_nodes 4 hide_expr assume x > 0 /\ y > 0; log x y= = end_of_answer arithmetic f_top_opr + f_nodes 5 hide_expr 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 `x > 0` ja `b > 1`

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` on mi­kä ta­han­sa reaa­li­lu­ku, mut­ta jäl­leen 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 vä­li­ot­sik­koon.

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! arithmetic f_nodes 3 assume x > 0 /\ y > 0; 10^(log x^y) = . tai

Joh­da al­la ole­vas­sa laa­ti­kos­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! arithmetic 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 ja käyt­tä­mäl­lä lä­hel­lä al­kua ol­lut­ta tär­keää kaa­vaa saa­daan
ok_text Oi­kein! arithmetic f_nodes 4 f_top_opr log assume x > 0 /\ y > 0; hide_expr log x^y = = end_of_answer arithmetic f_nodes 4 f_ban ^; assume x > 0 /\ y > 0; hide_expr y log x = . tai

Tä­mä­kin 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.

Luon­nol­li­nen lo­ga­rit­mi

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`. Siis `ln x = log_e x`. Lu­vun `e` ar­vo on li­ki­main 2.71828. Se ei ole esi­tet­tä­vis­sä mur­to­lu­ku­na. Syy näin omi­tui­sen kan­ta­lu­vun käyt­töön on sii­nä, et­tä 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)`. Siis `ln` ikään kuin tun­keu­tuu kaa­voi­hin vä­ki­sin.

Sa­mas­ta syys­tä luon­nol­li­sen lo­ga­rit­min käyt­tö te­kee mo­nes­ta kaa­vas­ta yk­sin­ker­tai­sem­man kuin muut kan­ta­lu­vut. ok_text Oi­kein! arithmetic f_nodes 1 hide_expr 0b+1 = Kos­ka `log_b b =`, end_of_answer arithmetic only_no_yes_on f_nodes 1 hide_expr 1 = pä­tee `ln e =``log_e e =`. end_of_answer arithmetic only_no_yes_off f_nodes 3 hide_expr 1/x = Sik­si `d/dx ln x =`.
tai

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`

kun `x > 0` ja `b > 1`

Muun­na seu­raa­vat luon­nol­li­sik­si lo­ga­rit­meik­si: ok_text Oi­kein! arithmetic f_nodes 5 f_ban log log2; log2 x =
`log_2 x =` tai

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

ok_text Oi­kein! arithmetic f_nodes 7 f_ban log log2; 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! arithmetic 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! arithmetic f_nodes 2 hide_expr ln 10 = .
tai

Kak­si­kan­tai­nen lo­ga­rit­mi

Tie­to­jen­kä­sit­te­lys­sä käy­te­tään pal­jon kan­ta­lu­kua 2. Jos esi­mer­kik­si tar­vit­see suun­ni­tel­la esi­tys `n` eri vaih­to­eh­dol­le, niin tar­vi­taan `|~ log_2 n ~|` bit­tiä. Kos­ka vii­kon­päi­viä maa­nan­tai, tiis­tai, … on seit­se­män, vii­kon­päi­vän koo­daa­mi­sek­si tar­vi­taan `|~ log_2 7 ~| = 3` bit­tiä. Mo­ni al­go­rit­mi toi­mii ja­ka­mal­la kä­si­tel­tä­vän da­tan kah­dek­si suun­nil­leen yh­tä­suu­rek­si osak­si. Myös osat puo­li­te­taan jne., kun­nes kä­si­tel­tä­vä­nä on vain yk­si tie­to­al­kio. Sii­hen tar­vi­taan suun­nil­leen `log_2 n` puo­li­tus­ta.

Kak­si­kan­tais­ta lo­ga­rit­mia mer­ki­tään Math­Checkis­sä log2.

Tie­to­lii­ken­tees­sä ja da­tan pak­kaa­mi­ses­sa hyö­dyn­ne­tään si­tä, et­tä jot­kin mer­kit esiin­ty­vät har­vem­min kuin toi­set. Esi­mer­kik­si z on har­vi­nai­nen suo­men­kie­li­ses­sä teks­tis­sä. Clau­de Shan­non osoit­ti, et­tä täl­löin mer­kin esit­tä­mi­seen tar­vi­taan kes­ki­mää­rin `-log_2 p` bit­tiä, mis­sä `p` on mer­kin to­den­nä­köi­syys eli osuus da­tas­ta. Esi­mer­kik­si mer­kin ä to­den­nä­köi­syys sa­nas­sa kes­ki­mää­rä on `3/10`, kos­ka se esiin­tyy kol­mes­ti ja sa­nas­sa on kaik­kiaan 10 merk­kiä.

Jos eri­lai­sia merk­ke­jä on `n` kap­pa­let­ta ja ne ovat yh­tä to­den­nä­köi­siä, niin kun­kin mer­kin to­den­nä­köi­syys on ok_text Oi­kein! arithmetic f_nodes 3 hide_expr 1/n = . Shan­no­nin kaa­van mu­kaan merk­ki tar­vit­see kes­ki­mää­rin end_of_answer arithmetic f_nodes 5 hide_expr -log2 1/n = bit­tiä, jo­ka sie­ve­nee muo­toon end_of_answer arithmetic f_nodes 3 hide_expr -log2 1/n = .
tai

Al­go­rit­mien suo­ri­tus­ajan ana­lyy­sis­sä ei yleen­sä ol­la kiin­nos­tu­nei­ta tar­kois­ta lu­vuis­ta, kos­ka lau­sek­keen ylei­nen muo­to vai­kut­taa yleen­sä pal­jon enem­män kuin tar­kat lu­vut ja kos­ka tar­kat lu­vut ovat usein mah­dot­to­mia sel­vit­tää (ne riip­pu­vat mm. sii­tä, mi­tä tie­to­ko­net­ta käy­te­tään ja on­ko se vir­ran­sääs­tö­ti­las­sa). Sik­si ta­pa­na on jät­tää kaa­vois­sa esiin­ty­vät va­kiot pois.

Edel­lä näh­tiin, et­tä esi­mer­kik­si 2-kan­tai­ses­ta lo­ga­rit­mis­ta pääs­tään luon­nol­li­seen lo­ga­rit­miin ker­to­mal­la lu­vul­la `ln 2`. Myös `ln 2` on pois jä­tet­tä­vä va­kio. Tä­mä tar­koit­taa, et­tä al­go­rit­mien suo­ri­tus­ajan ana­lyy­sis­sä ei yleen­sä ole mi­tään vä­liä sil­lä, mi­tä kan­ta­lu­kua käy­te­tään (kun­han se on suu­rem­pi kuin 1).

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