my pleasure
meg van az otos?

kellene 3 darab 16 bites szám eredője.
a processzor csak 16 bitit tudja kezelni a számokat, a nagyobb változók nem működnek.

valami matek pro szakértse meg nekem, hogy hogyan tudnám elvégezni a műveletet.

odáig eljutottam meg tudom oldani, hogy szorzás helyett sorozatos összeadást csinálok és a carry flag figyelésével n darab 16 bites változóban el tudom tárolni a szorzatot.

Na de ebből hogy tudok gyököt vonni? mert nem tudom így átadni az értéket az sqrt függvénnyek. Tehát kéne egy olyan saját függvény, ami úgy tud gyököt vonni, hogy a szám több 16 bites változóból tevődik össze és az 1 lépésben végrehajtható műveletek maximum 16 bitesek lehetnek.

Esetleg gondoltam arra, hogy a sorozatos összeadás mintájára megcsinálom és úgy keresem meg a gyökét, de ez iszonyatosan nagy teher a processzornak és rengeteg ideig tart (egy mikroverzélőről van szó), ez meg egy soft real-time rendszer, tehát nem működik.

This post was edited by CyberPunk666 on Nov 24 2013 04:04am

Tehát mit is akarsz csinálni? Írd le valami képlettel, hogy mit akarsz csinálni, mert ezt így szerintem senki se érti. float vagy int?
A processzor típusát is mellékelhetnéd, hogy világos legyen az utasításkészlet.

This post was edited by Jason89 on Nov 24 2013 05:34am

van egy gyorsulásmérőm, ami 6 tengelyes (x,-x,y,-y,z,-z)

Ezt ő 3 darab előjeles 16 bites számként adja meg.

int16_t X,Y,Z

Kellene az eredő g erő.

Mivel ezek mind egymásra merőleges tengelyek:
eredo=sqrt(X*X+Y*Y+Z*Z)

A probléma pedig a következő.
Mivel X egy előjeles 16 bites szám, és a processzor maximum ekkorát tud kezelni, ezért az X*X műveletet nem tudja elvégezni, hiszen két 15 bites szám szorzata (az MSB az előjel), nem fér el 16 biten. Már az 1024*1024 (egyhelyben tartva 1024=1g az Y értéke, ami gravitációs erőt mutatja) is jóval nagyobb, mint a 65534 (16 biten maximálisan tárolható érték).
Ezt a problémát megoldottam még ciklussal, ami X alkalommal összeadja X-t önmagával. Minden összeadás alkalmával megvizsgálja, hogy ez a 16 bites változó túlcsordult-e, ha igen, akkor egy másikat inkrementál. Így végül az X*X kiszámítható és kettő darab 16 bites regiszterben tárolható.

Még ezek összeadása is megoldható, aminek eredménye egy olyan szám, ami maximális kitérések esetén ((32767^2)*3)=3 221 028 867
Ez a szám 32 bites változót igényel.

Ez a 32 bites változó rendelkezésre áll 2 darab 16 bites változóban. Ezeket a rendszer nem tudja egy, összetartozó adatként fogadni. Tehát nekem kell a kapcsolatot megcsinálni.
Hogyan vonjak belőle gyököt?

Az elv érdekel, nem mással akarom megcsináltatni, szóval a processzor típusa lényegtelen.


A baj az, hogy valahogy becsülni kéne, hogy rendes időn belül le tudjon futni az algoritmus. Mivel az eredő gyakorlatilag 0-56754-ig terjedhet, ezért ez kibaszott sok számítást igényelne.
Reméltem, hogy van itt valami pr0 eltés vagy bmes, aki tud erre valami gyors és optimális módszert.

This post was edited by CyberPunk666 on Nov 24 2013 06:15am

megoldottam. Szereztem olyan headereket, amikkel tudok lebegőpontos számokat használni. Kurva lassúak, de még belefér, majd spórolok máshol.

Így nem azzal a számmal végzek műveletet, amit a szenzor szolgáltat, hanem átkonvertálom g erővé, és így a maximális érték 16,000g, amivel kényelmesen tudok számolni.

Mondjuk ez is kurvára megerőszakolás a procinak.

Mostantól csak 32 bites processzorra fogok alapozni bármilyen projektet is csinálok. Ráadásul azok olcsóbbak is.
Csak azoknál meg a beforrasztást a probléma. ^^


