Skriv brøkleddet som potens:

Da får vi

For første ledd bruker vi kjerneregelen. Den indre funksjonen er \(3x+2\), og den deriverte er \(3\).

For logaritmeleddet får vi

Et produkt er lik null når minst én faktor er null.

Faktoren \(e^x\) er alltid positiv, så vi må ha

Da er funksjonsverdien \(0\).

Først ganger vi ut funksjonen:

Da blir den deriverte

Faktoriser uttrykket:

Vi setter den deriverte lik null:

Siden \(2e^x>0\), må

Funksjonsverdien blir

For \(x<\ln 3\) er \(3-e^x>0\), og for \(x>\ln 3\) er \(3-e^x<0\). Dermed går grafen fra stigende til avtagende.

import sympy as sp
x = sp.symbols('x')
f = sp.exp(x)*(6 - sp.exp(x))
f_derivert = sp.diff(f, x)
kritisk = sp.solve(sp.Eq(f_derivert, 0), x)
verdi = [sp.simplify(f.subs(x, p)) for p in kritisk]
andrederivert = sp.diff(f, x, 2)
print("f'(x) =", sp.factor(f_derivert))
print("Kritiske x-verdier:", kritisk)
print("Funksjonsverdier:", verdi)
print("f''(ln(3)) =", sp.simplify(andrederivert.subs(x, sp.log(3))))

# Utskrift:
# f'(x) = 2*exp(x)*(3 - exp(x))
# Kritiske x-verdier: [log(3)]
# Funksjonsverdier: [9]
# f''(ln(3)) = -18

Vi vurderer hvert uttrykk:

Videre er \(\lg 7\approx 0{,}845\), og siden \(2^4=16\) og \(3^4=81\), ligger \(\sqrt[4]{33}\) mellom \(2\) og \(3\).

import math
verdier = {
    "lg(7)": math.log10(7),
    "e^(3*ln(1))": math.exp(3*math.log(1)),
    "fjerderot(33)": 33**(1/4),
    "log_2(8)": math.log(8, 2),
}
for navn, verdi in sorted(verdier.items(), key=lambda par: par[1]):
    print(f"{navn:14s} = {verdi:.6f}")

# Utskrift:
# lg(7)          = 0.845098
# e^(3*ln(1))   = 1.000000
# fjerderot(33) = 2.396782
# log_2(8)      = 3.000000

Vi bruker logaritmereglene \(\lg(uv)=\lg u+\lg v\), \(\lg(u/v)=\lg u-\lg v\) og \(\lg(100)=2\):

Dette kan også skrives som \(\lg(100b^5)\).

Telleren har grad \(1\), mens nevneren har grad \(2\). Nevneren vokser derfor raskere enn telleren.

Vi kan dele teller og nevner på \(x^2\):

Når \(x\to\infty\), går \(\frac{2}{x}\), \(\frac{2}{x^2}\) og \(\frac{3}{x^2}\) mot null.

Påstanden er ikke alltid sann. Dersom telleren også har faktoren \(x-d\), kan faktoren forkortes bort. Da får vi et hull i grafen, ikke nødvendigvis en vertikal asymptote.

Et moteksempel er

For \(x\ne d\) er dette bare \(x+1\). Grafen går ikke mot uendelig når \(x\) nærmer seg \(d\).

Antall grupper med \(k\) medlemmer fra \(7\) medlemmer er \(\binom{7}{k}\).

Dette er også logisk fordi det å velge fire personer er det samme som å velge hvilke tre personer som ikke skal være med.

Fra grafen leser vi omtrent

Gjennomsnittlig vekstfart er stigningstallet til sekanten:

Siden verdiene er lest av en figur, er svaret et omtrentlig svar.

Momentan vekstfart er stigningstallet til tangenten i punktet.

• Ved \(x=0\) ser grafen ut til å ha et toppunkt. Tangenten er omtrent vannrett, så \(f\prime(0)\approx 0\).
• Ved \(x=3\) er grafen stigende. En tangent som tegnes inn fra figuren, får omtrent stigningstall \(1{,}5\).

Dette er grafiske avlesninger, så små variasjoner i svaret kan aksepteres dersom metoden er godt forklart.

For én oppgave er sannsynligheten for riktig svar \(\frac{1}{3}\), og for feil svar \(\frac{2}{3}\). Vi bruker binomisk modell med \(n=3\) og \(p=\frac{1}{3}\):

from fractions import Fraction
from math import comb
n = 3
p = Fraction(1, 3)
sannsyn = Fraction(comb(n, 1), 1) * p * (1 - p)**2
print("P(nøyaktig ett riktig) =", sannsyn)
print("Desimaltall =", float(sannsyn))

# Utskrift:
# P(nøyaktig ett riktig) = 4/9
# Desimaltall = 0.4444444444444444

Først finner vi hvor mange som har valgt minst ett av fagene:

Da har

elever verken valgt tysk eller S1. Sannsynligheten blir derfor

