# Laboratorium 




```python
import numpy as np
```


```python

```

#### Zadanie 1
Napisz metodę, która oblicza pole między osią OX a wykresem funkcji na danym przedziale za pomocą sum Riemanna (przybliżeń prostokątami). Sprawdź jej działanie na wybranej przez siebie funkcji porównując z wynikiem całkownia symbolicznego. 

Korzystając z symbolicznych pochodnych i szukania ekstremów dobierz takie parametry do swojej funkcji, aby błąd całkowania był mniejszy niż $10^{-5}$.



```python
import numpy as np
from sympy import*
import math


def calka(funkcja,a,b,N):
  podzial=np.linspace(a,b,N)
  podstawa=(b-a)/(N-1)
  wartosc=0
  for i in range(N-1):
    wartosc+=podstawa*abs(funkcja(podzial[i]))
  return wartosc

def supremum(f, a, b):
  pochodna  = diff(f(x), x)
  druga_pochodna = diff(pochodna, x)
  kandydaci = (solve(druga_pochodna, x))
  kandydaci.extend([a, b])  #Funkcja może być malejąca na danym odcinku, zatem wtedy wartości maksymalnej szukamy na krańcach.
  sup = []
  for i in kandydaci:
    if a<=i<=b:
      sup.append(abs(pochodna.subs(x, i)))
  return (max(sup))

print("Podaj przedział całkowania: ")
a = int(input("a = "))
b = int(input("b = "))

x, N_ = sym.symbols("x, N_")

f = lambda x: 4/(1 + x**2)

M = supremum(f, a, b).evalf()

N_ = ((solve((b-a)**2 * M/(2*N_) - 10**(-5), N_)))
N_ = int((math.ceil(N_[0])) + 1)


blad = abs(integrate(f(x), (x, a, b)) - calka(f, a, b, N_))

if blad <= 10**(-5):
  print("Yes")

```

    Podaj przedział całkowania: 
    a = 0
    b = 1
    Yes


#### Zadanie 2
a) Zaimplementuj w postaci funkcji algorytm obliczania pierwiastka kwadratowego z $x>0$ z wykorzystaniem algorytmu Herona. Funkcja powinna przyjmować jako argumenty liczby: $x$, punkt startowy $x_0$ oraz liczbę kroków (wyrazów ciągu do obliczenia).

b) Następnie, dodaj argument show_step (domyślnie ustawiony jako False), który będzie pozwalał wyświetlać kolejne kroki przybliżenia aż do zadanego.

c) Na bazie a) stwórz nową funkcję, która wykona odpowiednią liczbę kroków by przybliżenie miało podaną dokładność


```python

```


```python

```


```python

```


```python

```

# NumPy

np.ndarray (N-dimensional array)

Najważniejsze atrybuty:
* shape
* ndim
* size
* dtype (int,float,bool,complex)
* nbytes



```python
tab=np.array([[1,2],[3,4],[4,1]])
```


```python
tab.nbytes
```




    48




```python

```


```python

```

#### Zadanie 3

Stwórz dowolną tablicę liczb całkowitych ndarray z zagnieżdżonej listy. Sprawdź jej różne atrybuty. Spróbuj zamienić wszystkie liczby całkowite na zmiennoprzecinkowe.


```python
tab2=np.array(tab,dtype=float)
```


```python
tab2
```




    array([[1., 2.],
           [3., 4.],
           [4., 1.]])




```python
tab3=np.array([-1,0,1])
```


