# i denne r-info, r-info10.txt, skal vi fullfoere
# gjennom bedre kontakt med visse innsikter i tall,
# mens vi faar mer erfaring med hvordan R's syntaks
# for aa bygge funksjoner og arrays og slik er.
# trigonometri knyttet til smaa tall kan vi faa til
# med arrays som har eksakthet; kan vi med tilsvarende
# metode -- arrays som f.eks. har opploesningsnivaa
# til titusen -- klare aa dekke ikke bare smaa tall,
# men lage gode nok estimater av kvadratrot for hele
# spektret av heltall opp til en milliard og mer,
# altsaa hele spekret av 32-bits tall vi gjerne bruker?
# vi tar utgangspunkt i hoderegning om kvadratrot
# for aa lage en algoritme (denne har jeg ikke sett
# foer i dataform men den har sikkert vaert laget
# mange ganger for alt jeg vet).

# uansett hvor mange ferdiglagde avanserte moduler
# som gjoer mange ting i en enkelt kommando som 
# et dataspraak har, er det viktig aa kunne bygge
# ting tall etter tall, regneoperasjon etter
# regneoperasjon, og ikke gjoere det 'wholesale'
# hver eneste gang. de grunnleggende trekk av R
# gir noekkel til aa analysere de svaert avanserte
# grafiske eksempler vi ga i begynnelsen, og til
# aa finne flere kommandoer i manualer, som ofte
# forutsetter bra kompetanse innen hvordan bygge
# og kalle funksjoner og endel variabeltyper i R.

# foer vi begynner med en enkel maate aa estimere
# mange kvadratroetter gitt en mindre array, kan 
# vi ta med at hvis du starter R via en terminal 
# f.eks. i linux er det mulig aa lagre all tekst 
# som genereres av R paa en tekst-fil. i forrige 
# r-info hadde vi funksjonen noenverdier() som skrev 
# noe ut paa skjermen i tekstform. hvis du tar vekk 
# plottingen rett foran den og legger programmet som 
# begynner med generating_sine_values() og fullfoerer i
# kommandoen noenverdier() inn i en fil som heter
# f.eks. test1.R kan du, dersom du har skrive-
# tilgang til folderen du starter R i, naar du 
# bruker f.eks. xubuntu, ubuntu eller centos 
# TERMINAL, skrive noe slikt som dette:
                 R < test1.R --no-save > test5.txt
# dette vil foere til at all tekst som R genererer
# naar den leser inn programmet test1.R lagres i
# test5.txt. dette boer normalt bare gjoeres med
# programmer som ikke forventer noe fra tastatur,
# mus eller lignende. --no-save er det samme som 
# aa svare 'no' naar R spoer om 'workspace' skal
# lagres naar man gaar ut av R. R vil avslutte 
# seg selv automatisk uten at du behoever aa 
# legge inn en q() eller quit() naar du bruker
# denne syntaks. dette gir god mening naar du
# lager veldig mye utskrift som skal lagres i
# tekstform -- saa mye at copy og paste fra 
# tekstskjermen ikke er en egnet metode.

# her skal vi, som med sinus og cosinus, bruke
# heltall, men funksjonen som vi her lager i r
# kan brukes i en kontekst der vi setter inn et
# desimalpunktum etterpaa. alt forskningsarbeid med 
# tall og statistikk har glede av det vi kan kalle
# "kompetanse om tall". tall er ikke bare
# rekkefoelger, men kompliserte strukturer av
# faktorer og symmetrier og interessante analogier,
# slik som at det gylne snitt har 1618 i seg som
# start, mens kvadratroten av to har 1414 i seg
# som start, mens etter tretallet i pi kommer,
# avrundet, 1416 (3.14159). det er nesten som
# om noe ved eller i eller bak naturen tegner en
# ung puls mellom ettallet og 4, 6 og 8. tall
# rommer resonanser, og byr paa intet mindre enn
# uendelig mye forskningsmateriale. det er en 
# form for direkte mental empiri, og samtidig
# kan vi bruke digital teknologi til hjelp i
# forskningen paa denne mentale empiri. 

