Probleme rezolvate

1. Implementarea unei structuri de tip for în limbaj de asamblare. Pseudocod:
for i=0 -> n-1 do
eax=eax+1;
ebx=ebx-5;
end for
Varianta 1

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
n db 5
.code
start:

    mov edi,n
mov esi,0
et_for:
inc eax
sub ebx,5
inc esi
cmp esi, edi
jbe et_for

    ;apel functie exit
    push 0
    call exit
end start

Varianta 2

 .386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
n db 5
.code
start:
mov ecx,n
et_loop:
inc eax
sub ebx,5
loop et_loop

    ;apel functie exit
    push 0
    call exit
end start

2. Să se determine minimul şi maximul dintr-un şir de numere fără semn reprezentate pe octet şi să se scrie valorile găsite în memorie.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 10,21,3,14,2,22,11
lgsir dd $-sir
min db 0
max db 0
   
.code
start:
   
    mov ax, 0 ; al-minim, ah-maxim
   
    mov esi, 0
    mov ecx, lgsir
    mov al, sir[esi]
    mov ah, sir[esi]

    et_loop:
    cmp al, sir[esi]
    JB cmp_max
    mov al, sir[esi]
    cmp_max:
    cmp ah, sir[esi]
    JA urmator
    mov ah, sir[esi]
    urmator:
    inc esi   
    loop et_loop
   
    mov min, al
    mov max, ah
   
    ;apel functie exit
    push 0
    call exit
end start

Probleme propuse

1. Să se determine minimul şi maximul dintr-un şir de numere cu semn reprezentate pe cuvânt şi să se scrie valorile găsite în memorie.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir dw -10,21,-3,14,2,-22,11
lgsir dd $-sir
min dw 0
max dw 0
   
.code
start:
   
    mov eax, 0
    mov ebx, 0
    ; ax-minim, bx-maxim
   
    mov esi, 0
    mov ecx, lgsir
    mov ax, sir[esi]
    mov bx, sir[esi]
    ;mov esp, 0
    ;mov esi, 0

    ;lup:
    ;push dword ptr sir[esi]
    ;inc esi
    ;loop lup

    ;inc esi
   
    et_loop:
    cmp sir[esi],ax
    JGE cmp_max
    mov ax, sir[esi]
    cmp_max:
    cmp sir[esi],bx
    JLE urmator
    mov bx, sir[esi]
    urmator:
    inc esi   
    loop et_loop
   
    mov min, ax
    mov max, bx
   
   
    ;apel functie exit
    push 0
    call exit
end start

Varianta 2

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir dw 10,21,3,14,2,-22,11
lgsir dd $-sir
min dw 0
max dw 0
   
.code
start:
   
    mov eax, 0
    mov ebx, 0; ax-minim, bx-maxim
   
    mov esi, 0
    mov ecx, lgsir
    mov ax, sir[esi]
    mov bx, sir[esi]

    et_loop:
    cmp ax, sir[esi]
    JL cmp_max
    mov ax, sir[esi]
    cmp_max:
    cmp bx, sir[esi]
    JG urmator
    mov bx, sir[esi]
    urmator:
    inc esi  
    loop et_loop
   
    mov min, ax
    mov max, bx
   
    ;apel functie exit
    push 0
    call exit
end start

2. Să se scrie un program pentru calculul sumei unui şir de numere întregi reprezentate pe octet.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 1,-2,3,4,5
n db $-sir
suma db 0
   
.code
start:
    mov esi,0
    mov edx,0
    mov dl,n
    mov eax,0
    eticheta:
    add al,sir[esi]
    inc esi
    cmp esi,edx
    JB eticheta
   
    ;apel functie exit
    push 0
    call exit
end start

