PC World Komputer 1995 November

home *** CD-ROM | disk | FTP | other *** search

/ PC World Komputer 1995 November / PCWK1195.iso / inne / dos / fraktale / frasr192.exe / CALMANFP.ASM < prev next >

Wrap

Assembly Source File | 1994-09-24 | 64.4 KB | 1,815 lines

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; calmanfp.asm - floating point version of the calcmand.asm file ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; The following code was adapted from a little program called "Mandelbrot ; Sets by Wesley Loewer" which had a very limited distribution (my ; Algebra II class). It didn't have any of the fancy integer math, but it ; did run floating point stuff pretty fast. ; ; The code was originally optimized for a 287 ('cuz that's what I've got) ; and for a large maxit (ie: use of generous overhead outside the loop to get ; slightly faster code inside the loop), which is generally the case when ; Fractint chooses to use floating point math. This code also has the ; advantage that once the initial parameters are loaded into the fpu ; register, no transfers of fp values to/from memory are needed except to ; check periodicity and to show orbits and the like. Thus, values keep all ; the significant digits of the full 10 byte real number format internal to ; the fpu. Intermediate results are not rounded to the normal IEEE 8 byte ; format (double) at any time. ; ; The non fpu specific stuff, such as periodicity checking and orbits, ; was adapted from CALCFRAC.C and CALCMAND.ASM. ; ; This file must be assembled with floating point emulation turned on. I ; suppose there could be some compiler differences in the emulation ; libraries, but this code has been successfully tested with the MSQC 2.51 ; and MSC 5.1 emulation libraries. ; ; Wes Loewer ; ; and now for some REAL fractal calculations... ; (get it, real, floating point..., never mind) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; 1. Made maxit a dword variable. 1/18/94 ; required for compatibility if Turbo ASM IFDEF ??version MASM51 QUIRKS ENDIF .8086 .8087 .MODEL medium,c ; external functions EXTRN keypressed:FAR ; this routine is in 'general.asm' EXTRN getakey:FAR ; this routine is in 'general.asm' EXTRN plot_orbit:FAR ; this routine is in 'fracsubr.c' EXTRN scrub_orbit:FAR ; this routine is in 'fracsubr.c' ; external data EXTRN init:WORD ; declared as type complex EXTRN parm:WORD ; declared as type complex EXTRN new:WORD ; declared as type complex EXTRN maxit:DWORD EXTRN inside:WORD EXTRN outside:WORD EXTRN fpu:WORD ; fpu type: 87, 287, or 387 EXTRN cpu:WORD ; cpu type EXTRN rqlim:QWORD ; bailout (I never did figure out ; what "rqlim" stands for. -Wes) EXTRN coloriter:DWORD EXTRN oldcoloriter:DWORD EXTRN realcoloriter:DWORD EXTRN periodicitycheck:WORD EXTRN reset_periodicity:WORD EXTRN closenuff:QWORD EXTRN fractype:WORD ; Mandelbrot or Julia EXTRN kbdcount:WORD ; keyboard counter EXTRN dotmode:WORD EXTRN show_orbit:WORD ; "show-orbit" flag EXTRN orbit_ptr:WORD ; "orbit pointer" flag EXTRN potflag:WORD ; potential flag EXTRN magnitude:QWORD ; when using potential extrn nextsavedincr:word ; for incrementing AND value extrn firstsavedand:dword ; AND value JULIAFP EQU 6 ; from FRACTYPE.H MANDELFP EQU 4 GREEN EQU 2 ; near y-axis YELLOW EQU 6 ; near x-axis KEYPRESSDELAY equ 16383 ; 3FFFh initx EQU <qword ptr init> ; just to make life easier inity EQU <qword ptr init+8> parmx EQU <qword ptr parm> parmy EQU <qword ptr parm+8> newx EQU <qword ptr new> newy EQU <qword ptr new+8> ; Apparently, these might be needed for TC++ overlays. I don't know if ; these are really needed here since I am not familiar with TC++. -Wes FRAME MACRO regs push bp mov bp, sp IRP reg, <regs> push reg ENDM ENDM UNFRAME MACRO regs IRP reg, <regs> pop reg ENDM pop bp ENDM .DATA align 2 savedx DQ ? savedy DQ ? orbit_real DQ ? orbit_imag DQ ? _2_ DQ 2.0 _4_ DQ 4.0 close DD 0.01 round_down_half DD 0.5 one_8_zero DD 180.0 tmp_word DW ? tmp_dword DD ? inside_color DD ? periodicity_color DW ? savedand DD ? ; need 4 bytes now, not 2 ;savedincr DW ? ;savedand EQU SI ; this doesn't save much time or savedincr EQU DI ; space, but it doesn't hurt either .CODE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; This routine is called once per image. ; Put things here that won't change from one pixel to the next. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PUBLIC calcmandfpasmstart calcmandfpasmstart PROC ; not sure if needed here FRAME <di,si> ; std frame, for TC++ overlays mov ax,inside cmp ax,0 ; if (inside color == maxiter) jnl non_neg_inside mov ax,word ptr maxit ; use maxit as inside_color mov dx,word ptr maxit+2 ; use maxit as inside_color non_neg_inside: ; else mov word ptr inside_color,ax ; use inside as inside_color mov word ptr inside_color+2,dx ; use inside as inside_color cmp periodicitycheck,0 ; if periodicitycheck < 0 jnl non_neg_periodicitycheck mov ax,7 ; use color 7 (default white) non_neg_periodicitycheck: ; else mov periodicity_color,ax ; use inside_color still in ax mov word ptr oldcoloriter,0 ; no periodicity checking on 1st pixel mov word ptr oldcoloriter+2,0 ; no periodicity checking on 1st pixel sub ax,ax ; ax=0 sub dx,dx UNFRAME <si,di> ; pop stack frame ret calcmandfpasmstart ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; floating point version of calcmandasm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PUBLIC calcmandfpasm calcmandfpasm PROC FRAME <di,si> ; std frame, for TC++ overlays ; initialization stuff sub ax,ax ; clear ax mov dx,ax ; dx=0 cmp periodicitycheck,ax ; periodicity checking? je initoldcolor ; no, set oldcolor 0 to disable it cmp inside,-59 ; zmag? je initoldcolor ; set oldcolor to 0 cmp reset_periodicity,ax ; periodicity reset? je short initparms ; no, inherit oldcolor from prior invocation mov ax,word ptr maxit ; yup. reset oldcolor to maxit-250 mov dx,word ptr maxit+2 sub ax,250 ; (avoids slowness at high maxits) sbb dx,0 ; (faster than conditional jump) initoldcolor: mov word ptr oldcoloriter,ax ; reset oldcolor mov word ptr oldcoloriter+2,dx ; reset oldcolor initparms: sub ax,ax ; clear ax mov dx,ax ; clear dx mov word ptr savedx,ax ; savedx = 0.0 mov word ptr savedx+2,ax ; needed since savedx is a QWORD mov word ptr savedx+4,ax mov word ptr savedx+6,ax mov word ptr savedy,ax ; savedy = 0.0 mov word ptr savedy+2,ax ; needed since savedy is a QWORD mov word ptr savedy+4,ax mov word ptr savedy+6,ax mov ax,word ptr firstsavedand+2 ; high part of savedand=0 mov word ptr savedand+2,ax ; high part of savedand=0 mov ax,word ptr firstsavedand ; low part of savedand mov word ptr savedand,ax ; low part of savedand mov savedincr,1 ; savedincr = 1 mov orbit_ptr,0 ; clear orbits dec kbdcount ; decrement the keyboard counter jns short step_nokey ; skip keyboard test if still positive mov kbdcount,10 ; stuff in a low kbd count cmp show_orbit,0 ; are we showing orbits? jne quickkbd ; yup. leave it that way. ;this may need to be adjusted, I'm guessing at the "appropriate" values -Wes mov kbdcount,5000 ; else, stuff an appropriate count val cmp fpu,387 ; ("appropriate" to the FPU) je short kbddiskadj ; ... mov kbdcount,3000 ; ... cmp fpu,287 ; ... je short kbddiskadj ; ... mov kbdcount,1000 ; ... cmp fpu,87 ; ... je short kbddiskadj ; ... mov kbdcount,500 ; emulation jmp short kbddiskadj step_nokey: jmp nokey kbddiskadj: cmp dotmode,11 ; disk video? jne quickkbd ; no, leave as is shr kbdcount,1 ; yes, reduce count shr kbdcount,1 ; yes, reduce count quickkbd: call far ptr keypressed ; has a key been pressed? cmp ax,0 ; ... je nokey ; nope. proceed mov kbdcount,0 ; make sure it goes negative again cmp ax,'o' ; orbit toggle hit? je orbitkey ; yup. show orbits cmp ax,'O' ; orbit toggle hit? jne keyhit ; nope. normal key. orbitkey: call far ptr getakey ; read the key for real mov ax,1 ; reset orbittoggle = 1 - orbittoggle sub ax,show_orbit ; ... mov show_orbit,ax ; ... jmp short nokey ; pretend no key was hit keyhit: mov ax,-1 ; return with -1 mov dx,ax mov word ptr coloriter,ax ; set color to -1 mov word ptr coloriter+2,ax ; set color to -1 UNFRAME <si,di> ; pop stack frame ret ; bail out! nokey: ; OK, here's the heart of the floating point code. ; In my original program, the bailout value was loaded once per image and ; was left on the floating point stack after each pixel, and finally popped ; off the stack when the fractal was finished. A lot of overhead for very ; little gain in my opinion, so I changed it so that it loads and unloads ; per pixel. -Wes fld rqlim ; everything needs bailout first cmp cpu,386 je check_for_386_387 not_a_386_387: mov cx,word ptr maxit+2 ; using cx and bx as loop counter mov bx,word ptr maxit ; using cx and bx as loop counter cmp fpu,387 ; jump to fpu specific code je start_387 ; 387, slight efficiency tweeking cmp fpu,287 ; je to_start_287 ; 287 (original version) jmp start_87 ; else must be 87/emulation to_start_287: jmp start_287 ; needs a long jump here check_for_386_387: cmp fpu,387 jb not_a_386_387 .386 mov ecx,maxit .8086 jmp start_386_387 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; _387 code is just like _287 code except that it uses an FADD instead ; of an FSCALE per orbit and also saves an FLD1 per pixel. ; ; You could use .386/.387 here, but it is not necessary. The _387 floating ; point routines in this file do not have any 387 specific op-codes, ; only 387 specific optimizations. (And plus my MS QuickAssembler does not ; recognize the .386/.387 directives.) -Wes ; .286 .287 start_387: cmp fractype,JULIAFP ; julia or mandelbrot set? je short dojulia_387 ; julia set - go there ; Mandelbrot _387 initialization of stack sub bx,1 ; always requires at least 1 iteration sbb cx,0 ; the fpu stack is shown below ; st(0) ... st(7) ; b (already on stack) fld inity ; Cy b fld initx ; Cx Cy b fld st(1) ; Cy Cx Cy b fadd parmy ; Py+Cy Cx Cy b fld st ; Py+Cy Py+Cy Cx Cy b fmul st,st ; (Py+Cy)^2 Py+Cy Cx Cy b fld st(2) ; Cx (Py+Cy)^2 Py+Cy Cx Cy b fadd parmx ; Px+Cx (Py+Cy)^2 Py+Cy Cx Cy b fmul st(2),st ; Px+Cx (Py+Cy)^2 (Py+Cy)(Px+Cx) Cx Cy b fmul st,st ; (Px+Cx)^2 (Py+Cy)^2 (Py+Cy)(Px+Cx) Cx Cy b ; which is the next x^2 y^2 xy Cx Cy b jmp short top_of_cx_loop_387 ; branch around the julia switch dojulia_387: ; Julia 387 initialization of stack ; note that init and parm are "reversed" ; b (already on stack) fld parmy ; Cy b fld parmx ; Cx Cy b fld inity ; y Cx Cy b fld st ; y y Cx Cy b fmul st,st ; y^2 y Cx Cy b fld initx ; x y^2 y Cx Cy b fmul st(2),st ; x y^2 xy Cx Cy b fmul st,st ; x^2 y^2 xy Cx Cy b top_of_cx_loop_387: ; x^2 y^2 xy Cx Cy b fsubr ; x^2-y^2 xy Cx Cy b fadd st,st(2) ; x^2-y^2+Cx xy Cx Cy b fxch ; xy x^2-y^2+Cx Cx Cy b ; FADD is faster than FSCALE for 387 fadd st,st ; 2xy x^2-y^2+Cx Cx Cy b fadd st,st(3) ; 2xy+Cy x^2-y^2+Cx Cx Cy b ; now same as the new ; y x Cx Cy b cmp outside,-2 ; real, imag, mult, or sum ? jg no_save_new_xy_387 ; if not, then skip this fld st(1) ; x y x Cx Cy b fstp newx ; y x Cx Cy b fst newy ; y x Cx Cy b no_save_new_xy_387: cmp inside,-100 ; epsilon cross ? jne end_epsilon_cross_387 call near ptr epsilon_cross ; y x Cx Cy b cmp bx,0 jnz end_epsilon_cross_387 cmp cx,0 jnz end_epsilon_cross_387 ; if cx=0, pop stack jmp pop_stack_387 end_epsilon_cross_387: test bx,KEYPRESSDELAY ; bx holds the low word of the loop count jne notakey1 ; don't test yet push cx push bx call far ptr keypressed ; has a key been pressed? pop bx pop cx cmp ax,0 ; ... je notakey1 ; nope. proceed jmp keyhit notakey1: cmp cx,word ptr oldcoloriter+2 ; if cx > oldcoloriter ja end_periodicity_check_387 ; don't check periodicity cmp bx,word ptr oldcoloriter ; if bx >= oldcoloriter jae end_periodicity_check_387 ; don't check periodicity call near ptr periodicity_check_287_387 ; y x Cx Cy b cmp bx,0 jnz end_periodicity_check_387 cmp cx,0 jnz end_periodicity_check_387 ; if cx=0, pop stack jmp pop_stack_387 end_periodicity_check_387: cmp show_orbit,0 ; is show_orbit clear je no_show_orbit_387 ; if so then skip call near ptr show_orbit_xy ; y x Cx Cy b no_show_orbit_387: ; y x Cx Cy b fld st(1) ; x y x Cx Cy b fld st(1) ; y x y x Cx Cy b fmul st(3),st ; y x y xy Cx Cy b fmulp st(2),st ; x y^2 xy Cx Cy b fmul st,st ; x^2 y^2 xy Cx Cy b fld st ; x^2 x^2 y^2 xy Cx Cy b fadd st,st(2) ; x^2+y^2 x^2 y^2 xy Cx Cy b cmp potflag,0 ; check for potential je no_potflag_387 fst magnitude ; if so, save magnitude no_potflag_387: fcomp st(6) ; x^2 y^2 xy Cx Cy b fstsw ax sahf ja over_bailout_387 ;less than or equal to bailout ; loop top_of_cx_loop_387 ; x^2 y^2 xy Cx Cy b sub bx,1 sbb cx,0 jnz top_of_cx_loop_387 cmp bx,0 jnz top_of_cx_loop_387 ; reached maxit, inside mov word ptr oldcoloriter,-1 ; check periodicity immediately next time mov word ptr oldcoloriter+2,-1 ; check periodicity immediately next time mov ax,word ptr maxit mov dx,word ptr maxit+2 sub kbdcount,ax ; adjust the keyboard count mov word ptr realcoloriter,ax ; save unadjusted realcoloriter mov word ptr realcoloriter+2,dx ; save unadjusted realcoloriter mov ax,word ptr inside_color mov dx,word ptr inside_color+2 cmp inside,-59 ; zmag ? jne no_zmag_387 fadd st,st(1) ; x^2+y^2 y^2 xy Cx Cy b fimul maxit ; maxit*|z^2| x^2 y^2 xy Cx Cy b ; When type casting floating point variables to integers in C, the decimal ; is truncated. When using FIST in asm, the value is rounded. The following ; line cause the positive value to be truncated. fsub round_down_half fist tmp_dword ; tmp_word = |z^2|*maxit fwait mov ax,word ptr tmp_dword mov dx,word ptr tmp_dword+2 shr dx,1 ; |z^2|*maxit/2 rcr ax,1 add ax,1 ; |z^2|*maxit/2+1 adc dx,0 no_zmag_387: pop_stack_387: fninit mov word ptr coloriter,ax mov word ptr coloriter+2,dx cmp orbit_ptr,0 ; any orbits to clear? je calcmandfpasm_ret_387 ; nope. call far ptr scrub_orbit ; clear out any old orbits mov ax,word ptr coloriter ; restore color mov dx,word ptr coloriter+2 ; restore color ; speed not critical here in orbit land calcmandfpasm_ret_387: UNFRAME <si,di> ; pop stack frame fwait ; just to make sure ret over_bailout_387: ; x^2 y^2 xy Cx Cy b ; outside mov dx,cx mov ax,bx sub ax,10 ; 10 more next time before checking sbb dx,0 jns no_fix_underflow_387 ; if the number of iterations was within 10 of maxit, then subtracting ; 10 would underflow and cause periodicity checking to start right ; away. Catching a period doesn't occur as often in the pixels at ; the edge of the set anyway. sub ax,ax ; don't check next time mov dx,ax no_fix_underflow_387: mov word ptr oldcoloriter,ax ; check when past this - 10 next time mov word ptr oldcoloriter+2,dx ; check when past this - 10 next time mov ax,word ptr maxit mov dx,word ptr maxit+2 sub ax,bx ; leave 'times through loop' in ax sbb dx,cx ; and dx ; zero color fix jnz zero_color_fix_387 cmp ax,0 jnz zero_color_fix_387 inc ax ; if (ax == 0 ) ax = 1 zero_color_fix_387: mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count cmp outside,-1 ; iter ? (most common case) je pop_stack_387 cmp outside,-2 ; outside <= -2 ? jle special_outside_387 ; yes, go do special outside options mov ax,outside ; use outside color sub dx,dx jmp short pop_stack_387 special_outside_387: call near ptr special_outside jmp short pop_stack_387 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; _386_387 code is just like _287 code except that it uses an FADD ; instead of an FSCALE per orbit and also saves an FLD1 per pixel. ; And uses 386 specific speedups. ; .386 .387 start_386_387: cmp fractype,JULIAFP ; julia or mandelbrot set? je short dojulia_386_387 ; julia set - go there ; Mandelbrot _386_387 initialization of stack dec ecx ; always requires at least 1 iteration ; the fpu stack is shown below ; st(0) ... st(7) ; b (already on stack) fld inity ; Cy b fld initx ; Cx Cy b fld st(1) ; Cy Cx Cy b fadd parmy ; Py+Cy Cx Cy b fld st ; Py+Cy Py+Cy Cx Cy b fmul st,st ; (Py+Cy)^2 Py+Cy Cx Cy b fld st(2) ; Cx (Py+Cy)^2 Py+Cy Cx Cy b fadd parmx ; Px+Cx (Py+Cy)^2 Py+Cy Cx Cy b fmul st(2),st ; Px+Cx (Py+Cy)^2 (Py+Cy)(Px+Cx) Cx Cy b fmul st,st ; (Px+Cx)^2 (Py+Cy)^2 (Py+Cy)(Px+Cx) Cx Cy b ; which is the next x^2 y^2 xy Cx Cy b jmp short top_of_cx_loop_386_387 ; branch around the julia switch dojulia_386_387: ; Julia 387 initialization of stack ; note that init and parm are "reversed" ; b (already on stack) fld parmy ; Cy b fld parmx ; Cx Cy b fld inity ; y Cx Cy b fld st ; y y Cx Cy b fmul st,st ; y^2 y Cx Cy b fld initx ; x y^2 y Cx Cy b fmul st(2),st ; x y^2 xy Cx Cy b fmul st,st ; x^2 y^2 xy Cx Cy b top_of_cx_loop_386_387: ; x^2 y^2 xy Cx Cy b fsubr ; x^2-y^2 xy Cx Cy b fadd st,st(2) ; x^2-y^2+Cx xy Cx Cy b fxch ; xy x^2-y^2+Cx Cx Cy b ; FADD is faster than FSCALE for 387 fadd st,st ; 2xy x^2-y^2+Cx Cx Cy b fadd st,st(3) ; 2xy+Cy x^2-y^2+Cx Cx Cy b ; now same as the new ; y x Cx Cy b cmp outside,-2 ; real, imag, mult, or sum ? jg no_save_new_xy_386_387 ; if not, then skip this fld st(1) ; x y x Cx Cy b fstp newx ; y x Cx Cy b fst newy ; y x Cx Cy b no_save_new_xy_386_387: cmp inside,-100 ; epsilon cross ? jne end_epsilon_cross_386_387 call near ptr epsilon_cross_386_387 ; y x Cx Cy b jecxz step_to_pop_stack_386_387 ; if ecx=0, pop stack end_epsilon_cross_386_387: test ecx,KEYPRESSDELAY ; ecx holds the loop count jne notakey2 ; don't test yet push ecx call far ptr keypressed ; has a key been pressed? pop ecx cmp ax,0 ; ... je notakey2 ; nope. proceed jmp keyhit notakey2: cmp ecx,oldcoloriter ; if ecx > oldcolor jae end_periodicity_check_386_387 ; don't check periodicity call near ptr periodicity_check_386_387 ; y x Cx Cy b jecxz step_to_pop_stack_386_387 ; if ecx=0, pop stack jmp short end_periodicity_check_386_387 step_to_pop_stack_386_387: jmp short pop_stack_386_387 end_periodicity_check_386_387: cmp show_orbit,0 ; is show_orbit clear je no_show_orbit_386_387 ; if so then skip call near ptr show_orbit_xy ; y x Cx Cy b no_show_orbit_386_387: ; y x Cx Cy b fld st(1) ; x y x Cx Cy b fld st(1) ; y x y x Cx Cy b fmul st(3),st ; y x y xy Cx Cy b fmulp st(2),st ; x y^2 xy Cx Cy b fmul st,st ; x^2 y^2 xy Cx Cy b fld st ; x^2 x^2 y^2 xy Cx Cy b fadd st,st(2) ; x^2+y^2 x^2 y^2 xy Cx Cy b cmp potflag,0 ; check for potential je no_potflag_386_387 fst magnitude ; if so, save magnitude no_potflag_386_387: fcomp st(6) ; x^2 y^2 xy Cx Cy b fstsw ax sahf ja over_bailout_386_387 ;less than or equal to bailout ; loopd top_of_cx_loop_386_387 ; x^2 y^2 xy Cx Cy b dec ecx jnz top_of_cx_loop_386_387 ; reached maxit, inside mov oldcoloriter,-1 ; check periodicity immediately next time mov eax,maxit sub kbdcount,ax ; adjust the keyboard count mov realcoloriter,eax ; save unadjusted realcolor mov eax,inside_color cmp inside,-59 ; zmag ? jne no_zmag_386_387 fadd st,st(1) ; x^2+y^2 y^2 xy Cx Cy b fimul maxit ; maxit*|z^2| x^2 y^2 xy Cx Cy b ; When type casting floating point variables to integers in C, the decimal ; is truncated. When using FIST in asm, the value is rounded. The following ; line cause the positive value to be truncated. fsub round_down_half fist tmp_dword ; tmp_dword = |z^2|*maxit fwait mov eax,tmp_dword shr eax,1 ; |z^2|*maxit/2 inc eax ; |z^2|*maxit/2+1 no_zmag_386_387: pop_stack_386_387: fninit mov coloriter,eax cmp orbit_ptr,0 ; any orbits to clear? je calcmandfpasm_ret_386_387 ; nope. call far ptr scrub_orbit ; clear out any old orbits mov eax,coloriter ; restore color ; speed not critical here in orbit land calcmandfpasm_ret_386_387: shld edx,eax,16 ; put results in ax,dx shr eax,16 UNFRAME <si,di> ; pop stack frame fwait ; just to make sure ret over_bailout_386_387: ; x^2 y^2 xy Cx Cy b ; outside mov eax,ecx sub eax,10 ; 10 more next time before checking jns no_fix_underflow_386_387 ; if the number of iterations was within 10 of maxit, then subtracting ; 10 would underflow and cause periodicity checking to start right ; away. Catching a period doesn't occur as often in the pixels at ; the edge of the set anyway. sub eax,eax ; don't check next time no_fix_underflow_386_387: mov oldcoloriter,eax ; check when past this - 10 next time mov eax,maxit sub eax,ecx ; leave 'times through loop' in eax ; zero color fix jnz zero_color_fix_386_387 inc eax ; if (eax == 0 ) eax = 1 zero_color_fix_386_387: mov realcoloriter,eax ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count cmp outside,-1 ; iter ? (most common case) je pop_stack_386_387 cmp outside,-2 ; outside <= -2 ? jle to_special_outside_386_387 ; yes, go do special outside options sub eax,eax ; clear top half of eax for next mov ax,outside ; use outside color jmp short pop_stack_386_387 to_special_outside_386_387: call near ptr special_outside_386_387 jmp short pop_stack_386_387 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; _287 version (closely resembles original code) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .286 .287 start_287: ; 287 cmp fractype,JULIAFP ; julia or mandelbrot set? je short dojulia_287 ; julia set - go there ; Mandelbrot _287 initialization of stack sub bx,1 ; always requires at least 1 iteration sbb cx,0 ; the fpu stack is shown below ; st(0) ... st(7) ; b (already on stack) fld inity ; Cy b fld initx ; Cx Cy b fld st(1) ; Cy Cx Cy b fadd parmy ; Py+Cy Cx Cy b fld1 ; 1 Py+Cy Cx Cy b fld st(1) ; Py+Cy 1 Py+Cy Cx Cy b fmul st,st ; (Py+Cy)^2 1 Py+Cy Cx Cy b fld st(3) ; Cx (Py+Cy)^2 1 Py+Cy Cx Cy b fadd parmx ; Px+Cx (Py+Cy)^2 1 Py+Cy Cx Cy b fmul st(3),st ; Px+Cx (Py+Cy)^2 1 (Py+Cy)(Px+Cx) Cx Cy b fmul st,st ; (Px+Cx)^2 (Py+Cy)^2 1 (Py+Cy)(Px+Cx) Cx Cy b ; which is the next x^2 y^2 1 xy Cx Cy b jmp short top_of_cx_loop_287 ; branch around the julia switch dojulia_287: ; Julia 287 initialization of stack ; note that init and parm are "reversed" ; b (already on stack) fld parmy ; Cy b fld parmx ; Cx Cy b fld inity ; y Cx Cy b fld1 ; 1 y Cx Cy b fld st(1) ; y 1 y Cx Cy b fmul st,st ; y^2 1 y Cx Cy b fld initx ; x y^2 1 y Cx Cy b fmul st(3),st ; x y^2 1 xy Cx Cy b fmul st,st ; x^2 y^2 1 xy Cx Cy b top_of_cx_loop_287: ; x^2 y^2 1 xy Cx Cy b fsubr ; x^2-y^2 1 xy Cx Cy b fadd st,st(3) ; x^2-y^2+Cx 1 xy Cx Cy b fxch st(2) ; xy 1 x^2-y^2+Cx Cx Cy b ; FSCALE is faster than FADD for 287 fscale ; 2xy 1 x^2-y^2+Cx Cx Cy b fadd st,st(4) ; 2xy+Cy 1 x^2-y^2+Cx Cx Cy b ; now same as the new ; y 1 x Cx Cy b cmp outside,-2 ; real, imag, mult, or sum ? jg no_save_new_xy_287 ; if not, then skip this fld st(2) ; x y 1 x Cx Cy b fstp newx ; y 1 x Cx Cy b fst newy ; y 1 x Cx Cy b no_save_new_xy_287: cmp inside,-100 ; epsilon cross ? jne end_epsilon_cross_287 call near ptr epsilon_cross ; y 1 x Cx Cy b cmp bx,0 jnz end_epsilon_cross_287 cmp cx,0 jnz end_epsilon_cross_287 ; if cx=0, pop stack jmp pop_stack_287 end_epsilon_cross_287: test bx,KEYPRESSDELAY ; bx holds the low word of the loop count jne notakey3 ; don't test yet push cx push bx call far ptr keypressed ; has a key been pressed? pop bx pop cx cmp ax,0 ; ... je notakey3 ; nope. proceed jmp keyhit notakey3: cmp cx,word ptr oldcoloriter+2 ; if cx > oldcolor ja end_periodicity_check_287 ; don't check periodicity cmp bx,word ptr oldcoloriter ; if bx >= oldcolor jae end_periodicity_check_287 ; don't check periodicity call near ptr periodicity_check_287_387 ; y 1 x Cx Cy b cmp bx,0 jnz end_periodicity_check_287 cmp cx,0 jnz end_periodicity_check_287 ; if cx=0, pop stack jmp pop_stack_287 end_periodicity_check_287: cmp show_orbit,0 ; is show_orbit clear je no_show_orbit_287 ; if so then skip call near ptr show_orbit_xy ; y 1 x Cx Cy b no_show_orbit_287: ; y 1 x Cx Cy b fld st(2) ; x y 1 x Cx Cy b fld st(1) ; y x y 1 x Cx Cy b fmul st(4),st ; y x y 1 xy Cx Cy b fmulp st(2),st ; x y^2 1 xy Cx Cy b fmul st,st ; x^2 y^2 1 xy Cx Cy b fld st ; x^2 x^2 y^2 1 xy Cx Cy b fadd st,st(2) ; x^2+y^2 x^2 y^2 1 xy Cx Cy b cmp potflag,0 ; check for potential je no_potflag_287 fst magnitude ; if so, save magnitude no_potflag_287: fcomp st(7) ; x^2 y^2 1 xy Cx Cy b fstsw ax sahf ja over_bailout_287 ;less than or equal to bailout ; loop top_of_cx_loop_287 ; x^2 y^2 1 xy Cx Cy b sub bx,1 sbb cx,0 jnz top_of_cx_loop_287 cmp bx,0 jnz top_of_cx_loop_287 ; reached maxit, inside mov word ptr oldcoloriter,-1 ; check periodicity immediately next time mov word ptr oldcoloriter+2,-1 ; check periodicity immediately next time mov ax,word ptr maxit mov dx,word ptr maxit+2 sub kbdcount,ax ; adjust the keyboard count mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor mov ax,word ptr inside_color mov dx,word ptr inside_color+2 cmp inside,-59 ; zmag ? jne no_zmag_287 fadd st,st(1) ; x^2+y^2 y^2 1 xy Cx Cy b fimul maxit ; maxit*|z^2| x^2 y^2 1 xy Cx Cy b ; When type casting floating point variables to integers in C, the decimal ; is truncated. When using FIST in asm, the value is rounded. The following ; line cause the positive value to be truncated. fsub round_down_half fist tmp_dword ; tmp_word = |z^2|*maxit fwait mov ax,word ptr tmp_dword shr dx,1 ; |z^2|*maxit/2 rcr ax,1 add ax,1 ; |z^2|*maxit/2+1 adc dx,0 no_zmag_287: pop_stack_287: fninit mov word ptr coloriter,ax mov word ptr coloriter+2,dx cmp orbit_ptr,0 ; any orbits to clear? je calcmandfpasm_ret_287 ; nope. call far ptr scrub_orbit ; clear out any old orbits mov ax,word ptr coloriter ; restore color mov dx,word ptr coloriter+2 ; restore color ; speed not critical here in orbit land calcmandfpasm_ret_287: UNFRAME <si,di> ; pop stack frame fwait ; just to make sure ret over_bailout_287: ; x^2 y^2 1 xy Cx Cy b ; outside mov dx,cx mov ax,bx sub ax,10 ; 10 more next time before checking sbb dx,0 jns no_fix_underflow_287 ; if the number of iterations was within 10 of maxit, then subtracting ; 10 would underflow and cause periodicity checking to start right ; away. Catching a period doesn't occur as often in the pixels at ; the edge of the set anyway. sub ax,ax ; don't check next time mov dx,ax no_fix_underflow_287: mov word ptr oldcoloriter,ax ; check when past this - 10 next time mov word ptr oldcoloriter+2,dx ; check when past this - 10 next time mov ax,word ptr maxit mov dx,word ptr maxit+2 sub ax,bx ; leave 'times through loop' in ax sbb dx,cx ; and dx ; zero color fix jnz zero_color_fix_287 cmp ax,0 jnz zero_color_fix_287 inc ax ; if (ax == 0 ) ax = 1 zero_color_fix_287: mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count cmp outside,-1 ; iter ? (most common case) je pop_stack_287 cmp outside,-2 ; outside <= -2 ? jle special_outside_287 ; yes, go do special outside options mov ax,outside ; use outside color sub dx,dx jmp short pop_stack_287 special_outside_287: call near ptr special_outside jmp short pop_stack_287 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; _87 code is just like 287 code except that it must use ; fstsw tmp_word ; fwait ; mov ax,tmp_word ; instead of ; fstsw ax ; .8086 .8087 start_87: ; let emulation fall through to the 87 code here ; as it seems not emulate correctly on an 8088/86 otherwise cmp fractype,JULIAFP ; julia or mandelbrot set? je short dojulia_87 ; julia set - go there ; Mandelbrot _87 initialization of stack sub bx,1 ; always requires at least 1 iteration sbb cx,0 ; the fpu stack is shown below ; st(0) ... st(7) ; b (already on stack) fld inity ; Cy b fld initx ; Cx Cy b fld st(1) ; Cy Cx Cy b fadd parmy ; Py+Cy Cx Cy b fld1 ; 1 Py+Cy Cx Cy b fld st(1) ; Py+Cy 1 Py+Cy Cx Cy b fmul st,st ; (Py+Cy)^2 1 Py+Cy Cx Cy b fld st(3) ; Cx (Py+Cy)^2 1 Py+Cy Cx Cy b fadd parmx ; Px+Cx (Py+Cy)^2 1 Py+Cy Cx Cy b fmul st(3),st ; Px+Cx (Py+Cy)^2 1 (Py+Cy)(Px+Cx) Cx Cy b fmul st,st ; (Px+Cx)^2 (Py+Cy)^2 1 (Py+Cy)(Px+Cx) Cx Cy b ; which is the next x^2 y^2 1 xy Cx Cy b jmp short top_of_cx_loop_87 ; branch around the julia switch dojulia_87: ; Julia 87 initialization of stack ; note that init and parm are "reversed" ; b (already on stack) fld parmy ; Cy b fld parmx ; Cx Cy b fld inity ; y Cx Cy b fld1 ; 1 y Cx Cy b fld st(1) ; y 1 y Cx Cy b fmul st,st ; y^2 1 y Cx Cy b fld initx ; x y^2 1 y Cx Cy b fmul st(3),st ; x y^2 1 xy Cx Cy b fmul st,st ; x^2 y^2 1 xy Cx Cy b top_of_cx_loop_87: ; x^2 y^2 1 xy Cx Cy b fsubr ; x^2-y^2 1 xy Cx Cy b fadd st,st(3) ; x^2-y^2+Cx 1 xy Cx Cy b fxch st(2) ; xy 1 x^2-y^2+Cx Cx Cy b ; FSCALE is faster than FADD for 87 fscale ; 2xy 1 x^2-y^2+Cx Cx Cy b fadd st,st(4) ; 2xy+Cy 1 x^2-y^2+Cx Cx Cy b ; now same as the new ; y 1 x Cx Cy b cmp outside,-2 ; real, imag, mult, or sum ? jg no_save_new_xy_87 ; if not, then skip this fld st(2) ; x y 1 x Cx Cy b fstp newx ; y 1 x Cx Cy b fst newy ; y 1 x Cx Cy b no_save_new_xy_87: cmp inside,-100 ; epsilon cross ? jne end_epsilon_cross_87 call near ptr epsilon_cross ; y 1 x Cx Cy b cmp bx,0 jnz end_epsilon_cross_87 cmp cx,0 jnz end_epsilon_cross_87 ; if cx=0, pop stack jmp pop_stack_6_87 ; with a long jump end_epsilon_cross_87: test bx,KEYPRESSDELAY ; bx holds the low word of the loop count jne notakey4 ; don't test yet push cx push bx call far ptr keypressed ; has a key been pressed? pop bx pop cx cmp ax,0 ; ... je notakey4 ; nope. proceed jmp keyhit notakey4: cmp cx,word ptr oldcoloriter+2 ; if cx > oldcolor ja no_periodicity_check_87 ; don't check periodicity cmp bx,word ptr oldcoloriter ; if bx >= oldcolor jae no_periodicity_check_87 ; don't check periodicity call near ptr periodicity_check_87 ; y 1 x Cx Cy b cmp bx,0 jnz no_periodicity_check_87 cmp cx,0 jnz no_periodicity_check_87 ; if cx=0, pop stack jmp pop_stack_6_87 no_periodicity_check_87: cmp show_orbit,0 ; is show_orbit clear je no_show_orbit_87 ; if so then skip call near ptr show_orbit_xy ; y 1 x Cx Cy b no_show_orbit_87: ; y 1 x Cx Cy b fld st(2) ; x y 1 x Cx Cy b fld st(1) ; y x y 1 x Cx Cy b fmul st(4),st ; y x y 1 xy Cx Cy b fmulp st(2),st ; x y^2 1 xy Cx Cy b fmul st,st ; x^2 y^2 1 xy Cx Cy b fld st ; x^2 x^2 y^2 1 xy Cx Cy b fadd st,st(2) ; x^2+y^2 x^2 y^2 1 xy Cx Cy b cmp potflag,0 ; check for potential je no_potflag_87 fst magnitude ; if so, save magnitude no_potflag_87: fcomp st(7) ; x^2 y^2 1 xy Cx Cy b fstsw tmp_word fwait mov ax,tmp_word sahf ja over_bailout_87 ;less than or equal to bailout ; loop top_of_cx_loop_87 ; x^2 y^2 1 xy Cx Cy b sub bx,1 sbb cx,0 jnz top_of_cx_loop_87 cmp bx,0 jnz top_of_cx_loop_87 ; reached maxit mov word ptr oldcoloriter,-1 ; check periodicity immediately next time mov word ptr oldcoloriter+2,-1 ; check periodicity immediately next time mov ax,word ptr maxit mov dx,word ptr maxit+2 sub kbdcount,ax ; adjust the keyboard count mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor mov ax,word ptr inside_color mov dx,word ptr inside_color+2 cmp inside,-59 ; zmag ? jne no_zmag_87 fadd st,st(1) ; x^2+y^2 y^2 1 xy Cx Cy b fimul maxit ; maxit*|z^2| x^2 y^2 1 xy Cx Cy b ; When type casting floating point variables to integers in C, the decimal ; is truncated. When using FIST in asm, the value is rounded. The following ; line cause the positive value to be truncated. fsub round_down_half fist tmp_dword ; tmp_word = |z^2|*maxit fwait mov ax,word ptr tmp_dword mov dx,word ptr tmp_dword+2 shr dx,1 ; |z^2|*maxit/2 rcr ax,1 add ax,1 ; |z^2|*maxit/2+1 adc dx,0 no_zmag_87: pop_stack_7_87: ; The idea here is just to clear the floating point stack. There was a ; problem using FNINIT with the emulation library. It didn't seem to ; properly clear the emulated stack, resulting in "stack overflow" ; messages. Therefore, if emulation is being used, then FSTP's are used ; instead. cmp fpu,0 ; are we using emulation? jne no_emulation ; if not, then jump fstp st ; you could just jump over this next check, but its faster to just check again pop_stack_6_87: cmp fpu,0 ; are we using emulation? jne no_emulation ; if not, then jump fstp st fstp st fstp st fstp st fstp st fstp st jmp short end_pop_stack_87 no_emulation: ; if no emulation, then fninit ; use the faster FNINIT end_pop_stack_87: mov word ptr coloriter,ax mov word ptr coloriter+2,dx cmp orbit_ptr,0 ; any orbits to clear? je calcmandfpasm_ret_87 ; nope. call far ptr scrub_orbit ; clear out any old orbits mov ax,word ptr coloriter ; restore color mov dx,word ptr coloriter+2 ; restore color ; speed not critical here in orbit land calcmandfpasm_ret_87: UNFRAME <si,di> ; pop stack frame fwait ; just to make sure ret over_bailout_87: ; x^2 y^2 1 xy Cx Cy b ; outside mov dx,cx mov ax,bx sub ax,10 ; 10 more next time before checking sbb dx,0 jns no_fix_underflow_87 ; if the number of iterations was within 10 of maxit, then subtracting ; 10 would underflow and cause periodicity checking to start right ; away. Catching a period doesn't occur as often in the pixels at ; the edge of the set anyway. sub ax,ax ; don't check next time mov dx,ax no_fix_underflow_87: mov word ptr oldcoloriter,ax ; check when past this - 10 next time mov word ptr oldcoloriter+2,dx ; check when past this - 10 next time mov ax,word ptr maxit mov dx,word ptr maxit+2 sub ax,bx ; leave 'times through loop' in ax sbb dx,cx ; and dx ; zero color fix jnz zero_color_fix_87 cmp ax,0 jnz zero_color_fix_87 inc ax ; if (ax == 0 ) ax = 1 zero_color_fix_87: mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count cmp outside,-1 ; iter ? (most common case) je pop_stack_7_87 cmp outside,-2 ; outside <= -2 ? jle special_outside_87 ; yes, go do special outside options mov ax,outside ; use outside color sub dx,dx jmp pop_stack_7_87 special_outside_87: call near ptr special_outside jmp pop_stack_7_87 calcmandfpasm ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Since periodicity checking is used most of the time, I decided to ; separate the periodicity_check routines into a _287_387 version ; and an _87 version to achieve a slight increase in speed. The ; epsilon_cross, show_orbit_xy, and special_outside routines are less ; frequently used and therefore have been implemented as single routines ; usable by the 8087 and up. -Wes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .286 .287 periodicity_check_287_387 PROC NEAR ; REMEMBER, the cx counter is counting BACKWARDS from maxit to 0 ; fpu stack is either ; y x Cx Cy b (387) ; y 1 x Cx Cy b (287/emul) cmp fpu,387 jb pc_load_x fld st(1) ; if 387 jmp short pc_end_load_x pc_load_x: fld st(2) ; if 287/emul pc_end_load_x: ; x y ... test cx,word ptr savedand+2 ; save on 0, check on anything else jnz do_check_287_387 ; time to save a new "old" value test bx,word ptr savedand ; save on 0, check on anything else jnz do_check_287_387 ; time to save a new "old" value ; save last value ; fpu stack is fstp savedx ; x y ... fst savedy ; y ... dec savedincr ; time to lengthen the periodicity? jnz per_check_287_387_ret ; if not 0, then skip shl word ptr savedand,1 ; savedand = (savedand << 1) + 1 rcl word ptr savedand+2,1 ; savedand = (savedand << 1) + 1 add word ptr savedand,1 ; for longer periodicity adc word ptr savedand+2,0 ; for longer periodicity mov ax,nextsavedincr ; and restart counter mov savedincr,ax ; and restart counter ret ; y ... do_check_287_387: ; fpu stack is ; x y ... fsub savedx ; x-savedx y ... fabs ; |x-savedx| y ... fcomp closenuff ; y ... fstsw ax sahf ja per_check_287_387_ret fld st ; y y ... fsub savedy ; y-savedy y ... fabs ; |y-savedy| y ... fcomp closenuff ; y ... fstsw ax sahf ja per_check_287_387_ret ; caught a cycle!!! mov word ptr oldcoloriter,-1 ; check periodicity immediately next time mov word ptr oldcoloriter+2,-1 ; check periodicity immediately next time mov ax,word ptr maxit mov dx,word ptr maxit+2 mov word ptr realcoloriter,ax ; save unadjusted realcolor as maxit mov word ptr realcoloriter+2,dx ; save unadjusted realcolor as maxit sub dx,cx ; subtract half c sbb ax,bx ; subtract half c sub kbdcount,ax ; adjust the keyboard count mov ax,periodicity_color ; set color sub dx,dx sub cx,cx ; flag to exit cx loop immediately mov bx,cx per_check_287_387_ret: ret periodicity_check_287_387 ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .386 .387 periodicity_check_386_387 PROC NEAR ; REMEMBER, the cx counter is counting BACKWARDS from maxit to 0 ; fpu stack is ; y x Cx Cy b fld st(1) ; ; x y ... test ecx,savedand ; save on 0, check on anything else jnz do_check_386_387 ; time to save a new "old" value ; save last value ; fpu stack is fstp savedx ; x y ... fst savedy ; y ... dec savedincr ; time to lengthen the periodicity? jnz per_check_386_387_ret ; if not 0, then skip shl savedand,1 ; savedand = (savedand << 1) + 1 inc savedand ; for longer periodicity mov ax,nextsavedincr ; and restart counter mov savedincr,ax ; and restart counter ret ; y ... do_check_386_387: ; fpu stack is ; x y ... fsub savedx ; x-savedx y ... fabs ; |x-savedx| y ... fcomp closenuff ; y ... fstsw ax sahf ja per_check_386_387_ret fld st ; y y ... fsub savedy ; y-savedy y ... fabs ; |y-savedy| y ... fcomp closenuff ; y ... fstsw ax sahf ja per_check_386_387_ret ; caught a cycle!!! mov oldcoloriter,-1 ; check periodicity immediately next time mov eax,maxit mov realcoloriter,eax ; save unadjusted realcolor as maxit sub eax,ecx ; subtract half c sub kbdcount,ax ; adjust the keyboard count sub eax,eax ; clear top half of eax for next mov ax,periodicity_color ; set color sub ecx,ecx ; flag to exit cx loop immediately per_check_386_387_ret: ret periodicity_check_386_387 ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .8086 .8087 periodicity_check_87 PROC NEAR ; just like periodicity_check_287_387 except for the use of ; fstsw tmp_word ; instead of ; fstsw ax ; REMEMBER, the cx counter is counting BACKWARDS from maxit to 0 fld st(2) ; x y ... test cx,word ptr savedand+2 ; save on 0, check on anything else jnz do_check_87 ; time to save a new "old" value test bx,word ptr savedand ; save on 0, check on anything else jnz do_check_87 ; time to save a new "old" value ; save last value ; fpu stack is ; x y ... fstp savedx ; y ... fst savedy ; y ... dec savedincr ; time to lengthen the periodicity? jnz per_check_87_ret ; if not 0, then skip shl word ptr savedand,1 ; savedand = (savedand << 1) + 1 rcl word ptr savedand+2,1 ; savedand = (savedand << 1) + 1 add word ptr savedand,1 ; for longer periodicity adc word ptr savedand+2,0 ; for longer periodicity mov ax,nextsavedincr ; and restart counter mov savedincr,ax ; and restart counter ret ; y ... do_check_87: ; fpu stack is ; x y ... fsub savedx ; x-savedx y ... fabs ; |x-savedx| y ... fcomp closenuff ; y ... fstsw tmp_word fwait mov ax,tmp_word sahf ja per_check_87_ret fld st ; y y ... fsub savedy ; y-savedy y ... fabs ; |y-savedy| y ... fcomp closenuff ; y ... fstsw tmp_word fwait mov ax,tmp_word sahf ja per_check_87_ret ; caught a cycle!!! mov word ptr oldcoloriter,-1 ; check periodicity immediately next time mov word ptr oldcoloriter+2,-1 ; check periodicity immediately next time mov ax,word ptr maxit mov dx,word ptr maxit+2 mov word ptr realcoloriter,ax ; save unadjusted realcolor as maxit mov word ptr realcoloriter+2,dx ; save unadjusted realcolor as maxit sub dx,cx ; subtract half c sbb ax,bx ; subtract half c sub kbdcount,ax ; adjust the keyboard count mov ax,periodicity_color ; set color sub dx,dx sub cx,cx ; flag to exit cx loop immediately mov bx,cx per_check_87_ret: ret periodicity_check_87 ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .8086 .8087 epsilon_cross PROC NEAR ; fpu stack is either ; y x Cx Cy b (387) ; y 1 x Cx Cy b (287/87/emul) cmp fpu,387 jb ec_load_x fld st(1) ; if 387 jmp short ec_end_load_x ec_load_x: fld st(2) ; if 287/87/emul ec_end_load_x: ; x y ... fabs ; |x| y 1 x Cx Cy b fcomp close ; y 1 x Cx Cy b fstsw tmp_word fwait mov ax,tmp_word sahf jae no_x_epsilon_cross mov ax,word ptr maxit ; x is close to y axis mov dx,word ptr maxit+2 ; x is close to y axis sub ax,bx ; leave 'times through loop' in ax,dx sbb dx,cx ; leave 'times through loop' in ax,dx ; zero color fix jnz zero_color_fix_1 cmp ax,0 jnz zero_color_fix_1 inc ax ; if (ax == 0 ) ax = 1 zero_color_fix_1: mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count mov ax,GREEN ; sub dx,dx sub cx,cx ; flag to end loop mov bx,cx mov word ptr oldcoloriter,bx ; don't check next time mov word ptr oldcoloriter+2,cx ; don't check next time ret ; return no_x_epsilon_cross: ; y 1 x Cx Cy b fld st ; y y 1 x Cx Cy b fabs ; |y| y 1 x Cx Cy b fcomp close ; y 1 x Cx Cy b fstsw tmp_word fwait mov ax,tmp_word sahf jae no_y_epsilon_cross mov ax,word ptr maxit ; y is close to x axis mov dx,word ptr maxit+2 ; y is close to x axis sub ax,bx ; leave 'times through loop' in ax,dx sbb dx,cx ; leave 'times through loop' in ax,dx ; zero color fix jnz zero_color_fix_2 cmp ax,0 jnz zero_color_fix_2 inc ax ; if (ax == 0 ) ax = 1 zero_color_fix_2: mov word ptr realcoloriter,ax ; save unadjusted realcolor mov word ptr realcoloriter+2,dx ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count mov ax,YELLOW sub dx,dx sub cx,cx ; flag to end loop mov bx,cx mov word ptr oldcoloriter,bx ; don't check next time mov word ptr oldcoloriter+2,cx ; don't check next time ret ; return no_y_epsilon_cross: ret epsilon_cross ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .386 .387 epsilon_cross_386_387 PROC NEAR ; fpu stack is ; y x Cx Cy b fld st(1) ; fabs ; |x| y x Cx Cy b fcomp close ; y x Cx Cy b fstsw tmp_word fwait mov ax,tmp_word sahf jae no_x_epsilon_cross mov eax,maxit ; x is close to y axis sub eax,ecx ; leave 'times through loop' in eax ; zero color fix jnz zero_color_fix_1 inc eax ; if (eax == 0 ) eax = 1 zero_color_fix_1: mov realcoloriter,eax ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count mov eax,GREEN ; sub ecx,ecx ; flag to end loop mov oldcoloriter,ecx ; don't check next time ret ; return no_x_epsilon_cross: ; y 1 x Cx Cy b fld st ; y y 1 x Cx Cy b fabs ; |y| y 1 x Cx Cy b fcomp close ; y 1 x Cx Cy b fstsw tmp_word fwait mov ax,tmp_word sahf jae no_y_epsilon_cross mov eax,maxit ; y is close to x axis sub eax,ecx ; leave 'times through loop' in ax,dx ; zero color fix jnz zero_color_fix_2 inc eax ; if (eax == 0 ) eax = 1 zero_color_fix_2: mov realcoloriter,eax ; save unadjusted realcolor sub kbdcount,ax ; adjust the keyboard count mov eax,YELLOW sub ecx,ecx ; flag to end loop mov oldcoloriter,ecx ; don't check next time ret ; return no_y_epsilon_cross: ret epsilon_cross_386_387 ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .8086 .8087 show_orbit_xy PROC NEAR USES cx si di local tmp_ten_byte_0:tbyte ; stupid klooge for MASM 5.1 LOCAL bug local tmp_ten_byte_1:tbyte local tmp_ten_byte_2:tbyte local tmp_ten_byte_3:tbyte local tmp_ten_byte_4:tbyte local tmp_ten_byte_5:tbyte local tmp_ten_byte_6:tbyte ; USES is needed because in all likelyhood, plot_orbit surely ; uses these registers. It's ok to have to push/pop's here in the ; orbits as speed is not crucial when showing orbits. ; fpu stack is either ; y x Cx Cy b (387) ; y 1 x Cx Cy b (287/87/emul) cmp fpu,387 jb so_load_x fld st(1) ; if 387 jmp short so_end_load_x so_load_x: fld st(2) ; if 287/87/emul so_end_load_x: ; x y ... ; and needs to returned as ; y ... fstp orbit_real ; y ... fst orbit_imag ; y ... mov ax,-1 ; color for plot orbit push ax ; ... ; since the number fpu registers that plot_orbit() preserves is compiler ; dependant, it's best to fstp the entire stack into 10 byte memories ; and fld them back after plot_orbit() returns. fstp tmp_ten_byte_1 ; store the stack in 80 bit form fstp tmp_ten_byte_2 fstp tmp_ten_byte_3 fstp tmp_ten_byte_4 fstp tmp_ten_byte_5 cmp fpu,287 ; with 287/87/emul the stack is 6 high jg no_store_6 ; with 387 it is only 5 high fstp tmp_ten_byte_6 no_store_6: fwait ; just to be safe push word ptr orbit_imag+6 ; co-ordinates for plot orbit push word ptr orbit_imag+4 ; ... push word ptr orbit_imag+2 ; ... push word ptr orbit_imag ; ... push word ptr orbit_real+6 ; co-ordinates for plot orbit push word ptr orbit_real+4 ; ... push word ptr orbit_real+2 ; ... push word ptr orbit_real ; ... call far ptr plot_orbit ; display the orbit add sp,9*2 ; clear out the parameters cmp fpu,287 jg no_load_6 fld tmp_ten_byte_6 ; load them back in reverse order no_load_6: fld tmp_ten_byte_5 fld tmp_ten_byte_4 fld tmp_ten_byte_3 fld tmp_ten_byte_2 fld tmp_ten_byte_1 fwait ; just to be safe ret show_orbit_xy ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .8086 .8087 special_outside PROC NEAR ; When type casting floating point variables to integers in C, the decimal ; is truncated. When using FIST in asm, the value is rounded. Using ; "FSUB round_down_half" causes the values to be rounded down. cmp outside,-2 jne not_real fld newx fsub round_down_half fistp tmp_dword add ax,7 adc dx,0 fwait add ax,word ptr tmp_dword adc dx,word ptr tmp_dword+2 jmp check_color not_real: cmp outside,-3 jne not_imag fld newy fsub round_down_half fistp tmp_dword add ax,7 adc dx,0 fwait add ax,word ptr tmp_dword adc dx,word ptr tmp_dword+2 jmp check_color not_imag: cmp outside,-4 jne not_mult fld newy ftst ; check to see if newy == 0 fstsw tmp_word push ax ; save current ax value fwait mov ax,tmp_word sahf pop ax ; retrieve ax (does not affect flags) jne non_zero_y ret ; if y==0, return with normal ax non_zero_y: fdivr newx ; newx/newy mov word ptr tmp_dword,ax mov word ptr tmp_dword+2,dx fimul tmp_dword ; (ax,dx)*newx/newy (Use FIMUL instead of MUL fsub round_down_half ; to make it match the C code.) fistp tmp_dword fwait mov ax,word ptr tmp_dword mov dx,word ptr tmp_dword+2 jmp short check_color not_mult: cmp outside,-5 jne not_sum fld newx fadd newy ; newx+newy fsub round_down_half fistp tmp_dword fwait add ax,word ptr tmp_dword adc dx,word ptr tmp_dword+2 not_sum: cmp outside,-6 ; currently always equal, but put here jne not_atan ; for future outside types call near ptr FPUatan ; return with atan on FPU stack fmul one_8_zero ; 180*Angle fldpi ; pi 180*Angle fdiv ; 180*Angle/pi fabs fsub round_down_half fistp tmp_dword fwait mov ax,word ptr tmp_dword mov dx,word ptr tmp_dword+2 not_atan: check_color: cmp dx,word ptr maxit+2 ; use UNSIGNED comparison jb special_outside_ret ; color < 0 || color > maxit cmp ax,word ptr maxit ; use UNSIGNED comparison jbe special_outside_ret ; color < 0 || color > maxit sub ax,ax ; ax = 0 mov dx,ax ; dx = 0 special_outside_ret: ret special_outside ENDP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .386 .387 special_outside_386_387 PROC NEAR ; When type casting floating point variables to integers in C, the decimal ; is truncated. When using FIST in asm, the value is rounded. Using ; "FSUB round_down_half" causes the values to be rounded down. cmp outside,-2 jne not_real fld newx fsub round_down_half fistp tmp_dword add eax,7 fwait add eax,tmp_dword jmp check_color not_real: cmp outside,-3 jne not_imag fld newy fsub round_down_half fistp tmp_dword add eax,7 fwait add eax,tmp_dword jmp check_color not_imag: cmp outside,-4 jne not_mult fld newy ftst ; check to see if newy == 0 fstsw tmp_word push ax ; save current ax value fwait mov ax,tmp_word sahf pop ax ; retrieve ax (does not affect flags) jne non_zero_y ret ; if y==0, return with normal ax non_zero_y: fdivr newx ; newx/newy mov tmp_dword,eax fimul tmp_dword ; (ax,dx)*newx/newy (Use FIMUL instead of MUL fsub round_down_half ; to make it match the C code.) fistp tmp_dword fwait mov eax,tmp_dword jmp short check_color not_mult: cmp outside,-5 jne not_sum fld newx fadd newy ; newx+newy fsub round_down_half fistp tmp_dword fwait add eax,tmp_dword not_sum: cmp outside,-6 ; currently always equal, but put here jne not_atan ; for future outside types fld newy ; newy fld newx ; newx newy fpatan ; arctan(y/x) fmul one_8_zero ; 180*atan fldpi ; pi 180*atan fdiv ; 180*atan/pi fabs fsub round_down_half fistp tmp_dword fwait mov eax,tmp_dword not_atan: check_color: cmp eax,maxit ; use UNSIGNED comparison jbe special_outside_ret ; color < 0 || color > maxit sub eax,eax ; eax = 0 special_outside_ret: ret special_outside_386_387 ENDP .8086 ;just to be sure .8087 FPUatan PROC NEAR ; This is derived from FPUcplxlog in fpu087.asm ; The arctan is returned on the FPU stack LOCAL Status:word mov ax, word ptr newy+6 or ax, word ptr newx+6 jnz NotBothZero fldz jmp atandone NotBothZero: fld newy ; newy fld newx ; newx newy mov dh, BYTE PTR newx+7 or dh, dh jns ChkYSign fchs ; |newx| newy ChkYSign: mov dl, BYTE PTR newy+7 or dl, dl jns ChkMagnitudes fxch ; newy |newx| fchs ; |newy| |newx| fxch ; |newx| |newy| ChkMagnitudes: fcom st(1) ; |newx| |newy| fstsw Status test Status, 4500h jz XisGTY test Status, 4000h jz XneY ; newx = newy and atan = pi/4 fstp st ; newy fstp st ; empty fldpi ; pi fdiv _4_ ; pi/4 jmp short ChkSignZ XneY: fxch ; newy newx fpatan ; pi/2 - Angle fldpi ; pi, pi/2 - Angle fdiv _2_ ; pi/2, pi/2 - Angle fsubr ; Angle jmp short ChkSignZ XisGTY: fpatan ; pi-Angle or Angle+pi ChkSignZ: or dh, dh js NegX or dl, dl jns short atandone fchs jmp short atandone NegX: or dl, dl js QuadIII fldpi ; pi, pi-Angle fsubr ; Angle jmp short atandone QuadIII: fldpi ; pi, Angle+pi fsub ; Angle atandone: ret ; Leave result on FPU stack and return FPUatan ENDP END