OldComp.cz • Zobrazit téma

Vyhledat témata bez odpovědí | Zobrazit aktivní témata

Obsah fóra » ZX Spectrum, Sinclair a kompatibilní » ZX Spectrum - programování a vývoj software

Všechny časy jsou v UTC + 1 hodina [ Letní čas ]

Macro FORTH

Moderátoři: Jiiira, SCjoe

Stránka 24 z 40

[ Příspěvků: 598 ]

Přejít na stránku Předchozí 1 ... 21, 22, 23, 24, 25, 26, 27 ... 40 Další

Verze pro tisk

Předchozí téma | Následující téma

Autor

Zpráva

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 26.10.2022, 03:36

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

l00k píše:

nemyslel jsem proměnlivou mantisu, ale využít víc než 5 bajtů co má spectrum (ty 2 bajtové FP jen jsou na extrémní rychlost), a mít větší přesnost, když integery děláš s možností až tak velké.
Třeba něco jako 1 bajt znaménko čísla, 1 bajt znaménko exponentu, 2 bajty exponent (16 bitů), a třeba 28 bajtů mantisy (32 bajtů celkem)

ale klidně můžu fp číslo vynásobit trilionem nebo triliardou a budu mít 12, resp.15 desetinných míst jen posuvem a pak s tím počítat jako s integerem

Myslim ze se bavime o tom samem. Ja to chapu jako promnenlivou mantisu, protoze dokud programator nezada pocet bajtu tak ty rutiny musi byt univerzalni.

Exponent nepotrebuje drzet bokem znamenko (dokonce cely vyhrazeny bajt), protoze ma Bias. Hodnotu u ktere budeme tvrdit, ze je jeji velikost je chapan jako nulovy exponent a vse pod tim (mensi hodnoty) zaporny a nad tim (vetsi hodnoty) kladny.

Na exponent staci jedna bunka (2 bajty).
Ohledne drzeni znamenka mimo cislo tak to neni nutne, jen se s tim nekdy usnadnuji nektere operace jako je nasobeni a deleni, kdyz mas "mantisu" vzdy unsigned a jen xorujes bit znamenka a nemusis provadet "negate".
Vsechno ma sve vyhody a nevyhody. Takhle nejak udelas ze dvou cisel nenormalizovane floating point cislo.

S tim se pak pracuje asi stejne spatne jako s klasickym floting point cislem. Musis resit stejne posuny mantis kdyz se budes snazit scitat dve cisla, nebo je odcitat. Proto doporucuji tu fixed point aritmetiku. Navic jsem ji nikdy v podstate nepouzil. Maximalne na nejaky konkretni vypocet, ne jako "formalizovany" zpusob zapisu relaneho cisla.

Ti co navrhovali jak bude vypadat floating point format byli fakt genialni. Mit to ve formatu jako 0.5000..0.9999 * 2^E. Nejvic zasadni bity nikdy neztracis, vzdy zacnes ztracet nejmene vyznamne bity. Pokud preteces nebo podteces tak jedine v exponentu. Mantisa bude vzdy nasobkem nebo "celociselnym" podilem nasobku dvou. U fixed point kdyz preteces tak mas neco jako spatna_hodnota = spravna_hodnota MOD (maximalni_hodnota+1).

Dival jsem se jak by se resilo nasobeni ve fixed point cislech a je to slozitejsi nez jsem si myslel.

A.a * B.b = Aa * 0.1 * Bb * 0.1 = Aa*Bb * 0.01 = CCcc * 0.01 = CC.cc = C.c

Musis to orezavat jak zhora tak zdola.

Slo by to pocitat z tech polovin jako

(A+a*0.1)*(B+b*01)=A*B+0.1*(0A*0b+0B*0a)+0.01*0a*0b = C + C.c + C.c + 0.cc

ale vypada to ze si nic neusetris, jedine to preteceni u A*B, kde ti to staci pocitat tak aby vysledek mel stejny pocet bitu jako vstup.

Mozna misto tri pricitani ctyr mezivysledku, kde nejmensi jeste musis stale orezavat by to slo delat jako kombinace dvou zpusobu jak udelat nasobeni.

Prvni je ze vysledek v kazdem kroku vydelis dvema a postupne zjistujes od nejnizsiho bitu stav prvniho nasobitele a pokud je jednickovy, tak k vysledku pricist druheho nasobitele. Tim si zajistis spravne zaokrouhleni. Pocita se ta cast 0.cc ze ktere se pouzije jen 0.c a zbytek vypadne. Proto se vysledek deli dvema. Pak v nejakem bode prejit do druhe faze (myslim ze by to melo byt +-1 + cislo ktery odpovida polovine bitu co ma vstup), kdy misto deleni vysledku dvema se zacne nasobit druha hodnota co se pricita dvema. Tam ti zase postupne zacne ten druhy nasobitel pretikat zhora, to jsou ty hodnoty co ma prvni C ve vysledku CC.cc.
Tim ale prijdes o hodnotu toho druheho nasobitele, ale vypada to jako nejefektivnejsi zpusob (zato nejslozitejsi) nez to fakt nasobit o dvojitem rozsahu a pak orezat nahore a dole a resit jeste posuny vysledku.

Proc vsechno musi byt tak slozite...

A to jsem ani neresil zda to jde pocitat se znamenky, nebo to musis prvne vse prevest do absolutni hodnoty.

K deleni jsem se ani nedostal.

Mozna bych si mel jen neco precist jak se to dela...? .)

PS: Koukam ze jsem fixed point aritmetiku minul, protoze

píše: píše: píše: píše: píše: píše: píše: píše: píše: píše: píše: píše:

Explicitní podporu pro čísla s pevnou čárkou poskytuje několik počítačových jazyků, zejména PL/I , COBOL , Ada , JOVIAL a Coral 66 . Poskytují datové typy s pevnou řádovou čárkou s binárním nebo desítkovým měřítkem. Kompilátor automaticky generuje kód, aby provedl příslušné převody měřítka při provádění operací s těmito datovými typy, při čtení nebo zápisu proměnných nebo při převodu hodnot na jiné datové typy, jako je plovoucí desetinná čárka.

