CAIET DE PRACTICĂ

Anul II AIA
(AUTOMATICA SI INFORMATICA APLICATA)

Tutore

Conf. Univ. Dr

Student

Bucuresti
2022-2023
CUPRINS
I. CADRUL GENERAL DE ORGANIZARE A STAGIULUI DE PRACTICĂ………........………3

II. TEMATICA, OBIECTIVELE Ș I COMPETENȚ ELE DOBÂNDITE

ÎN CADRUL STAGIULUI DE PRACTICĂ………………………………………………......…..4
III. PROGRAM DE ACTIVITATE STAGIUL DE PRACTICĂ.......................................................5
III. FIȘA DE EVALUARE A STAGIULUI DE PRACTICĂ……………………….....……….……

I. CADRUL GENERAL DE DESFĂȘURARE A STAGIULUI DE PRACTICĂ

Perioada de desfășurare:
De la: ____________26.06.2023______________până la: _______14.07.2023_____________________

Program de lucru ……3 săptămâni, 5 zile/săpt, 6 ore/zi……………………….

Luni_______________________
Marți_______________________
Miercuri____________________
Joi_________________________
Vineri______________________
Durata totala a stagiului de practica: 90 de ore

Responsabil de practica/Mentor:
Numele și prenumele__________________________________________
Gradul didactic_______________________________________________
Telefon, e-mail________________________________________________
Compania organizatoare a stagiului de practica:
Denumire____________________________________________________
Sediul social__________________________________________________
Domeniul de activitate_________________________________________
(se va menționa codul CAEN)

Domeniul de desfășurare a activității:

..........................................................................................................
(ex. Compartiment, Serviciu, Birou ....)

Tutorele desemnat din partea firmei

Numele și prenumele__________________________________________
Funcția ocupată _______________________________________________
Telefon, e-mail________________________________________________
 II. TEMATICA, OBIECTIVELE ȘI COMPETENȚELE URMĂRITE ÎN
CADRUL STAGIULUI DE PRACTICĂ

Stagiul de practică va viza următoarele aspecte:

1. Cunoașterea generală a domeniului în care se desfășoară practica (primele 2 zile):

▪ Cunoașterea legislației specifice și normelor de protecție a muncii;

▪ Prezentarea societății – istoricul și evoluția societății și prezentarea domeniilor de

activitate;

▪ Prezentarea obiectivelor pe termen lung, cât și misiunea, viziunea și strategia

societății;

▪ Prezentarea relațiilor manageriale, a sistemului organizatoric;

▪ Prezentarea strategiei de marketing – profilul clienților și tendințele pieței.

2. Aspecte și probleme legate de activitatea din cadrul societății:

1. Redactarea textelor în Word cu diverse utilizări ale altor componente Microsoft Office.
2. Aplicații complexe cu vectori, fișiere, liste înlănțuite, grafuri, metode de programare.
3. Aplicații privind rezolvarea ecuațiilor algebrice și transcendente și calculul aproximativ al
integralelor definite. Interpolare și metoda celor mai mici pătrate. Tabelarea funcțiilor.
4. Aplicații privind metodele rapide de sortare a tablourilor și tehnici de căutare.
5. Aplicații privind algoritmi grafici.
6. Aplicații complexe de gestiune a datelor cu ajutorul bazelor de date relaționale – SGBD-ul
ORACLE – limbajul SQL.
7. Aplicații complexe care utilizează noțiuni specifice programării pe obiecte. Implementare in
limbajele C++ și Java.
8. Programare în Arduino
III. PROGRAM DE ACTIVITATE ÎN STAGIUL DE PRACTICĂ
ATENȚIE:Această parte a caietului de practică reflectă activitatea efectivă din stagiul de practică a studentului.
ZIUA DATA DESCRIEREA ACTIVITĂȚII INSTRUMENTE ȘI
DOCUMENTE DE LUCRU
1. Programare in c++ Am folosit aplicatia jdoodle iar
26.06.2023 pentru ajutor am folosit materialele
didactice care ne au fost date in
semestrele trecute

2. Programare in c++ Am folosit aplicatia jdoodle iar

27.06.2023 pentru ajutor am folosit materialele
didactice care ne au fost date in
semestrele trecute

3. Programare in c++ Am folosit aplicatia jdoodle iar

pentru ajutor am folosit materialele
28.06.2023 didactice care ne au fost date in
semestrele trecute

4. Programare in c++ Am folosit aplicatia jdoodle iar

pentru ajutor am folosit materialele
29.06.2023 didactice care ne au fost date in
semestrele trecute