# eksakt produksjon av kvadratrot innen et visst
# antall siffre over hele spekret av tall er 
# sjelden noedvendig i kalkyler der alt man trenger 
# er et bra estimat prosentmessig sett, og eksakt
# naar man trenger det for et forhaandsbestemt
# spektrum. her blir det eksakt innen det antall
# siffer vi velger opp til ti tusen. heltall inn,
# og heltall ut men det kan lett omformatteres
# til desimaltall om man vil.

# en liten diversjon:
# siden vi naa er i en mer lekende avslutnings-
# stund av denne tutorial vi kanskje tillate
# oss aa fremme hva noe sikkert vil synes er
# en ganske vill paastand, men som jeg synes
# det er paa tide aa faa frem mer tydelig --
# og som i alle fall kan inspirere til talltanker:
# her er paastanden P1:
# [P1] desimaltall mellom 0 og 1 (eller -1) 
# er ikke ekte tall, men tall blandet opp med 
# divisjons-aritmetikk
# eksemplet er enkelt: mens multiplikasjon
# av 5 med 5 gir 25, et hoeyere tall, gir
# multiplikasjon av 0.5 med 0.5 resultatet
# 0.25, og derfor er det et brudd med 
# flyten. for hvis tallet hadde vaert ekte
# og naturlig, ville man hatt et stoerre
# tall, ikke et mindre, som resultat av
# multiplikasjon, og det tall skulle vaert
# 2.5; men siden det i en viss forstand er
# riktig at 0.25 er resultatet, for halvparten
# av en halvpart er, faktisk, 0.25, er det
# best aa fastslaa at det er en indre
# inkonsistens i tall mellom 0 og 1 (eller
# -1) og at disse tall skal holdes utenfor
# naar man bygger gode datasystemer.
# sagt paa annen maate, naar vi arbeider
# med manuell utregning av kvadratrot,
# kommer vi til aa gjoere endel deling og
# multiplikasjon, i tillegg til oppslag
# i en tabell vi forebereder i analogi til
# hvordan vi har gjort det i tidligere r-info
# med sine og cosine. med positive tall som
# er hele, og som er skalert, og aldri antatt
# aa representere noe som helst som er en
# fraksjon mellom 0 og 1 (eller 0 og -1),
# vil vi ha et nydelig, enkelt, og logisk
# oppsett. vi vil faa frem alle de essensielle
# siffer-serier, f.eks. den som er kjent fra
# det som i tradisjonell aritmetikk heter
# 'kvadratroten av 2', og som var noe som 
# phytagoras opplevde som religioest truende,
# skal vi tro fortellingene om han. disse
# siffer-serier er altsaa ikke avhengig av
# desimalpunktum og de kan anvendes og 
# fremkommer naturlig ved skalerte, positive,
# hele tall, eller med tall som omfortolkes
# til desimaltall. men dette prinsipp 
# gjelder ikke dersom man skal inkludere
# den kombinasjon av tall og delings-
# aritmetikk som maa til for aa definere
# fraksjoner mellom 0 og 1 (eller 0 og -1).

# for skal man inkludere slike fraksjoner,
# maa man vende alle prinsippene. mens
# 10 ganger 10 gir 100, gir 0.10 ganger
# 0.10 resultatet 0.010 -- det gaar
# motsatt vei. og hvorfor? fordi det
# ikke er et ordentlig tall. det er en
# deleprosess som innfoeres paa 
# usystematisk vis. det er usystematisk
# for overalt ellers i tallverdenen
# kan man skalere ting og operasjoner
# fungerer stort sett bra. men vi kan
# ikke skalere 0.10 og 0.10 til f.eks.
# 10 og 10 og reprodusere resultatet,
# for straks vi har skalert tallene opp
# og over 1, oppfoerer de seg som tall 
# skal, ikke som disse underlige vesener
# mellom 0 og 1 som baerer deling i seg
# som del av deres definisjon.

