Xilinx 8bits getal vermenigvuldigen met breuk/decimaal

[Verwijderd]

Ik weet niet of dit het juiste subforum is, maar voor een schakeling ben ik bezig in Xilinx.
Daarbij moet ik een 8 bits getal vermenigvuldigen met 0.875 en 0.5.

Het 0.5 verhaal dacht ik opgelost te hebben d.m.v bitshifting, wat dan ook wel werkt voor even getallen.
Bij de oneven getallen weet ik dat als het laatste bit 1 is, er nog 0.5 bij moet.

Gezien ik deze uitkomst alleen op grootte moet vergelijken met het 0.875 x getal kan ik dit later wel bepalen.

Maar ik ga dus stuk op het 0.875 x 8bit getal gedeelte, nu is 0.875 7/8e en 0.5 4/8e, maar ik heb geen idee hoe ik dit nou moet shiften of dat er andere manieren zijn om dit uit te rekenen.

Wie kan mij uitleg geven aan de hand van een voorbeeld?

[madwizard]

Gaat het alleen om het vergelijken van x * 0,875 en x * 0,5 of heb je de getallen ook echt nodig? Want anders kun je natuurlijk ook x * 7 en x * 4 vergelijken, dat is dezelfde vergelijking.

Bedenk ook dat 7 = 8 - 1, dus x * 7 = x * 8 - x * 1 = (x << 3) - x
Dus x 3 bits naar links shiften en dan weer een keer x eraf halen geeft x * 7.

[Verwijderd]

Ik moet na het vergelijken inderdaad een waarde gebruiken, maar ik ga eens aan de gang met jouw laatste tip.

[GG85]

Kan de Xilinx WebPack of ISESuite synthesyser dit zelf niet oplossen? Dus een variabele maken, getal toekennen en vermenigvuldigen met x?

[Verwijderd]

Ik heb enkel de beschikking over een legale Xilinx Foundation F4.1i
Dit zal wel een oude versie zijn?

[DaWaN]

Wat voor taal gebruik je überhaupt ? VHDL ofzo ?

In principe doe je dat soort dingen met een variable met als type een integer.

Persoonlijk zou ik delen altijd proberen te vermijden, tenzij het delen door een macht van 2 is dan valt het te overzien.

[Dido]

DaWaN schreef op woensdag 06 januari 2010 @ 18:53:
Wat voor taal gebruik je überhaupt ? VHDL ofzo ?

In principe doe je dat soort dingen met een variable met als type een integer.

Persoonlijk zou ik delen altijd proberen te vermijden, tenzij het delen door een macht van 2 is dan valt het te overzien.

Volgens mij hoef je in dit geval dan ook alleen maar te delen door 2 en door 8.

*0,5 is /2^1, maar dat was al gemeld.

x*.875 is x-(x/2^3), dus dat moet ook te doen zijn

[Verwijderd]

DaWaN schreef op woensdag 06 januari 2010 @ 18:53:
Wat voor taal gebruik je überhaupt ? VHDL ofzo ?

In principe doe je dat soort dingen met een variable met als type een integer.

Persoonlijk zou ik delen altijd proberen te vermijden, tenzij het delen door een macht van 2 is dan valt het te overzien.

VHDL taal ken ik niet, het bied er wel ondersteuning voor.
Ik gebruik de schematic editor voor de xc4000e serie en heb ook enkel de bouwstenen daarvan tot mijn beschikking, dat maakt het juist zo lastig.

Als input variabelen kan ik hex (in een 8 bits bus) of high/low gebruiken (enkele verbindingen)... vrij basic dus.

Integer is een heel getal, ik denk dat ik hier toch met decimals aan de gang zou moeten... maar dat kan dus niet.... op papier kom ik er niet uit om de genoemde voorbeelden te realiseren.

[Verwijderd]

Dido schreef op woensdag 06 januari 2010 @ 19:02:
[...]

Volgens mij hoef je in dit geval dan ook alleen maar te delen door 2 en door 8.