5. Programare in c++ Am folosit aplicatia jdoodle iar

pentru ajutor am folosit materialele
didactice care ne au fost date in
semestrele trecute
30.06.2023

6. Proiectarea algoritmilor Am folosit aplicatia chat gbd iar

pentru ajutor am folosit materialele
03.07.2023 didactice care ne au fost date in
 semestrele trecute

7. 04.07.2023 Proiectarea algoritmilor Am folosit aplicatia chat gbd iar

pentru ajutor am folosit materialele
didactice care ne au fost date in
semestrele trecute

8. Implementați metoda Newton de Am folosit materialele didactice

05.07.2023 rezolvare a unui sistem neliniar. care ne au fost puse la dispozitie

9. Realizarea unui joc Am folosit aplicatia visual studio

06.07.2023

10. Realizarea unui joc Am folosit aplicatia visual studio

07.07.2023

11. Crearea unor tabele in SQL Am folosit site-ul Apex Oracle

10.07.2023

12. 11.07.2023 Crearea unor tabele in SQL Am folosit site-ul Apex Oracle

13. 12.07.2023 Programare orientata pe obiecte Am folosit aplicatia jdoodle iar

pentru ajutor am folosit materialele
 didactice care ne au fost date in
semestrele trecute

14. 13.07.2023 Programare orientata pe obiecte Am folosit aplicatia jdoodle iar

pentru ajutor am folosit materialele
didactice care ne au fost date in
semestrele trecute

15. 14.07.2023 Crearea unui proiect cu ajutorul Pentru proiect am

placutei arduino folosit:leduri,cabluri,o placa
arduino,o breadboard si rezistente

1)
1.1
#include <iostream>
#include <unordered_map>

// Functie pentru generarea tablourilor bidimensionale

void generareTablouri(int tablou1[5][5], int tablou2[5][5]) {
int numar = 1;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
tablou1[i][j] = numar;
tablou2[i][j] = numar + 20;
numar++;
}
}
}

// Functie pentru codificarea textului

std::string codificareText(const std::string& text, const int tablou1[5][5], const int tablou2[5][5])
{
std::string codificare;
std::unordered_map<char, std::pair<int, int>> pozitii;

for (int i = 0; i < 5; i++) {

for (int j = 0; j < 5; j++) {
pozitii['a' + i * 5 + j] = std::make_pair(i, j);
}
}

for (char caracter : text) {

if (caracter == ' ') {
continue; // Ignoram spatiile
}

auto pozitie = pozitii[caracter];

int linie = pozitie.first;
int coloana = pozitie.second;

int codificat = tablou1[linie][coloana];

codificare += std::to_string(codificat) + " ";

// Permutam circular linia spre dreapta cu i pozitii

for (int i = 0; i < linie; i++) {
std::swap(tablou1[i][coloana], tablou1[i + 1][coloana]);
}

// Permutam circular coloana in sus cu j pozitii

for (int j = 0; j < coloana; j++) {
std::swap(tablou1[linie][j], tablou1[linie][j + 1]);
}
}
 return codificare;
}