Většina z těchto jazyků byla navržena v letech 1940 až 1990. Modernější jazyky obvykle nenabízejí žádné datové typy s pevnou čárkou ani podporu pro převod měřítka. To je také případ několika starších jazyků, které jsou stále velmi populární, jako FORTRAN , C a C++ . Široká dostupnost rychlých procesorů s plovoucí desetinnou čárkou s přísně standardizovaným chováním výrazně snížila požadavky na podporu binárních pevných řádů.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

l00k

Předmět příspěvku: Re: Macro FORTH

Napsal: 26.10.2022, 08:11

Profík

Registrován: 26.11.2018, 16:59
Příspěvky: 581
Bydliště: Holešov
Has thanked: 13 times
Been thanked: 91 times

ten návrh fp čísel je opravdu moc chytrej, ty bajty na znaménka jsem tam psal pro jednodušší operace (nemusíš nic maskovat rotovat)
pokud ty dlouhé integery se použíjí na ty přesnější FP čísla tak máš hotovo.

jak moc složitá operace je ln a exp (logaritmus a exponenciální fce) ? nedaly by se u těchto čísel využít? převedli bysme násobení a dělení na sčítání a odčítání

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 26.10.2022, 19:59

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

l00k píše:

Nejsnazsi operace je u malych mantis pro me asi nasobeni, pokud to rozdelis na nasobeni mensich podcasti a vyuzijes tabulky.

Deleni je o neco tezsi a budes potrebovat tabulku jeste pro 1/x. Protoze y/x = y * (1/x). U dlouhych matic jako v tomto pripade to nepujde pouzit.

Pak je scitani, posuny jsou pomale. Ale taky muzes mit na to tabulky o velikosti 7*256
Odcitani bude na tom stejne jako scitani, protoze je to ten samy algoritmus, protoze scitani dvou cisel, ktere maji opacna znamenka je vlastne odcitani.

Logaritmus a exponencialni funkce jsou asi 100x tezsi a pomalejsi. Udelat v assembleru emulaci nasobeni je jako udelat v C emulaci logaritmu. Kdyz budes brat nasobeni, deleni, scitani a odcitani jako samozrejmost. Jako jen nejakou instrukci a pomci nich pises nejaky Tayleruv rozvoj nebo nejakou iteraci. Prvne se snazis najit na netu vzorec co nejrychleji konverguje. K tomu vzorci zjistit pro jake hodnoty (rozsah hodnot) to nejlepe konverguje. A pak jeste studujes vzorce jake existuji vztahy, aby jsi mohl upravovat vstup tak, aby lezel v optimalnim rozsahu nejrychlejsi konvergence a po vypoctu vysledek zmenit o nejake konstanty, protoze jsi vstup menil.

Pro ty kratke mantisy si muzes ale zase pomoct s tabulkama.

Prevadet nasobeni na scitani logaritmus je u dlouhych mantis nesmysl, bude to asi 100x tezsi a ke vsemu to bude mene presne, ztracis nejnizsi bity. Muzes to delat u malych mantis, kdy to mas v tabulkach a chces to mit relativne rychle a setrit mistem pro tabulky na nasobeni a jeste ti nejde o presnost. Pokud mas misto na tabulku pro nasobeni tak jak jsem rekl i scitani je pomalejsi jak nasobeni. A tam to jeste prevadis pres dve tabulky exp a ln.

PS: Chtel jsem tady vlastne napsat neco jineho. Ze u nasobeni dlouhych cisel se znamenky se misto prviho prevadeni na unsigned a vraceni vstupudo puvodniho stavu a nastaveni vystupu na spravne znamenko po nasobeni se da udelat v podstate cela funkce pro nasobeni se znamenkem. Ta by mela byt o neco slozitejsi nez nasobeni unsigned takze celkove by program byl delsi pokud se pouzivaji obe operace. Ale melo by to byt rychlejsi.
Dworkin píše:

Pouziva se tam jeden zajimavy trik, ktery me dosud uplne unikl.

Pro kladne cisla plati: 13 = 0x0D = 0000 1101b = 128*0 + 64*0 + 32*0 + 16*0 + 8*1 + 4*1 + 2*0 + 1*1

Pro zaporne ale plati, ze pokud vezmete uplne nejvyssi znamenkovy bit (je to zavisle na poctu bitu cisla) a budete ho chapat jako minusovy tak z toho mate jakoby kladne cislo.

Kód:

  13 = 0x0D = 0000 1101b = -128*0 + 64*0 + 32*0 + 16*0 + 8*1 + 4*1 + 2*0 + 1*1 = 8+4+1
-13 = 256-13 = 243 
243 = 0xF3 = 1111 0011b =  -128*1 + 64*1 + 32*1 + 16*1 + 8*0 + 4*0 + 2*1 + 1*1 = -128+64+32+16+2+1= -128+115 = -13

To vam pak umozni delat nasobeni jako obvykle a az na to, ze pri narazeni na "zaporny" bit nebudete pricitat ale odcitat.
Bohuzel to stale nebude tak jednoduche, protoze vysledek ma dvojnasobny pocet bitu jako vstup, takze pokud pricitate zaporne cislo tak ho musite rozsirit o 0xFF na zacatku. A uz nebudete pricitat 8 bitu ale 16 bitu.

Pokud ma vystup stejny pocet bitu jak vstup tak stale nemusite znamenka resit.

https://www.allaboutcircuits.com/technical-articles/multiplication-examples-using-the-fixed-point-representation/

PPS: Jak jsem asi pred pulrokem? resil nasobeni konstantou a zjistil ze napriklad kdyz nasobite cislo 255
Dworkin píše:

tak je to X*255 --> X*1111 1111b