Det er nok å velge hvem som skal ligge på rommet med plass til to. De tre andre må ligge på det andre rommet.

For å minimere risikoen velger Anastasia rommet med plass til to personer. Da er det bare én ledig plass på hennes rom.

De fire andre jentene fordeles tilfeldig, og Elena er én av disse fire. Sannsynligheten for at Elena havner på den ene ledige plassen sammen med Anastasia er derfor

Mulige gruppestørrelser med fem personer og inntil tre rom er \(3+2\), \(3+1+1\) og \(2+2+1\).

• Type \(3+2\): Velg tremannsgruppen: \(\binom{5}{3}=10\).
• Type \(3+1+1\): Velg tremannsgruppen: \(\binom{5}{3}=10\).
• Type \(2+2+1\): Velg personen som sover alene: \(5\) måter. De fire andre kan deles i to par på \(3\) måter. Det gir \(5\cdot 3=15\).

Totalt får vi

Dersom en tolker oppgaven slik at alle tre rom må brukes, skal typen \(3+2\) ikke tas med. Da blir svaret \(25\). Slik teksten står, er det ikke sagt at et rom ikke kan stå tomt.

Vi bruker potensregresjon. Ved å ta logaritmen på begge sider får vi

Da kan vi gjøre lineær regresjon på punktene \((\ln x,\ln V)\).

import numpy as np
import math

radius = np.array([3.5, 3.6, 3.8, 4.5, 4.7, 4.9], dtype=float)
volum = np.array([440, 470, 530, 730, 830, 900], dtype=float)

# Potensregresjon: ln(V) = ln(a) + b*ln(x)
log_x = np.log(radius)
log_v = np.log(volum)
b, ln_a = np.polyfit(log_x, log_v, 1)
a = math.exp(ln_a)

print("a =", a)
print("b =", b)
print(f"Modell: V(x) = {a:.3f} * x^{b:.3f}")

# Utskrift:
# a = 31.95543872867012
# b = 2.0968378894156467
# Modell: V(x) = 31.955 * x^2.097

For modellen \(V(x)=31{,}96x^{2{,}097}\) er

Setter vi inn \(x=4\), får vi omtrent \(306{,}5\).

import math

a = 31.95543872867012
b = 2.0968378894156467

def V(x):
    return a * x**b

def V_derivert(x):
    return a * b * x**(b - 1)

print("V(4) =", V(4))
print("V'(4) =", V_derivert(4))
print("Avrundet V'(4) =", round(V_derivert(4), 1), "mL per cm")

# Utskrift:
# V(4) = 584.7456315837342
# V'(4) = 306.52919899376417
# Avrundet V'(4) = 306.5 mL per cm

I en potensmodell \(V(x)=a x^b\) gir dobling av \(x\)

Her er \(b\approx 2{,}097\), så

Dette er trekking uten tilbakelegging, så vi bruker hypergeometrisk sannsynlighet.

from math import comb

antall_sokere = 80
eldre = 66
under_16 = 14
intervjuer = 10

sannsynlighet = 0
for k in range(8, 11):
    gunstige = comb(eldre, k) * comb(under_16, intervjuer - k)
    alle = comb(antall_sokere, intervjuer)
    bidrag = gunstige / alle
    sannsynlighet += bidrag
    print(f"k = {k}: bidrag = {bidrag:.6f}")

print("P(X >= 8) =", sannsynlighet)
print("Avrundet =", round(sannsynlighet, 3))

# Utskrift:
# k = 8: bidrag = 0.233665
# k = 9: bidrag = 0.367188
# k = 10: bidrag = 0.159457
# P(X >= 8) = 0.760309414538745
# Avrundet = 0.76

Vi lar \(n\) være antall som intervjues. Vi må finne minste \(n\) slik at

der \(X\) er antall søkere på 16 år eller mer blant de \(n\) som trekkes.

from math import comb

N = 80
K = 66          # 16 år eller eldre
ikke_K = 14     # under 16 år

def hypergeom_minst_10(n):
    total = comb(N, n)
    s = 0
    for k in range(10, min(K, n) + 1):
        if 0 <= n - k <= ikke_K:
            s += comb(K, k) * comb(ikke_K, n - k) / total
    return s

for n in range(10, N + 1):
    p = hypergeom_minst_10(n)
    print(f"n = {n:2d}, P(X >= 10) = {p:.6f}")
    if p >= 0.90:
        print("Minste n som virker:", n)
        break

# Siste del av utskriften:
# n = 12, P(X >= 10) = 0.677752
# n = 13, P(X >= 10) = 0.833242
# n = 14, P(X >= 10) = 0.937464
# Minste n som virker: 14

Den horisontale lengden fra \(x=a\) til \(x=5\) er

Den vertikale lengden fra \(y=f(a)\) til \(y=200\) er

Arealet er

Vi deriverer og løser \(A\prime(a)=0\). Endepunktene må også vurderes.

import sympy as sp

