OPM.py

# 2a) U SAGE-u nacrtajte graf funkcije h na [0, 4] × [0, 4].
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
P = plot3d(h,(0,4),(0,4), plot_points=40)
P.show()

#2b Pomocu colormaps funkcije nacrtajte graf funkcije h u crnobijelim bojama
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
cm=colormaps.gray
P = plot3d(h,(0,4),(0,4), color=(h,cm), plot_points=40)
P.show()

#Pogledajte u listi colormaps.keys() vec definirane predloske boja i sa nekoliko
#odabranih predlozaka obojite svoju plohu. 

#varijanta sa summer color mapom
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
cm=colormaps.summer
P = plot3d(h,(0,4),(0,4), color=(h,cm), plot_points=40)
P.show()

#varijanta sa coolwarm color mapom
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
cm=colormaps.coolwarm
P = plot3d(h,(0,4),(0,4), color=(h,cm), plot_points=40)
P.show()

#Pomocu funkcije hue obojite svoju plohu.
#2b varijanta sa hue()
from sage.plot.colors import aqua
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
P = plot3d(h,(0,4),(0,4), rgbcolor = hue(*aqua.hsv()), plot_points=40)
P.show()

#2c) Nacrtajte graf funkcije h u bijeloj boji. Nacrtajte graf funkcije h u plavoj boji.
#2c bijela
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
P = plot3d(h,(0,4),(0,4), color='white', plot_points=40)
P.show()

#2c plava
def h(x,y):
    return float((2*math.cos(0.4*x)*math.cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)))
P = plot3d(h,(0,4),(0,4), color='blue', plot_points=40)
P.show()

#2d) Nacrtajte nivo-linije funkcije h. Nacrtajte te nivo-linije bez sjencanja, 
#sa crnobijelim sjencanjem i sa sjencanjem u boji. Svaki dio tog zadatka napravite
#s nacrtanih 10, 20 i 30 nivo-linija. Kod sjenˇcanja napravite slike sa vidljim i
#nevidljivim nivo-linijama.
#DAMIR SJENCANJE
x,y = var('x,y')
graf1=contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),cmap='RdGy_r',fill=True,contours=1000)#,, linewidths=10,cmap='winter')
graf2=contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),fill=False,contours=10)#,, linewidths=10,cmap='winter')
graf = graf1+graf2
graf[0].set_zorder(10)
graf[1].set_zorder(20)
show(graf)

#prijedlog ISPRAVNOG RJESENJA
x,y = var('x,y')
graf=contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),cmap='Greys_r',fill=True,contours=30,linewidths=1, plot_points=40)
show(graf)
#za bez boje makni cmap, ovo je sad crno bijelo, treba u boji biti, i biti bez sjencanja
#broj nivo linija je argument contours
#ukljuci/iskljuci sjencanje fill=True/False
#linewidth, širina/debljina nivo-linije
#plot_points 40, mora biti jer zadatak tak veli (sluzi za finije rubove)


#iv) S 10 nivo linija
#sage: x,y = var('x,y')
#sage: contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),plot_points=10)
#v) S 20 nivo linija
#sage: x,y = var('x,y')
#sage: contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),plot_points=20)
#vi) S 30 nivo linija
#sage: x,y = var('x,y')
#sage: contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),plot_points=30)

#2e) Nacrtajte nivo-linije na samoj plohi.
#promijeniti varijable
#PRIJEDLOG RJESENJA
var('x,y,z')
def f(x,y):
    return (2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2))
levels=[0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6.5]
epsilon=0.05
p=plot3d(f(x,y),(x,0,4),(y,0,4),color='khaki',opacity=0.7)
for h in levels:
    p+=implicit_plot3d(f(x,y)==h,(x,0,4),(y,0,4),(z,h,h+epsilon))
show(p)

#2f) Pronadite gradijent funkcije h. Takoder, pronadite gradijent funkcije h i rucno. JOS TREBA RUCNO NAJTI
#TREBA NAJTI JOS RUCNO
f(x, y) = 2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)
f.gradient()

#2g) Proucite naredbu plot vector field i pomocu nje nacrtajte gradijentno vektorsko polje funkcije h. Stavite da
#bude vidljiv okvir, a nevidljive koordinatne osi i uzmite 20 tocaka za crtanje (plot points). GOTOVO 
x, y = var('x y')
f=exp(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2))
plot_vector_field(f.gradient(), (x,0,4), (y,0,4),plot_points=20,axes=False)

#Isto tako, nacrtajte sliku na kojoj ce biti zajedno nivo-linije i gradijentno vektorsko polje funkcije h.
x, y = var('x y')
f = exp(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2))
graf1 = contour_plot(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2),(x,0,4),(y,0,4),cmap='winter')
graf2 = plot_vector_field(f.gradient(), (x,0,4), (y,0,4),plot_points=20,axes=False)
graf = graf1+graf2
graf[0].set_zorder(10)
graf[1].set_zorder(20)
show(graf)