*0,5 is /2^1, maar dat was al gemeld.

x*.875 is x-(x/2^3), dus dat moet ook te doen zijn

Ik blijf met mijn restwaarde zitten achter de komma, ik vergelijk de uitkomsten en de max uitkomst heb ik nodig. Nu is bijv a 8.875 hoger als b 8.125 dus zou de schakeling al niet kloppen gezien ze beiden 8 zouden worden als ik binair reken.

[Dido]

Verwijderd schreef op woensdag 06 januari 2010 @ 23:02:
Ik blijf met mijn restwaarde zitten achter de komma, ik vergelijk de uitkomsten en de max uitkomst heb ik nodig. Nu is bijv a 8.875 hoger als b 8.125 dus zou de schakeling al niet kloppen gezien ze beiden 8 zouden worden als ik binair reken.

Je wilt weten wat groter is: 7A/8 of 4B/8

Als A-(A/8)>B/2, dan geldt ook A>(B/2)+(A/8)

A/8 is een drievoudige bitshift, uiteraard. Bewaar die drie bits die eraf vallen. (Ar = 00000xxx)
B/2 idem dito, maar dan een enkele shift. (Br = 00000x000 !)
(B/2)+(A/8) is nu te klein vanwege die restwaarden (maximaal 1,375). Als het al groter is dan A zijn we er echter al!
Zo niet, tel Ar en Br bij elkaar op, als dat groter is dan 7 tel je 1 op bij je uitkomst van (B/2)+(A/8). Wederom, als dat groter is dan A, zijn we er. Als dat kleiner is ook, trouwens (er is nog maximaal 0,375 te vergeven, dus dat gaat niet meer uitmaken).
Als ((B/2)+(A/8) + 1) = A, dan trekken we 8 af van (Ar+Br), als dat dan nog groter is dan 0 moeten we B hebben. Als gelijk aan 0, dan zijn 7A en 4B gelijk. Ik weet niet wat je dan moet doen.

In een voorbeeld:

code:

A = 116, B = 203

A         = 01110100, A/8 = 00001110, Ar = 00000100
B         = 11001011, B/2 = 01100101, Br = 00000100
A/8 + B/2 = 01110011                      dit is niet groter dan A, we gaan verder

Ar + Br   = 00001000                      groter dan 7, we tellen 1 op bij de eerdere uitkomst

A/8 + B/2 = 01110100                      dit is gelijk aan A

Ar+Br - 1 = 0                             we weten niet welke we moeten kiezen!

[blackangel]

Verwijderd schreef op woensdag 06 januari 2010 @ 23:02:
[...]


Ik blijf met mijn restwaarde zitten achter de komma, ik vergelijk de uitkomsten en de max uitkomst heb ik nodig. Nu is bijv a 8.875 hoger als b 8.125 dus zou de schakeling al niet kloppen gezien ze beiden 8 zouden worden als ik binair reken.

Wat let je om van de gehele getallen fixed points te maken? Als je precisie nodig hebt, ga je gewoon grotere getallen gebruiken De 0.875 is hetzelfde als de 7/8e. Maak van je 8 bitter een 11 bitter, waarbij je de laatste 3 bit als fixed point gebruikt. Je begint dan dus met 1/8'e van je waardes, en om dan op 1/2e uit te komen (voor de 0.5) moet je 2 naar links shiften ipv. 1 naar rechts.

Dan heb je dus de twee 8bits vectors, a_8 en b_8, die respectievelijk met 0.5 en 0.875 vermenigvuldigd moeten worden.

Pseudocode:
a_int = int(a_8 << 2);
b_int = int(b_8 << 3) - int(b_8);

Dan nog a_int < b_int enzo, dat moet dan wel te doen zijn lijkt mij


Overigens is VHDL veel handiger dan schematics. In een 5 minuten had ik hier een implementatie voor (niet getest, wel compileerbaar). Maar dat mag je lekker zelf doen. Hoef ik ook niet mijn bug te demo'en