Ohjeita shell-skriptaukseen (bash)

[petteriIII]

Tässä on 16 numeroinen neliöjuuri-laskun tarvitsema summaaja-vähentäjä. Aluksi tehdään versio joka toimii ainoastaan kokonaisluvuilla ja vasta pitkien testauksien jälkeen sitä voi alkaa sovittamaan desimaaliluvuille. Inhottavan näköistä koodia siinä on paljon - mutta BASH:iksi se on kuitenkin hyvin nopea vaikkakin muiden kielien kannalta todella hidas - tämä funktio vie aikaa alle millisekunnin - ja bc tai awk:kin kuluttaa aikaa 2-3 millisekuntia samaan laskuun - se 3ms kestää ennenkuin ne aloivat toimia.

BASH:in toiminnan tarkoitus on opettaa muunmuassa kuinka vaikeita alkeis-tehtävätkin ovat ratkaista siten että ne toimisivat aina moitteettomasti - ja nehän ovat samat kaikissa kielissä. Ja jokainen kieli on samojen matematiikan sääntöjen sitoma ja kaikki ratkaisevat tämmöisiä olemattoman kokoisia tehtäviä sammallatavoin - muut kielet tosin ratkovat ne kirjastojensa sokkeloissa ja prosessoriensa langoituksessa - joten varmaankaan et ole noita ratkaisuja nähnytkään. Mutta riittää kun tietää että niitä on.

- eihän matematiikkaa voi millään kielellä toteuttaa moitteettomasti kokonaan vaan aina tulee tilanteita joissa nikotellaan. Ja koska BASH:in on valehdeltu olevan täysin kykenemätön mihinkään eikä ole tehty ohjelmia alkeis-ongelmia ratkomaan niin että kun BASH alkaa nyt siitä missä toiset kielet olivat yli kolmekymmentä vuotta sitten niin BASH nikottelee alkuunsa ihan kaikissa tehtävissä. Mutta se hyvä puoli näissä ohjelmallisissa ratkaisuissa on että vaikka ne ovat todella hitaita niin kaiken saa lopulta toimimaan.

- kielen toiminnassa arvostetaan usein joustavuutta nopeutta enemmän - joten jos kielen perusteet ovat kunnossa niin joustavampi voittaa ilmanmuuta - ja vanhoilla käskyillä BASH on erittäin joustava - ja siitähän se riemu repesi sillä sellaista ei voi sallia että harrastelijan työkalu olisi parempi kuin ammattilaisella joten BASH:in vanhemmat veivät lapseltaan hampaat. Onneksi he eivät uskaltaneet kajota tulkkiin ja vanhat käskyt ovat tulkissa.
 
Pikku-tehtävistä tämä oli ehdottomasti elämäni työläin tehtävä - koska en kuunnellut omia puheitani siitä että vähennyslasku käsitellään ensimmäisenä - silloinkin kun toiminnan aikana saattaa jostain väli-tuloksesta tulla negatiivinen:

Koodia: [Valitse]