3. Să se scrie un program care numără câţi biţi de 1 sunt într-un număr întreg reprezentat pe cuvânt, păstrat în memorie. Se va utiliza instrucţiunea de deplasare logică shr, urmată de verificarea valorii regăsite în flag-ul CF.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
n dw 1580
.code
start:
    mov ax,n
    mov ebx,0
   
    eticheta:
    ;clc
    shr ax,1
    jnc next
    ;JNE next
    inc ebx
    next:
    cmp ax,0
    JNE eticheta
   
    ;apel functie exit
    push 0
    call exit
end start

4.  Să se implementeze un program care caută un string s1 în alt string s2. În caz că s1 se regăseşte, registrul EAX va conţine poziţia din s2 unde s-a găsit s1. Altfel, EAX va conţine -1 (0FFFFFFFh).

Probleme rezolvate

1.S a se scrie un program care copiaz a un sir de valori din locat, ii consecutive de memorie in alta locatie inn ordine invers a.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir1 dw 1,2,3
sir2 dw 0,0,0
.code
start:
   
    lea esi, sir1
    lea edi, sir2
   
    ;iau din primul sir si pun in stiva
    push word ptr[esi]
    add esi, 2
    push word ptr[esi]
    add esi, 2
    push word ptr[esi]
   
    ;scot de pe stiva si pun in al doilea sir
    pop word ptr[edi]
    add edi, 2
    pop word ptr[edi]
    add edi, 2
    pop word ptr[edi]
   
    ;apel functie exit
    push 0
    call exit
end start

2. S a se scrie un program pentru adunarea a dou a matrici bidimensionale.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
m1 db 1,2,3
   db 4,5,6
m2 db 7,8,9
   db 10,11,12       
.code
start:
    mov eax, 0 ;in ax se vor pastra sumele elementelor de pe aceeasi
                  ;pozitie
   
    mov esi, 0 ;pentru parcurgerea liniilor
    mov ebx, 0 ;pentru parcurgerea coloanelor   
   
    ;suma prima linie
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al ;rezultatul se pastreaza in matricea m1
   
    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    ;suma a doua linie
    mov al, 0
    mov esi, 0
    ;bx se aduna cu 3
    add ebx, 3
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al

    mov al, 0
    inc esi
    add al, m1[ebx][esi]
    add al, m2[ebx][esi]
    mov m1[ebx][esi], al
   
   
    ;apel functie exit
    push 0
    call exit
end start

Probleme propuse

1. S a se scrie un program care calculeaz a media unui sir de numere intregi din memorie.
Numerele sunt de tip octet. Media va memorat a ca valoare i ntreaga i ntr-o variabil a de tip octet.

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 1,2,3,4,4 ;sirul
cat db 0 ;catul mediei
restul db 0 ;restul mediei
.code
start:

    lea esi,sir ;trebuie copiat sirul in esi pentru a-l parcurge
    mov eax,0 ;initialiarea registrului pentru suma cu 0

    add al,[esi] ;adaugarea primului element in registrul suma
    add esi,1 ;referirea la urmatorul element
    add al,[esi]
    add esi,1
    add al,[esi]
    add esi,1
    add al,[esi]
    add esi,1
    add al,[esi]
   
    mov ecx,5 ;initializarea registrului ecx (cl) cu 5 - 5 elemente in sir
    mov edx,eax ;salvarea sumei in edx
   
    div cl ;impartirea lui al la cl (5) pentru a calcula media
    ;in AL (bitii 1,2 de la dreapta) - catul, in AH (bitii 3,4 de la dreapta) - restul
    mov cat,al ;cat contine catul mediei aritmetice
    mov restul,ah ;restul contine restul mediei aritmetice
   
    ;apel functie exit
    push 0
    call exit
end start

2. S a se scrie un program care i nsumeaz a salariile unor angajati. Datele referitoare la
angajati se p astreaz a i ntr-un tablou de i nregistr ari.
Exemplu tablou de ^inregistr ari:

