Serie 2

D-MATH
Dr. Vasile Gradinaru
Alexander Dabrowski
Numerische Methoden
FS 2016
Serie 2
Best before: Di. 15.3 / Mi. 16.3, in den Übungsgruppen
Koordinatoren: Alexander Dabrowski, HG G 52.1, [email protected]
Webpage: http://www.math.ethz.ch/education/bachelor/lectures/fs2016/other/nm_pc
1. Trajektorie bei Streuung (Prüfungsaufgabe FS 13)
Die Trajektorie eines Teilchens bei Streuung an einem Potential U (x, y) wird beschrieben durch:
r̈ = −∇U
wobei r = (x, y)T die Teilchenkoordinaten sind und U das Lennard-Jones Potential:
12 6 !
1
1
U (x, y) = 4
−
r
r
ist und r2 = x2 + y 2 .
a) Plotten Sie die Teilchen-Trajektorien, die sich mit dem Störmer-Verlet Verfahren ergeben.
b) Verwenden Sie folgende Anfangsbedingungen und Parameter:
8
• r(t = 0) = (−10, b)T , wobei b = 0.15, 0.3, 0.45, . . . , 3,
6
T
• ṙ(t = 0) = (1, 0) ,
y
4
• Zeitschritt ∆t = 0.02,
2
0
−2
• Endzeit Tende = 15.
−4
−10
−8
−6
−4
−2
x
0
2
4
6
Hinweis: Benutzen Sie das Template 1 ljones Template.py.
Solution:
Zunächst muss die Kraft auf das Teilchen explizit ausgerechnet werden:
2
1
x
∇U = −24
−
.
y
r14
r8
(1)
Anschliessend gibt es zwei Möglichkeiten das Störmer-Verlet Verfahren zu implementieren. Die
Implementierungen sind in Listing 1 zu finden. Die Trajektorien sind in Abbildung 1 gezeigt.
Listing 1: 1 ljones.py
1
import numpy a s np
import matplotlib . pylab a s plt
3
d e f F(r):
5
Bitte wenden!
7
"""
Bereche Beschleunigung fuer Streuproblem
9
Input : r ... Teilchen Koordinaten [x,y]
11
Output : Fval ... F(r)
13
"""
15
Fval = np. zeros (2)
r2 = r [0]**2 + r [1]**2
rr = np. sqrt (r2)
r14 = rr **14
r8 = rr **8
Fval [0] = 24.* r [0]*(2./ r14 - 1./ r8)
Fval [1] = 24.* r [1]*(2./ r14 - 1./ r8)
17
19
21
23
# return
r e t u r n Fval
25
d e f integrate_SV1 (r0 ,v0 ,dt , tEnd ):
27
29
"""
Integriere Trajektorien im Lennard - Jones Potential mit dem
Einschritt Stoermer - Verlet Verfahren
31
33
35
37
Input : r0
v0
dt
tEnd
...
...
...
...
Anfangskoordinaten r0 = [x0 ,y0]
Anfangsgeschwindigkeiten v0 = [vx0 , vy0 ]
Zeitschritt
Endzeit
39
Output : t ... Zeit
r ... Trajektorien r = [x ,y]
v ... Geschwindigkeiten v = [vx ,vy]
41
"""
43
# Bestimme Anzahl Schritte
N = tEnd /dt
45
47
49
51
53
#
t
r
v
mache Speicher
= np. zeros (( N +1) )
= np. zeros ((2 ,N +1) )
= np. zeros ((2 ,N +1) )
# Setze Anfangsbedingungen
t [0] = 0.
r [: ,0] = r0
v [: ,0] = v0
55
57
59
61
# Integriere
f o r i i n np. arange (N):
ip = i + 1
t[ip] = t[i] + dt
v12 = v[: ,i] + 0.5* dt*F(r[: ,i])
r[: , ip] = r[: ,i] + dt* v12
v[: , ip] = v12 + 0.5* dt*F(r[: , ip ])
63
65
67
69
# return
r e t u r n t,r,v
d e f integrate_SV2 (r0 ,v0 ,dt , tEnd ):
"""
Integriere Trajektorien im Lennard - Jones Potential mit dem
Siehe nächstes Blatt!
71
Zweischritt Stoermer - Verlet Verfahren
73
Input : r0
v0
dt
tEnd
75
...
...
...
...
Anfangskoordinaten r0 = [x0 ,y0]
Anfangsgeschwindigkeiten v0 = [vx0 , vy0 ]
Zeitschritt
Endzeit
77
79
Output : t ... Zeit
r ... Trajektorien r = [x ,y]
81
"""
83
# Bestimme Anzahl Schritte
N = tEnd /dt
85
87
89
91
93
#
t
r
v
mache Speicher
= np. zeros (( N +1) )
= np. zeros ((2 ,N +1) )
= np. zeros ((2 ,N +1) )
# Setze Anfangsbedingungen
t [0] = 0.
r [: ,0] = r0
v [: ,0] = v0
95
97
99
101
103
# Mache ersten Schritt
r [: ,1] = r [: ,0] + dt* v0 + 0.5* dt **2* F(r [: ,0])
# Integriere
f o r i i n np. arange (1 ,N):
im = i - 1
ip = i + 1
t[ip] = t[i] + dt
r[: , ip] = - r[: , im] + 2.* r[: ,i] + dt **2* F(r[: ,i])
105
107
109
111
# return
r e t u r n t,r
# Parameter
tEnd = 15.
dt = 0.02
Einschritt = True # Einschritt ( True ) oder Zweischritt ( False ) SV
113
115
117
119
121
123
125
127
# Berechne und Plotte Trajektorien
plt . clf ()
f o r b i n np. linspace (0 ,3. ,21) :
r0 = np. array ([ -10. , b])
v0 = np. array ([1. ,0.])
i f ( Einschritt ):
[t,r,v] = integrate_SV1 (r0 ,v0 ,dt , tEnd )
else:
[t,r] = integrate_SV2 (r0 ,v0 ,dt , tEnd )
plt . plot (r [0 ,:] ,r [1 ,:])
plt . grid (True)
plt . xlabel ( ’$x$ ’)
plt . ylabel ( ’$y$ ’)
plt . savefig (’lj. pdf ’)
2. Plancksches Strahlungsgesetz (Aufgabe aus der Vorlesung)
Verstehen Sie den Code BoltzmanConst.py
Bitte wenden!
8
6
y
4
2
0
−2
−4
−10
−8
−6
−4
−2
x
0
2
4
6
Abbildung 1: Trajektorien im Lennard-Jones Potential.
Solution:
Listing 2: Python-Skript zu Aufgabe 2)
2
4
6
from numpy import linspace , exp , inf
from pylab import figure , plot , savefig , show
# Plank ’s law for blackbody radiation
c1 = 3.7413*10**8 # W \ mu m ^4/ m ^2
c2 = 1.4388*10**4 # \mu m K
T = 1000.0 # T = temperature in K
8
10
12
# monochromatic emissive power of a blackbody :
d e f Eblam (lam , T =1000.0) :
# lam = wavelength in \um
r e t u r n c1 / ( lam **5 * ( exp (c2 /( lam *T)) -1.0) )
14
16
18
20
p r i n t ’ ------------ plot ---------------’
y = linspace (0.01 , 10 , 1000)
figure ()
plot (y, Eblam (y ,1600.0) / 10.0**4)
savefig ("E. png ")
show ()
22
24
p r i n t ’ ------------ integrate : quad ---------------’
from scipy import integrate
26
28
# total energy lost per unit area
Q, abserr , info = integrate . quad ( Eblam ,0 , inf , full_output =True)
neval = info [’neval ’]
Siehe nächstes Blatt!
30
# Q = sigma * T ^4; sigma = Stefan - Boltzmann constant
p r i n t Q/T**4 , abserr , ’neval =’, neval
32
34
36
T = 200. # 5778.
Q, abserr , info = integrate . quad ( Eblam ,0 , inf , args =(T), full_output =True)
neval = info [’neval ’]
# Q = sigma * T ^4; sigma = Stefan - Boltzmann constant
p r i n t Q/T**4 , abserr , ’neval =’, neval
38
40
42
p r i n t ’ ------------ integrate : simpson ---------------’
from simpson import simpson
f o r N i n xrange (20 ,50) :
p r i n t simpson ( Eblam ,0.01 ,20. , N) /1000**4 , N
44
46
48
p r i n t ’ ------------ integrate : simpsadapt ---------------’
from simpsadapt import simpsadapt
a = simpsadapt ( Eblam ,0.01 ,200. , eps =1E -6)
p r i n t a, a [0]/1000**4
Abbildung 2: Plancksches Strahlungsgesetz
Listing 3: Ausgabe des Skript
1
3
5
7
9
------------ plot --------------BoltzmanConst .py :13: RuntimeWarning : overflow encountered i n exp
r e t u r n c1 / ( lam **5 * ( exp (c2 /( lam *T)) -1.0) )
------------ integrate : quad --------------5.66929491023 e -08 9.87919738904 e -07 neval = 105
5.66929491023 e -08 2.74856409294 e -08 neval = 165
------------ integrate : simpson --------------5.58764899512 e -08 20
5.58633622191 e -08 21
Bitte wenden!
11
13
15
17
19
21
23
25
27
29
31
33
35
37
39
5.58568841455 e -08 22
5.58550419581 e -08 23
5.58561175664 e -08 24
5.5858777415 e -08 25
5.58620684146 e -08 26
5.58653667597 e -08 27
5.58683087932 e -08 28
5.58707211582 e -08 29
5.58725592785 e -08 30
5.58738578675 e -08 31
5.587469394 e -08 32
5.58751610543 e -08 33
5.58753527541 e -08 34
5.58753530235 e -08 35
5.58752317476 e -08 36
5.58750435057 e -08 37
5.58748283976 e -08 38
5.58746139549 e -08 39
5.58744174882 e -08 40
5.5874248457 e -08 41
5.58741106215 e -08 42
5.58740038646 e -08 43
5.58739256451 e -08 44
5.58738721014 e -08 45
5.58738388444 e -08 46
5.58738214943 e -08 47
5.58738160147 e -08 48
5.58738188954 e -08 49
------------ integrate : simpsadapt --------------(56691.894595927217 , 1.6007106751203537 e -10 , 8192) 5.66918945959 e -08
Siehe nächstes Blatt!
3. Kernaufgabe: Anfangsamplitude eines Pendels zu gegebener Periode
Solution:
12 Punkte insgesamt.
Die Bewegungsgleichung eines mathematischen Pendels (Reibung vernachlässigt) der Länge l
ist eine nicht-lineare gewöhnliche Differentialgleichung 2. Ordnung und das zugehörige Anfangswertproblem ist
g
ϕ̈ = − sin (ϕ) ,
l
ϕ(0) = ϕ0 ∈ ]0,
π
],
2
ϕ̇(0) = 0 ,
wobei ϕ(t) der Winkel des Pendels in Bezug zur vertikalen Richtung und g die Gravitationskonstante ist. Für grosse Amplituden ist die Periode T eine Funktion des Anfangswertes. Man
kann eine Formel für T (ϕ0 ) wie folgt herleiten. Wir betrachten die gesamte Energie des Pendels,
welche in der Zeitentwicklung erhalten bleiben muss
1
mgl(1 − cos ϕ0 ) = ml2 ϕ̇2 + mgl(1 − cos ϕ) .
{z
} |2
|
{z
}
E0 =E(0)
E(t)
Auflösen dieser Gleichung nach ϕ̇ ergibt
dϕ
ϕ̇ =
=±
dt
r
2g
(cos ϕ − cos ϕ0 )
l
und per Integration nach t bekommt man die Periode
s Z
ϕ0
1
l
√
dϕ .
T (ϕ0 ) = 4
2g 0
cos ϕ − cos ϕ0
Dieses Integral ist singulär bei ϕ = ϕ0 und numerisch
schwierig zu berechnen. Deshalb wendet
man erst die Substitution cos ϕ = 1 − 2 sin2 ϕ2 und dann die Variabeltransformation sin θ =
sin( ϕ
2)
an und bekommt
ϕ
sin( 20 )
s Z π
2
l
1
p
(2)
T (ϕ0 ) = 4
dθ .
g 0
1 − k 2 sin2 θ
{z
}
|
:=K(k)
ϕ0
wobei k := sin 2 und |ϕ0 | < π. Das bestimmte Integral K(k) ist gerade die Definition einer
wohlbekannten speziellen Funktion: das vollständige elliptische Integral erster Art.
Wir betrachten in dieser Aufgabe das nicht-lineare Anfangswertproblem.
Bestimmen Sie den Anfangswinkel ϕ0 , so dass T = 1.8 s die Periode der Lösung ist.
Die Parameter sind l = 0.6 m und g = 9.81 ms−2 . Aufgrund der Symmetrie passiert das Pendel
in jedem Fall bei t = T4 und t = 3T
4 seinen tiefsten Punkt. Daher können wir das Problem
folgendermassen formulieren:
Bestimmen Sie ϕ0 > 0, so dass für die Lösung t 7→ ϕ(t) ϕ(0.45) = 0 gilt.
Bitte wenden!
a) Schreiben Sie die Differentialgleichung 2. Ordnung als eine System von Differentialgleichungen 1. Ordnung.
Solution:
1 Punkt. Wir definieren y1 := ϕ und y2 := ϕ̇ ≡ y˙1 , und erhalten das AWP:
(
ẏ1 = y2
y1 (0) = ϕ0 ,
g
y2 (0) = 0 .
ẏ2 = − l sin (y1 )
(3)
b) Schreiben Sie eine Python Funktion IntegratePendulum(phi0, tEnd, l, g, flag) die
den Integrator ode45 benutzt, um die Pendelgleichung mit den Parametern l und g zu
lösen. Für flag=True soll nur die numerische Approximation von φ(tEnd) anstatt der
gesamten numerischen Lösung zurückgegeben werden.
Solution:
1 Punkt. (Implementation der right-hand-side.)
c) Lösen Sie das Anfangswertproblem auf [0, tEnd] für die beiden gegebenen Anfangswerte
ϕ0 = 0.8 π2 und ϕ0 = 0.99 π2 . Plotten Sie in beiden Fällen den zeitlichen Verlauf von ϕ und
ϕ̇. Verifizieren Sie, dass die Periode der Lösung für den ersten Startwert kleiner und für
den zweiten Startwert grösser als T = 1.8 s ist.
Solution:
2 Punkte. (Korrekter Aufruf der Funktion aus der letzten Teilaufgabe.)
d) Die Funktion F sei nun mithilfe der Lösung ϕ(t) definiert als
F (ϕ0 ) := ϕ(0.45) .
Verwenden Sie die Python Funktion fsolve aus dem Modul scipy.optimize um die Nullstelle von F (ϕ0 ) zu bestimmmen1 . Plotten Sie die Lösung und verifizieren Sie, dass die
numerische Lösung tatsächlich die Periode T = 1.8 s hat.
Solution:
2 Punkte. (Korrekter Aufruf von fsolve mit extra Argumenten.)
e) Anstelle einer numerischen Approximation der Lösung ϕ(t) der Differentialgleichung kann
auch die Formel (2) in der Definition der Funktion F verwendet werden
F (ϕ0 ) :=
1
T (ϕ0 ) − 0.45 .
4
Bestimmen Sie wiederum die Nullstelle von F . Das elliptische Integral K(k) soll mittels
einer zusammengesetzten Simpson Quadraturregel auf 10 Intervallen approximiert werden.
Solution:
3 Punkte. (1 Implementation der Quadratur, 1 Berechnung des elliptischen Integrals, 1
Aufruf von fsolve mit Lambda.)
f ) Eine wesentlich effizientere Methode zur Berechnung der Funktion K(k) verwendet das
arithmetisch-geometrische Mittel agm(x, y) zweier Zahlen. Es berechnet sich iterativ wie
folgt: x0 := x, y0 := y und
xn + yn
2
√
:= xn yn .
xn+1 :=
yn+1
1 F ist stetig und steigend auf [0.8π/2, 0.99π/2] (grössere Anfangswerte sind längere Perioden) daher hat F auf
diesem Intervall eine eindeutige Nullstelle.
Siehe nächstes Blatt!
Im Limit n → ∞ gilt xn = yn = agm(x, y). Das elliptische Integral lässt sich nun schreiben
als
Z π2
1
π
1
p
.
dξ = K(k) =
2
2
2
agm(1
−
k, 1 + k)
0
1 − k sin ξ
Verwenden Sie diese Iteration zur Approximation von T (ϕ0 ) und bestimmen Sie die Nullstelle von F . Aufgrund der guten Konvergenz sind nur sehr wenige Iterationen notwendig.
Für diese Berechnung hier reichen 5, da stets 0 < k < 1.
Solution:
3 Punkte. (1 Implementation der AGM Iteration, 1 Berechnung des elliptischen Integrals,
1 Aufruf von fsolve mit Lambda.)
Hinweis: Verwenden Sie das Template 2 pendulum Template.py und ode45.py.
Solution:
Listing 4: 2 pendulum.py
1
3
from numpy import array , sin , pi , shape , sqrt , linspace
import matplotlib . pyplot a s plt
from ode45 import ode45
import scipy . optimize
5
7
9
d e f PendulumODE (y, l, g):
""" PendulumODE return the right - hand side of the math . pendulum """
dydt = array ([ y[1] , -g * sin (y [0]) / l])
r e t u r n dydt
11
13
d e f IntegratePendulum (phi0 , tEnd =1.8 , l =0.6 , g =9.81 , flag = F a l s e ):
""" IntegratePendulum solve the mathematical pendulum with ode45
15
17
19
21
23
25
27
29
Input : phi0
tEnd
flag
... initial condition
... end time
... flag == False return complete solution : (phi , phi ’, t)
flag == True return solution at endtime only : phi ( tEnd )
"""
i f shape ( phi0 ) == (1 ,) :
phi0 = phi0 [0]
y0 = array ([ phi0 , 0])
tspan = (0 , tEnd )
t, y = ode45 (lambda t, y: PendulumODE (y, l, g) , tspan , y0 )
i f flag :
r e t u r n y [ -1][0]
else:
r e t u r n (y, t)
31
33
d e f simpson (f, a, b, N):
r """
Simpson quadrature of function f from a to b with N subintervals .
35
37
39
41
f:
Function f(x)
a, b: Bounds of the integration interval
N:
Number of subintervals
"""
x, h = linspace (a, b , 2*N+1 , retstep =True)
I = h /3.0 * sum(f(x [: -2:2]) + 4.0* f(x [1: -1:2]) + f(x [2::2]) )
return I
43
Bitte wenden!
45
47
49
51
53
d e f elliptic_k_quad (k, N =10) :
""" Compute the elliptic integral K(k)
via composite Simpson qudrature .
Input : k
... function argument
N
... number of intervals for Simpson
Output : K(k) ... function value
"""
f = lambda x: 1.0 / sqrt (1.0 - k **2 * sin (x) **2)
r e t u r n simpson (f, 0, 0.5* pi , N)
55
57
d e f agm (x , y, nit =5) :
""" Computes the arithmetic - geometric mean of two numbers x and y.
59
61
63
65
67
69
71
Input : x , y ... two numbers
nit
... number of iteration
Output : agm (x,y)
"""
xn = x
yn = y
f o r i i n xrange ( nit ):
xnp1 = 0.5 * (xn + yn)
ynp1 = sqrt (xn *yn)
xn = xnp1
yn = ynp1
r e t u r n xn
73
75
d e f elliptic_k_agm (k , nit =5) :
""" Compute the elliptic integral K(k)
via arithmetic - geometric mean iteration .
77
Input : k
79
81
... function argument
nit
... number of iteration
Output : K(k) ... function value
"""
r e t u r n 0.5* pi / agm (1.0 -k, 1.0+k, nit = nit )
83
85
i f __name__ == ’ __main__ ’:
from time import time
87
89
91
# Parameter values
tEnd = 1.8
l = 0.6
g = 9.81
93
# Unteraufgabe c)
95
97
99
# Solve ODE for extreme values to check the period length :
a1 = 0.8
y1 , t1 = IntegratePendulum (a1 * pi * 0.5 , tEnd , l, g, F a l s e )
a2 = 0.99
y2 , t2 = IntegratePendulum (a2 * pi * 0.5 , tEnd , l, g, F a l s e )
101
103
105
plt . figure ()
ax1 = plt . subplot (211)
plt . plot (t1 , y1. transpose () [0] , ’b’, label =r’$f \, | \, f_0 = %1.2 f \, \ frac &
· · · {\ pi }{2} $’ % a1)
plt . plot (t1 , y1. transpose () [1] , ’b--’, label =r’$\ frac {df }{ dt} \, | \, f_0 = &
· · · %1.2 f \, \ frac {\ pi }{2} $’ % a1 )
plt . plot (t2 , y2. transpose () [0] , ’r’, label =r’$f \, | \, f_0 = %1.2 f \, \ frac &
Siehe nächstes Blatt!
107
109
111
· · · {\ pi }{2} $ ’ % a2)
plt . plot (t2 , y2. transpose () [1] , ’r--’, label =r’$\ frac {df }{ dt} \, | \, f_0 =
· · · %1.2 f \, \ frac {\ pi }{2} $’ % a2 )
plt . title ( ’ Solutions to the pendulum ODE for different initial amplitudes ’)
plt . xlabel (r’$t$ ’)
plt . legend ( loc =’upper left ’)
plt . grid (True)
&
113
# Unteraufgabe d)
115
117
119
121
123
125
127
129
131
133
135
137
# zero finding :
p r i n t (" Initial value via time - integration ")
starttime = time ()
phiT = scipy . optimize . fsolve ( IntegratePendulum , a1* pi *0.5 , args =( tEnd *0.25 , l &
· · · , g, True))
p r i n t ( phiT )
endtime = time ()
p r i n t (’ needed %f seconds ’ % ( endtime - starttime ))
# compute complete solution with period = tEnd for plotting
y3 , t3 = IntegratePendulum (phiT , tEnd , l, g, F a l s e )
y3 = y3. transpose ()
ax1 = plt . subplot (212)
plt . plot (t3 , y3 [0] , ’-’, label =r ’$f$ ’)
plt . plot (t3 , y3 [1] , ’b-- ’, label =r’$\ frac {df }{ dt}$’)
plt . title (r’ Solution to the pendulum ODE for $f_0 = %1.3 f $’ % phiT )
plt . xlabel (r’$t$ ’)
plt . legend ( loc =’upper left ’)
plt . grid (True)
plt . savefig (’ Pendulum . pdf ’)
plt . show ()
139
# Unteraufgabe e)
141
143
145
p r i n t (" Initial value via exakt formula for T")
p r i n t (" Elliptic Integral by Quadrature ")
d e f quarter_period_quad ( phi ):
r e t u r n sqrt (l /(1.0* g)) * elliptic_k_quad ( sin ( phi /2.0) )
147
149
151
starttime = time ()
phiT = scipy . optimize . fsolve (lambda tau : quarter_period_quad ( tau ) - 0.45 , pi &
· · · *0.5)
p r i n t ( phiT )
endtime = time ()
p r i n t (’ needed %f seconds ’ % ( endtime - starttime ))
153
155
# Unteraufgabe f)
157
p r i n t (" Initial value via exakt formula for T")
p r i n t (" Elliptic Integral by Arithmetic - Geometric Mean ")
159
161
163
165
d e f quarter_period_agm ( phi ):
r e t u r n sqrt (l /(1.0* g)) * elliptic_k_agm ( sin ( phi /2.0) )
starttime = time ()
phiT = scipy . optimize . fsolve (lambda tau : quarter_period_agm ( tau ) - 0.45 , pi &
· · · *0.5)
p r i n t ( phiT )
endtime = time ()
Bitte wenden!
167
p r i n t (’ needed %f seconds ’ % ( endtime - starttime ))
Abbildung 3: Die Lösung des AWP für ϕ0 = 0.8π/2, ϕ0 = 0.99π/2 und für den Startwert ϕ0 der
die Periode T = 1.8 Sekunden liefert.
6 Solutions to the pendulum ODE for different initial amplitudes
f | f0 =0.80 π2
4
df
π
2
dt | f0 =0.80 2
f | f0 =0.99 π2
0
df
π
2
dt | f0 =0.99 2
4
6
0.0
0.2
0.4
0.6
0.8
1.0
1.2
1.4
1.6
1.8
Solution
to
the
pendulum
ODE
for
f
=1
.
486
t
0
6
4
2
0
2
4
6
0.0
f
df
dt
0.2
0.4
0.6
0.8
t
1.0
1.2
1.4
Listing 5: Ausgabe des Skripts 4
1
3
5
7
9
11
Initial value via time - integration
[ 1.48551281]
needed 0.011535 seconds
Initial value via exakt formula f o r T
Elliptic Integral by Quadrature
[ 1.48551244]
needed 0.001089 seconds
Initial value via exakt formula f o r T
Elliptic Integral by Arithmetic - Geometric Mean
[ 1.48551244]
needed 0.000607 seconds
1.6
1.8