Azért ha valaki mégis meg tudja oldani, akkor érdekel a megoldás, hátha jobb, mint így, meg egyébként is érdekesnek találom és kíváncsi vagyok rá.

This post was edited by CyberPunk666 on Nov 24 2013 07:37am

hello, sziasztok!

wordpressben keszitek 1 oldalt, s szeretnem 2 nyelvure csinalni. Van erre valami megoldas? pl indexkent egy welcomekepernyo language selectel, vagy csak siman egy 2 zaszlo az egyik fenti sarokban?

fazsa, sikerült olyan érzékenységet elérni, hogy ha kopogok az asztalon az jól kivehető a számértékekben.

en qTranslate plugint használtam egyszer többnyelvű wordpresshez. postokhoz alap felületet biztosít adminban is ,hogy megírd több nyelvűre, meg oldalcímekre, de ha több kell akkor azt neked kell lekódolni. nemtom van e ennél jobb ingyenes.
cp: ehhez sajnos nem értek, csak gúglizgatni tudtam volna meg aztán számolgatni, de nem hiszem hogy jobb eredményt hoztam volna ki hozzád képest

abból mindig pontosan ez lesz ha valaki nekiáll, és azt mondja hogy megpróbálok lépésről lépésre eljutni a célba kódolás közben (kikötsz a legebőpontoknál, libeknél (életemben nem nyúlok libhez ha csak nem komponensről van szó, de akkor se szívesen), írsz egy esszét arról hogy milyen hogy stb.)

mondasz inkább egy reprezentációt amiben tudsz dolgozni egész idő alatt
mi a baj? "egész számok nem zártak a {szorzás, összeadás, kitevős szarok..} műveletekre
mit lehet tenni? sok mindent de mondjuk választunk egyet ami igazán kézenfekvő xD zárttá tesszük őket talán?
-> bitműveletekkel dolgozunk bittömbökben, arra nem lesz megszorítás



az hogy FancyInt-et hogy írod le az tök mindegy, 10000 dev 10000 módon írná le kihasználva a nyelvek sajátosságait (asm részlet, c++, c#, ..)

a lényeg az hogy ha ezt látod magad előtt és alkalmazod a "> 2013 > google > wikipedia > 5 másodperc kiguglizni mindegyik részfeladatot" szabályt, akkor kész is van a feladat..

összeszorzod binárisan a számokat
összeadod binárisan a számokat
gyököt vonsz binárisan a számokból
ahol a tömbök mérete a nem zárt műveleteknél 2x akkora lesz mint a bemenő adat mérete, majd egyszer csak megfelezhetjük, de ez megint egy invariáns dolog, amit kihasználhatunk mint információt, de nem kell

mindezt úgy hogy egy bittömbben van reprezentálva, mert ez volt a problémánk
igazából nem is értem hogy a feladatban mi a kérdés

természetesen az lehet (nem lehet, biztos) hogy egyik részfeladatot ezek közül úgy is meglehet oldani hogy nem kell tömbként kezelni, mert int16 bitjeire hivatkozunk, stb, de ez már a visszabutítás része
először egy absztrakción meg kell oldani a feladatot hogy működjön és utána jöhetnek a bitmagic vackok
ezzel meg pont azt éri el az ember hogy 15 perc alatt leprogramozza és működik //e és saját, és van jövője mert olyan algoritmusok vannak bitműveletekre hogy a végén negatív időben lefutnak


ja és ha ezt cpp-ben prokramozza meg az ember akkor ott alapból úgy van megírva az array hogy bool <T> esetén saját implementációt kapott, és a bool értékekeket nem külön külön tárolja hanem valódi int típusokat indexel mondjuk 8-asával (ezt jason majd megszakérti ha gondolja, én nem tudom pontosan, inkább .net orientált vagyok)
= gg much

This post was edited by Anarkin on Nov 24 2013 08:49am

Csak a kérdésre nem válaszoltál, mert az pont a bináris gyökvonás mikéntje volt. De inkább kigooglézom, minthogy mégegyszer válaszolj.

A többi részét megoldottam bittömbök nélkül, amik egyébként iszonyatosan lassúak.

C-ben kell megvalósítani. ASM betét megengedett.

This post was edited by CyberPunk666 on Nov 24 2013 08:59am