function summaa36 () { # ensimmäisen luvun tulee olla positiivinen ja suurempi mutta toinen pienempi luku voi olla negatiivinenkin

tulosta=: # yhdessä paikassa päätetään tulostetaanko skriptissä välituloksia missään. Vaihtoehdot:tulosta=echo ja tulosta=: . : on käsky olla tekemättä  mitään ja kuitenkin sillä voi olla parametreja aivan niinkuin echo:llakin.

luku1=$1
luku2=$2
[[ ${1:0:1} = - ]]  && merkki1=- || merkki1='+'
[[ ${2:0:1} = - ]]  && merkki2=- || merkki2='+'
luku1=${luku1//\-/}; luku2=${luku2//\-/} # poistetaan merkki -

luku1="0000000000000000000000000000000000000"$luku1; luku1=${luku1: -36:36}
luku2="0000000000000000000000000000000000000"$luku2; luku2=${luku2: -36:36}   

luku11=${luku1:0:18}; luku12=${luku1:18:18} #; [[ $luku11 -eq 0 ]] && luku11=0
luku21=${luku2:0:18}; luku22=${luku2:18:18} #; [[ $luku22 -eq 0 ]] && luku22=0                             
$tulosta annettu_luku           18_ensimmäistä_numeroa     18_viimeistä_numeroa
$tulosta $luku1 $luku11    $luku12 
$tulosta $luku2 $luku21    $luku22

alivuoto=0; ylivuoto=0
apu1=$((10#$luku12$merkki2 10#$luku22))
# [[ ${#apu1} -eq 19 ]] && { apu1=${apu1:0:18}; ylivuoto=1 ;} ; [[ $apu1 -lt 0 ]] && { apu1=$(($apu1+"100000000000000000")); alivuoto=1 ;}  # epäilyttävä
[[ $apu1 -lt 0 ]] && { apu1=$(($apu1+"1000000000000000000")); alivuoto=1 ;}; [[ ${#apu1} -eq 19 ]] && { apu1=${apu1:1:19}; ylivuoto=1 ;} ;   # epäilyttävä
apu1="000000000000000000000"${apu1#[-+]}; apu1=${apu1: -18:18}; $tulosta vähemmän merkitsevien lukujen summa: $apu1
apu2=$((10#$luku11$merkki2 10#$luku21+$ylivuoto-$alivuoto)); $tulosta enemmän merkitsevien lukujen summa: $apu2 ylivuoto: $ylivuoto alivuoto: $alivuoto

apu=$apu2${apu1#0}; echo ${apu##+(0)} ;}

# esimerkkilaskuja:
echo -e '\n\n'; time summaa36 22222222222222211111111111111111 2222222299999999999922222222221   
echo -e '\n\n'; time summaa36 22222222222222211111111111111111 -2222222299999999999922222222221
echo -e '\n\n'; time summaa36 555 -6
echo -e '\n\n'; time summaa36 555 6

-tulokset voi tarkistaa vaikka bc-llä esimerkiksi käskyllä: bc<<<"22222222222222211111111111111111+2222222299999999999922222222221"

[petteriIII]

Osien yhteen-liittämisessä ei ollut vaikeuksia - ja se että kokonaisuus onnistui osoittaa kaikkien osien toimivan varsin hyvin - nimittäin osat vaativat toisiltaan paljon sellaista mitä ihminen ei tajua vaatia.

[petteriIII]

Seuraavaksi keskityn jakolaskuun. Sen varsinainen laskurutiini on hyvin yksinkertainen - joten tottakai se paranisi matemaatikon käsittelyssä. Ihan raakile jakolasku vielä on ja kaipaa paljon työstämistä.

Nyt alkaa tarkentua syy miksi BASH:ia on mollattu sillä tämä jakolaskukin on nopeampi kuin bc, awk ja semmoiset. Sillä eihän noilla mitään tee jos BASH itse on parempi. Kuvottava teko se mollaaminen aikanaan oli - mutta nykyään raadoksi mollatun BASH:in mollaaminen edelleen on vain typeryyttä.

Silti tulosta verrataan tässä bc:n tulokseen sillä onhan se bc:n tulos sentään varmasti oikein - ja bc muuten toimii muuten niinkuin lasku-ohjelman pitääkin - mitä muut eivät yleensaä osaa.

Eihän tämmöisillä enää käytännön merkitystä ole mutta onhan se kiva lisämauste kun voi haistattaa Pythonille muutamissa pikkuhommissa - ja kuka tietää jos joskus monessa merkittävässäkin tehtävässä.

Nimittäin kaikki mitä olen kokeillut - anonyymeistä funktioista alkaen - on toiminut erittäin nopeasti kun ottaa huomioon että BASH:in toimimisnopeus alkaa 0.5 ms:sta. Täytyy kyllä myöntää että BASH:issa on paljon huonoakin kummallisen logiikkansa lisäksi - eihän sitä ole paljoakaan kehitetty - muuten taitaa olla todella hyvä ettei olekaan kehitetty sillä koska ei ole tajuttu mitään niin luultavasti olisi 'kehitetty' se vainaaksi.

Skripti tulostaa noin 36 desimaalia jos ei lasku-käskyssä määrää tarkkuutta - tarkkuuden voi määrätätä rajoittamattomaksi mutta eihän se vielä toimi aina virhettömästi. Esimerkiksi:
jaa 1 3
jaa 1 3 360000    # 360000 desimaalin laskeminen kestää noin 15 sekuntia.

- paljon siinä on vielä hiottavaa - esimerkiksi tuo case-looppi on toistaiseksi ihan kummallinen.

Koodia: [Valitse]


function jaa () {
desimaaliluku=36; [[ $3 ]] && desimaaliluku=$3
tulosta=: # yhdessä paikassa päätetään tulostetaanko välituloksia.  Vaihtoehdot:tulosta=echo ja tulosta=:

[[ ${1//[^.]/} ]] && luku1=$1 || luku1=$1"."
[[ ${2//[^.]/} ]] && luku2=$2 || luku2=$2"."

desimaaliosa1=${luku1##*.}
desimaaliosa2=${luku2##*.}
int1=${luku1%%.*}; #_echo x$int1
int2=${luku2%%.*}; #_echo y$int2

apu=$((${#int2}-${#int1})); $tulosta $apu  # kokonaisten lukumäärä? tämä on kelvoton
etunollia=''
case $apu in
-{1..18} ) etunollia='';; # desimaaleja=$((-1*$apu+1 )) }  ;;
0)  etunollia='';; #desimaaleja=0 ;; # apu=85; printf "%${apu}s" | tr " " 0
1)  etunollia='' ;;
2)  etunollia=0 ;;
3)  etunollia=00 ;;
4)  etunollia=000 ;;
5)  etunollia=0000 ;;
6)  etunollia=00000 ;;
7)  etunollia=000000 ;;
8)  etunollia=0000000 ;;
9)  etunollia=00000000 ;;
10) etunollia=000000000 ;;
11) etunollia=0000000000 ;;
12) etunollia=00000000000 ;;
13) etunollia=000000000000 ;;
*) desimaaleja=$((-1*$apu-1 )) ;;
esac
$tulosta etunollia:$etunollia'  desimaaleja:'$desimaaleja

luku1=$int1$desimaaliosa1
luku2=$int2$desimaaliosa2

$tulosta #luvut ilman desimaalipistettä:  ";$luku1' '$luku2

tulos='' # vain varmistus että kaikki on tuloksessa tämänjälkeen uutta
until [ ${#tulos} -gt $desimaaliluku ] ; do # muodostetaan tulos-palasia n merkkiä kerrallaan  #

apu=$(($luku1/$luku2)); [[ $apu -eq 0 ]] && apu=''; [[ ${apu:0:1} -eq 9 && ${tulos: -1} -eq 9  ]] && apu="0"$apu; tulos=$tulos${apu} ; $tulosta a$luku1' '$luku2' '$apu
luku1=$(($luku1%$luku2))'000000000000000000000000'; luku1=${luku1:0:18} ; $tulosta z$luku1
done

$tulosta "oikea tulos 140 desimaalilla esitetynä on päällä ja alla tulos tästä laskusta:"

[[ $etunollia ]] && echo .$etunollia${tulos:0} || echo ${tulos:0:$desimaaleja}.${tulos:$desimaaleja} ;}


# esimerkkilaskuja - kuten huomaat niin paljon on ihan keskeneräistä:
a=75.1234567 b=1233457; echo $(bc<<<"scale=140; $a/$b" | tr -d '\\\n')'  tämä rivi on bc:stä'; echo; time jaa $a $b 168; echo; echo
a=1233457890123.23; b=.92345678999999; echo $(bc<<<"scale=140; $a/$b" | tr -d '\\\n  tämä rivi on bc:stä'); echo; time jaa $a $b 170; echo; echo
a=1233457890123.23 b=.1234567; echo $(bc<<<"scale=140; $a/$b" | tr -d '\\\n  tämä rivi on bc:stä'); echo; time jaa $a $b 170; echo; echo
a=.1234567 1233457890123.23; echo $(bc<<<"scale=140; $a/$b" | tr -d '\\\n  tämä rivi on bc:stä'); echo; time jaa $a $b 170; echo; echo


[petteriIII]

Yksi uusi käsky on hitaampi kuin vanhoista käskyistä kasatut isot skriptit. Uudet käskyt ovat niin tautisen hitaita ettei ole mielekästä niillä numeroita käsitellä. Ja sopii ihmetellä niitä yleisesti hyväksyttyjä harhaluuloja BASH:in kyvyttömyydestä joita vielä opetetaankin edelleen - sillä tosiasiassa BASH kykenee vanhoilla käskyillään mihin hyvänsä. 
 
Kehittämisen arvoisia näillä vanhoilla käskyillä toteutetut skriptit tosiaan ovat sillä skriptien rivimäärän kasvaessa suoritus-aika kasvaa hyvin hitaasti - voi tarvittaessa lisätä ehtoja ja looppeja melko suruttomasti - mutta vaatimus on ettei uusia käskyjä saa skriptissä olla yhtään - tai onhan uusissakin käskyissä nopeita. Eihän lopputulos sittenkään nopea ole mutta tästä elämästä kerkiää hautaan hitaamminkin - sillä eihän näillä rahaa tehdä vaan ajankuluahan nämä vain ovat. Ja saa samalla haukkua BASH:in opettajia.

---

Edellä esitetyn jako-skriptin epäilyttävin kohta on siinä tehtävässä suuruusluokan määrityksessä ( esitetyssä skriptissä se oli käskyrivi: apu=$((${#int2}-${#int1})) ).

Tosin toistaiseksi paranneltu jako-skripti toimii vain alle 18-numeroisille kokonaisluvuille ja vielä pienemmille desimaaliluvuille. Eihän tämä vielä moitteton ole mutta yritetään sentään:

Koodia: [Valitse]



function suuruusluokka () { # kuinka monta numeroa tuloksen kokonais-osassa tulee olemaan - tai etu-nollaa.
# set -x; trap "echo paina: return;read x" DEBUG # skriptin suoritus käsky kerrallaan
tulosta=: # yhdessä paikassa päätetään tulostetaanko välituloksia.  Vaihtoehdot:tulosta=echo ja tulosta=:

[[ $1 = ${1/./} && $2 = ${2/./} ]] && { apu=$(($1/$2)); echo ${#apu}; return ;}    # jos kummatkin ovat kokonaislukuja 

[[ ${1//[^.]/} ]] && luku1=$1 || luku1=$1".0"; $tulosta luku1:$luku1
[[ ${2//[^.]/} ]] && luku2=$2 || luku2=$2".0"; $tulosta luku2:$luku2

merkki=''; koko1=${luku1%%.*}; koko2=${luku2%%.*}; desi1=${luku1##*.}; desi2=${luku2##*.}
(( $koko1 < $koko2 )) && { apu=$koko1; koko1=$koko2; koko2=$apu; apu=$desi1; desi1=$desi2; desi2=$apu; merkki=- ;}
#[[ $koko1 = $koko2 ]] && [[ $desi1 > $desi2 ]] && { apu=$koko1; koko1=$koko2; koko2=$apu; apu=$desi1; desi1=$desi2; desi2=$apu; merkki=- ;}



# desimaaliosien tulee olla yhtäpitkät. Lyhyemmän perään kirjoitetaan nollia sillä desimaaliosan lopussa ne eivät muuta arvoa.
(( ${#desi1} >= ${#desi2} )) && desipituus=${#desi1} || desipituus=${#desi2}
desi1=$desi1'00000000000000000000'
desi2=$desi2'00000000000000000000'
desi1=${desi1:0:$desipituus}; $tulosta desi1:$desi1
desi2=${desi2:0:$desipituus}; $tulosta desi2:$desi2

luku1=$koko1$desi1; luku1=${luku1:0:18}; $tulosta luku1:$luku1
luku2=$koko2$desi2; luku2=${luku2:0:18}; $tulosta luku2:$luku2

(( 10#$luku1 > 10#$luku2 )) && kokonaisia=$((10#$luku1/10#$luku2)) || kokonaisia=$((10#$luku2/10#$luku1)) ; echo  $merkki${#kokonaisia} ;
}
 
suuruusluokka 19.99999999999999 2
suuruusluokka 20.0 2
suuruusluokka 77.9 0.00001

suuruusluokka 2 19.99999999999999
suuruusluokka 2 20.00000000000000
suuruusluokka 0.00001 77.9


[petteriIII]

Edellinen on hyvä esimerkki siitä kuinka päästään tilanteeseen jossa saa ikuisesti tehdä toinen toistaan vaikeampia korjauksia - sillä alkuperäinen syy on ihan muualla:

Kyse oli siis siitä että jako-laskuja vaivaa 'katoavien nollien syndrooma´ - tuloksesta tipahtaa siellä-täällä nolla pois vaikka kaikki muut numerot ovat aina oikein. Se taas johtuu siitä että jakojäännöstä ei käsitellä oikein: otetaanpa esimerkiksi lasku 1001%100. Aivan varmasti jokainen sanoo että yksihän se ilmanmuuta on. Katsotaanpa - kirjoita tavalliseen kalkulaattoriin 1001/100 ja laskun jäkeen se tuloksessa pisteen jälkeen tuleva on se jakojäännös. Mikä on 01. Matemaattisessa mielessä 01 on sama asia kuin 1 ja matematiikka jättääkin tulostuksestaan aina etu-nollat pois - olettaen että ne ovat turhia ja hankaloittavatkin joskus.

- BASH:issa asioita hankaloittaa se vielä lisää että jos luvun edessä on 0 tajutaan se oktaaliluvuksi ja laskusta tulee omituisia tuloksia ja joskus virhekin. Koska sillekin on tehty estotapa on varmaa että nämä etu-nollat ovat kiusanneet aikoinaan paljonkin - joten  tämänkaltaisia desimaalisia jakolaskuja ovat aikoinaan jotkut vamasti tehneet sillä ei näitä muuten eteen tule.

- yksi keino jota BASH kykenee käyttämää tuon etu-nollan löytämiseksi on sittenkin yksinkertainen - käske : echo $((10*1001/100)) - vastaukseksi tulee 100 eikä 10. Mutta itse asiassa se merkitsee että: 1001/100 jakojäännös on 01 eikä 1. Koodina tämmöinen on:

Koodia: [Valitse]

jaettava=111453800000000000; jakaja=1233457; tulos=$(($jaettava/$jakaja)); apu2=$((10*$jaettava/$jakaja)); [[ ${apu2: -1} -eq 0 ]] && tulos=${apu2: -1}$tulos; echo $tulos

- lisäys korjasikin ilmeisesti kaiken näissä helpoissa tapauksissa. Pitää kuitenkin jatkaa harjoituksia sillä ei tämä vielä valmis ole - eikä tavallaan voi koskaan valmistukaan - vaikeus alkaa siitä että BASH:in matikka tuntee vain alle 18 numeroiset luvut joten vaikka uutta löytyisikin niin kovin hyvää tästä ei saa - toimintakin menee yhtä hitaaksi kuin matematiikka-ohjelmilla. Mutta onhan se kiva pystyä ratkomaan parissa millisekunnissa jakolaskuja joiden tulos on:
.00006090480389669035888563606189757729697914074021226520259725308624459547434568047366061403032290546002008987747444783239302221317808403535
.00006090480389669035888563606189757729697914074021226520259725308624459547434568047366061403032290546002008987747444783239302221317808403535  sama lasku bc:llä

- lukujen etumerkitkin pitäisi ottaa laskuissa huomioon. Mutta sen voi kopioida kertolaskusta. Enpä jaksa nyt.

- muuten tässäkin tehtävässä toimisi kaksois-tarkkuus mutta kaavat ovat niin vaikeat etten minä osaa niistä koodia tehdä. Nopeus kylläkin säilyisi.

- mihin tässä BASH:issa katseensa kääntääkin niin tuntuu siltä että moni muukin on aikoinaan tehnyt samaa sillä aina löytyy joku omituinen käsky joka ratkaisee kaiken - niin omituinen ettei sillä muuta käyttöä voi olla. Siis aina on tiedetty että esimerkiksi BASH on tehokas numeron-murskain - aikoinaan liian tehokas taviksien käsiin.

[petteriIII]

Toimintansa alussa kaikki skriptit kutsuvat tulkkia ja myöhemminkin aina tarvittaessa ja aikaahan jokainen kutsu vie. Tulkkaukseenkin kuluu aikaa, mutta koska vanhat komennot kuuluvat tulkkiin on tulkkaaminen niille muutenkin nopeampaa ja nopeutuu vielä enemmän jos skriptin kaikki komennot ovat niitä vanhoja sillä ne tulkataan silloin kaikki kerralla - uusien komentojen hitaus taitaa johtua siitä että ne tulkataan yksitellen.

BASH:in vanhat komennot ovat yksinäänkin yli kymmenen kertaa nopeampia ja ryhmässä yli sata kertaa nopeampia kuin uudet komennot joten uudella käskykannalla ei matematiikan toimimista ole pystynyt kehittämään - sillä vaikka desimaali-laskujen periaatteet ovat yksinkertaisia niin toimivan koodin kehittäminen vaatii miljoonia kokeita ja jos yksi koe kestääkin satakertaa kauemmin venyisi kehitysaika kuukausista vuosikymmeneen.
- miljoonia kokeita siksi että vielä siinävaiheessa uskoni virtuooseihin oli vankkumaton ja vain hitaasti pystyin kokeilemaan jotakin jota he väittivät mahdottomaksi.
- nyt skriptit olisivatkin yksinkertaisia kirjoittaa sillä havaittuani että myös nimi-parametrit toimivat automaattisine parametrin palautuksineen ja paljon muutakin sellaista toimii joita virtuoosit väittävät mahdottomaksi. Usko BASH-virtuoosien puheisiin on nykyään negatiivinen - ja virtuoosien on turha urputtaa vastaan sillä skriptini toimivat.
- kyllä uusillakin käskyillä desimaalimatematiikan saisi toimimaan sillä toiminnallisuus on jokseenkin sama - tosin uusilla käskyillä paljon-paljon hitaammin ja hankalammin.

Ilmeisesti ihan alussa BASH:in luomisen jälkeen joku BASH:in iso-kenkäinen huomasi desimaali-laskujen toimivan nopeasti kunhan rutiinit tekee sitävarten - ja koska BASH:ista haluttiin eroon jo silloin ja kyvykkäästä BASH:ista eroon pääseminen olisi mahdotonta niin tehtiin uusi käskykanta joka oli miellyttävämmän näköinen ja toimi tiedostonkäsittelyssä vielä kelvollisesti mutta koska matematiikkassa jokaiseen toimeen kuuluu vähintään kymmeniä käskyjä tulisi siitä sika-hidas - joten kukaan ei edes yrittänyt suorittaa desimaalilaskuja - tai tosiasiassa monikin on yrittänyt ja epä-onnistunut surkeasti joten vuosikymmenien kuluessa kehittyi luulo ettei BASH desimaali matematiikkaan kykene.

Kaikki pienet perus-laskutoimitukset:  + - * / ja '8-numeroinen neliöjuuri'
toimivat BASH:in vanhoilla komennoilla nopeammin kuin mikään matematiikka-ohjelma jonka voit liittää BASH:iin - sillä BASH alkaa laskemisen heti ja on valmis jo ennenkuin toiset voivat aloittaa.

Eihän laskuilla sittenkään käytännön toimia tee mutta protoyyppien tekemiseen BASH:illa ne ovat loistavan hyviä.

Nyt viimeisenä desimaali-laskuista valmistui jakolasku - jakolaskua oli vaikea saada toimimaan oikein, sillä jakolaskun tuloksesta tipahti siellä-täällä nolla pois. Syy oli yksinkertainen kun se vuoden etsimisen jälkeen löytyi - jakojäännös operaattori % toimii matemaattisessa mielessä aivan oikein mutta oikeaa tulosta se ei anna  - tämän kun otti huomioon niin jakolasku alkoi toimimaan aina oikein.

- siis desimaalinen 36 numeroinen perus-laskenta toimii ajassa millisekunti ja kymmenessä millisekunnssa saa laskettua vaikka mitä.

- uusilla komennoilla desimaalilaskut olisivat todella hitaat - ne saisi kyllä toimimaan nyt kun menetelmät ovat selvillä mutta aikaisemminhan toimintaa on ollut mahdotonta kehittää.

[petteriIII]

Aloin jo kauan sitten selvittää syytä miksi väitetään ettei BASH desimaalilaskuihin kykene - ja paljastui että väitetty syy on sama kuin miksi hiihtokilpailuissa hävitään: voitelu oli väärää - tai siis BASH:in suhteen sanottiin että eihän BASH:issa edes ole desimaali-tyyppiä eikä sen matematiikka-moottorikaan desimaalipilkkua hyväksy. Ei kummallakaan ole desimaalilaskujen kanssa muuta tekemistä kuin että ne yleensä helpottaa ja joskus romahduttaa - mutta täyyhän ne silti kumota:

1. desimaali-tyyppimäärittely on suurten lukujen suhteen rajoittava tekijä eikä siitä tyyppimäärityksestä ole mitään iloa. Esimerkiksi luku:
12345678901234567890123456789012345678901234567890123456789012345678901234567890.1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901. Onko se desimaaliluku? Mahtuuko se johonkin? Sitäpaitsi BASH tuntee lukujärjestelmät joiden kantaluku on välillä 2-60 joten merkeissä löytyy - joten oikeastaan ne olisivat tekstijonoja koska kaikki aakkosetkin kelpaavat. Siinäpä muuten salasana: $((60#petteriIII)) elikä kun sen kirjoittaa päätteeseen saa: 254376408104369084: command not found

2. ei semmoista asiaa olekaan kun desimaalilaskin sillä kaikki laskimet ovat kokonaislukulaskimia - sillä numerot tulevat laskuissa oikein kun desimaali pisteen poistaa. Siinä desimaali-laskimeksi kutsutussa on lisäosa pilkun paikan määrittämiseen. BASH:issa siis joutuu töihin kaksi kertaa - mutta koska kumpikin kerta on nopeudeltaan satakertainen uusilla käskyillä suoritettuihin verrattuna niin nopea se lopputuloskin vielä on.

Esitetäänpä niiden desimaali-laskujen nopeuksia:

- vähänumeroiset laskut ovat niin nopeita ettei oikeastan voi sanoa minkä nopeutta mitataan - linuxin, tulkkin vaiko skriptin.
- sillä Linux myöntää todella pieniä toiminta-aikoja kaikille toimille - ja jotkut toimethan täytyy suorittaa aivan ehdottomasti ja loput hommat laitetaan tärkeysjärjestykseen - kaikille annetaan toiminta-aikoja mutta toisille useammin ja esimerkiksi BASH:ille tosiharvoin. Tämä paitsi hidastaa niin tekee myös toimimisen nopeudesta epämääräistä. BASH-skriptien toiminta-ajat vaihtelevatkin liian paljon vaikka ottaisi väli-muistienkin toiminnan huomioon. Siitä päätellen niitä on hidastettu tälläkin tavoin vähintään kymmenkertaisesti ja ehkäpä paljon enemmänkin. Sillä BASH:istahan halutaan päästä eroon.

- 36 numeroinen liuku-luvun kertolasku - siinä on 30 käskyä ja aikaa kuluu millisekunti joten yhden käskyn suoritus kestää 33 mikrosekuntia. 
- jakolasku on omituinen - esimerkiksi: 75.1234567 / 1233457 = 
.00006090480389669035888563606189757729697914074021226520259725308624459547434568047366061403032290546002008987747444783239302221317808403535753577
sen satakunta käskyä se käy läpi millisekunnissa joten yhden käskyn suoritusaika on 10 mikrosekuntia. Tulos on tarkka numerolleen. Skripti on rekursiivinen ilman rekursiota - siinä se omituisuus.

- sitten potenssiin korottaminen - siis laskujen tyyppiä: 10.987654321098 ^ 10 - siinä on yli 300 käskyä ja aikaa kuluu 3 millisekuntia elikä yhden käskyn nopeus on parempi kuin 10 mikrosekuntia.

- sitten logaritmointi - siis laskujen tyyppiä: ota briggsin logaritmi luvusta: 17.35178533715 . Käskyrivejä tulee 1965 ja nopeudella 12ms tulee käskyä kohti noin 6 mikrosekuntia.

- kelvottoman huonoja aikoja muille kielille mutta BASH:ille ajat ovat erinomaisia sillä pienet perus-laskut ovat nopeampia mitä matematiikka-ohjelmilla saisi - ja tulevaisuudestahan ei tiedä - vaikkka jotain vielä mullistavampaa löytyisi.
- näin alussa on ehdottoman tärkeää voida todeta tuleeko laskuista oikea tulos. Siksi noissa laskuissani esitetään aina myös bc:n tulos välittömästi edellisellä rivillä tulosten desimalipisteet samalla kohtaa jotta vertaileminen olisi nopeaa ja varmaa - sillä bc:n tulos on varmasti oikea ja lisäksi se esittää tulokset oikealla tavalla. Miksei siis käytetä bc:tä kokoajan? Koska pienissä perus-laskuissa se jää toiseksi ja muut laskut ovat vain leikkimistä numeroilla.
- senkin takia noita lasku-rutiineja kannattaa tehdä koska opittuaan niiden toiminnan voi samoilla menetelmillä määritellä muitakin aikaisemmin mahdottomiksi luultuja toimia.

- alkeellisimmista toteutuksista saa toistaiseksi vain vajaat 18 oikeaa numeroa, kaksoistarkkuudestan 36 numroa, nelois-tarkkuudesta 72 numeroa .... ainakin kaksoistarkkuus on melkein yhtänopeaa kuin tavallinenkin ja eiköhän ne muutkin ole melkein yhtä nopeita - mutta skriptien tekeminen niihin olisi niin vaivalloinen ja puuduttava tehtävä etten enää pysty semmoisiin tehtäviin - vaikka periaate on sama kuin ennenkin ja onnistuminen varmaa.
- ohjelmalliset toteutukset häviävät kyllä rautalangasta tehdyille tuhatkertaisesti ilmanmuuta - mutta BASH:in tarkoitus on vain tehdä mahdolliseksi tehdä kohtuullisessa ajassa toimivia prototyyppejä eikä toimia käytännössä.
- ne alkuperäisetkin komennot oli tehty tekstinkäsittelyyn eikä niillä numeron-murskausta noinvaan pysty tekemään. En tiedä varmasti mutta todennäköiseltä tuntuu että monikin on noita vanhoja komentoja desimaalilaskuihin käyttänyt. 
- koska myös vanhat komennot ovat tekstinkäsittely-käskyjä nopeutuisi kaikki muukin skriptaaminen niitä käytettäessä.