PythonCalyLab3

LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA LAURA
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 19 14:50:13 2019

@author: laura
"""
#kolos
#def my_generator():
#    current_value = 'A'
#
#    while True:
#        temp_value = current_value
#        if ord(current_value) > ord('Z'):
#            return
#        current_value = chr(ord(current_value) + 1)
#        yield temp_value
#for letter in range():




import os
import csv
import numpy as np
import time
import random




#zadanie 1
#Zdefiniuj tablice jednowymiarowa zawierajaca 101 elementów od 0 do 100 (włacznie). Nastepnie zdefiniuj
#druga tablice jednowymiarowa zawierajaca elementy od 100 do 0 (włacznie). Wyobraz sobie, ze tablice
#reprezentuja pomiar temperatury z dwóch czujników. Wykonaj nastepujace operacje: dodaj do siebie zadane
#temperatury, przemnóz je przez siebie, wybierz z tablicy pierwszej 10 pierwszych elementów i odejmij od nich
#10 ostatnich elementów drugiej tablicy. Wybierz z tablicy pierwszej tylko elementy, które sa podzielne przez 3.
#W przypadku wszystkich powyzszych operacji nie uzywaj zadnych petli oraz instrukcji warunkowych. Korzystaj
#jedynie z funkcji dostepnych w bibliotece NumPy.


#tablica_1 = np.arange(101)
#print(tablica_1)
#tablica_2 = np.arange(100,-1, -1)
#print(tablica_2)

#dodawanie
#c = tablica_1 + tablica_2
#print(c)
#mnozenie
#d =  tablica_1 * tablica_2
#print(d)
#odejmowanie 10 elementow
#e = tablica_1[:10] - tablica_2 [-10:]
#print(e)
#lementy podzielne przez 3
#f = tablica_1[tablica_1 % 3 == 0]
#print(f)



#zadanie 2
#Zadeklaruj liste pomiarów zawierajaca elementy od 0 do 1000000. Nastepnie korzystajac z petli for stwórz
#nowa liste składajaca sie z kazdego pomiaru podniesionego do kwadratu. Korzystajac z biblioteki time zmierz
#czas tego zadania.
#Nastepnie zadeklaruj tablice pomiarów zawierajaca elementy od 0 do 1000000. Podnies wszystkie pomiary do
#kwadratu (bez korzystania z jakiejkolwiek petli) i przypisz do nowej tablicy. Analogicznie jak w poprzednim
#przypadku zmierz czas tego zadania.

#l1= list(range(0, 1000000))
#l2 = []
#bt_1 = time.time()
#for i in l1:
#    l2.append(i)
#et_1 = time.time()
#print("pomiar 1", et_1- bt_1)
#
#array1= np.arange(0, 100000)
#bt_2= time.time()
#array2 = array1 * array1
#et_2= time.time()
#print("pomiar 2", et_2- bt_2)


#zadanie 3
#Wygeneruj losowa macierz (tablice) pomiarów o wymiarze 7x7 i rozkładzie normalnym o wartosci sredniej
#równej 50 i odchyleniu standardowym równym 20. Zrzutuj ja na typ całkowity. Oblicz jej wyznacznik, slad,
#wartosci własne oraz odpowiadajace im wektory własne (załóz, ze nie wystapia przypadki zdegenerowane).
#Wyznacz macierz odwrotna. Przemnóz wygenerowana macierz przez wektor [1, 2, 3, 4, 5, 6, 7]. Przypisz
#wartosci na głównej przekatnej do nowego wektora i podnies wszystkie jego elementy do kwadratu. Dokonaj
#rozkładu pierwotnej macierzy na wartosci osobliwe (SVD).

#tablica = np.random.standard_normal(49)
#tablica = tablica.reshape(7,7)
#print(tablica)
#tablica_1 = np.matrix(np.random.standard_normal(49))
#tablica_1 = tablica_1.reshape(7,7)
#print(tablica_1)

#my_mean = 50.00
#my_std = 20.00
#tablica_2 = np.random.normal(loc = my_mean, scale = my_std, size = 49)
#tablica_2 = tablica_2.reshape(7,7)
#tablica_2 = tablica_2.astype(int)
#print(tablica_2)
#print("srednia:\n", tablica_2.mean())
#print("odchylenie:\n", tablica_2.std())
#wyznacznik = np.linalg.det(tablica_2)
#print("wyznacznik\n", wyznacznik)
#slad = np.trace(tablica_2)
#print("slad\n", slad)
#wartosci_wlasne, wektory_wlasne = np.linalg.eig(tablica_2)
#print("wartosci_wlasne:\n", wartosci_wlasne," \n wektory wlasne:\n", wektory_wlasne)
#macierz_odwrotna  = np.linalg.inv(tablica_2)
#print("macierz odwrotna:\n", macierz_odwrotna)
#wektor = np.arange(1,8)
#print(wektor)
#iloczyn = wektor * tablica_2
#print("iloczyn wektora i tablicy:\n", iloczyn)
#nowy_wektor = tablica_2.diagonal() **2
#print(nowy_wektor)
#w1, w2, w3 = np.linalg.svd(tablica_2)
#print("w1: \n",w1,"\n",  w1.shape, "\nw2:\n", w2,"\n", w2.shape, "\nw3:\n",w3,"\n",  w3.shape)



#zadanie 4
#Wczytaj plik iris.csv. Dane zapisz do słownika, który do kazdej cechy danych wejsciowych przyporzadkuje
#liste wszystkich wartosci. Policz i wypisz srednia˛ oraz odchylenie standardowe dla kazdego atrybutu. Wyjscie
#sformatuj do czterech miejsc po przecinku. Wyznacz i wypisz liczebnosc kazdej klasy.

##wczytywanie
current_dir = os.path.abspath(os.path.dirname(__file__))
data_path = os.path.join(current_dir, "Data")
csv_path = os.path.join(data_path, "iris.csv")
##print(current_dir)
#try:
#    data_file = open(csv_path)
#except:
#    pass
#finally:
#    pass
#with open(csv_path) as csv_file:
#    reader = list(csv.reader(csv_file, delimiter=';'))
#    print(reader)
    #print(dir(reader))
#    for item in reader:
#        print(item)


current_dir = os.path.abspath(os.path.dirname(__file__))
data_path = os.path.join(current_dir, "Data")
csv_path = os.path.join(data_path, "iris.csv")

with open(csv_path) as csv_file:
    output_dict = dict()
    csv_reader = csv.reader(csv_file)
    first_row = next(csv_reader)
    for item in first_row:
        output_dict[item] = []
    for item in csv_reader:
        for i in range(len(item)):
            try:
                output_dict[first_row[i]].append(float(item[i]))
            except:
                output_dict[first_row[i]].append(item[i])

    for key in output_dict.keys():
        try:
            output_dict[key] = np.array(output_dict[key], dtype=np.float)
        except:
            pass


#    print("Sepal width:", round(np.mean(output_dict['sepal.width']), 4))
#    print("Sepal width std:", round(np.std(output_dict['sepal.width']),4))
#    print("Sepal length mean:", round(np.mean(output_dict['sepal.length']),4))
#    print("Sepal length std:", round(np.std(output_dict['sepal.length']), 4))
#    print("Petal width:", round(np.mean(output_dict['petal.width']), 4))
#    print("Petal width std:", round(np.std(output_dict['petal.width']),4))
#    print("Petal length mean:", round(np.mean(output_dict['petal.length']),4))
#    print("Petal length std:", round(np.std(output_dict['petal.length']), 4))
    #print("Number of Setosa:", round(np.size((output_dict[,2))


#Zadanie 5
#Napisz funkcje, która jako argument przyjmuje sciezke do folderu. Funkcja powinna zwrócic liste zawierajaca
#absolutne sciezki do kazdego pliku zawierajacego rozszerzenie .png. Pozostałe pliki powinny zostac zignorowane.
#Funkcje przetestuj na folderze cifar_subset.

#current_dir = os.path.abspath(os.path.dirname(__file__))
#data_path = os.path.join(current_dir, "Data")
#csv_path = os.path.join(data_path, ".png")
##print(current_dir)
#try:
#    data_file = open(csv_path)
#except:
#    pass
#finally:
#    pass
#with open(csv_path) as csv_file:
#    reader = csv.reader(csv_file)
#    print(reader)
#    #print(dir(reader))
#    for item in reader:
#        print(item)



#Zadanie 6
#Korzystajac z rozwiazania Zadania 4. wczytaj dane z pliku iris.csv. Nastepnie do kazdego przypadku atrybutu
#"Sepal Length" dodaj 1, od kazdego atrybutu "Sepal Width" odejmij 1, "Petal Length" podnies do kwadratu, a
#"Petal Width" spierwiastkuj. Wyniki zapisz do pliku iris_zad_6.csv o takim samym formacie jak oryginalny
#plik iris.csv. Zapisz plik do tego samego folderu co plik iris.csv.

#current_dir = os.path.abspath(os.path.dirname(__file__))
#data_path = os.path.join(current_dir, "Data")
#csv_path = os.path.join(data_path, "iris.csv")
#
#with open(csv_path) as csv_file:
#    output_dict = dict()
#    csv_reader = csv.reader(csv_file)
#    first_row = next(csv_reader)
#    for item in first_row:
#        output_dict[item] = []
#    for item in csv_reader:
#        for i in range(len(item)):
#            try:
#                output_dict[first_row[i]].append(float(item[i]))
#            except:
#                output_dict[first_row[i]].append(item[i])
#
#    for key in output_dict.keys():
#        try:
#            output_dict[key] = np.array(output_dict[key], dtype=np.float)
#        except:
#            pass
#    output_dict["sepal.length"] = output_dict["sepal.length"] + 1
#    print(output_dict["sepal.length"])
#    output_dict["sepal.width"] = output_dict["sepal.length"] - 1
#    print(output_dict["sepal.width"])
#    output_dict["petal.length"] = output_dict["petal.length"] ** 2
#    print(output_dict["petal.length"])
#    output_dict["petal.width"] = np.sqrt(output_dict["petal.width"])
#    print(output_dict["petal.width"])
#
#current_dir_zadanie_6 = os.path.abspath(os.path.dirname(__file__))
#data_path_zadanie_6 = os.path.join(current_dir_zadanie_6, "Data")
#
#with open(os.path.join("Data", "zad_6.csv"),'w', encoding='utf-8') as csvfile:
#    # inicjujemy *zapisywacz*
#    csvwriter = csv.writer(csvfile)
#    # wpisujemy pierwsza linie naszego pliku CSV (nazwy kolumn)
#    csvwriter.writerow(output_dict["sepal.length"])
#    csvwriter.writerow(output_dict["sepal.width"])
#    csvwriter.writerow(output_dict["petal.length"])
#    csvwriter.writerow(output_dict["petal.width"])
#



#zadanie 7
#Wygeneruj losowa tablice zawierajaca 1000 elementów o typie float32 (korzystajac z dowolnego rozkładu).
#Nastepnie pomnóz tablice przez 1000 i wynik zapisz do pliku zad_7.txt. Nastepnie wczytaj dane z pliku do
#nowej tablicy i podziel ja przez 1000. Oblicz bład sredniokwadratowy pomiedzy oryginalnie wygenerowana
#tablica a tablica wynikowa.

#tablica = np.random.standard_normal(1000)
#tablica = tablica.astype(np.float32)
#print(tablica)
#tablica = tablica * 1000
#print(tablica)
#np.save("Zadanie_7.txt", tablica)
#tablica_2 = np.loadtxt("Zadanie_7.txt")
#print(tablica_2)
#tablica_2= tablica_2 / 1000
#mse = ((tablica - tablica_2)**2).mean()
#print("mse wynosi:\n", mse)

#broadcasting! skladnanie macierzy bez petli for

#Zadanie 8!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#Wygeneruj tablice trójwymiarowa zawierajaca 50 losowych macierzy reprezentujacych pomiary o wymiarze
#100x100. Dla kazdej z macierzy oblicz wyznacznik. Nastepnie wygeneruj losowe 50 wektorów o wymiarze
#100x1. Przemnóz kazda z losowo wygenerowanych macierzy przez odpowiadajacy jej (indeksem) losowo
#wygenerowany wektor. Nie uzywaj jakichkolwiek petli, instrukcji warunkowych, badz instrukcji sterujacych.
#Załóz, ze wygenerowane macierze nie beda zdegenerowane. Nastepnie zrób to samo ale uzyj petli for i licz
#wyznacznik oraz przemnazaj macierze przez wektory jeden po drugim. Korzystajac z biblioteki time porównaj
#czas potrzebny na przeprowadzenie obliczen.

#tab = np.ndarray((100, 100, 50))
#for i in range(50):
#    tab[:,:,i] = np.asmatrix(np.random.rand(100, 100))
#    print("Wyznacznik macierz(", i, ") :", np.linalg.det(tab[:,:,i]) )
#wektory = np.asmatrix(np.random.rand(50,100))
#print("mnozenie", wektory * tab[100:100:,])
#matrix = np.random.rand(10000)
#matrix = matrix.reshape(100,100)
#print(matrix)
#vector =  np.random.rand(100)
#print(vector)




#Zadanie 9
#Zaproponuj trzy sposoby (jedna linia kodu) na wyznaczenie przekatnej głównej rezultatu mnozenia dwóch
#macierzy kwadratowych.

#matrix_1 = np.random.standard_normal(9)
#matrix_1 = matrix_1.reshape(3,3)
#matrix_1 = matrix_1.astype(int)
#print(matrix_1)
#matrix_2 = np.random.standard_normal(9)
#matrix_2 = matrix_2.reshape(3,3)
#matrix_2 = matrix_2.astype(int)
#print(matrix_2)
#przekatna = (matrix_1 * matrix_2).diagonal()
#print("przekatna:\n", przekatna)

np.sum( A * B.T, axis=1)
np.einsum("i, j, j i -> i ", A, B)



#Zadanie 10
#Zdefiniuj dowolny wektor o długosci 10 elementów. Kazdy element o parzystym indeksie podnies do kwadratu,
#a kazdy element o nieparzystym indeksie wyzeruj.

#wektor = np.random.randint(10,size =(1,10))
#for i in range(wektor.shape[0]):
#    if i% 2 == 0:
#        wektor[i] = wektor[i] * wektor[i]
#    else:
#        wektor[i]=0

#print(wektor)

#inny sposob:
#v1 = np.random.randint(100,size =(1,10))
#print(v1)
#
#def n_largest(v,n):
#    l = []
#    d = list(v[0])
#    print(d)
#    for i in range(n):
#        l.append(max(d))
#        d.remove(max(d))
#    print(l)
#
#
#print(n_largest(v1,5))






#Zadanie 11
#Wygeneruj losowy wektor 1000 liczb całkowitych. Napisz funkcje, która zwróci n (argument) najwiekszych
#wartosci.

#N = 1000
#vector =  np.random.rand(N)
#liczba = 3
#print(vector)
#def n_largest(array, n):
#    #print(np.sort(array))
#    sorted_array = np.sort(array)
#    return sorted_array[-n:]
#print(n_largest(vector, liczba))



#Zadanie 12
#Zdefiniuj dowolna tablice. Spraw by próba zmiany wartosci zadanej tablicy skutkowała zgłoszeniem błedu.

#N = 10
#array = np.random.rand(N)
##print(array)
#array.flags.writeable =  False
#try:
#    array[5] = 7
#except Exception as e:
#    print(e)



#Zadanie 13!!!!!!!!!!!!!!!!!!!!!!!!
#Zdefiniuj funkcje liczaca rzad macierzy wejsciowej bez uzycia funkcji matrix_rank z biblioteki numpy.

#array = np.random.uniform(0, 1, (10,10))
#print(array)
#def rank(A, eps=1e-12):
#    u, s, vh = np.linalg.svd(A)
#    return len([x for x in s if abs(x) > eps])
#print("rzad:\n", rank(array))



#Zadannie 14
#Zdefiniuj ustrukturyzowana tablice zawierajaca w kazdym polu pozycje (x, y, z), a nastepnie wypełnij ja
#losowymi wartosciami.


#N=random.randint(0,9)
#print(N)
#x = np.random.rand()
#y = np.random.rand()
#z = np.random.rand()
#
#array =[(x, y, z) for i in range(N)]
#print(array)



#Zadanie 15
#Zdefiniuj losowy wektor liczb zmiennoprzecinkowych o losowej długosci. Zamien wszystkie wartosci stanowiace
# wartosc minimalna wartoscia srednia. Powtórz tak długo az nie zostania dokonana zadna zmiana.

#N = random.randrange(0,9) #losowanie dlugosci wektora
##print(N)
#vector = np.random.rand(N)
##print(vector)
#minimum = np.amin(vector)
##print(minimum)
#mean_value = np.mean(vector)
##print(mean_value)
#for i in range(0, N):
#    vector[i]= mean_value
#print(vector)




JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK JACEK





# 1   Jest
# 2   Jest
# 3   Jest
# 4   Jest
# 5   xxx
# 6   xxx
# 7   Jest
# 8   Jest
# 9   50 %
# 10  Jest
# 11  Jest
# 12
# 13  Jest
# 14
# 15

#          ZADANIE 1
#import numpy as np
#
#array_1 = np.arange(0, 101)
#array_2 = np.arange(100, -1, -1)
#print(array_1)
#print(array_2)
#print(array_1 + array_2)
#print(array_1 - array_1)
#print(array_1 * array_2)
#print(array_1[:10] - array_1[-10:])
#print(array_1[array_1 % 3 == 0])


#000000000000000000000000000000000000000000000000000000000000000000000000000

#          ZADANIE 2

#import numpy as np
#import time
#import csv
#
#
#b_t = time.time()
#for item in list_1:
#	list_2.append(item*item)
#e_t = time.time()
#print("Elapsed time: ", e_t - b_t)
#
#list_1 = list(range(0, 10000000))
#b_t = time.time()
#list_2 = [item*item for item in list_1]
#e_t = time.time()
#print("Elapsed time: ", e_t - b_t)
#
#array_1 = np.arange(0, 10000000)
#b_t = time.time()
#array_2 = array_1 * array_1
#e_t = time.time()
#print("Elapsed time: ", e_t - b_t)



#000000000000000000000000000000000000000000000000000000000000000000000000000

#           ZADANIE 3
#import random
#import numpy as np
#import matplotlib.pyplot as plt
#
#
#tab = np.random.normal(50,20,(7,7))
#tab1 =np.round(tab)
#
#

#count, bins, ignored = plt.hist(tab1, 30, density=True)
#plt.plot(bins, 1/(20 * np.sqrt(2 * np.pi)) *
#               np.exp( - (bins - 50)**2 / (2 * 20**2) ),
#         linewidth=3, color='r')
#plt.show()


#print("Wyznacznik: {}".format(np.linalg.det(tab1)))
#print("Slad: {}".format(np.trace(tab1)))
#print("Wartosci i wketory wlasne {}".format(np.linalg.eig(tab)))
#print("Wektory wlasne: {}".format(np.dot(tab1)))

#Elementy tablicy razy wektor
#print("Matrix Tab przemnzona przez wektor [1,2,3,4,5,6,7]\n{}".format(np.dot(tab1,[1,2,3,4,5,6,7])))

#RevTab = np.linalg.inv(tab1)     #Macierz odwrotna

#Przkątna macierzy do kwadratu
#print("Na przekatnej macierzy mamy:\n{}".format(np.square(np.diagonal(tab1))))

#print(np.linalg.svd(tab1))    <-- SVD macierzy

#000000000000000000000000000000000000000000000000000000000000000000000000000



#Zadanie 4
#import os
#import numpy as np
#import csv
#
#
#current_dir = os.path.abspath(os.path.dirname(__file__))
#data_folder = os.path.join(current_dir, "Data")
#csv_path = os.path.join(data_folder, "iris.csv")
#
#
#with open(csv_path) as csv_file:
#	output_dict = dict()
#	reader = csv.reader(csv_file)
#	first_row = next(reader)
#	for key in first_row:
#		output_dict[key] = []
#	for row in reader:
#		for i in range(len(first_row)):
#			try:
#				output_dict[first_row[i]].append(float(row[i]))
#			except:
#				output_dict[first_row[i]].append(row[i])
#
#	for key in output_dict.keys():
#		output_dict[key] = np.array(output_dict[key])
#
#print("Septal Length mean: ", np.mean(output_dict['sepal.length']))
#print("Septal Length std: ", np.std(output_dict['sepal.length']))
#print("Septal Width mean: ", np.mean(output_dict['sepal.width']))
#print("Septal Width std: ", np.std(output_dict['sepal.width']))
#print("Petal length mean: ", np.mean(output_dict['petal.width']))
#print("Petal length std: ", np.std(output_dict['petal.length']))
#print("Petal width mean: ", np.mean(output_dict['petal.length']))
#print("Petal width std: ", np.std(output_dict['petal.length']))
#


#000000000000000000000000000000000000000000000000000000000000000000000000000

# ZADANIE 5

#current_dir = os.path.abspath(os.path.dirname(__file__))
#data_path = os.path.join(current_dir, "Data")
#csv_path = os.path.join(data_path, ".png")
##print(current_dir)
#try:
#    data_file = open(csv_path)
#except:
#    pass
#finally:
#    pass
#with open(csv_path) as csv_file:
#    reader = csv.reader(csv_file)
#    print(reader)
#    #print(dir(reader))
#    for item in reader:
#        print(item)

#000000000000000000000000000000000000000000000000000000000000000000000000000

#Zadanie 7 , blad MSE
#
#import numpy as np
#
##array_1 = np.arange(1000, dtype=np.float32)
#array_1 = np.float32(np.random.normal((1000,1)))
#array_1_export = array_1 * 1000
#
#array_1_export.tofile('zad7.txt')
#
#array_2_import = np.fromfile('zad7.txt',dtype=np.float32)
#array_2 = array_2_import /1000
#
##print(array_2[:25])
#
#ax=0
#mse = (np.square(array_1 - array_2)).mean(axis=ax)
#print("MSE: {}".format(mse))
#
#
#000000000000000000000000000000000000000000000000000000000000000000000000000
##Zadanie 8
#import numpy as np
#
#tab_1 = np.ndarray((100,100,50))
#
#for i in range(50):
#    tab_1[:,:,i] = np.asmatrix(np.random.rand(100,100))
#    print("Wyznacznik macierzy (", i,"):",np.linalg.det(tab_1[:,:,i]))
#
#wektory = np.asmatrix(np.random.rand(50,100))
#000000000000000000000000000000000000000000000000000000000000000000000000000
##Zadanie 9
#import numpy as np
#
#tab = np.random.rand(5,5)
#tab1 = np.random.rand(5,5)
#tab2=tab*tab1
#print(np.diag(tab*tab1))   #Metoda 1

#j=-1
#for i in range(0,len(tab)):
#    j = j + 1
#    print(tab2[i,j])

#000000000000000000000000000000000000000000000000000000000000000000000000000
#Zadanie 10
#import numpy as np
#
#vector = np.arange(0,10)
#for i in range(0,len(vector)):
#    if i % 2 == 0:
#        vector[i] = vector[i] * vector[i]
#    else:
#        vector[i] = 0
#
#print(vector)
#



#000000000000000000000000000000000000000000000000000000000000000000000000000
#Zadanie 11
#import numpy as np
#
#def largest_num(array,count):
#    array_out = []
#    for i in range(0,count):
#        array_out.append(np.amax(array))
#        array = np.delete(array,array.argmax(axis=0))
#    return array_out
#
#array_1 = np.arange(0,1000)
#print(largest_num(array_1,3))
#
#000000000000000000000000000000000000000000000000000000000000000000000000000

#   Zadanie 12

#N = 10
#array = np.random.rand(N)
##print(array)
#array.flags.writeable =  False
#try:
#    array[5] = 7
#except Exception as e:
#    print(e)


#Zadanie 13
#import numpy as np
#
#def rank(A, eps=1e-12):
#    u, s, vh = np.linalg.svd(A)
#    return len([x for x in s if abs(x) > eps])
#
#array_1 = ([1,2,3],[3,4,5],[5,3,3])
#print(rank(array_1))
#print(np.linalg.matrix_rank(array_1))


#000000000000000000000000000000000000000000000000000000000000000000000000000


#Zadannie 14
#Zdefiniuj ustrukturyzowana tablice zawierajaca w kazdym polu pozycje (x, y, z), a nastepnie wypełnij ja
#losowymi wartosciami.


#N=random.randint(0,9)
#print(N)
#x = np.random.rand()
#y = np.random.rand()
#z = np.random.rand()
#
#array =[(x, y, z) for i in range(N)]
#print(array)

 #000000000000000000000000000000000000000000000000000000000000000000000000000

#Zadanie 15
#Zdefiniuj losowy wektor liczb zmiennoprzecinkowych o losowej długosci. Zamien wszystkie wartosci stanowiace
# wartosc minimalna wartoscia srednia. Powtórz tak długo az nie zostania dokonana zadna zmiana.

#import random
#import numpy as np
#
#N = random.randrange(0,9) #losowanie dlugosci wektora
##print(N)
#vector = np.random.rand(N)
##print(vector)
#minimum = np.amin(vector)
##print(minimum)
#mean_value = np.mean(vector)
##print(mean_value)
#for i in range(0, N):
#    vector[i]= mean_value
#print(vector)





#import numpy as np
#import random
#
#mean = 10
#sigma = 6
#tab = np.random.normal(mean,sigma,(100,100))
#
#print(abs(mean - np.mean(tab)) < 0.01)
#print(abs(sigma - np.std(tab, ddof=1)) < 0.01)
#
##print("Wartosci i wketory wlasne {}".format(np.linalg.eig(tab)))
#InvTab = np.linalg.inv(tab)      #Wartosci na ujemne
#InvTab2 = np.flip(tab)           #Odwraca przód - tył
#print(InvTab)
#print(InvTab2)
#
#
#print(np.linalg.eig(InvTab2))


#import numpy as np
#import random
#import time
#
#
#arr = np.random.poisson(5, (1000,100,100))
#bt_1 = time.time()
#print(np.transpose(arr))
#et_1 = time.time()
#print("pomiar 1", et_1- bt_1)
#
#