1 ANGAJAT struct
2 nume DB 20 dup(0)
3 salariu DW 0
4 ANGAJAT ends
5
6 nrAngajati DW 4
7 angajati ANGAJAT {"georgescu", 100}, {"pop", 100},
8 {"popescu", 300}, {"ionescu", 450}

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
;structura ANGAJAT cu doua campuri, nume (de 20 de ori cate un bit) si salariu (2 biti)
ANGAJAT struct
nume DB 20 dup(0)
salariu DW 0
ANGAJAT ends

;declararea unui vector de tip ANGAJAT
nrAngajati DW 4
angajati ANGAJAT {"georgescu", 1}, {"pop", 1},
{"popescu", 3}, {"ionescu", 4}
.code
start:
    lea esi,angajati ;mutam vectorul de tip ANGAJAT in esi
    mov eax,0 ;registru pentru suma salariilor
   
    add ax,word ptr[esi+20] ;se aduna primul salariu (pentru referirea la salariu se aduna 20 de biti (se sare peste
    ;cei pentru nume))
    add esi,22 ;trecerea la al doilea element al vectorului (se sare peste 20 de biti pt nume si inca 2 pentru
    ;salariu)
    add ax,word ptr[esi+20] ;se aduna pe ax pentru a fi de aceeasi lungime (ax - 16 biti, salariu - 16 biti)
    add esi,22
    add ax,word ptr[esi+20]
    add esi,22
    add ax,word ptr[esi+20]
   
    ;suma se pastreaza in eax
    ;apel functie exit
    push 0
    call exit
end start

3. Folosind doar instructiunile push si pop, scrieti un program care roteste registrii
EAX, EBX, ECX si EDX (valoarea din EAX merge in EBX, din EBX i n ECX, din ECX i n
EDX iar din EDX in EAX).

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data

.code
start:
    mov eax,1 ;initializarae registrilor
    mov ebx,2
    mov ecx,3
    mov edx,4
   
    push eax
    push ebx
    push ecx
    push edx
   
    pop eax
    pop edx
    pop ecx
    pop ebx
   
    ;apel functie exit
    push 0
    call exit
end start

4. Intr-un sir de 2n - 1 elemente se g asesc i ntr-o ordine aleatoare toate numerele de
la 1 la n, de dou a ori fi ecare, mai putin un num ar k care se g aseste o singur a dat a.
Scrieti un program care g aseste num arul k. 

.386
.model flat, stdcall
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;includem msvcrt.lib, si declaram ce functii vrem sa importam
includelib msvcrt.lib
extern exit: proc
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;declaram simbolul start ca public - de acolo incepe executia
public start
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;sectiunile programului, date, respectiv cod
.data
sir db 1,2,1,3,4,3,5,5,6,6,4
lung DB $-sir ;punem lungimea sirului sir in variabila lung
i db 2 ;variabila pentru inmultire/impartire cu 2 (formula sumei primelor n nr nat)
.code
start:

    mov eax,0
    mov ebx,0
    mov cl,lung ;lungimea sirului in cl
    mov edx,0
    lea esi,sir
   
    eticheta:
    add al, [esi+ebx] ;suma elementelor din sir va fi in AL (EAX)
    inc bl ;indicele pentru parcurgerea sirului
    cmp bl,cl ;conditia de continuare (indicele < lungimea)
    jb eticheta ;jump la eticheta daca bl<cl
   
    mov ebx,0
    inc cl ;pentru calculul sumei de la 1 la n
    push eax
    mov eax,ecx
    div i ;se calculeaza de fapt pana la n, impartire cu 2
   
    mov ecx,eax ;formula pt suma primelor n nr nat (dar luata de 2 ori, nu se mai face impartirea la 2)
    add ecx, 1
    mul ecx
    mov ecx, 0
    pop ecx
   
    ;in eax avem de 2 ori suma de la 1 la n
    ;in ecx avem suma elementelor din sir
    sub eax, ecx
    ;in eax vom avea diferenta dintre suma de la 1 la n (de 2 ori) si suma el din vector
    ;adica chiar valoarea care apare o singura data in sir
   
   
    ;apel functie exit
    push 0
    call exit