# paastanden [P1] gir mening ut fra min
# egen tallteori, fordi tallet 0 har mye
# til felles med nettopp den grenseloeshet
# som man ikke skal proeve aa fange inn
# gjennom grense-orienterte begreper;
# ideene mister klarhet om man ikke styrer
# unna slike forsoek. derfor har jeg ogsaa
# en sympati for at spraaket R begynner
# sine arrays med indeks 1 istedenfor 0.
# men du skal vite at du kan lese og
# studere videre i denne teksten selv om
# du ikke er helt enig i [P1]. her brukes
# den ogsaa for aa rettferdiggjoere at vi
# innskrenker rekkevidden av hva vi vil
# bruke kvadratroten til, slik at vi faar
# et enklere, mer meningsfylt, mer klart
# dataprogram. 
# [P1] kan populaeriseres ut paa avslappet
# vis slik: hvis man sier 0.5 mener man
# ikke et tall, man mener deling paa to --
# altsaa, man mener to ting, nemlig 'deling',
# og et tall, tallet 'to'. 
# tilsvarende, dersom man sier noe slikt
# som 0.738 mener man ikke et tall, men
# man mener deling paa cirka 1.355. vi skal
# godta at man leter etter kvadratroten av
# 1.355, og kvadratroten av et tall som er
# 1 eller hoeyere blir aldri under 1. men
# vi vil vise de som leter etter kvadratroten
# av tall mellom 0 og 1 til baren, der de
# kan ta seg en drink: vi anser dem som i
# en stemning der man ikke boer bruke tid
# paa mer regning og dataprogrammering, inntil
# stemningen gir seg hen.

# la oss da gaa igang med implementering av
# en estimering av kvadratrot med faa prosents
# avvik for hele spekret av tall, gitt den
# enklest mulige algoritme og en begrenset
# liste med tall, og ingenting utover vanlig
# heltallsmultiplikasjon og heltallsdivisjon
# og modulus (%%-operatoren vi har sett paa
# tidligere). det er ogsaa et kriterium at
# vi vil ha faerrest mulig trinn i algoritmen
# og slett ingen loop eller noe slikt der.

# estimering av kvadratrot kan begynne med
# at vi reflekterer over hva det er vi driver
# med mentalt naar vi noen ganger regner ut
# cirka kvadratrot av tall vi ikke helt vet
# hva har som kvadratrot. la oss foerst
# gruble paa tall som er saerlig
# lett aa ta roten av, og sammenligne 
# proporsjonene i forskjellene, for det er
# vel slikt vi jobber mentalt -- vi tar
# utgangspunkt i noen mer eller mindre kjente
# tallfenomener, og tilpasser derfra. la oss ta
# f.eks. det faktum at 30 ganger 30 er 900:
# kvadratroten av 900 er 30. vi vet jo
# at kvadratroten av 9 er 3. vi ser her at
# det er en total analogi, og at gjennom
# aa kjenne til det enklere eksempel, med
# mindre tall, nemlig at sqrt(9) er 3, kan
# vi raskere finne ut at sqrt(900) er 30. 
# er det slik at har sqrt(9) og sqrt(100)
# vil vi kunne dele 900 paa 100 og faa 9.
# svaret vi er ute etter er kvadratroten
# av 100 ganger kvadratroten av 9, altsaa
# 30. vi ser at vi kan bruke mindre tall for
# aa faa bukt med store tall, gjennom bruk
# av deling og multiplikasjon. tallet er
# idealisert enkelt fordi delingen paa
# 100 ikke har noen restverdi. hvis tallet
# er 909 og vi deler paa 100 faar vi fremdeles
# 9, naar vi bruker heltallsdivisjon. 
# hadde vi visst paa forhaand at vi vil
# faa liten eller ingen rest ved aa dele
# paa saann og slikt tall hadde det vaert
# veldig enkelt aa redusere feilmarginen
# til nesten null med en gang. slik som det
# er, hvis vi skal ha det hele absolutt
# enkelt og takle milliarder av tall med
# en liste som bare har ti tusen av tall,
# og ingen bruk av andre funksjoner slik
# som logaritmer eller noe saant, maa vi
# bare dele paa et eller annet og haape
# det beste!

