<jupyter_start><jupyter_text>April 2015, <NAME> in <NAME> Vprašanje 1: Na podatkih:$$x = [-1.00, -0.50, 0.00, 0.50, 1.00]$$$$y = [−1.00, −0.55, 0.00, 0.45, 1.00]$$uporabite linearne zlepke in določite prvi odvod. Uvozimo module:<jupyter_code>from sympy import *
init_printing()
import numpy as np
import matplotlib.pyplot as plt
% matplotlib inline<jupyter_output><empty_output><jupyter_text>Definiramo podatke:<jupyter_code>x = np.asarray([-1, -0.50, 0.00, 0.50, 1.00], dtype = float)
y = np.asarray([-1, -0.55, 0.00, 0.45, 1.00], dtype = float)<jupyter_output><empty_output><jupyter_text>Uvozimo zlepke, izračunamo odvod in narišemo rezultate:<jupyter_code>from scipy.interpolate import InterpolatedUnivariateSpline

spl_lin = InterpolatedUnivariateSpline(x, y, k=1)
spl_odv_1 = spl_lin.derivative(1)

# Izpišimo odvode v točkah
print('Odvodi:', spl_odv_1(x))

xint = np.linspace(np.min(x), np.max(x), 40)

plt.plot(x, y, 'ro');
plt.plot(xint, spl_lin(xint));<jupyter_output>Odvodi: [ 0.9  1.1  0.9  1.1  1.1]<jupyter_text>Vprašanje 2: Na zgornjih podatkih izračunajte linearno aproksimacijo ter določite parametra aproksimacije. "Ročni" način:<jupyter_code>A = [[np.sum(x**2), np.sum(x)],
     [np.sum(x), len(x)]]
b = [np.dot(y,x), np.sum(y)]

A = np.asarray(A)
b = np.asarray(b)

a0, a1 = np.linalg.solve(A, b)
a0, a1<jupyter_output><empty_output><jupyter_text>Uporaba vgrajene numpy funkcije:<jupyter_code>a0_np, a1_np = np.polyfit(x, y, deg=1)
a0_np, a1_np<jupyter_output><empty_output><jupyter_text>Parameter $a_0$ zgoraj predstavlja naklon premice, to je hkrati tudi vrednost prvega odvoda.  Vprašanje 3: Na nateznem testu ste testirali aluminijeve vzorce; rezultati testa so podani spodaj.    Napetost [MPa]:$$\sigma = [34.5, 69.0, 103.5, 138.0]$$    Specifična deformacija [mm/m]$$vzorec_1 = [0.46, 0.95, 1.48, 1.93]$$$$vzorec_2 = [0.34, 1.02, 1.51, 2.09]$$$$vzorec_3 = [0.37, 1.00, 1.51, 2.05]$$    S pomočjo linearne aproksimacije določite elastični modul (napetost/specifična deformacija) vsakega posameznega vzorca.     Definiramo podatke:<jupyter_code>sigma = np.asarray([34.5, 69, 103.5, 138], dtype=float)               # [Mpa]
epsilon_1 = np.asarray([0.46, 0.95, 1.48, 1.93], dtype=float)         # [mm/m] 
epsilon_2 = np.asarray([0.34, 1.02, 1.51, 2.09], dtype=float)         # [mm/m]
epsilon_3 = np.asarray([0.37, 1.00, 1.51, 2.05], dtype=float)         # [mm/m]<jupyter_output><empty_output><jupyter_text>Linearna aproksimacija ($\sigma = E\,\epsilon$):<jupyter_code>E_1, zamik_1 = np.polyfit(epsilon_1, sigma, deg=1)
E_2, zamik_2 = np.polyfit(epsilon_2, sigma, deg=1)
E_3, zamik_3 = np.polyfit(epsilon_3, sigma, deg=1)

print('E_1:{:6.4g} GPa'.format(E_1))
print('E_2:{:6.4g} GPa'.format(E_2))
print('E_3:{:6.4g} GPa'.format(E_3))<jupyter_output>E_1: 69.77 GPa
E_2: 59.87 GPa
E_3: 62.04 GPa<jupyter_text>Prikaz:<jupyter_code>eps = epsilon_1
sig = sigma
fun = np.poly1d(np.polyfit(eps, sig, deg=1))  # Naredimo polinom s pomočjo np.poly1d 
#fun = np.poly1d([E_1, zamik_1])

plt.plot(eps, sig, 'ro')
plt.plot(eps, fun(eps));<jupyter_output><empty_output><jupyter_text>Vprašanje 4: Za Al vzorce zgoraj linearno aproksimirajte elastični modul čez vse vzorce. Določite tudi standardno napako (glejte ``np.std``). Najprej združimo vse specifične deformacije v en vektor:<jupyter_code>epsilon = np.asarray([epsilon_1, epsilon_2, epsilon_3])
epsilon = epsilon.flatten()    # Flatten vrne kopijo prvotnih podatkov, jih stisne v 1D niz
epsilon<jupyter_output><empty_output><jupyter_text>Napetost ustrezno razširimo:<jupyter_code>sigma = np.asarray([sigma for _ in range(3)])
sigma
sigma = sigma.flatten()   # Preoblikujemo v 1D niz
sigma<jupyter_output><empty_output><jupyter_text>Linearno aproksimiramo čez vse vzorce (dobimo 3 rezultate, ker imamo 3 sete vzorcev):<jupyter_code>fit = np.polyfit(epsilon, sigma, deg=1)
fit_func = np.poly1d(fit)  # Pripravimo si funkcijo
E, zamik = fit
E<jupyter_output><empty_output><jupyter_text>Narišemo:<jupyter_code>eps = epsilon
sig = sigma

plt.plot(eps, sig, 'ro')
plt.plot(eps, fit_func(eps));<jupyter_output><empty_output><jupyter_text>Preverimo razliko med aproksimacijo in podatki:<jupyter_code>razlika = sigma - fit_func(eps)
razlika<jupyter_output><empty_output><jupyter_text>Določimo standardno napako:<jupyter_code>Std = np.std(razlika) 
Std<jupyter_output><empty_output><jupyter_text>Vprašanje 5: Raziščite pomoč za funkcijo ``np.polyfit`` in utežite različne vzorce z različno utežjo (npr. da prvi meritvi zaupate manj). Izračunajte nato linearno aproksimiran elastični modul. Podobno kot zgoraj, le da dodatno definiramo še utež:<jupyter_code># Definiramo utež (prvi in zadnji meritvi manj zaupamo)
utez = np.asarray([0.1, 1, 1, 0.1])

# Sedaj pa to pripravimo za vse vzorce
utez = np.asarray([utez for _ in range(3)]).flatten()
utez
fit = np.polyfit(epsilon, sigma, deg=1, w=utez)
fit_func = np.poly1d(fit) # Pripravimo si funkcijo
E, zamik = fit
E
eps = epsilon
sig = sigma

plt.plot(eps, sig, 'ro')
plt.plot(eps, fit_func(eps));<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14780186990252636, 'fraction_numerical': 0.051919633976526755, 'mean_word_length': 5.7854251012145745, 'pattern_counts': {'":': 0, '<': 61, '<?xml version=': 0, '>': 61, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '15', 'dir': 'jupyter-structured-clean-dedup', 'id': '53683', 'license': 'MIT', 'n_tokens_mistral': 2488, 'n_tokens_neox': 2328, 'n_words': 452, 'path': 'pypinm-master/vprasanja za razmislek/Vaja 8 - polovica.ipynb', 'repo_name': 'CrtomirJuren/python-delavnica', 'size': '5031'}