end start

Adunarea a două matrici, scăderea a două matrici, afisarea unei matrici, calculul mediei aritmetice a elementelor unei matrici + clasă de test pentru medie

Main.java

package ro.utcluj.poo.lab3matrix;

public class Main {

    public static void main(String[] args) {
        Matrice a1,a2,a3;
        int[][] p=new int[][] {{1,2},{3,4}};
        int[][] pp=new int[][] {{1,2},{3,4}};
        a1=new Matrice(2, 2, p);
        a2=new Matrice(2,2,pp);
        a3=a1.add(a2);
        a1.Afisare();
        a2.Afisare();
        a3.Afisare();
   
        System.out.println(a1.Medie());
        System.out.println(a2.Medie());
        System.out.println(a3.Medie());
    }

}

Matrice.java

package ro.utcluj.poo.lab3matrix;

public class Matrice {
    private int[][] a;
    private int n,m;
    public Matrice(int n, int m, int[][] a)
    {
        this.a = new int[n][m];
        int i,j;
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
                this.a[i][j] = a[i][j];
        //this.a=a;
        this.n=n;
        this.m=m;
    }
   
    public void Afisare()
    {
        int i,j;
        for(i=0;i<n;i++)
            {for(j=0;j<m;j++)
                System.out.print(a[i][j]+" ");
            System.out.println();
            }      
    }
   
    public Matrice add(Matrice mm)
    {
        Matrice x;
        x=new Matrice(this.n,this.m,this.a);
        int i,j;
        x.n=this.n;
        x.m=this.m;
        for(i=0;i<this.n;i++)
            for(j=0;j<this.m;j++)
                x.a[i][j]=mm.a[i][j]+this.a[i][j];
        return x;
    }
   
    public Matrice scadere(Matrice mm)
    {
        Matrice x;
        x=new Matrice(this.n,this.m,this.a);
        int i,j;
        x.n=this.n;
        x.m=this.m;
        for(i=0;i<this.n;i++)
            for(j=0;j<this.m;j++)
                x.a[i][j]=-mm.a[i][j]+this.a[i][j];
        return x;
    }
   
    public double Medie()
    {
        int i,j;
        double s=0;
        for(i=0;i<this.n;i++)
            for(j=0;j<this.m;j++)
                s=s+this.a[i][j];
        double m;
        m=s/(this.n*this.m);
        return m;
    }

   
   
    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

MatriceTest.java

package ro.utcluj.poo.lab3matrix;

import static org.testng.Assert.assertEquals;

import org.testng.annotations.Test;

public class MatriceTest {

  @Test
  public void Medie() {
      Matrice a1=new Matrice(2,2,new int[][] {{1,2},{3,4}});
      assertEquals(a1.Medie(),2.5,0.01);
    //throw new RuntimeException("Test not implemented");
  }
}

Surse de tensiune continua

Redresor cu filtru

D1 1 2 di
D2 1 0 di
D3 3 0 di
D4 3 2 di
C1 2 0 1m
R1 2 0 100
Vin 1 3 sin(0 10 50k 0 0)
.model di D
.model di D tt=1e-9  //  tt transit time

Redresor cu filtru

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 30m
R1 2 0 100
Vin 1 3 sin(0 10 50 0 0)
.model di D
.model di D tt=1e-9

Cu afisarea curentului i(vin) pe grafic

Redresor cu filtru

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 30m
R1 2 0 10
Vin 1 3 sin(0 10 50 0 0)
.model di D
.model di D tt=1e-9

Stabilizator parametric cu dioda Zener

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 1m
Rb 2 out 30
D5 out 0 zener
Rs 0 out 100
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6

Stabilizator parametric cu dioda Zener

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 10m
Rb 2 out 30
D5 out 0 zener
Rs 0 out 100
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6

Stabilizator cu reactie fara amplificator de eroare (sursa cu tranzistor)

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 1m
Rb 2 vz 400
D5 0 vz zener
Rs 0 out 100
Q1 2 vz out tranz
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6
.model tranz NPN tr=1e-9 tf=1e-9

Stabilizator cu reactie fara amplificator de eroare (sursa cu tranzistor)

D1 1 2 di
D2 0 1 di
D3 0 3 di
D4 3 2 di
C1 2 0 1m
Rb 2 vz 50
D5 0 vz zener
Rs 0 out 100
Q1 2 vz out tranz
Vin 1 3 sin(0 10 50 0 0)
.model di D tt=1e-9
.model zener D bv=5.6
.model tranz NPN tr=1e-9 tf=1e-9

//Prob 1 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 15; f[x_] := Sin[Pi * x];
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 2 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 15; f[x_] := 1/(1 + 25*x^2);
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 3 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := Cos[(2 i + 1)*Pi/(2 n + 2)];
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 15; f[x_] := 1/(1 + 25*x^2);
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 4.2 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 20; f[x_] := Abs[x];
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]},
 PlotRange -> All]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 4.3 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := Cos[(2 i + 1)*Pi/(2 n + 2)];
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 20; f[x_] := Abs[x];
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]