tak vyhodnejsi je misto osmi scitani mit jedno scitani a jedno odcitani

X*255=X*256-X*1=X*1 0000 0000b - X* 0000 0001b

A tohle ma sve jmeno "Booth's Algorithm".

https://witscad.com/course/computer-architecture/chapter/fixed-point-arithmetic-multiplication

PPPS: Ani u jednoho odkazu jsem teda nepochopil jak se vyhnout posunum pri nastavovani desetine carky.
Dworkin píše:

A wiki je jeste vic znamena, ta tvrdi ze u fixed point se ta desetina carka (imaginarne) posouva v prubehu vypoctu, jak se ti to hodi. To uz pak podle me ani neni FIXED. A kdyz bych to mel iplementovat, tak by me musel programator rici, kolik bitu chce mit v desetine casti a ja si to pak mam nekde drzet, tak to uz je v podstate floating point cislo. Ten exponent + mantisa drzici informaci znamenka.

V praxi by to vypadalo tak ze u nasobeni by se pridal parametr navic, o kolik bitu orezat nejmene vyznamne bity vysledku.
Protoze oba vstupy mohou mit jinde desetinou cast. To u nasobeni nicemu nevadi a vystup muzeme chapat taky ruzne, ale co vypadne(orezeme) je dulezite.
To vytvari problem pri scitani(odcitani), kdy muze vzniknout situace kde mame dve cisla, ktera maji jiny pocet desetinych mist... takze musime delat posuvy jako u floating point. To by si ale mel asi resit programator sam, ze si osetri vstup.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 01.11.2022, 03:57

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Neni cas, takze po nocich delam jen po troskach a myslim ze uz mam funkcni (ale ne moc peknou) rutinu pro vypis dlouhych cisel v dekadickem formatu.

PDOT() a PUDOT()

Protoze se mi s tim nechtelo moc drbat, tak obe rutiny ocekavaji v NNOS ukazatel na delitele, tzn 10. Ale muze tam byt v podstate cokoliv od 2 do 10. Aktualne je limit to, ze pri tisku by hodnota vic jak 9 zacala tisknout nasledujici znak za devitkou co je dvojtecka, strednik, atd. Ale mozna pristi noc to uz upravim aby to preslo na A, B...

V NOS je ukazatel na hodnota co se bude tisknout, ale je to destruktivni, na konci pravdepodobne (v pripade ze ma cislo vic jak jednu cifru vzdy) bude obsahovat druhou cislici.

TOS ma obsahovat ukazatel na pomocnou promennou a na konci pravdepodobne bude mit hodnotu prvni cifry.

To ze PUDIVMOD vraci po deleni delitele, zbytek a vysledek neni az tak idealni. Protoze pro dalsi deleni potrebuji prohodit zbytek a vysledek. Protoze vysledek se bude znovu delit. Zbytek jen tisknout.

Tak nejak me nedoslo, ze postupne deleni 10 bude vracet vysledek pozpatku, takze kazdou cifru ukladam na zasobnik jako 16bitovou hodnotu. Normalne to resim rutinama co deli cislo napriklad 10000,1000,100,10. Takze to mohu tisknout rovnou. Tady by to teoreticky slo taky, ale bylo by to jeste pomalejsi nez to je.

32 bajtove cislo by melo zabrat 2^256=1.15*10^77 --> 78*2 = 156 bajtu na zasobniku i se zarazkou.

256 bajtove cislo nevim kolik zabira protoze me kalkulacka pretece u 2^2048... .)

ale 128 bajtove cislo 2^1024=1.80*10^308 --> 309*2 = 618 bajtu na zasobniku. Takze kdyz se kouknu ze 4x vic bitu ma zhruba 4x vic cifer tak by 256 bajtove nemelo chtit vic jak 1300 bajtu, a to neni az tak strasne.

Mel jsem docela problem jak tisknou cisla narvane na zasobniku kdyz mate obsazeno BC,DE,HL a HL' protoze ta tisknouci ZX ROM rutina nici AF,AF',DE' a BC' takze nic nezbyva a zasobnik nemuzete pouzit... .) Jeste ze me napadla ta zarazka.

PS: Pri prvni verzi jsem mel vtipnou chybu, kdy jsem nepocital s tim, ze cislo muze mit jen jednu cifru a vypisovalo to pak pocatecni nulu.

PPS: A mel jsem docela problem neprohodit na konci pointer na tisknute cislo a pomocne cislo. Je to zavisle zda ma vypis sudy nebo lichy pocet cifer.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 02.11.2022, 04:36

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Malej test co udela vypocet faktorialu 100! Asi je to dobre, nekontroloval jsem kazdou cifru ani pocet. Kalkulacka ukaze 9.3326215443944152681699238856266700490716×10¹⁵⁷.
Aby se vysledek vlezl do pameti tak je potreba 66 bajtu...

Smycku jsem napsal co nejjednodussi (fakt jsou tam dve J? a dve Š? :shock:

) takze nasobi i jednickou.

Kód:

include(`../M4/FIRST.M4')dnl
ORG 0x8000
INIT(60000)

ALIGN(256)

CREATE(_a)
PUSH(100) COMMA
PUSH(256-2) ALLOT

CREATE(_b)
PUSH(99) COMMA
PUSH(256-2) ALLOT

CREATE(_c)
PUSH(256) ALLOT

CREATE(_d)
PUSH(10) COMMA
PUSH(256-2) ALLOT


PUSH(_a)
PUSH(_b)
PUSH(_c)

BEGIN
   PUMUL(66)
   NROT
   P1SUB(66)
   P0NE(66) WHILE
      SWAP
AGAIN

DROP PUSH(_d) NROT

PUDOT(66) CR

DROP DROP DROP

DEPTH UDOT CR

STOP

Kód:

;   ===  b e g i n  ===
    ld  (Stop+1), SP    ; 4:20      init   storing the original SP value when the "bye" word is used
    ld    L, 0x1A       ; 2:7       init   Upper screen
    call 0x1605         ; 3:17      init   Open channel
    ld   HL, 60000      ; 3:10      init   Init Return address stack
    exx                 ; 1:4       init
                        ;           align(256)
    ld   BC, 100        ; 3:10      100 ,
    ld  (__create__a),BC; 4:20      100 ,
    ld   BC, 99         ; 3:10      99 ,
    ld  (__create__b),BC; 4:20      99 ,
    ld   BC, 10         ; 3:10      10 ,
    ld  (__create__d),BC; 4:20      10 ,
    push DE             ; 1:11      _a _b _c   ( -- _a _b _c )
    push HL             ; 1:11      _a _b _c
    ld   HL, _a         ; 3:10      _a _b _c
    push HL             ; 1:11      _a _b _c
    ld   DE, _b         ; 3:10      _a _b _c
    ld   HL, _c         ; 3:10      _a _b _c
begin101:               ;           begin 101
    pop  BC             ; 1:10      p528u*
    ld    A, 0x42       ; 2:7       p528u*
    call PXUMUL         ; 3:17      p528u*
    push BC             ; 1:11      p528u*
                        ;[2:23]     nrot ( c b a -- a c b )
    ex  (SP),HL         ; 1:19      nrot a . b c
    ex   DE, HL         ; 1:4       nrot a . c b
    ld    C, L          ; 1:4       p528 1-   ( p528 -- p528 )  [p528] -= 1  with align 66
    ld    B, 0x42       ; 2:7       p528 1-
    ld    A, 0xFF       ; 2:7       p528 1-
    add   A,(HL)        ; 1:7       p528 1-
    ld  (HL),A          ; 1:7       p528 1-
    jr    c, $+4        ; 2:7/12    p528 1-
    djnz $-4            ; 2:8/13    p528 1-
    ld    L, C          ; 1:4       p528 1-
    push DE             ; 1:11      p528 0<>   ( p528_1 -- p528_1 flag )  flag = [p528_1] <> 0  with align 66
    ld   DE, 0xFFFF     ; 3:10      p528 0<>
    ld    C, L          ; 1:4       p528 0<>
    ld    B, 0x42       ; 2:7       p528 0<>
    xor   A             ; 1:4       p528 0<>
    or  (HL)            ; 1:7       p528 0<>
    jr   nz, $+5        ; 2:7/12    p528 0<>
    djnz $-3            ; 2:8/13    p528 0<>
    inc  DE             ; 1:6       p528 0<>
    ld    L, C          ; 1:4       p528 0<>
    ex   DE, HL         ; 1:4       p528 0<>
    ld    A, H          ; 1:4       while 101
    or    L             ; 1:4       while 101
    ex   DE, HL         ; 1:4       while 101
    pop  DE             ; 1:10      while 101
    jp    z, break101   ; 3:10      while 101
    ex   DE, HL         ; 1:4       swap   ( b a -- a b )
    jp   begin101       ; 3:10      again 101
break101:               ;           again 101
    ld   HL, _d         ; 3:10      drop _d
                        ;[2:23]     nrot ( c b a -- a c b )
    ex  (SP),HL         ; 1:19      nrot a . b c
    ex   DE, HL         ; 1:4       nrot a . c b
    ld    A, 0x42       ; 2:7       pu.
    pop  BC             ; 1:10      pu.
    call PRT_PU         ; 3:17      pu.
    push BC             ; 1:11      pu.
    ld    A, 0x0D       ; 2:7       cr      Pollutes: AF, DE', BC'
    rst   0x10          ; 1:11      cr      with 48K ROM in, this will print char in A
    pop  HL             ; 1:10      drop drop drop   ( c b a -- )
    pop  HL             ; 1:10      drop drop drop
    pop  DE             ; 1:10      drop drop drop
                        ;[13:72]    depth   ( -- +n )
    push DE             ; 1:11      depth
    ex   DE, HL         ; 1:4       depth
    ld   HL,(Stop+1)    ; 3:16      depth
    or    A             ; 1:4       depth
    sbc  HL, SP         ; 2:15      depth
    srl   H             ; 2:8       depth
    rr    L             ; 2:8       depth
    dec  HL             ; 1:6       depth
    call PRT_U16        ; 3:17      u.   ( u -- )
    ld    A, 0x0D       ; 2:7       cr      Pollutes: AF, DE', BC'
    rst   0x10          ; 1:11      cr      with 48K ROM in, this will print char in A
Stop:                   ;           stop
    ld   SP, 0x0000     ; 3:10      stop   restoring the original SP value when the "bye" word is used
    ld   HL, 0x2758     ; 3:10      stop
    exx                 ; 1:4       stop
    ret                 ; 1:10      stop
;   =====  e n d  =====

Příloha:

fact100.png [ 3.08 KiB | Zobrazeno 2855 krát ]

PS: Big num kalkulacka ukazuje
93,326,215,443,944,152,681,699,238,856,266,
700,490,715,968,264,381,621,468,592,963,89
5,217,599,993,229,915,608,941,463,976,156,5
18,286,253,697,920,827,223,758,251,185,210,
916,864,000,000,000,000,000,000,000,000

PPS: Na youtubu me vyskocilo video https://youtu.be/F2X1pKEHIYw, ktere me vysvetluje proc se v anglictine nekdy vyslovuje

SR jako ŠR
TR jako (T)ČR
DR jako "Dž"R
STR jako ŠTR

Pamatuji si jak muj mozek nemohl pochopit jak se vyslovuje TRUCK, porad jsem cekal to T a ten zvuk me nedaval zadny smysl.

Stejny problem s kratkym "e". Nejde to napsat v cestine, v rumunstine je to A s nejakym ogonkem nebo jak se tomu nadava. Pritom jako dite, kdyz jsem neumel psat a neresil to misto NE a ANO mohl rikat "e"-"e" a "e...e"-"h!". Pochopil ten zapis nekdo? Muvi se tak vsude?

PPPS: Ten prst me pri praci porad boli, staci male bouchtnuti, horka voda, nebo stisknuti s pomoci palce. V podstate co se deje porad. Sice to po cca 3 dnech prestalo krvacet, ale postupne se me zacalo odhalovat luzko, takze ho mam skoro o 50% vetsi nez na druhe ruce. Az ted jsem si vsiml ze kdyz trochu posunu tu napuchlou cast tak ho vidim komplet cely a jak je videt cely tak se ukazalo ze byl pod tou kuzi proboreny (proto to krvacelo) jak dostal zasah. Nevim co s tim, protoze to srusta pod sebe. Asi pockam a uvidim... jak se zlomenym zubem. Po roce me ta jedna vyklajici se pulka s dvema koreny nekam upadla a druha je ostra jako britva (pokousany jazyk boli 5 dni...) K doktorovi s tim nepujdu, je to pesky daleko a stejne neumim anglicky. Je to takova zivotni lekce, jak se dostat do stavu, kdy je ti skoro vsechno u .... Sorry za troling. .)

PPPPS: Lol 66 je 0x42

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

l00k

Předmět příspěvku: Re: Macro FORTH

Napsal: 02.11.2022, 16:24

Profík

Registrován: 26.11.2018, 16:59
Příspěvky: 581
Bydliště: Holešov
Has thanked: 13 times
Been thanked: 91 times

přesnost perfektní,
kolik z toho času byl výpočet a kolik byl výpis?

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 03.11.2022, 03:17

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

l00k píše:

přesnost perfektní,
kolik z toho času byl výpočet a kolik byl výpis?

Probehlo tam sto nasobeni a podle vypisu kdyz vidim 4 plne radky a u pateho dva znaky chybi to bude 32,64,128... 128+30 = 158x deleni.

Dal jsem vypis jako hex

Příloha:

fact100hex.png [ 2.95 KiB | Zobrazeno 2792 krát ]

a vypada to ze 80% casu zabere vypis. On by se dal celkem snadno asi 2x zrychlit, ale nemam to ted jako prioritu.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 05.11.2022, 06:06

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Jak jste si asi mohli vsimnout v zdrojovem kodu programu pro vypocet faktorialu, jsem zadaval hodnoty pro vstupni promenne jako konstanty. Ale nektere z nich se v prubehu vypoctu prepisovali. Takze pri opakovanem spusteni uz to bude pocitat neco jineho.

Kód:

CREATE(_a)
PUSH(100) COMMA
PUSH(256-2) ALLOT

Jak to teda zadat s inicializaci na hodnotu?
Slo by to pres COMMA

Kód:

CREATE(_a)
PUSH(100) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA
PUSH(0) COMMA

Ale to neni to co by chtel programator delat...

Takze jak zadavat snadno hodnotu?

Udelal jsem prvne slovo HEXPUSH_COMMA(hex_string)

Kód:

dworkin@dw-A15:~/Programovani/ZX/Forth/Nova_testovaci$ ../check_word.sh 'HEXPUSH_COMMA(0xffeeddccbbaa99887766554433221100)'

    push HL             ; 1:11      0x1100 , 0x3322 , ... 0xffee ,   default version
    ld   HL, 0x1100     ; 3:10      0x1100 ,
    ld  (VARIABLE_SECTION),HL; 3:16      0x1100 ,
    ld   HL, 0x3322     ; 3:10      0x3322 ,
    ld  (VARIABLE_SECTION+2),HL; 3:16      0x3322 ,
    ld   HL, 0x5544     ; 3:10      0x5544 ,
    ld  (VARIABLE_SECTION+4),HL; 3:16      0x5544 ,
    ld   HL, 0x7766     ; 3:10      0x7766 ,
    ld  (VARIABLE_SECTION+6),HL; 3:16      0x7766 ,
    ld   HL, 0x9988     ; 3:10      0x9988 ,
    ld  (VARIABLE_SECTION+8),HL; 3:16      0x9988 ,
    ld   HL, 0xBBAA     ; 3:10      0xbbaa ,
    ld  (VARIABLE_SECTION+10),HL; 3:16      0xbbaa ,
    ld   HL, 0xDDCC     ; 3:10      0xddcc ,
    ld  (VARIABLE_SECTION+12),HL; 3:16      0xddcc ,
    ld   HL, 0xFFEE     ; 3:10      0xffee ,
    ld  (VARIABLE_SECTION+14),HL; 3:16      0xffee ,
    pop  HL             ; 1:10      0x1100 , 0x3322 , ... 0xffee ,
                        ;[50:229]   0x1100 , 0x3322 , ... 0xffee ,

VARIABLE_SECTION:

    dw 0x1100
    dw 0x3322
    dw 0x5544
    dw 0x7766
    dw 0x9988
    dw 0xbbaa
    dw 0xddcc
    dw 0xffee
                       ;[50:229]

Ktere v podstate jen zjisti zda retezec zacina "0x" a pokud ano tak to odstrani a pak postupne rekurzivne od konce odsekava 2 bajty a vytvari token pro PUSH_COMMA. A tokenove pravidla pak PUSH_COMMA() retezi do PUSHS_COMMA(). Viz jak jsem si hral s tim obrazkem.

Pak jsem mirne upravil slovo HEXPUSH_COMMA(hex_string) na PHEXPUSH_COMMA(bajtu,hex_string), ktery navic doplni pocatecni nuly, aby data zabirala presne pocte bajtu co mu zadame.

Kód:

dworkin@dw-A15:~/Programovani/ZX/Forth/Nova_testovaci$ ../check_word.sh 'PHEXPUSH_COMMA(256,0x64)'


    push HL             ; 1:11      0x0064 , 0x0000 , ... 0x0000 ,   default version
    ld   HL, 0x0000     ; 3:10      0x0000 ,
    ld  (VARIABLE_SECTION+2),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+4),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+6),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+8),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+10),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+12),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+14),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+16),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+18),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+20),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+22),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+24),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+26),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+28),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+30),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+32),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+34),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+36),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+38),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+40),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+42),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+44),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+46),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+48),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+50),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+52),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+54),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+56),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+58),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+60),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+62),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+64),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+66),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+68),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+70),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+72),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+74),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+76),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+78),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+80),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+82),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+84),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+86),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+88),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+90),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+92),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+94),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+96),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+98),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+100),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+102),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+104),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+106),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+108),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+110),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+112),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+114),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+116),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+118),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+120),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+122),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+124),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+126),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+128),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+130),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+132),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+134),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+136),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+138),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+140),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+142),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+144),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+146),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+148),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+150),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+152),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+154),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+156),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+158),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+160),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+162),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+164),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+166),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+168),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+170),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+172),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+174),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+176),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+178),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+180),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+182),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+184),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+186),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+188),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+190),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+192),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+194),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+196),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+198),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+200),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+202),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+204),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+206),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+208),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+210),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+212),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+214),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+216),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+218),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+220),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+222),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+224),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+226),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+228),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+230),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+232),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+234),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+236),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+238),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+240),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+242),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+244),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+246),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+248),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+250),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+252),HL; 3:16      0x0000 ,
    ld  (VARIABLE_SECTION+254),HL; 3:16      0x0000 ,
    ld    L, 0x64       ; 2:7       0x0064 ,
    ld  (VARIABLE_SECTION),HL; 3:16      0x0064 ,
    pop  HL             ; 1:10      0x0064 , 0x0000 , ... 0x0000 ,
                        ;[391:2086] 0x0064 , 0x0000 , ... 0x0000 ,

VARIABLE_SECTION:

    dw 0x0064
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
    dw 0x0000
                       ;[391:2086]

Problem je trosku s tim ze zrovna tady bych nepreferoval rychlost, ale spis velikost a ty nuly vytvarel spis smyckou...
Navic se mi to generuje nejak dlouho a to jsem jeste u zadani hodnoty v hex formatu...

Nad dekadickym vstupem zatim jen premyslim a vypada to, ze tohle jeste nikdo neresil. Mit vstup jako retezec s dekadickym cislem a mit vystup retezec s hexadecimalnim cislem. Proste to prevedou na cislo. Jenze to u BigNum nejde.

Napada me to jen zdimat po jednom bitu. Dekadicke cislo ma ulozenou informaci zda je sude nebo liche uz v posledni cifre. A pak to delit dvema od nejvyssi cifry a pokud byla licha pricitat 5 k nizsi cifre atd. To by bylo az 2048 iteraci pro 256 bajtu...
Existuje na to nejaky trik? Jak si to cislo rozsekat nejak...
Nastesti mam limit 256 bajtu takze mozna pujde pouzit nejake konstanty...
Ale i tak to vypada jako pekna vyzva, protoze je to retezec a delam to v makru...

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

l00k

Předmět příspěvku: Re: Macro FORTH

Napsal: 05.11.2022, 09:55

Profík

Registrován: 26.11.2018, 16:59
Příspěvky: 581
Bydliště: Holešov
Has thanked: 13 times
Been thanked: 91 times

a co klasická cesta?
jít po číslicích zleva,první číslice bude základ a pokud máme víc než 1 znak tak, rovnou vynásobit 10, přičíst další číslici, vynásobit 10x (3 rotace a 2 součty), přičíst další číslici a opakovat až do konce řetězce

asi by to chtělo 2 optimalizované pomocné funkce na násobení 10x a zvětšení čísla o 1-9

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 06.11.2022, 04:37

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

l00k píše:

Jestli to dobre chapu tak ty prevadis retezec s dekadickym cislem na (binarni) cislo. M4 umi maximalne 32bit.
Ja to potrebuji prevest z retezce do retezce. Jeden je dekadicky a druhy hexadecimalni zapis.

PS: Nebo presneji ja potrebuji retezec s cislem v desitkove soustave dostat do takoveho tvaru, ktery pujde snadno rozsekat na jednotlive bajty.

PPS: Hmm... mozna by tak slo ziskat (snadno) retezec niblu, ktery ale bude nakonec spatne zarovnany, takze nakonec by stacilo (snad) udelat nejaky bitovy posun o 0 az 3 bity?

PPPS: Nebo to tak prevest do retezce bitu. To vypada schudne. Hmm.. vlastne ne. To nasobeni deseti znamena, ze to nejde snadno prevest. Neni tam nic jako nactu nejake cifry a tady to odseknu a mam nejvyssi bity a na ty uz nemusim sahat. Takze jedine si udelat v M4 BigNum aritmetiku nad binarnim retezcem.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 06.11.2022, 20:22

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Existuje nejaky (C-style) prefix nebo suffix pro dekadicke cislo? Mam dekadicke cislo, ale muze mit uvodni nuly... a to je pak chapano jako oktalove.

A tohle je opruz

Kód:

define({__NO_LEADING_ZERO},{dnl
__{}ifelse(dnl
__{}len($1),1,{$1},
__{}substr($1,0,1),0,{__NO_LEADING_ZERO(substr($1,1))},
__{}{$1})}){}dnl

GNU M4 to ma mit stejne jako C. A ted se bavim o konstantach a ne formatovani pro printf.

0x -> hex
0X -> hex
0 -> oktalove
0b -> binarni

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Naposledy upravil _dworkin dne 06.11.2022, 23:48, celkově upraveno 1

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 06.11.2022, 21:09

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Mam nejake makro na prevod retezce s decimalnim cislem na retezec s hexadecimalnim cislem.
Ale neni to tak jasne jak jsem doufal.
Princip je takovy ze si ten retezec rozsekam po osmi cifrach (v prubehu vypoctu si pak vystacim s 32 bitovym cislem se znamenkem).
To cislo vydelim 16 a vytisknu. S puvodnimi 8 ciframi jeste udelam mod 16 a to pak vynasobim 100000000.
Pokracuji s dalsimi osmi ciframi a pricitam k tomu ten zbytek z predchoziho kroku.
Uplne na konci si bokem ulozim ten zbytek, protoze to je nejnizsi hodnota toho hexadecimalniho cisla.
To co se vytisklo je decimalni cislo do dalsiho kroku.

A ted ty problemy.
Ten vysledek po deleni 16 musim tisknout (nevim proc) v osmi cifrach. Jinak me muzou vypadnout nuly. Nevim zda to funguje vzdy, nemam to nijak overeno, asi by to chtelo si udelat nejaky dukaz pro minimalni a maximalni vstup.

Vstup MUSI zvladnout i ty uvodni nuly, abych mel jistotu, ze me nebude preskakovat kdyz na vstupu bude neco jako
16 0000 0000 1234 5678

Nacte 16 a vydeli 16 -> tiskne 1, zbytek je nula

V dalsim kroku ma byt 0000 0000 + 0 a ne 1234 5678 + 0

Kód:

dworkin@dw-A15:~/Programovani/ZX/Forth/M4$ ../check_word.sh '__STR10_TO_STR16(5512345678907771234567890123456789,0)'
>344521604931735702160493132716049:5<
>21532600308233481385030820794753:1<
>01345787519264592586564426299672:1<
>84111719954037036660276643729:8<
>5256982497127314791267290233:1<
>328561406070457174454205639:9<
>20535087879403573403387852:7<
>1283442992462723337711740:c<
>080215187028920208606983:c<
>5013449189307513037936:7<
>313340574331719564871:0<
>19583785895732472804:7<
>1223986618483279550:4<
>76499163655204971:e<
>4781197728450310:b<
>0298824858028144:6<
>18676553626759:0<
>1167284601672:7<
>72955287604:8<
>4559705475:4<
>284981592:3<
>17811349:8<
10fc7958348706be4707cc7918115
                       ;[ 0:0]

Kód:

define({__NO_LEADING_ZERO},{dnl
__{}ifelse(dnl
__{}len($1),1,{$1},
__{}substr($1,0,1),0,{__NO_LEADING_ZERO(substr($1,1))},
__{}{$1})}){}dnl
dnl
dnl
dnl
define({__STR10_DIV_16},{dnl
ifelse(1,0,{errprint({
}len($1),$1,$2{
})}){}dnl
__{}ifelse(eval(len($1)<9),1,{dnl
__{}__{}define({__STR10_MOD_16},eval((__NO_LEADING_ZERO($1)+$2)%16)){}dnl
__{}__{}eval((__NO_LEADING_ZERO($1)+$2)/16,10,8)},
__{}eval(len($1)%8),0,{dnl
__{}__{}eval((__NO_LEADING_ZERO(substr($1,0,8))+$2)/16,10,8){}dnl
__{}__{}__STR10_DIV_16(substr($1,8),eval(((__NO_LEADING_ZERO(substr($1,0,8))+$2)%16)*100000000))},
__{}{dnl
__{}__{}ifelse(eval((substr($1,0,eval(len($1)%8))+$2)>15),1,eval((substr($1,0,eval(len($1)%8))+$2)/16)){}dnl
__{}__{}__STR10_DIV_16(substr($1,eval(len($1)%8)),eval(((substr($1,0,eval(len($1)%8))+$2)%16)*100000000)){}dnl
__{}}){}dnl
}){}dnl
dnl
dnl
dnl
define({__STR10_TO_STR16_REC},{dnl
__{}ifelse(eval(len($1)>8),1,{dnl
__{}__{}define({__TEMP},__STR10_DIV_16(__NO_LEADING_ZERO($1),0)){}dnl
__{}__{}define({__RES_HEX},eval(__STR10_MOD_16,16){}__RES_HEX){}dnl
__{}__{}>__TEMP:eval(__STR10_MOD_16,16)<
__{}__{}__STR10_TO_STR16_REC(__TEMP){}dnl
__{}},
__{}{dnl
__{}__{}define({__RES_HEX},eval($1,16){}__RES_HEX){}dnl
__{}}){}dnl
}){}dnl
dnl
dnl
dnl
define({__STR10_TO_STR16},{dnl
__{}define({__RES_HEX},{}){}dnl
__{}__STR10_TO_STR16_REC($1){}dnl
__{}__RES_HEX}){}dnl

PS: Asi to jde nejak pochopit i bez dukazu, ze nactu 8 cifer (+zbytek s predchoziho co ma 9+ cifer) a vyleze me zase 8 i kdyz to delim.

PPS: Dnes je prvni den po 10 pracovnich dnech a ja jsem fakt strasne unaveny a to me jeste psali v poledne zda bych neprisel... Vubec me to nemysli... Hrozny tyden, vysokoskolaci meli inauguraci nebo nejakou jinou slavnost, takze bylo cely tyden narvano. Mam za sebou dvakrat patek se sobotou, kdy je to narocne i ve dvou a musel jsem byt sam v restauraci pro cca 187 mist. Prsty mam porezane, popalene a k tomu ten nehet. Mam toho fakt dost...

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 07.11.2022, 02:29

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Puvodni CONSTANT(name,value) jen vytvari

Kód:

name EQU value

a nic nealokuje.

Udelal jsem ale PCONSTANT(bytes,name,value), ktery jen vytvori label a pod nim alokuje inicializovany prostor cislem. Ktere se nikdy neobnovi, pokud ho prepisete. Zvladne to i lichy pocet bajtu.

Kód:

dworkin@dw-A15:~/Programovani/ZX/Forth/M4$ ../check_word.sh 'PCONSTANT(5,_b,2271560481)'


VARIABLE_SECTION:

_b:                     ; = 2271560481
    dw 0x4321
    dw 0x8765
    db 0x00
                       ;[ 0:0]
dworkin@dw-A15:~/Programovani/ZX/Forth/M4$ ../check_word.sh 'PCONSTANT(4,_b,0x87654321)'


VARIABLE_SECTION:

_b:
    dw 0x4321
    dw 0x8765
                       ;[ 0:0]
dworkin@dw-A15:~/Programovani/ZX/Forth/M4$ ../check_word.sh 'PCONSTANT(3,_b,2271560481)'

  .warning Overflow 0x87 from constant _b!

VARIABLE_SECTION:

_b:                     ; = 2271560481
    dw 0x4321
    db 0x65
                       ;[ 0:0]

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 07.11.2022, 02:43

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Takze ted by zdrojak pro vypocet faktorialu mohl vypadat nejak takto

Kód:

include(`../M4/FIRST.M4')dnl
ORG 0x8000
INIT(60000)

NO_SEGMENT(66) CREATE(_a) PHEXPUSH_COMMA(66,0x64)

NO_SEGMENT(66) CREATE(_b) PDECPUSH_COMMA(66,99)

NO_SEGMENT(66) CREATE(_c) PUSH(66) ALLOT

NO_SEGMENT(66) PCONSTANT(66,_d,10)

PUSH(_a)
PUSH(_b)
PUSH(_c)

BEGIN
   PUMUL(66)
   NROT
   P1SUB(66)
   P0NE(66) WHILE
      SWAP
AGAIN

DROP PUSH(_d) NROT

PUDOT(66) CR

DROP DROP DROP

DEPTH UDOT CR

STOP

Mozna by stalo za to dat NO_SEGMENT primo do PCONSTANT.

Nad PPUSH_VALUE() uz premyslim... (PUSH_PVALUE?) V podstate by melo delat to same co CREATE + P(HEX|DEC)PUSH_COMMA.

Kód:

dworkin@dw-A15:~/Programovani/ZX/Forth/Nova_testovaci$ ../check_word.sh 'VARIABLE(_b,0x87654321)'


VARIABLE_SECTION:

_b:
    dw 0x87654321
                       ;[ 0:0]
dworkin@dw-A15:~/Programovani/ZX/Forth/Nova_testovaci$ ../check_word.sh 'PUSH_VALUE(0x87654321,_b)'

    ld   BC, 0x87654321 ; 3:10      0x87654321 value _b
    ld  (_b), BC        ; 4:20      0x87654321 value _b

VARIABLE_SECTION:

_b: dw 0x87654321
                       ;[ 7:30]

Spravny zmatek nad poradim parametru, tam kde to nacitam ze zasobniku to mam uz podle FORTH standardu, tam kde jsem to delal jako C-styl to mam zase naopak...

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

_dworkin

Předmět příspěvku: Re: Macro FORTH

Napsal: 07.11.2022, 04:37

Pan Štábní

Registrován: 23.06.2013, 23:49
Příspěvky: 1114
Has thanked: 100 times
Been thanked: 160 times

Tak jsem provedl nejake zmeny v poradi parametru u PCONSTANT(bytes,value,name) a vytvoril PPUSH_VALUE(bytes,value,name). Do obou implicitne pridal NO_SEGMENT. Spis jsem to tak poskladal z rutin co uz mam, zadny velky problem.
Kod ted bude vypadat takto:

Kód:

include(`../M4/FIRST.M4')dnl
ORG 0x8000
INIT(60000)

PPUSH_VALUE(66,100,_a)
PPUSH_VALUE(66,99,_b)
PCONSTANT(66,0,_c)
PCONSTANT(66,10,_d)

PUSH(_a)
PUSH(_b)
PUSH(_c)

BEGIN
   PUMUL(66)
   NROT
   P1SUB(66)
   P0NE(66) WHILE
      SWAP
AGAIN

DROP PUSH(_d) NROT

PUDOT(66) CR

DROP DROP DROP

DEPTH UDOT CR

STOP

Programator je izolovan skoro od vsech nizkourovnovych starosti a muze si delat vlastni... s programem. .)

PPUSH_VALUE(bytes,hex_value,name) = NO_SEGMENT(bytes) + PHEXPUSH_COMMA(bytes,hex_value)
PPUSH_VALUE(bytes,dec_value,name) = NO_SEGMENT(bytes) + PDECPUSH_COMMA(bytes,dec_value)

Uploadnu to na github ale az zitra.

PS: Uz jsem zapomnel kde..., ale nejake slovo si muselo pamatovat zda je double nebo single, protoze na to reagovalo jine slovo, kde se to implicitne neuvadelo. Asi DOT? To musim zase nastudovat a doresit. Fakt si nic nepamatuji... demence.

PPS: Hmmm... jak se na ten zdrojak koukam, tak by mozna stalo za to mit i neco co nastavi p_hodnotu od urcite adresy v TOS(HL). Mam tam 4 promenne v pameti a jednu zahazuji. Jednu a z a_,_b nebo _c podle toho kde skonci rotace. Obecne by to nemelo usetrit ani pamet ani cas. Ale pro 10,0,0,0,0,0,0... zalezi na optimalizaci a trochu pameti by mohlo. Na tohle bych ale musel napsat novou rutinu.

_________________
Z80 Forth compiler (ZX Spectrum 48kb): https://codeberg.org/DW0RKiN/M4_FORTH

Nahoru

Stránka 24 z 40

[ Příspěvků: 598 ]

Přejít na stránku Předchozí 1 ... 21, 22, 23, 24, 25, 26, 27 ... 40 Další

Obsah fóra » ZX Spectrum, Sinclair a kompatibilní » ZX Spectrum - programování a vývoj software

Všechny časy jsou v UTC + 1 hodina [ Letní čas ]

Kdo je online

Uživatelé procházející toto fórum: stamil a 8 návštevníků

Nemůžete zakládat nová témata v tomto fóru
Nemůžete odpovídat v tomto fóru
Nemůžete upravovat své příspěvky v tomto fóru
Nemůžete mazat své příspěvky v tomto fóru
Nemůžete přikládat soubory v tomto fóru

Přejít na: