Övning 2

del 1

In [2]:
import math

def kedjebråk(x):
    if x == 0: return 1
    #sum = 100
    #sum = (1+math.sqrt(5))/2
    sum = (1-math.sqrt(5))/2
    for i in range(x, 0, -1):
        sum = 1 + 1/(sum)
    return sum 


print (kedjebråk(1))  
print (kedjebråk(10))
print (kedjebråk(76))
print (kedjebråk(77))
print (kedjebråk(78))
print (kedjebråk(100))

-0.6180339887498947
-0.6180339887509818
1.618033988749896
1.6180339887498945
1.618033988749895
1.618033988749895

Del 2

Diagram för olika initialvärden sum och efter x iterationer:

sum x returns
1 1 2.0
1 1000 1.6180339887498_95
2 1 1.5
2 2 1.6666666666666665
2 50 1.6180555555555556
2 100 1.6180339887498_95
10 1 1.1
10 10 1.6181506849315068
10 100 1.6180339887498_95
20 1 1.05
20 10 1.6181657848324515
20 100 1.6180339887498_95
1+sqrt(5)/2 1 1.6180339887498_95
1-sqrt(5)/2 1 -0.6180339887498947
1-sqrt(5)/2 10 -0.6180339887509818
1-sqrt(5)/2 50 1.61812184348574740
1-sqrt(5)/2 77 1.6180339887498945
1-sqrt(5)/2 78 1.6180339887498_95

Kedjebråket får, efter 1000 iterationer, värdet 1.618033988749895 Som man kan se i diagrammet så blir svaret några decimaler större, men skillnaden blir mindre och mindre ju högra initialvärde vi väljer att använda. Använder vi 1+sqrt(5)/2 som argument skickas 1.618033988749895 ut redan efter första iterationen. Om vi stoppar in den andra fixpunkten 1-sqrt(5)/2 skickas ett annat värde ut: -0.6180339887498947.

I diagrammet ser man tydligt att $\frac{1+\sqrt5}{2}$ är en attraherande fixpunkt medans $\frac{1-\sqrt5}{2}$ är en reppelerande.

Övning 3

In [75]:
import math
def kedjesqrt(x):
    sum =  1.6180339887498950
    if x == 1:
        return math.sqrt(1) 
    for i in range(x):
        sum = math.sqrt(1 + sum)
    return sum


print (kedjesqrt(2))
print (kedjesqrt(32))

1.618033988749895
1.618033988749895

Diagram som visar resultat från chainsqrt med x antal iterationer:

x kedjesqrt(x) sum
2 1.4142135623730951 0
10 1.6180165422314876 0
37 1.6180339887498950 0
1000 1.6180339887498950 0
2 1.5537739740300374 1
10 1.6180285974702324 1
10 1.6180165422314876 1
31 1.6180339887498950 1
31 1.6180339887498951 5
32 1.6180339887498950 5
32 1.6180339887498951 9
33 1.6180339887498950 9
33 1.6180339887498951 89
33 1.6180339887498953 999
33 1.6180339887498956 10000
2 1.6180339887498956 1.6180..

Som vi ser har denna funktion samma fixpunkter som kedjebråk(x).

Om man väljer ett högre initialvärde krävs det fler iterationer för att få fram fixpunkten. Använder vi fixpunkten som startvärde får man fram fixpunkten redan efter 2 iterationer

Övning 4

Det approximativt värde på cos som jag räknat ut är 0.7390851332151607. Detta är efter 92 iterationer och startvärde 0. Efter det ändras inte längre några siffror. Gränsvärdet måste därför vara det svaret man får efter så många iterationer, dvs det är en fixpunkt till rekursionen. Testar man att använda den fixpunkten som argument returnerar den fixpunkten direkt.

Det spelar ingen roll om man ökar startvärdet, approx. förblir densamma efter 92 iteration.

In [14]:
import math

def cosIter(n):
    summa = 0
    if n == 0:
        return 1
    summa = math.cos(cosIter(n-1))
    return summa

print (cosIter(91))
print (math.cos(0.7390851332151607))

0.7390851332151606
0.7390851332151607

Övning 5

In [17]:
def funktion(x):
    return x**3-2*x**2+1

def fprime(x):
    return 3*x**2-4*x

def fun(f, x):
    return abs(0-f(x))
    
def Newton(f, df, n, e):
    delta = dx(f,n)
    while delta > e:
        n = n - (f(n)/df(n))
        delta = dx(f,n)
    print ('första rot är: ', n)
    print ("f(x) roten är: ",  f(n), "\n" )

nList = [.5, 1, 2, 5, 10]
for n in nList:
    print(Newton(funktion,fprime,n, 1e-5))

första rot är:  1.0
f(x) roten är:  0.0 

None
första rot är:  1
f(x) roten är:  0 

None
första rot är:  1.6180368184751346
f(x) roten är:  3.910606956480933e-06 

None
första rot är:  1.6180339964744885
f(x) roten är:  1.0675125672321428e-08 

None
första rot är:  1.6180339918238231
f(x) roten är:  4.24806501087005e-09 

None

Övning 6

In [11]:
from random import random
def logistik(r,x_start=random(),itteration=250):
    print ('Value x:' ,x_start)
    if (itteration==0):
        return x_start
    else:
        x=x_start
        for i in range(itteration-1):
            x= r*x*(1-x)
        return x
print(logistik(1))

Value x: 0.0925558393453304
0.0038016421520561186

För $ r≤1 $ har den logistiska avbildningen två fixpunkter, den första är $x_1$=0 och den andra är $x_2$=$\frac{r-1}{r}$ Och i just detta intervallet är det $x_1$ som är den attraherande fixpunkten, som kan kan ses i tabellen nedanför. Däremot krävs det fler itterationer då r=1 för att det lika tydligt ska ses att även då går swn logistiska avbildningen mot 0.

r xstart x_250
0.2 0.25074654873341484 1.6209419248852563e-175
0.4 0.4203637355618177 1.6975159743459639e-10
0.6 0.002625733749145986 1.4999122135064112e-58
0.8 0.07290833196098168 3.9145508905531837e-26
1 0.38734930413593427 0.0038991671029242492

För 1 < $r$ < 3 ser man att funktionen konvergerar mot 0.6. För $r$ = 3.2, 3,5 och 3,8 verkar det enligt enligt Geogebra att funktionen inte konvergerar mot några fixpunkter. Den når aldrig in till någon mittpunkt/fixpunkt

In [ ]: