Archive for martie 2014

Lucrările 4 şi 5 VHDL - Operatori. Tipuri de date (4), Atribute (5) (25 martie)

Pachet valuta

package Myp is
type Valuta is range 0 to INTEGER'HIGH
units ban;
        RON=100 ban;
        USD=324 ban;
        EUR=440 ban;
        GBP=569 ban;
    end units;
end Myp;
-- Folosim package Myp pentru architecture
use Myp.all;

entity E is
    port(S: out Valuta);
end E;
--    architecture
architecture A of E is
signal X,Y,Z:Valuta;
begin
    X<=10 RON;
    Y<=10 USD;
    Z<=X+Y;
end A;

Registru de deplasare

entity Registru is
    port(CLK : in bit;
    SIN : in bit;
    Q: out bit_vector(3 downto 0));
end Registru;
-- Arhitectura registru de deplasare
architecture Deplasare of Registru is
begin
    process
    variable a:bit_vector(3 downto 0):= "0000";
    begin
       if (CLK='1' and CLK'EVENT) then
           a:=a sll 1;
           a(0):= SIN;
           Q<=a;
       end if;
       wait on CLK;
    end process;
end Deplasare;

Registru M3rin cu 2 clock-uri

entity Registru is
    port(SIN:in bit;
    CLKR:in bit;
    CLKL:in bit;
    Q: out bit_vector (3 downto 0));
end Registru;

architecture Gunners of Registru is
begin
    process
    variable a:bit_vector (3 downto 0):="0000";
    begin
       if (CLKL='1'and CLKL'EVENT) then
           a:=a srl 1;
           a(3):=SIN;
           Q<=a;
       end if;
       if (CLKR='1'and CLKR'EVENT) then
           a:=a sll 1;
           a(0):=SIN;
           Q<=a;
       end if;
       wait on CLKL,CLKR;
    end process;
end Gunners;

Registru stânga-dreapta în funcţie de un semnal j

entity Registru is
    port(CLK : in bit;
    SIN : in bit;
    j : in bit;
    Q: out bit_vector(3 downto 0));
end Registru;

architecture Deplasare of Registru is
begin
    process
    variable a:bit_vector(3 downto 0):= "0000";
    begin
       if (CLK='1' and (CLK'EVENT and j='1')) then
           a:=a srl 1;
           a(3):= SIN;
           Q<=a;
       end if;
       if (CLK='1' and (CLK'EVENT and j='0')) then
           a:=a sll 1;
           a(0):= SIN;
           Q<=a;
       end if;
       wait on CLK;
    end process;
end Deplasare;

Unitate aritmetico-logică

library ieee;
use ieee.std_logic_1164.all;
entity UAL is
    port(A,B:in bit_vector(3 downto 0);
    S:in bit_vector(2 downto 0);
    REZ:out bit_vector(3 downto 0));
end UAL;

library ieee;
use ieee.std_logic_1164.all;
architecture MUX of UAL is
begin
    process
    begin
       case S is
           --when "000" => REZ<=std_logic_vector(integer(A)+integer(B));
           --when "001" => REZ<=A-B;
           when "010" => REZ<=A and B;
           when "011" => REZ<=A or B;
           when "100" => REZ<=not A;
           when "101" => REZ<=A srl 1;
                          --REZ<=AA;
           when others => null;
       end case;
       wait on A,B;
    end process;
end MUX;

--library ieee;
--use ieee.std_logic_1164.all;
--entity MUX_8_1 is
--   port(
    --S:in bit_vector(2 downto 1);
    --I1:in bit_vector(3 downto 0);
    --I2:in bit_vector(3 downto 0);
    --I3:in bit_vector(3 downto 0);
--   I4:in bit_vector(3 downto 0);
    --I5:in bit_vector(3 downto 0);
    --I6:in bit_vector(3 downto 0);
    --REZ:out bit_vector(3 downto 0));
--end MUX_8_1;

luni, 31 martie 2014 by DlMuresan
Categories: atribute, operatori, pachet valuta, PSN, registru, tipuri de date, unitate aritmetico-logica, VHDL | Leave a comment

Laborator 5 - Arbori (25 martie)

Afisarea arborelui in modul DRS (rotit cu 90 de grade spre stanga, nivelul se numara de la stanga la dreapta)

void inordine2(nod *r, int nivel)
{
    if(r)
    {
        inordine2(r->dr,nivel+1);
        int i=0;
        for(i=0;i<nivel;i++)
            printf(" ");
        printf("%c",r->ch);
        inordine2(r->st,nivel+1);
    }
}

Construire, afisare, inaltime si nr de frunze

#include <stdio.h>
#include <stdlib.h>
typedef struct tip_nod
{
char ch;
struct tip_nod *st, *dr;
} nod;

void inordine_DRS(nod *r, int nivel)
{
if(r)
{
inordine_DRS(r->dr,nivel+1);
int i=0;
for(i=0; i<nivel; i++)
printf(" ");
printf("%c\n",r->ch);
inordine_DRS(r->st,nivel+1);
}
}

nod* construire()
{
nod *p;
int n;
char c;
n=sizeof(nod);
printf("Cititi: ");
fflush(stdin);
scanf("%c",&c);
if(c=='*')
return 0;
else
{
p=(nod *)malloc(n);
p->ch=c;
p->st=construire();
p->dr=construire();
}
return p;
}

int nr_frunze2(nod *p)
{
int nr=0;
if(p==NULL) return 0;
else if (p->st==NULL && p->dr==NULL)
return 1;
else nr=nr_frunze2(p->st)+nr_frunze2(p->dr);
return nr;
}

void inaltime3(nod *p, int *h)
{
if(p==0)
*h=0;
else
{
int h1=0;
inaltime3(p->st,&h1);
int h2=0;
inaltime3(p->dr,&h2);
if(h1>h2)
*h=h1+1;
else *h=h2+1;
}
}

int main()
{
nod *r;
r=construire();
inordine_DRS(r,0);
int hmax=0,nr=0;
nr=nr_frunze2(r);
inaltime3(r,&hmax);
printf("\nInaltime: %d\nNr frunze: %d",hmax,nr);
printf("\nApasati o tasta pentru terminare");
getch();
return 0;
}

Să se scrie o funcţie care determină înălţimea unui arbore binar.

void inaltime3(nod *p, int *h)
{
if(p==0)
*h=0;
else
{
int h1=0;
inaltime3(p->st,&h1);
int h2=0;
inaltime3(p->dr,&h2);
if(h1>h2)
*h=h1+1;
else *h=h2+1;
}
}

Să se scrie o funcţie care determină numărul de frunze ale unui arbore binar.

int nr_frunze2(nod *p)
{
int nr=0;
if(p==NULL) return 0;
else if (p->st==NULL && p->dr==NULL)
return 1;
else nr=nr_frunze2(p->st)+nr_frunze2(p->dr);
return nr;
}

marți, 25 martie 2014 by DlMuresan
Categories: arbori, arbori binari, Laborator, sda | Leave a comment

Lucrarea 3 VHDL - Semnale. Parametri generici. Constante (18 martie)

Memorie ROM (ieşirea pe un bit)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity rom is
    port (A:in std_logic_vector(3 downto 0);
    C:out std_logic);
end rom;

architecture Arch of rom is
signal Harta:std_logic_vector (15 downto 0):="0110100110101010";
begin
    C<=Harta(CONV_INTEGER(A));
end Arch;

Xilinx

NET "A(3)" LOC=T5;
NET "A(2)" LOC=V8;
NET "A(1)" LOC=U8;
NET "A(0)" LOC=N8;
NET "C" LOC=U16;

Memorie ROM (ieşirea pe doi biţi)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity rom is
    port (A:in std_logic_vector(3 downto 0);
    C:out std_logic_vector(1 downto 0));
end rom;

architecture Arch of rom is
type MM is array(15 downto 0) of std_logic_vector (1 downto 0);
signal Harta:MM:=("00","01","11","10","11","11","11","00","01","10","01","11","10","11","11","11");
begin
    C<=Harta(CONV_INTEGER(A));
end Arch;

Memorie RAM (ieşirea pe doi biţi)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity RAM is
    port (WE:in std_logic;
    A:in std_logic_vector (3 downto 0);
    DIN:in std_logic_vector (1 downto 0);
    C:out std_logic_vector (1 downto 0));
end RAM;

architecture Arch of RAM is
type MM is array (15 downto 0) of std_logic_vector(1 downto 0);
signal Harta:MM:=("00","01","10","11","00","01","10","11","00","01","10","11","00","01","10","11");
begin
    process
    begin
       if (WE='0') then
           C<=Harta(CONV_INTEGER(A));
       end if;
       if(WE='1') then
           Harta(CONV_INTEGER(A))<=DIN;
       end if;
    wait on WE,A,DIN;
    end process;
end Arch;

duminică, 23 martie 2014 by DlMuresan
Categories: constante, Laborator, memorie ram, memorie rom, parametri generici, PSN, semnale, VHDL | Leave a comment

Laborator 4 - Liste circulare dublu inlantuite (18 martie)

Din fisier se citesc, caracter cu caracter, n caractere; să se creeze o listă dublu înlănţuită, care să conţină în noduri caracterele distincte şi frecvenţa lor de apariţie. Lista va fi ordonată alfabetic. Se vor afişa caracterele şi frecvenţa lor de apariţie a) în ordine alfabetică crescătoare şi b) în ordine alfabetică descrescătoare.

#include <stdio.h>
#include <stdlib.h>
typedef struct nodtype
{
    char s[20];
    int a;
    struct nodtype *urm;
    struct nodtype *prec;
} nod;

void adaug(nod **prim,nod **ultim,char s[])
{
    nod *p;
    p=(nod *)malloc(sizeof(nod));
    strcpy(p->s,s);
    p->urm=NULL;
    p->prec=NULL;
    p->a=1;

    if (!(*prim))
    {
        (*prim)=p;
        (*ultim)=p;
        return 0;
    }
    else
    {
        if (!(*prim)->urm)
        {
            if (strcmp(p->s,(*prim)->s)<0)
            {
                p->urm=(*prim);
                (*ultim)=(*prim);
                (*prim)=p;
                (*ultim)->prec=p;
                return 0;
            }
            else
            {
                if (strcmp(p->s,(*prim)->s)>0)
                {
                    p->prec=(*prim);
                    (*prim)->urm=p;
                    (*ultim)=p;
                    return 0;
                }
                else
                {
                    (*prim)->a=(*prim)->a+1;
                    return 0;
                }
            }
        }
    }

    nod *q;
    q=(nod *)malloc(sizeof(nod));
    q=(*prim);

    if (strcmp(p->s,q->s)<0)
    {
        p->urm=(*prim);
        (*prim)->prec=p;
        (*prim)=p;
        return 0;
    }

    while (strcmp(p->s,(q->urm)->s)>0)
    {
        q=q->urm;
        if (!q->urm)
            break;
    }
    if (!q)
    {
        p->prec=(*ultim);
        (*ultim)->urm=p;
        (*ultim)=p;
        return 0;
    }
    if (q->urm && strcmp(p->s,(q->urm)->s)==0)
    {
        (q->urm)->a=(q->urm)->a+1;
        return 0;
    }

    if (strcmp(p->s,q->s)==0)
        q->a=q->a+1;
    else
    {
        if (q!=(*ultim))
        {
            p->urm=q->urm;
            p->prec=q;
            (q->urm)->prec=p;
            q->urm=p;
        }
        else
        {
            p->prec=(*ultim);
            (*ultim)->urm=p;
            (*ultim)=p;
        }
    }
}

void afisare(nod *prim)
{
    while (prim)
    {
        printf("%s - %d\n",prim->s,prim->a);
        prim=prim->urm;
    }
    printf("\n");
}

int main()
{
    char s[20];
    FILE *f;
    nod *prim,*ultim;
    prim=(nod *)malloc(sizeof(nod));
    ultim=(nod *)malloc(sizeof(nod));
    prim=NULL;
    ultim=NULL;

    f=fopen("in.txt","r");

    while (!feof(f))
    {
        fscanf(f,"%s",s);
        adaug(&prim,&ultim,s);
    }
    afisare(prim);
    printf("\nTastati o tasta pentru terminare");
    getch();
    return 0;
}

Fisier in.txt

sepcile
rosii
u
u
haide
haide
u
u
sepcile
u
u
u
rosii
stadion
noi
universitatea

marți, 18 martie 2014 by DlMuresan
Categories: citire din fisier, liste, liste circulare dublu inlantuite, liste dublu inlantuite | 6 comments

Laborator 3 - Liste circulare simplu inlantuite (11 martie)

De la tastatură se citeşte numărul n şi numele a n copii. Să se simuleze următorul joc: cei n copii stau într-un cerc. Începând cu un anumit copil, se numără copiii în sensul acelor de ceasornic. Fiecare al n-lea copil iese din cerc. Câştigă ultimul copil rămas în joc.

#include <stdio.h>
#include <stdlib.h>
typedef struct n
{
char nume[20];
struct n *urm;
} nod;
void adaugare(nod **prim, nod **ultim, char nume[])
{
nod*p;
p=(nod*)malloc(sizeof(nod));
strcpy(p->nume,nume);
if((*prim)==NULL)
{
*prim=p;
*ultim=p;
(*prim)->urm=p;
(*ultim)->urm=p;
}
else
{
p->urm=(*ultim)->urm;
(*ultim)->urm=p;
*ultim=p;
}
}
void afisare(nod *prim, nod *ultim)
{
nod *p;
p=prim;
do
{
printf("%s | ",p->nume);
p=p->urm;
}
while(p!=prim);
printf("\n\n");
}
void joc(nod **prim, nod **ultim, int n)
{
int i=1;
nod *q=*prim,*p;
while(*prim!=*ultim)
{
for(i=1;i<=n-1;i++)
{
q=q->urm;
}
p=q->urm;
// if(p!=*prim && p!=*ultim)
q->urm=p->urm;
if(p==*prim)
{
// (*ultim)->urm=p->urm;
*prim=p->urm;
}
if(p==*ultim)
{
*ultim=q;
// (*ultim)->urm=prim;
}
afisare(*prim,*ultim);
}
}
int main()
{
nod *prim=NULL, *ultim=NULL, *p;
int i,n;
printf("n=");
scanf("%d",&n);
char nume[20];
printf("Cititi cele %d nume\n",n);
for(i=1;i<=n;i++)
{
printf("%d. ",i);
scanf("%s",nume);
adaugare(&prim,&ultim,nume);
}
afisare(prim,ultim);
joc(&prim,&ultim,n);
printf("\nTastati o tasta pentru terminare");
getch();
return 0;
}

Varianta 2

typedef struct n
{
char nume[20];
struct n *urm;
} nod;
typedef struct
{nod *prim;
nod *ultim;
int lungime;
}lista;
void adaugare(lista *l);
void afisare(lista *l);
void joc(lista *l, int n);

----------------------------------

#include <stdio.h>
#include <stdlib.h>
typedef struct n
{
    char nume[20];
    struct n *urm;
} nod;

typedef struct l
{
    nod *prim;
    nod *ultim;
    int lungime;
} lista;

void adaugare(lista *l,char nume[])
{
    nod*p;
    p=(nod*)malloc(sizeof(nod));
    strcpy(p->nume,nume);
    if((*prim)==NULL)
    {
        *prim=p;
        *ultim=p;
        (*prim)->urm=p;
        (*ultim)->urm=p;
    }
    else
    {
        p->urm=(*ultim)->urm;
        (*ultim)->urm=p;
        *ultim=p;
    }
}

void afisare(lista *l)
{
    nod *p;
    p=prim;
    do
    {
        printf("%s | ",p->nume);
        p=p->urm;
    }
    while(p!=prim);
    printf("\n\n");
}

void joc(lista *l, int n)
{
    int i=1;
    nod *q=*prim,*p;
    while(*prim!=*ultim)
    {
        for(i=1; i<=n-1; i++)
        {
            q=q->urm;
        }
        p=q->urm;
        //   if(p!=*prim && p!=*ultim)
        q->urm=p->urm;
        if(p==*prim)
        {
            // (*ultim)->urm=p->urm;
            *prim=p->urm;
        }
        if(p==*ultim)
        {
            *ultim=q;
            // (*ultim)->urm=prim;
        }
        afisare(*prim,*ultim);
    }
}

int main()
{
    nod *prim=NULL, *ultim=NULL, *p;
    int i,n;
    lista *l;
    printf("n=");
    scanf("%d",&n);
    char nume[20];
    printf("Cititi cele %d nume\n",n);
    for(i=1; i<=n; i++)
    {
        printf("%d. ",i);
        scanf("%s",nume);
        adaugare(&l,nume);
    }
    afisare(l);
    joc(&l,n);
    printf("\nTastati o tasta pentru terminare");
    getch();
    return 0;
}

TEMA
Să se conceapă o stuctură dinamică eficientă pentru reprezentarea matricelor rare. Să se scrie operaţii de calcul a sumei a două matrice rare. Afisarea se va face in forma naturală.

#include <stdio.h>
#include <stdlib.h>
typedef struct nod
{
int i,j,val;
struct nod *urm;
}nod;

typedef struct
{
int nrl;
int nrc;
nod *prim;
nod *ultim;
int nrelem;
}matrice;

void citire(nod **p)
{
(*p)=NULL;
nod *x;
int i,n;
int linie,coloana,valoare;
printf("Nr. de valori diferite de 0: ");
scanf("%d",&n);
printf("Cititi linie, coloana, valoare:\n");
for(i=1;i<=n;i++)
{
scanf("%d",&linie);
scanf("%d",&coloana);
scanf("%d",&valoare);
x=(nod*)malloc(sizeof(nod));
x->i=linie;;
x->j=coloana;
x->val=valoare;
x->urm=(*p);
(*p)=x;
}
}

void maxim(nod *a, nod *b, int *imax, int *jmax)
{
*imax=*jmax=0;
int i;
while(a)
{
if(a->i > *imax)
*imax=a->i;
if(a->j > *jmax)
*jmax=a->j;
a=a->urm;
}
while(b)
{
if(b->i > *imax)
*imax=b->i;
if(b->j > *jmax)
*jmax=b->j;
b=b->urm;
}
}

void afisare(nod*p)
{
printf("\n");
if(p==NULL)
{
printf("Lista goala");
exit(1);
}

while(p!=0)
{
printf("%d ",p->i);
printf("%d ",p->j);
printf("%d\n",p->val);
p=p->urm;
}
printf("\n");
}

nod* cautare(nod *s,int i,int j)
{
while(s)
{
if(s->i==i && s->j==j)
return s;
else s=s->urm;
}
return 0;
}

void suma(nod *a, nod *b, nod **s)
{
nod *x;
*s=NULL;
while(a)
{
if(cautare(b,a->i,a->j))
{ x=(nod*)malloc(sizeof(nod));
x->i=a->i;
x->j=a->i;
x->val=a->val+b->val;
x->urm=(*s);
(*s)=x;
}
else
{
x=(nod*)malloc(sizeof(nod));
x->i=a->i;
x->j=a->i;
x->val=a->val;
x->urm=(*s);
(*s)=x;
}
a=a->urm;
}

while(b)
{
if(cautare(a,b->i,b->j)==0 && cautare(*s,b->i,b->j)==0)
{
x=(nod*)malloc(sizeof(nod));
x->i=b->i;
x->j=b->i;
x->val=b->val;
x->urm=(*s);
(*s)=x;
}
b=b->urm;
}

}

void afisare_matrice(nod *s,int imax, int jmax)
{
int i,j;
nod *p;
for(i=1;i<=imax;i++)
{
for(j=1;j<=jmax;j++)
{
p=cautare(s,i,j);
if(p)
printf("%d ",p->val);
else printf("%d ",0);
}
printf("\n");
}
}

int main()
{
int n;
int imax,jmax;
int i,j;
nod *a,*b,*s,*p;
printf("Prima matrice\n");
citire(&a);
printf("A doua matrice\n");
citire(&b);
suma(a,b,&s);
printf("Lista a\n");
afisare(a);
printf("Lista b\n");
afisare(b);
printf("Lista suma\n");
afisare(s);
maxim(a,b,&imax,&jmax);
printf("Nr de linii: %d\nNr de coloane: %d\n\n",imax,jmax);
afisare_matrice(s,imax,jmax);

printf("\n\nTastati o tasta pentru terminarea programului");
getch();
return 0;
}

Varianta 2 (cam nefunctional)

#include <stdio.h>
#include <stdlib.h>
typedef struct nod
{
int i,j,val;
struct nod *urm;
}nod;

typedef struct
{
int nrl;
int nrc;
nod *prim;
nod *ultim;
int nrelem;
}matrice;

void adaug(matrice *m,int l,int c,int v)
{
nod *p;
p=(nod *)malloc(sizeof(nod));
p->i=l;
p->j=c;
p->val=v;
if(m->prim==0)
{
m->prim=m->ultim=p;
}
else
{
m->ultim->urm=p;
m->ultim=p;
}
p->urm=0;
}

int val(matrice *m,int i, int j)
{
while(m->prim)
{
if(m->prim->i==i && m->prim->j==j)
return m->prim->val;
else m->prim=m->prim->urm;
}
return 0;
}

void adun(matrice *d,matrice *m1, matrice *m2)
{
int i,j,suma;
for(i=1;i<=m1->nrl;i++)
{
for(j=1;j<=m1->nrc;j++)
{
suma=val(m1,i,j)+val(m2,i,j);
if(suma!=0)
adaug(d,i,j,suma);
}
//printf("\n");
}
}

void afisare_matrice(matrice *d)
{
int i,j,suma;
for(i=1;i<=d->nrl;i++)
{
for(j=1;j<=d->nrc;j++)
printf(" %d",val(d,i,j));
printf("\n");
}
}

int main()
{
matrice m1,m2,m3;
int n,i,v,l,c;
m1.prim=m1.ultim=m2.prim=m2.ultim=NULL;
printf("Matricea 1\nNr. linii:");
scanf("%d",&m1.nrl);
printf("Nr. coloane: ");
scanf("%d",&m1.nrc);
printf("Nr. de elemente diferite de 0: ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Linia: ");
scanf("%d",&l);
printf("Coloana: ");
scanf("%d",&c);
printf("Valoare: ");
scanf("%d",&v);
adaug(&m1,l,c,v);
}
printf("\nMatricea 2\nNr. linii:");
scanf("%d",&m2.nrl);
printf("Nr. coloane: ");
scanf("%d",&m2.nrc);
printf("Nr. de elemente diferite de 0: ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Linia: ");
scanf("%d",&l);
printf("Coloana: ");
scanf("%d",&c);
printf("Valoare: ");
scanf("%d",&v);
adaug(&m2,l,c,v);
}
printf("DDDDDD");
adun(&m3,&m2,&m1);
printf("DDDDDD");
printf("%d %d\n",m3->nrl,m3->nrc);
getch();
afisare_matrice(&m3);

printf("\n\nTastati o tasta pentru terminarea programului");
getch();
return 0;
}

marți, 11 martie 2014 by DlMuresan
Categories: liste, liste circulare simplu inlantuite, liste simplu inlantuite | Leave a comment

Faculty

Meniu

Orar semigroup #2

INTEGRALE