# de store tallene i en datamaskin er,
# praktisk sett, sjelden stoerre enn ni
# siffre, 999 millioner, for straks vi
# gaar opp til 2 milliarder naermer vi oss
# grensen for en veldig rask og elegant
# tallstruktur som heter '32-bit-tallene'.
# tallene er mest lesbare naar de ikke har
# mer enn seks-syv kanskje aatte siffre.
# hvis vi skal redusere et digert tall til
# et lite tall, trenger vi aa finne et egnet
# tall, med kjent kvadratrot, som vi kan dele
# det paa. ogsaa primtall har kvadratrot, vi
# er ikke ute etter tall som deler helt uten
# rest eller noe slikt. saa kanskje vi har en
# tabell som har noen digre tall, kanskje:
# 100=>10,  10000=>100,   1,000,000=>1000,
# 100,000,000=>10,000.

# deretter lar vi en algoritme finne et tall
# som er hoeyt men ikke saa hoeyt at det
# ikke blir noe igjen av tallet naar vi 
# deler paa det -- og vi holder oss til
# hele tall. vi vil da se at noe slikt som
# kvadratroten av 20,000 burde ha noe av
# sifferserien som er kjent fra kvadratroten
# av to, multiplisert med kvadratroten av
# titusen, nemlig hundre. taster vi inn
# (med aatte nuller etter totallet)
  round(sqrt(200000000))
# i R kommer da ogsaa 14142 som svar, og dette
# er nettopp den forventete sifferrekke.
# sjekker vi presisjonen av dette ved aa
# skrive 14142^2 eller
  14142*14142
# faar vi 
  199996164
# som er forholdsvis naert, faktisk. la oss
# legge merke til at forskjellen mellom 30
# og 900 er stor, og forskjellen mellom 
# 14,142 og 200,000,000 er stor, mens man
# kan ikke helt si det samme om forskjellen
# mellom 2 og 1.4142. saa 'noeytraliseringen'
# av tallene begynner naar naermer seg 1,
# mens det er foerst i fraksjoner under 1 
# at det hele blir et bakvendtland som ikke 
# helt henger paa greip. det synes som om vi
# skal ta sikte paa aa lagre sifferserien
# 14142 med en match i forhold til to-tallet
# og bruke dette paa et vis. hvor hoeyt maa
# vi gaa? vel, hvis vi begynner med aa lagre
# 14142 som er faktor*sqrt(2) med faktor 10000,
# kan vi jo gaa opp flere hundre uten at vi
# har laget en stoerre array enn den vi brukte
# med faktor 100 for sine og cosine. dersom
# vi vil ha hundre ganger noeyaktigheten for
# sine og cosine, kan vi gaa opp til titusen
# eller hoeyere for kvadratrot-arrayen, hvis
# den skal vaere av samme opploesningsnivaa,
# for aa si det slik. det er klart at jo stoerre
# array vi har til kvadratrot-funksjonen, dess
# enklere jobb har vi med aa dividere og 
# regne ut for de oevrige tall, opp til cirka
# 1 eller 2 millarder, som vi skal haandtere.

# dette viser seg aa produsere et bra estimat,
# for de tall vi tested ble estimatet stort sett
# saa bra at med to desimaler viste prosent-
# avviket 0.0, men i noen tilfeller ble det
# merkbart, f.eks. 0.15 prosents avvik. det er
# langt bedre presisjon enn det som trengs for
# den type grafikk som regner frem og tilbake
# med kvadratrot for f.eks. aa rotere bilder.
# slik lager du tabellen med de 10000 tall paa disk:

factor_for_getsqr <- 1000000
fresh_sqr_results <- 
  function(tallet=2, resolusjon=factor_for_getsqr) {
return( round(resolusjon * sqrt(tallet)) ) 
}
the_sqr_data <- fresh_sqr_results(1:10000, factor_for_getsqr)
write(the_sqr_data, "sqr-data.txt")

