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]]

Ex1 - Expresia EAX = 7EAX - 2EBX - EBX/8 folosind instrucţiuni de deplasare

.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:
    ;initializez pe eax si ebx cu valori oarecare
    mov eax, 2
    mov ebx, 12
   
    ;pastrez vechea valoare a lui eax in edx
    mov edx, eax

    ;eax*7 = eax*8 - aex
    ;eax*8 = eax << 3 (eax deplasat aritmetic la stanga cu 3 pozitii)
    mov ecx, 3
    sal eax, cl
   
    ;eax=eax*7
    sub eax, edx
   
    ;pastrez vechea valoare a lui ebx in edx
    mov edx, ebx
   
    ;ebx*2
    sal ebx, 1

    ;eax = eax-ebx*2
    sub eax, ebx
   
    mov ebx, edx
    ;ebx/8 = ebx >> 3 (deplasare la dreapta cu 3 pozitii)
    sar ebx, cl
   
    sub eax, ebx
   
    ;apel functie exit
    push 0
    call exit
end start

Problemă propusă. Expresia EAX = 7EAX - 2EBX - EBX/8 folosind instrucţiuni aritmetice

.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:
    ;initializez pe eax si ebx cu valori oarecare
    mov eax, 2
    mov ebx, 12
   
mov cl,7
mul cl
mov edx,eax
mov eax,ebx
mov cl,2
mul cl
sub edx,eax
mov eax,ebx
mov cl,8
div cl
sub edx,eax
mov eax,edx
   
    ;apel functie exit
    push 0
    call exit
end start

Ex2 - Să se scrie un program în LA care generează un întreg reprezentabil pe octet şi îl pune în locaţia de memorie rez după formula: rez=AL*num1 + num2*AL + BL. rez, num1 şi num 2 sunt valori reprezentate pe octet, aflate î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
NUM1 DB 10
NUM2 DB 5
REZ DB 0

.code
start:
    ;initializam pe eax cu 0
    mov eax, 0
   
    ;in al si bl punem niste valori oarecare
    mov al, 2
    mov bl, 4
   
    ;pastram vechea valoare a lui al pe stiva
    push eax
   
    mov ecx, 0
    mov cl, NUM2
    ;al*NUM2
    mul cl
       
    add REZ, bl
    add REZ, al
   
    ;luam de pe stiva vechea valoare a lui al
    pop eax
    mov cl, NUM1
    ;al*NUM1
    mul cl
   
    add REZ, al
    mov dl,rez
   
    ;apel functie exit
    push 0
    call exit
end start

Varianta II. Ex2 - Să se scrie un program în LA care generează un întreg reprezentabil pe octet şi îl pune în locaţia de memorie rez după formula: rez=AL*num1 + num2*AL + BL. rez, num1 şi num 2 sunt valori reprezentate pe octet, aflate în memorie.

.386
.model flat,stdcall
includelib msvcrt.lib
extern exit:proc
public start
.data
NUM1 DB 10
NUM2 DB 5
REZ DB 0
.code
start:
mov eax,0
mov al,2
mov bl,4
mov ecx,eax
mul num1
mov rez,al
mov eax,ecx
mul num2
add rez,al
add rez,bl
mov dl,rez
push 0
call exit
end start

Problemă propusă. Să se scrie un program în LA care generează un întreg reprezentabil pe cuvânt şi îl pune în locaţia de memorie rez după formula: rez = AX * num1 + num2 * (AX + BX). rez, num1, num2 sunt valori reprezentate pe cuvânt, aflate în memorie.

.386
.model flat,stdcall
includelib msvcrt.lib
extern exit:proc
public start
.data
rez dw 0
num1 dw 10
num2 dw 5
.code
start:
mov ax,2
mov bx,4
mov cx,ax
mul num1
mov rez,ax
add cx,bx
mov ax,cx
mul num2
add rez,ax
mov dx,rez
push 0
call exit
end start