int main() {
int tablou1[5][5];
int tablou2[5][5];

generareTablouri(tablou1, tablou2);

std::string text;
std::cout << "Introduceti textul: ";
std::getline(std::cin, text);

std::string codificare = codificareText(text, tablou1, tablou2);

std::cout << "Codificarea textului '" << text << "' este: " << codificare << std::endl;

return 0;
}
1.2
#include <iostream>
#include <vector>
// Functie pentru determinarea numarului de elemente nenule de pe o linie
int numarElementeNenule(const std::vector<int>& linie) {
int numarNenule = 0;
for (int elem : linie) {
if (elem != 0) {
numarNenule++;
}
}
return numarNenule;
}
// Functie pentru determinarea liniilor cu cele mai multe elemente nenule din matrice
std::vector<int> liniileCuCeleMaiMulteNenule(const std::vector<std::vector<int>>& matrice) {
int maxNenule = 0;
 std::vector<int> liniileMaxNenule;
for (int i = 0; i < matrice.size(); i++) {
int numarNenule = numarElementeNenule(matrice[i]);
if (numarNenule > maxNenule) {
maxNenule = numarNenule;
liniileMaxNenule.clear();
liniileMaxNenule.push_back(i);
} else if (numarNenule == maxNenule) {
liniileMaxNenule.push_back(i);
}
}
return liniileMaxNenule;
}
int main() {
int m, n;
std::cout << "Introduceti numarul de linii: ";
std::cin >> m;
std::cout << "Introduceti numarul de coloane: ";
std::cin >> n;
std::vector<std::vector<int>> matrice(m, std::vector<int>(n));
std::cout << "Introduceti elementele matricei:\n";
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
std::cin >> matrice[i][j];
}
}
std::vector<int> liniileMaxNenule = liniileCuCeleMaiMulteNenule(matrice);
std::cout << "Liniile cu cele mai multe elemente nenule sunt: ";
for (int linie : liniileMaxNenule) {
std::cout << linie << " ";
}
std::cout << std::endl;
return 0;
}
1.3
#include <iostream>
#include <vector>
bool existaNumarMajoritar(const std::vector<int>& secventa) {
int n = secventa.size();
std::unordered_map<int, int> frecventa;
// Calculam frecventa fiecarui numar din secventa
for (int numar : secventa) {
frecventa[numar]++;
}
// Verificam daca exista un numar majoritar
for (auto it = frecventa.begin(); it != frecventa.end(); ++it) {
if (it->second > n / 2) {
return true;
}
}
return false;
}
int main() {
int n;
std::cout << "Introduceti numarul de elemente din secventa: ";
std::cin >> n;
std::vector<int> secventa(n);
std::cout << "Introduceti elementele secventei:\n";
for (int i = 0; i < n; i++) {
std::cin >> secventa[i];
}
if (existaNumarMajoritar(secventa)) {
std::cout << "Exista un numar majoritar in secventa.\n";
} else {
std::cout << "Nu exista un numar majoritar in secventa.\n";
}
return 0;}
1.4
#include <iostream>
#include <vector>
#include <unordered_map>
// Functie pentru calcularea numarului de cifre 1 in reprezentarea in baza 2 a unui numar
int numarCifreUnuBazaDoi(int numar) {
int numarCifreUnu = 0;
while (numar > 0) {
if (numar % 2 == 1) {
numarCifreUnu++;
}
numar /= 2;
}
return numarCifreUnu;
}
// Functie pentru calcularea mediilor aritmetice in grupuri de numere cu acelasi numar de cifre
1 in baza 2
std::vector<double> mediiAritmeticeGrupuri(const std::vector<int>& numere) {
std::unordered_map<int, std::vector<int>> grupuri;
std::vector<double> medii;
// Grupam numerele in functie de numarul de cifre 1 in baza 2
for (int numar : numere) {
int numarCifreUnu = numarCifreUnuBazaDoi(numar);
grupuri[numarCifreUnu].push_back(numar);
}
// Calculam media aritmetica pentru fiecare grup
for (auto it = grupuri.begin(); it != grupuri.end(); ++it) {
const std::vector<int>& grup = it->second;
int numarElemente = grup.size();
int suma = 0;
for (int numar : grup) {
suma += numar;
}
double media = static_cast<double>(suma) / numarElemente;
medii.push_back(media);
 }
return medii;
}
int main() {
int n;
std::cout << "Introduceti numarul de elemente din vector: ";
std::cin >> n;
std::vector<int> numere(n);
std::cout << "Introduceti elementele vectorului:\n";
for (int i = 0; i < n; i++) {
std::cin >> numere[i];
}
std::vector<double> medii = mediiAritmeticeGrupuri(numere);
std::cout << "Mediile aritmetice ale grupurilor sunt: ";
for (double media : medii) {
std::cout << media << " ";
}
std::cout << std::endl;

return 0;
}

1.5
#include <iostream>
#include <string>
#include <sstream>
#include <unordered_map>
int main() {
std::string text;
std::cout << "Introduceti textul: ";
std::getline(std::cin, text);

std::unordered_map<int, int> frecventa;

// Citim cuvintele din text folosind un flux de string-uri
 std::stringstream ss(text);
std::string cuvant;
while (ss >> cuvant) {
int lungime = cuvant.length();
frecventa[lungime]++;
}
// Afisam distributia frecventelor
for (auto it = frecventa.begin(); it != frecventa.end(); ++it) {
std::cout << it->second << " cuvinte de lungime " << it->first << std::endl;
}
return 0;
}

}1.6
#include <iostream>
#include <string>
#include <cctype>
int main() {
std::string text;
std::cout << "Introduceti textul: ";
std::getline(std::cin, text);
// Verificam fiecare caracter din text
for (int i = 0; i < text.length(); i++) {
// Verificam daca caracterul curent este un punct urmat de spatiu(uri)
if (text[i] == '.' && i + 1 < text.length() && text[i + 1] == ' ') {
// Cautam primul caracter non-spatiu de dupa punct
int j = i + 2;
while (j < text.length() && std::isspace(text[j])) {
j++;
}
// Verificam daca exista un caracter non-spatiu si il transformam in litera mare
if (j < text.length()) {
 text[j] = std::toupper(text[j]);
}
}
}
// Eliminam spatiile inutile
std::string rezultat;
bool spatiuAnterior = false;
for (char caracter : text) {
if (std::isspace(caracter)) {
if (!spatiuAnterior) {
rezultat += ' ';
}
spatiuAnterior = true;
} else {
rezultat += caracter;
spatiuAnterior = false;
}
}
// Afisam rezultatul
if (rezultat == text) {
std::cout << "Nu s-a facut nicio modificare in text.\n";
} else {
std::cout << "Textul modificat:\n";
std::cout << rezultat << std::endl;
}
return 0;
}

2)
2.1

a)SELECT AVG(Salariu) AS Media_salariilor

FROM Angajati_GRN
WHERE Id_dept = 80;

b) SELECT Nume
FROM Angajati_GRN
WHERE Salariu > (
SELECT Salariu
FROM Angajati_GRN
WHERE Nume = 'Gheorghe' AND Prenume = 'Popescu');

c) SELECT Nume
FROM Angajati_GRN
WHERE Id_dept = (
SELECT Id_dept
FROM Departamente_GRN
WHERE Den_dept = 'Vanzari');

d) SELECT A.Nume, A.Prenume, M.Nume AS Nume_manager, M.Prenume AS

Prenume_manager
FROM Angajati_GRN A JOIN Angajati_GRN M ON A.Id_manager = M.Id_angajat;

2.2
a) SELECT Nume
FROM Angajati_GRN
WHERE Id_manager IS NULL;

b) SELECT Nume, Salariu

FROM Angajati_GRN
WHERE Id_manager = (
SELECT Id_angajat
FROM Angajati_GRN
WHERE Nume = 'Gheorghe' AND Prenume = 'Popescu'
);

c) SELECT A.Nume, A.Prenume, D.Den_dept AS Departament

FROM Angajati_GRN A JOIN Departamente_GRN D ON A.Id_dept = D.Id_dept AND
A.Comision IS NOT NULL;

d) SELECT Den_dept AS Departament

FROM Departamente_GRN
WHERE Id_dept IN (
SELECT DISTINCT Id_dept
FROM Angajati_GRN);
2.3
a) SELECT Nume, Prenume
FROM Angajati_GRN
WHERE Salariu % 3 = 0;

b) SELECT Nume, Prenume, ROUND(Salariu * 1.056, 2) AS Salariu_nou

FROM Angajati_GRN
WHERE Id_dept = 30;

c) SELECT Nume, Prenume, Salariu

FROM Angajati_GRN A JOIN Departamente_GRN D ON A.Id_dept = D.Id_dept AND
D.Locatie = 'Tg-Jiu';

3)
3.2
#include <iostream>
#include <string>
using namespace std;

class DataCalendaristica {
private:
int zi;
int luna;
int an;
public:
DataCalendaristica(int zi = 0, int luna = 0, int an = 0) {
 this->zi = zi;
this->luna = luna;
this->an = an;
}
static bool validareData(int zi, int luna, int an) {
if (an < 0 || luna < 1 || luna > 12 || zi < 1 || zi > 31) {
return false;
}
if (luna == 2) {
if (an % 4 == 0 && an % 100 != 0 || an % 400 == 0) {
return zi <= 29;
} else {
return zi <= 28;
}
}
if (luna == 4 || luna == 6 || luna == 9 || luna == 11) {
return zi <= 30;
}
return true;
}
void citire(string format) {
if (format == "zz/ll/aaaa") {
cout << "Introduceti data in formatul " << format << ": ";
cin >> zi >> luna >> an;
} else if (format == "ll/zz/aaaa") {
cout << "Introduceti data in formatul " << format << ": ";
cin >> luna >> zi >> an;
} else if (format == "aaaa/ll/zz") {
cout << "Introduceti data in formatul " << format << ": ";
cin >> an >> luna >> zi;
} else {
cout << "Format necunoscut!" << endl;
}
}
 void afisare(string format) {
if (format == "zz/ll/aaaa") {
cout << zi << "/" << luna << "/" << an;
} else if (format == "ll/zz/aaaa") {
cout << luna << "/" << zi << "/" << an;
} else if (format == "aaaa/ll/zz") {
cout << an << "/" << luna << "/" << zi;
} else {
cout << "Format necunoscut!" << endl;
}
}
static DataCalendaristica ziuaUrmatoare(DataCalendaristica d) {
int z = d.zi + 1, l = d.luna, a = d.an;
if (!validareData(z, l, a)) {
z = 1; ++l;
if (!validareData(z, l, a)) {
z = 1; l = 1; ++a;
}
}
return DataCalendaristica(z, l, a);
}
};