a = sp.symbols('a')
A = (5 - a) * (200 - 100 * sp.Rational(4, 5)**a)
A_derivert = sp.diff(A, a)

kritisk = sp.nsolve(A_derivert, 0.2)
areal_kritisk = sp.N(A.subs(a, kritisk))
areal_0 = sp.N(A.subs(a, 0))
areal_5 = sp.N(A.subs(a, 5))

print("A(a) =", A)
print("A'(a) =", A_derivert)
print("Kritisk a =", kritisk)
print("A(kritisk) =", areal_kritisk)
print("A(0) =", areal_0)
print("A(5) =", areal_5)

# Utskrift:
# Kritisk a = 0.170665710147171
# A(kritisk) = 500.979161563273
# A(0) = 500.000000000000
# A(5) = 0

Strømstøtten slår først inn når spotprisen kommer over en bestemt grense. Under grensen betaler husholdningen hele spotprisen selv. Over grensen trekkes en andel av det overskytende fra.

Derfor må funksjonen ha to regler: én regel før grensen og én regel etter grensen.

Funksjonen bør være kontinuerlig fordi en svært liten endring i spotprisen rundt grensen ikke skal gi et plutselig hopp i faktisk betalt pris. Støtteordningen skal bare redusere den delen som ligger over grensen.

Uten merverdiavgift og med støtteordningen der husholdningen får dekket \(90\,\%\) av prisen over \(75\) øre/kWh, blir regelen:

• Når \(x\le 75\), er det ingen støtte. Da er \(f(x)=x\).
• Når \(x>75\), betaler husholdningen de første \(75\) ørene selv og \(10\,\%\) av det som ligger over \(75\). Da er \(f(x)=75+0{,}10(x-75)\).

Den andre linjen kan også skrives \(f(x)=0{,}10x+67{,}5\).

Vi teller alle \(6\cdot 4\cdot 4=96\) like sannsynlige utfall.

For hver verdi Erik får, teller vi hvor mange par Kris kan få med begge terninger lavere enn Erik sin verdi.

gunstige = 0
alle = 0

for erik in range(1, 7):
    gunstige_for_erik = 0
    for kris_1 in range(1, 5):
        for kris_2 in range(1, 5):
            alle += 1
            if erik > max(kris_1, kris_2):
                gunstige += 1
                gunstige_for_erik += 1
    print(f"Erik = {erik}: gunstige Kris-utfall = {gunstige_for_erik}")

print("Gunstige totalt =", gunstige)
print("Alle utfall =", alle)
print("Sannsynlighet =", gunstige / alle)

# Utskrift:
# Erik = 1: gunstige Kris-utfall = 0
# Erik = 2: gunstige Kris-utfall = 1
# Erik = 3: gunstige Kris-utfall = 4
# Erik = 4: gunstige Kris-utfall = 9
# Erik = 5: gunstige Kris-utfall = 16
# Erik = 6: gunstige Kris-utfall = 16
# Gunstige totalt = 46
# Alle utfall = 96
# Sannsynlighet = 0.4791666666666667

Vi simulerer mange spill. Ett spill fortsetter til én av spillerne har fått \(100\) poeng. Erik vinner spillet dersom han når \(100\) først.

import random

random.seed(3060)

def erik_vinner_runde():
    erik = random.randint(1, 6)
    kris_1 = random.randint(1, 4)
    kris_2 = random.randint(1, 4)
    return erik > max(kris_1, kris_2)

def spill_til_100():
    erik_poeng = 0
    kris_poeng = 0
    while erik_poeng < 100 and kris_poeng < 100:
        if erik_vinner_runde():
            erik_poeng += 1
        else:
            kris_poeng += 1
    return erik_poeng == 100

antall_spill = 200_000
erik_vinner = 0
for _ in range(antall_spill):
    if spill_til_100():
        erik_vinner += 1

simulert_sannsynlighet = erik_vinner / antall_spill
print("Antall spill:", antall_spill)
print("Erik vant:", erik_vinner)
print("Simulert sannsynlighet:", simulert_sannsynlighet)

# Typisk utskrift med denne seed-en:
# Antall spill: 200000
# Erik vant: omtrent 55600
# Simulert sannsynlighet: omtrent 0.278

# Eksakt kontroll med negativ binomisk sum.
# Erik må vinne siste runde, og Kris kan ha 0, 1, ..., 99 poeng da Erik får sitt poeng nummer 100.
from math import comb

p = 23 / 48
q = 1 - p
sannsynlighet = 0
for kris_poeng in range(100):
    antall_rekkefolger = comb(99 + kris_poeng, kris_poeng)
    sannsynlighet += antall_rekkefolger * (p**100) * (q**kris_poeng)

print("p for Erik i én runde =", p)
print("P(Erik får 100 før Kris) =", sannsynlighet)
print("Avrundet =", round(sannsynlighet, 3))

# Utskrift:
# p for Erik i én runde = 0.4791666666666667
# P(Erik får 100 før Kris) = 0.278005999955146
# Avrundet = 0.278