//Prob 5 : primul grafic f(x) - cu rosu; Ln - cu verde; graficul al doilea - eroarea

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 3; f[x_] := x^3 + 2 x^2 - 17 x + 23;
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]},
 PlotRange -> All]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]
Simplify[L[f, n, x]]

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 3; f[x_] := x^3 + 3 x^2 - 2 x + 20;
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]},
 PlotRange -> All]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]
Simplify[L[f, n, x]]

X =.; X[i_, n_] := Cos[(2 i + 1)*Pi/(2 n + 2)];
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];
L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 3; f[x_] := x^3 + 3 x^2 - 2 x + 20;
Plot[Evaluate[{f[x], L[f, n, x]}], {x, -1, 1},
 PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0]}]
Plot[Evaluate[Abs[f[x] - L[f, n, x]]], {x, -1, 1}, PlotRange -> All]
Simplify[L[f, n, x]]

X = {1, 2, 3, 4, 5, 6}; f[x_] := x^5; n = Length[X] - 1;
t = Table[0., {i, 1, n + 1}, {j, 1, n + 1}];
For[i = 1, i <= n + 1, i++, t[[i, 1]] = f[X[[i]]];]; MatrixForm[t];
For[j = 2, j <= n + 1, j++,
 For[i = 1, i <= n + 2 - j, i++,
  t[[i, j]] = (t[[i + 1, j - 1]] - t[[i, j - 1]])/(X[[j + i - 1]] -
       X[[i]]);]]
MatrixForm[t]

X = {-1, -1/2, 0, 1/2, 1} ; f[x_] := Sin[Pi*x]; n = Length[X] - 1;
t = Table[0., {i, 1, n + 1}, {j, 1, n + 1}];
For[i = 1, i <= n + 1, i++, t[[i, 1]] = f[X[[i]]];]; MatrixForm[t];
For[j = 2, j <= n + 1, j++,
 For[i = 1, i <= n + 2 - j, i++,
  t[[i, j]] = (t[[i + 1, j - 1]] - t[[i, j - 1]])/(X[[j + i - 1]] -
       X[[i]]);]]
MatrixForm[t]

Newt[f_, x_, n_] :=
  f[X[[1]]] +
   Sum[Product[(x - X[[j]]), {j, 1, i}]*t[[1, i + 1]], {i, 1, n}];
Simplify[Newt[f, x, n]]

X =.; X[i_, n_] := -1 + 2 i/n;
l[i_, n_, x_] :=
  Product[If[i == j, 1, (x - X[j, n])/(X[i, n] - X[j, n])], {j, 0,
    n}];

L[f_, n_, x_] := Sum[f[X[i, n]]*l[i, n, x], {i, 0, n}];
n = 4; f[x_] := Sin[Pi*x];
Simplify[L[f, n, x]]