int main() {
DataCalendaristica d(31,12,2022);
d.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d2(31,2,2022);
d2.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d3(29,2,2024);
d3.afisare("zz/ll/aaaa");
 cout<<endl;

DataCalendaristica d4(30,4,2022);
d4.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d5(31,6,2022);
d5.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d6(31,9,2022);
d6.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d7(31,11,2022);
d7.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d8(31,12,-1);
d8.afisare("zz/ll/aaaa");
cout<<endl;

DataCalendaristica d9(31,-1,-1);
d9.afisare("zz/ll/aaaa");

3.3
#include <iostream>
#include <cmath>
using namespace std;

class Triunghi {
private:
double a;
double b;
double c;
 public:
Triunghi(double a = 0, double b = 0, double c = 0) {
this->a = a;
this->b = b;
this->c = c;
}
static bool validareTriunghi(double a, double b, double c) {
return (a + b > c && a + c > b && b + c > a);
}
double perimetru() {
return a + b + c;
}
double aria() {
double p = perimetru() / 2;
return sqrt(p * (p - a) * (p - b) * (p - c));
}
bool dreptunghic() {
if (!validareTriunghi(a, b, c)) {
return false;
}
if (a * a == b * b + c * c || b * b == a * a + c * c || c * c == a * a + b * b) {
return true;
}
return false;
}
};

int main() {
Triunghi t(3,4,5);
cout << "Perimetrul triunghiului este: " << t.perimetru() << endl;
cout << "Aria triunghiului este: " << t.aria() << endl;
cout << "Triunghiul este dreptunghic? " << (t.dreptunghic() ? "Da" : "Nu") << endl;

Triunghi t2(1,2,3);
 cout << "Perimetrul triunghiului este: " << t2.perimetru() << endl;
cout << "Aria triunghiului este: " << t2.aria() << endl;
cout << "Triunghiul este dreptunghic? " << (t2.dreptunghic() ? "Da" : "Nu") << endl;

Triunghi t3(1,1,1);
cout << "Perimetrul triunghiului este: " << t3.perimetru() << endl;
cout << "Aria triunghiului este: " << t3.aria() << endl;
cout << "Triunghiul este dreptunghic? " << (t3.dreptunghic() ? "Da" : "Nu") << endl;

Triunghi t4(1,1,-1);
cout << "Perimetrul triunghiului este: " << t4.perimetru() << endl;
cout << "Aria triunghiului este: " << t4.aria() << endl;
cout << "Triunghiul este dreptunghic? " << (t4.dreptunghic() ? "Da" : "Nu") << endl;

Triunghi t5(1,-1,-1);
cout << "Perimetrul triunghiului este: " << t5.perimetru() << endl;
cout << "Aria triunghiului este: " << t5.aria() << endl;
cout << "Triunghiul este dreptunghic? " << (t5.dreptunghic() ? "Da" : "Nu")<<endl;

}
4)
4.1
#include <fstream>
#include <iostream>
using namespace std;

int grad_intern(int x, int n, int matrice[][100]) {

int grad = 0;
for (int i = 1; i <= n; i++) {
if (matrice[x][i] == 1) {
grad++;
}
}
 return grad;
}
int grad_extern(int x, int n, int matrice[][100]) {
int grad = 0;
for (int i = 1; i <= n; i++) {
if (matrice[i][x] == 1) {
grad++;
}
}
return grad;
}
int main() {
ifstream fin("adiacenta.in");
ofstream fout("noduri.out");
int n;
fin >> n;
int matrice[100][100];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
fin >> matrice[i][j];
}
}
for (int i = 1; i <= n; i++) {
if (grad_intern(i, n, matrice) == grad_extern(i, n, matrice)) {
fout << i << " ";
}
}
fin.close();
fout.close();
return 0;
}
5.

Metoda Newton (varianta m - dimensională, m>1) este o metodă iterativă de rezolvare a

unor sisteme de m ecuații și m necunoscute:

f(x) = 0,

unde f : G → Rm, G ⊂ Rm.

Convenim să notăm cu x1, x2,…, xn,… un șir de elemente din Rm. Rezervăm indicii inferiori
pentru a desemna componentele unui element x = (x 1, x2,…,xm) din Rm. Dacă G este o mulțime

