DU$14$

"klasse Lagrange$\_$Polynomial:

def init$($self$,$ data$\_$x$,$ data$\_$y$)$:

$\text{'}\text{'}\text{'}$

Earst moatte wy kontrolearje oft de ynfiervektoren $($numpy arrays$)$ gelyk binne

of net.

assert $($betingst$),""$msg$""$

dit kommando kontrolearret as de betingst wier of falsk is$.$ As wier, de koade

rint normaal. Mar as falsk, dan jout de koade in flaterberjocht $""$msg$""$

en stopet $$tfiering

$\text{'}\text{'}\text{'}$

assert len$($data$\_$x$)==$ len$($data$\_$y$),""$lingte fan data$\_$x en data$\_$y moatte gelyk w$$ze$""$

$\text{'}\text{'}\text{'}$

Lagrange polynomen br$$ke gjin coefficeints a$\_$i$,$ leaver de knopen

$($x$\_$i$,$ y$\_$i$).$ D$$rom moatte wy dizze gewoan yn it objekt opslaan

$\text{'}\text{'}\text{'}$

self.data$\_$x $=$ data$\_$x

self.data$\_$y $=$ data$\_$y

self.degree $=$ len$($data$\_$x$)-1$

# wy geane derfan $$t dat de yngongen binne numpy array, dus wy kinne $$tfiere

# elemint wize operaasjes

def repr$($sels$)$:

# metoade foar tekenrige fertsjintwurdiging

# jo hoege jo gjin soargen te meitsjen oer de folgjende koade as jo it net begripe

strL $=$ f$""$LagrangePolynomial of order $\{$self$.$degree$\}$

$""$

strL $+=""$p$($x$)=""$

for i in range$($len$($self$.$data$\_$y$))$:

as self.data$\_$y$[$i$]==0$:

trochgean

elif self.data$\_$y$[$i$]>=0$:

strL $+=$ f$""+\{$self$.$data$\_$y$[$i$]\}*$l$\_\{$i$\}($x$)""$

oars:

strL $+=$ f$""-\{-$self.data$\_$y$[$i$]\}*$l$\_\{$i$\}($x$)""$

werom strL

def l$($sels$,$ k$,$ x$)$:

$\text{'}\text{'}\text{'}$

Dizze metoade ymplementearret de Lagrange Basis foar ynterpolaasje

mei help fan Lagrange Polynomials.

$\text{'}\text{'}\text{'}$

l$\_$k $=1\mathrm{.}0$ # Inisjalisaasje

# $--------------------------------------------$

# JIN KODE HJIR

#raise NotImplementedError$()$

#

# HINT FOAR LOOP METHODE: Soe der $$tsjen moatte

# x$\_$k $=$ self.data$\_$x$[$k$]$

# foar j yn berik$($self$.$degree $+1)$:

# l$\_$k $*=?????$

#

# TIP FOAR VEKTORISEERDE METODE $($gjin lussen$)$:

# Google hoe't jo np$.$prod en np$.$delete br$$ke

# l$\_$k $=$ np$.$prod$(??$ np$.$delete$(??)??)/$ np$.$prod$(??$ np$.$delete$(??)??)$

# $--------------------------------------------$

werom l$\_$k

def call$($self$,$ x$\_$arr$)$:

$""""""$

De metoade om it objekt callable te meitsjen $($sjoch de koade fan $\text{'}$e matrixmetoade$).$

$\text{'}$x$\_$arr' is in set fan opj$$ne punten $($in numpy array$).$ Jo moatte br$$ke

self.data$\_$x en self.data$\_$y te finen de ynterpolearre $$tfier fan de

polynoom foar alle eleminten fan $\text{'}$x$\_$arr'.

Implementearje sa't jo wolle, mar jo 'totale' numpy array w$$r$\text{'}$t it i$\text{'}$e elemint

p$\_$x$\_$arr$[$i$]$ stiet foar de ynterpolearre wearde fan p$($x$\_$arr$[$i$]).$

$""""""$

# inisjalisearje mei nul

p$\_$x$\_$arr $=$ np$.$zeros$($len$($x$\_$arr$))$

# $--------------------------------------------$

# JIN KODE HJIR

raise NotImplementedError$()$

#

# HINT: Soe der $$tsjen moatte

# foar i$,$ x yn enumerate$($x$\_$arr$)$:

# foar k yn berik $($self$.$degree $+1)$:

#$??????$

# p$\_$x$\_$arr$[$i$]=???$ self.data$\_$y$[$k$]???$ sels.l$($k$,$ x$)$

# $--------------------------------------------$

werom p$\_$x$\_$arr"