Archive for octombrie 2014

[POO] 28 octombrie - Lab 4 - Lucru cu Matrici

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");
}
}

marți, 28 octombrie 2014 by DlMuresan
Categories: clase, java, matrici, obiecte, poo, teste poo | Leave a comment

[CAN] 23 octombrie - Lab 3

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

joi, 23 octombrie 2014 by DlMuresan
Categories: can | Leave a comment

[CN] 20 octombrie - Lab 2

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

luni, 20 octombrie 2014 by DlMuresan
Categories: cn | Leave a comment

[PLA] 17 octombrie - Lab 3

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

vineri, 17 octombrie 2014 by DlMuresan
Categories: PLA | Leave a comment

[CAN] 16 octombrie - Lab 2

Dioda permite trecere curentului doar într-un singur sens (nu trec alternanţele negative, în acest caz). În AIM-Spice se trece întâi nodul de la + al diodei. Tensiune de prag - până la o anumită tensiune, dioda nu se deschide.

Redresor monoalternanta
D1 1 2 dioda
.model dioda D
R1 2 0 100
Vin 1 0 sin(0 10 1k 0 0)

Redresor dublu alternanta
D1 1 2 di
D2 0 1 di
D3 0 3 di
R1 2 0 100
D4 3 2 di
Vin 1 3 sin(0 10 1k 0 0)
.model di D

Redresor dublu alternanta azi 16.10
D1 1 2 di
D2 0 1 di
D3 0 3 di
R1 2 0 100
D4 3 2 di
Vin 1 3 sin(0 10 1k 0 0)
.model di D

joi, 16 octombrie 2014 by DlMuresan
Categories: can, dioda, dublu alternanta, monoalternanta, redresor | Leave a comment

[POO] 14 octombrie - Lab 2 - Suma 2 la n

Sa se calculeze suma 2^0+2^1+...+2^n

package ro.utcluj.poo.lab02;
import java.math.BigInteger;
public class Suma2n {
public static void main(String[] args) {
// TODO Auto-generated method stub
BigInteger s,p,c;
/*s=new BigInteger("2");
c=new BigInteger("-1");
s = s.pow(64);
s = s.add(c);
System.out.println(s.toString());*/
p=new BigInteger("1");
c=new BigInteger("2");
s=new BigInteger("0");
int i,n;
n=63;
for(i=0;i<=n;i++)
{
s=s.add(p);
p=p.multiply(c);
//System.out.println(s.longValue());
}
System.out.println(s.longValue());
}
}

Cu functie si test

package ro.utcluj.poo.lab02;
import java.math.BigInteger;
public class Suma2n {
public int putere(double n){
int s,p,c;
int i;
s=0;
p=1;
c=2;
for(i=0;i<=n;i++)
{
s=s+p;
p=p*c;
}
return s;
}
public static void main(String[] args) {
}
}

Test

package ro.utcluj.poo.lab02;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import org.testng.annotations.BeforeMethod;
import static org.testng.Assert.*;
public class Suma2nTest {
Suma2n main;
@BeforeClass
public void init(){
main = new Suma2n();
}
@DataProvider
public Object[][] valoriDeTest(){
return new Double[][]{
{2.0, 7.0, 0.001},
{3.0,15.0, 0.01},
{4.0,31.0,0.01}
};
}

@Test(dataProvider = "valoriDeTest")
public void get(double input, double expected, double precision) {
double result = main.putere(input);
assertEquals(result, expected,precision);
}
}

marți, 14 octombrie 2014 by DlMuresan
Categories: java, poo | Leave a comment

[CN] 13 octombrie - Lab 1

Să se afişeze termenii 1-30 ai şirurilor recurente x(k)=(n+1)x(k-1)-1 pentru valorile 1-10 ale lui n şi eroarea de calcul pentru fiecare termen.

For[n = 1, n < 11, n++,
v = Table[0, {i, 1, 30}];
x = N[1/n, 50];
For[k = 1, k < 31, k++,
   x = (n + 1)*x - 1;
   v[[k]] = x;]
Print["n=", n, " val rec ", MatrixForm[N[v]], " erorile ",
   MatrixForm[Abs[v - 1/n]]]]

Să se afişeze termenii 1-30 ai şirului dat de Integrala de la 0 la 1 din x^n/(x+5)

j = NIntegrate[1/(x + 5), {x, 0, 1}];
N[j]
x =.;
For[n = 1, n < 31, n++,
j = 1/n - 5 j;
Print["n=", n, " val.rec ", j, " eroare ",
Abs[j - NIntegrate[x^n/(x + 5), {x, 0, 1}]]]]
N[log[1.2], 10]

Să se aproximeze funcţia Sinus pentru un x dat folosind Polinomul lui Taylor. Să se afişeze valoarea calculată cu Taylor şi valoarea corectă Sin[x]

x = N[\[Pi]/4 + 40*\[Pi]];
While[x > 2 Pi,
x = x - 2 Pi;]
While[x < 0,
x = x + 2 Pi;]
s = 0;
t = x;
k = 1;
While[Abs[t] > 10^(-15),
s = s + t;
t = -x^2/(2 k)/(2 k + 1)*t;
k = k + 1;]
Print["x=", N[x, 20], " aprox. ", N[s, 20], " val.corecta ", Sin[x]]

luni, 13 octombrie 2014 by DlMuresan
Categories: cn, integrale, mathematica, recurenta, siruri | Leave a comment

[PLA] 10 octombrie - Lab 2

Ex1

.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
var1 DB 10,2,3,14
var2 DW 15,6,7,8
var3 DD 1020A0h, 011223344h, 01A2B3C4Dh
var4 equ 10
var5 DB '1', '2', "abc"
var6 DB 4 DUP(5)

.code
start:
    mov eax, 0
    mov al, var1
    mov ah, 11
    mov ebx, 0
    mov bx, var2
    mov ecx, var3
    mov edx, var4
    add ecx, edx
    mov dl, var5
    mov dh, var6

    ;terminarea programului
    push 0
    call exit
end start

Model

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

;includem biblioteci, 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
;aici declaram date
sir db 1,2,3
.code
start:
    ;aici se scrie codul
    mov si,0
    mov bx,0
    mov ax, sir[bx+si+1]

    ;terminarea programului
    push 0
    call exit
end start

vineri, 10 octombrie 2014 by DlMuresan
Categories: PLA | Leave a comment

[CAN] 9 octombrie - Lab 1

Reguli
1. Primul rând este întotdeauna un comentariu
2. Se scrie o singură componentă pe linie
select C1 - Shift+F1 - Help
C1 in (nod) out (nod)
3. Nu se speciufică unitatea de măsură (doar multipli sau submultipli)
4. Nodul de la masă se notează întotdeauna cu 0
5. Ordinea componentelor este arbitrară
6. * sau ! la începutul rândului îl transformă în comentariu
7. Nu se lasă spaţiu la începutul rândului
8. Prima poziţie pe rând este piesa (elementul de circuit)

RC trece jos
R1 in out 1k
C1 out 0 470n
!Vin in 0 dc 5 sin(0 5 200 0 0)
Vin in 0 dc 5 pulse(0 5 0 0.01e-3 0.01e-3 0.2e-3 0.4e-3)

RC trece jos
R1 in out 1k
C1 out 0 4,7n
!Vin in 0 dc 5 sin(0 5 200 0 0)
Vin in 0 dc 5 pulse(0 5 0 0.01e-4 0.01e-4 0.2e-4 0.4e-4)

RC trece sus
C1 in out 2500n
R1 out 0 1k
!Vin in 0 dc 5 sin(0 5 10k 0 0)
Vin in 0 dc 5 pulse(0 5 0 0.01e-3 0.01e-3 0.2e-2 0.4e-2)

joi, 9 octombrie 2014 by DlMuresan
Categories: aim-spice, can, rc trece jos, rc trece sus | Leave a comment

Faculty

Meniu

Orar semigroup #2

INTEGRALE