deschisă și f : G → Rm este o funcție diferențiabilă pe G, identificăm diferențiala de ordinul I a lui

f în x, df(x), cu matricea jacobiană lui f în x, notată Jf(x):

Jf(x) = ( ∂fi
∂ xj
(x) )
1≤ i , j ≤ m

În cele ce urmează presupunem că matricea Jf(x) este inversabilă pentru x ∈G.

Aplicând formula lui Taylor rezultă că

f( ^x ) = f(x*) + δJf(x*)h + o(δ),

lim ||o ( δ )||

unde δ→0 = 0. Ca urmare,
δ

f( ^x ) - f(x*) - o(δ) = Jf(x*)( ^x -x*)

Jf(x*)-1(f( ^x ) - f(x*) - o(δ)) =( ^x -x*)

și

|| ^x -x*||≤≈ || Jf(x*)-1|| f( ^x ) - f(x*)||.

Deci factorul de condiționare absolut al problemei f(x) = 0 este|| Jf(x)-1||. Dacă ε > 0 și ^x este un

număr real cu proprietatea că ||f( ^x )|| ≤ ε atunci

|| ^x - x*|| ≤≈ ε|| Jf(x*)-1||

(unde x* este o soluție a sistemului f(x) = 0). În general, || x^ -x*|| și ||f( ^x )|| nu sunt simultan mici (||

^x -x*|| este eroarea absolută cu care ^x aproximează x*, iar ||f( ^x )|| indică reziduu corespunzător lui ^x

). Dacă problema este bine condiționată (adică dacă norma || Jf(x*)-1|| este mică), atunci reziduu

mic implică faptul că eroarea absolută cu care x^ aproximează x*, || ^x -x*||, este mică.

Metoda Newton constă în aproximarea soluției ecuației considerate cu xn, unde

xn = xn-1 – Jf(xn-1)-1 f(xn-1) (*)

iar aproximația inițială x0∈G este suficient de apropiată de soluția sistemului.

Observații. 1) Presupunem că f este de clasă C2 și sistemul f(x) = 0 admite o soluție x* ∈ G

cu proprietatea că Jf(x*) este matrice inversabilă (sau echivalent det(Jf(x*)) ≠0). Atunci există o

vecinătate deschisă V ⊂ G a lui x* astfel încât pentru orice x ∈ V să avem Jf(x) este inversabilă.

Considerăm funcția

g: V → Rm, definită prin g(x) = x – Jf(x)-1 f(x).

Avem
g(x*) = x* - Jf(x*)-1 f(x*) = x*,
deci x* punct fix pentru g. Din faptul că

||Jg (x*)|| = 0 < 1,

rezultă că există r > 0 astfel încât astfel dacă notăm

¿
S = B(x , r ) = {x ∈ Rm, ||x-x*|| ≤ r}

avem S ⊂ V și g|S : S → S este contracție. Ca urmare șirul definit prin x n= g(xn-1), n≥1 converge la

x* pentru orice termen inițial x0∈S. Din definiția lui g rezultă că

xn = xn-1 – Jf(xn-1)-1 f(xn-1), n ≥ 1,

adică șirul dat de relația (*) (corespunzător metodei lui Newton pentru f(x) = 0 cu termenul inițial

x0 ∈S).

2) Amplificând relația (*) cu Jf(xn-1) rezultă

Jf(xn-1)(xn - xn-1) = –f(xn-1) (**)
sau echivalent
m
∂ f i ( x n−1 ) n n −1
∑ ❑ ∂ x ( x j −x j )=−f i ( x n−1 ), i = 1,2,…, m
j=1 j

Dacă se folosește relația (*) pentru determinarea lui xn este necesar să se calculeze inversa matricei
Jf(xn-1). Dacă se folosește relația (**), este necesar să se rezolve un sistem liniar cu m ecuații, și
n −1
necunoscutele Δ x n−1 n
k =x k −x k , k = 1, …, m. Rezolvarea acestui sistem necesită un număr mai

mic de operații decât inversarea matricei Jf(x n-1). Folosim relația (**) se înlocuiește rezolvarea
sistemului neliniar prin rezolvarea succesivă a unor sisteme liniare.
∂f i
3) Una din dificultățile metodei este necesitatea determinării derivatelor parțiale ( x ),
∂ xj
componentele matricei Jf(x) (dacă se utilizează un mediu de programare simbolică cum este
MAPLE aceasta nu e o dificultate majoră). O posibilitate de eliminare a acestei dificultăți este
aproximarea derivatelor parțiale prin diferențe finite