#Nacrtajte i gradijentno vektorsko polje od h u boji. (samo smo dodali color='blue')
x, y = var('x y')
f=exp(2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2))
plot_vector_field(f.gradient(), (x,0,4), (y,0,4), color='blue', plot_points=20,axes=False)

#2.h) Pronadite mjesto na kojemu je najvisi vrh i koliko je taj vrh visok.
f(x, y) = 2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)
#Moguce rjesenje zadatka: http://doc.sagemath.org/html/en/prep/Quickstarts/Multivariable-Calculus.html#partial-differentiation
#Trazimo hessian matricu i provjeravamo predznak determinante te matrice
#Ako je det>0, onda je to lokalni minimum, a inace je lokalni maksimum
#vise informacija:
#https://www.khanacademy.org/math/multivariable-calculus/applications-of-multivariable-derivatives/optimizing-multivariable-functions/a/maximums-minimums-and-saddle-points
H = f.hessian()
H(x,y)
html("$f_{xx}=%s$"%H(4,-2)[0,0])
html("$D=%s$"%H(4,-2).det())

#2.h) Tocnije rjesenje od prethodnog
f = lambda z:2*cos(0.4*x)*cos(0.4*y)+5*x*y*e^(-x^2-y^2)+3*e^(-(x-2)^2-(y-2)^2)
find_local_maximum(f,0,4)

#2.i) Koliki je maksimalni nagib brda u stupnjevima u tocki (1, 1)?


#2.j) Objasnite na koji biste nacin napravili skijasku stazu na nekom dijelu brda ako
#biste zeljeli da se postigne maksimalna brzina na unaprijed zadanim dijelovima
#brda. Na koji nacin biste smanjivali brzinu na odredenim dijelovima brda?
Smanjivali bismo brzinu tako da na tim dijelovima brda "izravnamo" brdo, tj. uklonimo nagib jer bismo onda prirodno usporili.

#Sve grafove u a), b), c) i d) dijelu zadatka nacrtajte tako da uzmete 40 toccaka
#za crtanje pomocu opcije plot points. Poigrajte se malo s tom opcijom tako da
#mijenjate broj tocaka. Sto se dogada?
Ako mijenjamo plot_points, tj. stavimo na mali broj (npr. plot_points=5) graf izgleda vrlo "grubo", tj. rigidno (valjda zato
jer s malim brojem točaka opisujemo graf. Ako povećamo (npr. plot_points=120) graf je puno "glađi" i lijepše izgleda.          
                                                                                                                 
                                                                                                                 
#5 Zadana je funkcija 80/(1+x^2+2*y^2+3*z^2)
#koja mjeri temperaturu u °C u nekoj točki (x,y,z), gdje su x,y,z u metrima. U kojem smjeru se
#temperatura u točki (1,1,−2) najbrže povećava? Kolika je maksimalna vrijednost tog
#povećanja? Proučite naredbu plot vector field3d i nacrtajte gradijentno vektorsko polje
#funkcije T.
x,y,z=var('x y z')
plot_vector_field3d((-160*x/(x^2 + 2*y^2 + 3*z^2 + 1)^2,-320*y/(x^2 + 2*y^2 + 3*z^2 + 1)^2,-480*z/(x^2 + 2*y^2 + 3*z^2 + 1)^2), (x,-4,4), (y,-4,4), (z,-4,4),colors=['red','green','blue'])  
#f(x, y, z) = 80/(1+x^2+2*y^2+3*z^2)
#f.gradient()
#izracunali smo gradijent i dobili uredjenu trojku (jer je funkcija 3 varijable)
#ta uredjena trojku koju smo dobili predstavlja tri funkcije koje opisuju redom x y z koordinatu vektora  
# SAD SMO DOBILI SLIKU   
#MAKSIMALNA VRIJEDNOST POVEĆANJA
x,y,z=var('x y z')    
f(x, y, z) = 80/(1+x^2+2*y^2+3*z^2)
fg1(x,y,z)=f.gradient()[0]
fg2(x,y,z)=f.gradient()[1]
fg3(x,y,z)=f.gradient()[2]
n=sqrt(fg1^2+fg2^2+fg3^2)
n(1,1,-2)                                                                                                                 
#https://www.fsb.unizg.hr/matematika/download/ZS/mat2/predavanje8-Micic-Hot.pdf 37. slajd
#izracunali smo gradijent i dobili uredjenu trojku (jer je funkcije 3 varijable)
#uzeli smo svaku od vrijednosti uređene trojke i izračunali maksimum        

#smjer najbržeg povećanja temperature u tocki (1,1,-2)
x,y,z,i,j,k=var('x y z i j k')
f(x,y,z) = 80/(1+x^2+2*y^2+3*z^2)
tockaG(x,y,z) = (f.gradient()[0]*i)+(f.gradient()[1]*j) +(f.gradient()[2]*k)
tockaG(1,1,-2)