# hvis du kjoerer dette paa en datamaskin der du ikke oensker
# aa skrive til disken, skip write(..) og hopp over den neste
# scan(..) og kjoer den koden som kommer naa sammen med den
# koden som staar rett over dette avsnittet, som ett program.
# merk at sqr-data.txt, hvis du kikker paa den, inneholder
# besynderlige kreaturer som 1.1e+07. dette er ikke fordi
# datamaskinen har drukket, eller gitt opp, eller elektronene
# er blitt slitne av aa slave for deg. det er en maate aa
# spare en smule plass i filen paa, naar det er mange nuller
# i tallet. det betyr ikke at maxgrensen for tall er naadd! ;)
# slike tall oppstaar ogsaa lett her. vi tester det hele
# gjennom 'probeit', som gjenskaper desimalpunktum slik at
# det er lett aa sammenligne med den 'elaborerte' (original-)
# funksjonen sqrt. vi beregner prosentvik avvik, det er 
# naturligvis ikke noe avvik naar tallet er under titusen.

the_sqr_data = scan("sqr-data.txt")
factor_for_getsqr <- 1000000
getsqr <- function( inputtall ) {
  if (inputtall < 10001) 
    return( the_sqr_data[ inputtall ] )
  if ((inputtall %/% 100) <= 10000)
    return( 10*(the_sqr_data[ inputtall %/% 100 ]) )
  if ((inputtall %/% 10000) <= 10000)
    return( 100*(the_sqr_data[ inputtall %/% 10000 ]) )
  return( 1000*(the_sqr_data[ inputtall %/% 1000000 ]) )
}
probeit <- function( inputx ) {
  estimate <- ((getsqr(inputx)) / factor_for_getsqr)
  elaboratenum <- (sqrt(inputx))
  percentdifference <- abs(100 - (100*(estimate / elaboratenum)))
  print( sprintf("quick estimate: %.2f  elaborate: %.2f  difference: ca %.2f percent",
      estimate, elaboratenum, percentdifference) )
}
probeit(328923)
probeit(3298)
probeit(9000000)
probeit(314314)
probeit(39823724)
probeit(3498338)
probeit(505393)
probeit(332982788)
probeit(15899492)


# man kan naturlig lage gradvis mer presise tilnaerminger til det
# klassiske 'sqrt' svar f.eks. ved aa gjoere bruk av mod-funksjonen
# og ikke minst ved stoerre lister og ved diverse iterasjon,
# men hva vi har laget er en usedvanlig kjapp rutine som gjoer ting 
# helt i traad med intuitiv tenkning paa slike talloperasjoner. 
# i mange tilfelle er bruken av kvadratrot helt aapen for naturlige
# fluktuasjoner og overpresisjon ikke noedvendig. det er jo en sentral
# faktor baade i foerste-haands tilnamering til programmering (slik vi 
# har definert begrepet i vaart firth-arbeid siden 2005), og i gode
# filosofiske refleksjoner over Heisenberg's Uncertainty Principle
# eller HUP (eller 'ubestemthets-relasjon', indeterminacy
# relation) at, ingen algoritmer, enkelhet og skjoennhet skal
# fokuseres paa fremfor meningsloest jag etter overpresisjon.
# gjennom aa tillate naturlige fluktuasjoner oppstaar kvantemagien
# og ikkelokaliteten som gaar bortenfor einstein's begrensete syn
# paa fotoner for det skjer ikke en unoedig nagling fast av bevegelsen.
# man skal derfor akte HUP prinsippet, ikke bare som en teknisk ting,
# men til inspirasjon for en filosofisk verdsetting av at ting
# ikke over-analyseres og ikke over-telles, enten det er fotoner,
# elektroner, eller sosiale ting. frihet fra unoedig presisjon gir
# rom for statistisk innsikt.



### lykke til!
=*=
ATWLAH