∂f i 1
( x ) ≈ ( f i ( x +hij e j )−f i ( x ))= Δij ( x )
∂ xj hij
unde hij sunt parametri specifici discretizării considerate, iar
 ej =(0,..,0,1,0…0)t
sunt vectorii bazei canonice. În acest fel Jf(x) se înlocuiește prin

J(x) = (Δij(x))1≤i,j≤m

Metoda obținută în acest caz se numește metoda iterativă discretă a lui Newton:

xn = xn-1 – J(xn-1)-1 f(xn-1), n ≥ 1.

Metoda Newton este o metodă frecvent folosită deoarece este foarte rapid convergentă
(rata convergenței este pătratică). Dar ca și în cazul metodei tangentei convergența metodei
depinde de alegerea aproximației inițiale. Aproximația inițială trebuie luată cât mai aproape de
soluția problemei, eventual utilizând o altă metodă de găsire a soluției. În următoarele teoreme se

presupune că s-a fixat o normă pe Rm, notată ‖‖ , iar pe spațiile de operatori liniari L(Rm, Rm),

L(Rm, L(Rm, Rm)) se consideră normele operatoriale induse. Pentru x ∈ Rm și r > 0, se notează

B(x,r) mulțimea:

{ y ∈ R m , ‖ y −x ‖< r }
și cu B ( x , r ) închiderea acestei mulțimi, adică

{ y ∈ R m , ‖ y −x ‖≤ r }
Teoremă (Metoda Newton). Fie G ⊂ Rm o mulțime deschisă, f : G → Rm o funcție de

2
clasă C2, cu proprietatea că există M > 0 astfel ca ‖d f ( x ) ‖ ≤ M pentru orice x ∈G. Presupunem că

ecuația f(x) = 0 admite o soluție x* astfel încât Jf(x*) să fie inversabil. Atunci pentru orice q ∈ (0,

1) există r, μ > 0 astfel încât Jf(x) este inversabil pentru orice x ∈ B(x*,r), șirul (xn)n, definit prin

xn = xn-1 – Jf(xn-1)-1 f(xn-1), n ≥ 1

rămâne în B(x*,r) oricare ar fi x0 ∈ B(x*, r) și converge la x*. În plus, au loc următoarele relații

n 2μ 2 n

‖ x −x∗‖ ≤ q
M
1 M n n−1 2
‖ x −x∗‖ ≤ ‖ f ( x ) ‖≤
n n
‖ x −x ‖ .
μ 2μ
Parametrii procedurii mnewton (de mai jos) sunt
funcția f (se presupune că se rezolvă sistemul f(x) = 0)
x0 = termenul inițial din șirul definit de (**)
epsilon = precizia
Nmax = numărul maxim de termeni din șir ce vor fi calculați
Se calculează n termeni, cu n verificând

( < epsilon) sau (n≥Nmax).

Comanda
>subs(expr1, expr2);
substituie subexpresia expr1 în expresia expr2. Comanda
>Jacobian(f(x,y,...), [x, y, ...]);
calculează matricea jacobiană a lui f. Este o comandă ce aparține pachetului VectorCalculus.
Comanda
>Norm(a, t);

calculează norma t, unde t =infinity, p (1 ≤ p < ∞) a vectorului (sau matricei pentru p=1,2,

infinity) a. Este o comanda ce aparține pachetului LinearAlgebra.

Procedură MAPLE
> mnewton := proc(f, x0, epsilon, Nmax)

local m,x1, x2, dx, b, fx, fx1, n, i, j, ex;

uses LinearAlgebra, VectorCalculus;

m:= op(2,ArrayDims(x0));

x1 := Vector(m);

x2:= Vector(m);

for i to m do x1[i] := x0[i] end do;

dx := Vector(m);

b := Vector(m);

fx := Jacobian(f(seq(x[i],i=1..m)), [seq(x[i],i=1..m)]);

fx1 := Matrix(m, m);

ex := seq(x[i] = x1[i], i = 1 .. m);

for i to m do

for j to m do

fx1[i, j] := subs(ex, fx[i, j])

end do

end do;

b := -Vector(f(seq(x1[i],i=1..m)));

try

dx := LinearSolve(fx1, b)

catch "inconsistent system":

print("Metoda nu se aplica");

return NULL;

end try;

for i to m do x2[i] := x1[i] + dx[i] end do;

n := 1;

print(Transpose(x2));

try