```python
np.sqrt(tab3)
```

    /usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt
      """Entry point for launching an IPython kernel.





    array([nan,  0.,  1.])




```python
tab4=tab3.astype(complex)
tab4
np.sqrt(tab4).imag
```




    array([1., 0., 0.])



### Konstruktory:
* np.array - tworzy z różnych tablicopodobnych typów
* np.zeros - same zera
* np.ones - same jedynki
* np.eye - macierz identycznościowa
* np.diag - macierz z elementami na przekątnej

* **!** np.linspace(start,koniec (domknięty),liczba elementów)
* **!** np.arange(start,koniec (otwarty),krok)
* np.meshgrid - tworzy siatkę punktów z pojedynczych wektorów) - zwraca tablice poszczególnych współrzędnych

from scipy.linalg import block_diag


```python
np.zeros((3,3))
```




    array([[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]])




```python
np.meshgrid([1,2,3],['a','b','c'])
```




    [array([[1, 2, 3],
            [1, 2, 3],
            [1, 2, 3]]), array([['a', 'a', 'a'],
            ['b', 'b', 'b'],
            ['c', 'c', 'c']], dtype='<U1')]




```python

```


```python

```

#### Zadanie 4
Skonstruuj macierz:
$$
Mat1=\begin{bmatrix}
1 &1 &0&0&0&0&0\\
1&1&0&0&0&0&0\\
0&0&0&0&0&0&0 \\
0&0&0&0&0&0&0 \\
0&0&0&0&3&0&0 \\
0&0&0&0&0&2&4 \\
0&0&0&0&0&4&2 \\
\end{bmatrix}
$$


```python
from scipy.linalg import block_diag
Mat1=block_diag(np.ones((2,2)),np.zeros((2,2)),3,(4*np.ones((2,2))-2*np.eye(2)))
Mat1
```




    array([[1., 1., 0., 0., 0., 0., 0.],
           [1., 1., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 3., 0., 0.],
           [0., 0., 0., 0., 0., 2., 4.],
           [0., 0., 0., 0., 0., 4., 2.]])




```python
Mat1[0,0]=3
```


```python
Mat1
```




    array([[3., 1., 0., 0., 0., 0., 0.],
           [1., 1., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 3., 0., 0.],
           [0., 0., 0., 0., 0., 2., 4.],
           [0., 0., 0., 0., 0., 4., 2.]])




```python
Mat1[:,::-1]
```




    array([[0., 0., 0., 0., 0., 1., 3.],
           [0., 0., 0., 0., 0., 1., 1.],
           [0., 0., 0., 0., 0., 0., 0.],
           [0., 0., 0., 0., 0., 0., 0.],
           [0., 0., 3., 0., 0., 0., 0.],
           [4., 2., 0., 0., 0., 0., 0.],
           [2., 4., 0., 0., 0., 0., 0.]])



#### Zadanie 5
W macierzy Mat1 zamień miejscami lewy górny narożnik 4X4 z prawym dolnym 3x3 (nazwij wynik Mat2)

#### Zadanie 6
Stwórz macierz Mat3, która będzie zawierała tylko elementy z Mat2 o obu parzystych współrzędnych.


```python
Mat1[:4,:4]
```




    array([[3., 1., 0., 0.],
           [1., 1., 0., 0.],
           [0., 0., 0., 0.],
           [0., 0., 0., 0.]])




```python
Mat1[-3:,-3:]
```




    array([[3., 0., 0.],
           [0., 2., 4.],
           [0., 4., 2.]])




```python
Mat2=block_diag(Mat1[-3:,-3:],Mat1[:4,:4])
```


```python
Mat3=Mat2[1::2,1::2]
```

### Zadanie 7
Utwórz tablicę

$$
\begin{bmatrix}
1&2&3&4\\
5&6&7&8 \\
9&10&11&12\\
13&14&15&16
\end{bmatrix}
$$


```python

```


```python

```


```python

```

Inne przydatne funkcje:

* łączenie macierzy ```np.concatenate((tab1,tab2),argumenty)```
* rozdzielanie macierzy ```np.array_split(tab1, \<liczba czesci\>)```
* wybieranie indeksów spełniających logiczny warunek: ```np.where(tab1>0)```
* sortowanie ```np.sort(tab1)```


```python

```


```python

```


```python

```


```python

```



b1eb3d366c2821d49b188f1c4e218196508d56a7
ipynb
Jupyter Notebook
Lab4.ipynb
SzymonSkrobiszewski/ON2022
e71f77001e6cd0739a051423c3b7b36ccdf0dbb5
MIT
Lab4.ipynb
SzymonSkrobiszewski/ON2022
e71f77001e6cd0739a051423c3b7b36ccdf0dbb5
MIT
Lab4.ipynb
SzymonSkrobiszewski/ON2022
e71f77001e6cd0739a051423c3b7b36ccdf0dbb5
MIT
Qwen/Qwen-72B
1. YES
2. YES