while evalf(epsilon - Norm(dx, infinity)^2) <= 0 and

n < Nmax do

for i to m do x1[i] := x2[i] end do;

ex := seq(x[i] = x1[i], i = 1 .. m);

for i to m do

for j to m do

fx1[i, j] := subs(ex, fx[i, j])

end do

end do;

b := -Vector(f(seq(x1[i],i=1..m)));

try

dx := LinearSolve(fx1, b)
 catch "inconsistent system":

print("Metoda nu se aplica");

return NULL;

end try;

for i to m do x2[i] := x1[i] + dx[i] end do;

n := n + 1;

print(Transpose(x2))

end do;

catch "FAIL":

print("Metoda nu se aplica.");
end try;

print(`Numar de pasi`, n);

b := Vector(f(seq(x2[i],i=1..m)));

print(`Valoarea functiei`, Transpose(b));

return Transpose(x2)

end proc;

Exemple de utilizare a procedurii mnewton

> f1:=(x,y)->[x^2-y,x^3-5*y];

> f2:=(x,y)->[x^2+y^2-1,x^3-y];

> f3:=(x,y,z)->[x+x^2-2*y*z-0.1,y-y^2+3*x*z+0.2, z+z^2+2*x*y-0.3];

> mnewton(f1, Vector([10.,0.1]), 10^(-Digits), 10);

> fsolve({f1(x,y)[1] = 0, f1(x,y)[2] = 0}, {x, y});

> mnewton(f1, Vector([0.1,10]), 10^(-Digits), 10);

> mnewton(f2, Vector([1,0.1]), 10^(-Digits), 10);

> fsolve({f2(x,y)[1] = 0, f2(x,y)[2] = 0}, {x, y});

> mnewton(f2, Vector([20.,10.]), 10^(-Digits), 10);

> mnewton(f3, Vector([0.,0., 0.]), 10^(-Digits), 10);

> fsolve({f3(x,y,z)[1] = 0, f3(x,y,z)[2] = 0, f3(x,y,z)[3] = 0},
{x, y, z});

> mnewton(f3, Vector([-2.,0., 0.]), 10^(-Digits), 10);

>

6.
Am creat un joc cu masini de ocolire a obstacolelor, in momentul cand jucatorul se loveste de
un obstacol, jocul se termina si apare un scor, in timp ce jucatorul acumuleaza mai multe pucte
fara a se lovi de obstacole, viteza creste si scorul afisat are diferite trofee afisate in functie de
scor.

7.
Cu ajutorul placii arduino am reusit sa creez un joc de lumini,pentru acest proiect aveti nevoie
doar de 3 led uri,2 cabluri,3 rezistent ,de o placa de tipul breadboard ,de o placa arduino si
bineinteles de o sursa de curent ,nu mai mare de 5V,dupa ce ati legat toate aceste componente
veti introduce codul de mai jos in aplicatia arduino ide iar in scurt timp veti putea vedea acel
joc de lumini

int led_pin = 12; // definim pini de pe placa de baza de unde isi ia ledurile curent "+"
int led_pin2 = 10; // a doua alternativa de declarare ar fi "#define nume "pin""
int led_pin3 = 8;

void setup()
{
pinMode(led_pin, OUTPUT); // selectam variabilele ce si daca sunt de intrarre sau de iesire
pinMode(led_pin2, OUTPUT);
pinMode(led_pin3, OUTPUT);
}

void loop()
{
digitalWrite(led_pin, HIGH); //declaram plrimul led sa merga la voltajul maxim
delay(100); // delay, timpul de asteptare fara voltaj

digitalWrite(led_pin, LOW); //declaram primul pin sa mearga la voltajul cel mai mic, adica fara
curent
delay(100); //delay, timpul de asteptare fara voltaj

{
digitalWrite(led_pin2, HIGH);
delay(100);
 digitalWrite(led_pin2, LOW);
delay(100);
}

{
digitalWrite(led_pin3, HIGH);
delay(100);

digitalWrite(led_pin3, LOW);
delay(100);
}

EVALUAREA STAGIULUI DE PRACTICĂ

Evaluarea stagiului de practica se face in conformitate cu METODOLOGIA DE
DESFĂȘURARE A PRACTICII (dezvoltata la nivelul UCB)

Precizări suplimentare:

Practica se finalizează cu susținerea COLOCVIULUI DE PRACTICĂ, la care studenții

vor prezenta:
a) Certificat de practica eliberat de unitatea la care au efectuat practică;
b) Caietul de practică - completat pe parcursul perioadei de practică;