From 9ad9bf96bbb4502209d7c2e8b1e3c729bdfbcfc4 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Sun, 9 May 2021 08:03:48 -0700 Subject: mandelbrot: streamline exposition --- html/mandelbrot-fixed.mu.html | 214 ++++++++++++++++++------------------ html/mandelbrot.mu.html | 245 ++++++++++++++++++++---------------------- 2 files changed, 222 insertions(+), 237 deletions(-) (limited to 'html') diff --git a/html/mandelbrot-fixed.mu.html b/html/mandelbrot-fixed.mu.html index 6f87111e..3a09bf53 100644 --- a/html/mandelbrot-fixed.mu.html +++ b/html/mandelbrot-fixed.mu.html @@ -170,118 +170,112 @@ if ('onhashchange' in window) { 111 width-f <- shift-left 0xb/log2-font-width-and-fixed-precision # 3 + 8 = 11 112 var height-f/edi: int <- copy b 113 height-f <- shift-left 0xc/log2-font-height-and-fixed-precision # 4 + 8 = 12 -114 # it might make sense to keep x and y as regular ints -115 # treating them as fixed-point for demonstration purposes -116 var y-f/ecx: int <- copy 0 -117 { -118 compare y-f, height-f -119 break-if->= -120 var imaginary-f/ebx: int <- mandelbrot-min-y y-f, width-f, height-f -121 var x-f/eax: int <- copy 0 -122 { -123 compare x-f, width-f -124 break-if->= -125 var real-f/edx: int <- mandelbrot-min-x x-f, width-f -126 var iterations/esi: int <- mandelbrot-pixel real-f, imaginary-f, 0x400/max -127 { -128 var x: int -129 var y: int -130 var tmp/eax: int <- fixed-to-int x-f -131 copy-to x, tmp -132 tmp <- fixed-to-int y-f -133 copy-to y, tmp -134 compare iterations, 0x400/max -135 { -136 break-if->= -137 pixel screen, x, y, 0xf/white -138 } -139 compare iterations, 0x400/max -140 { -141 break-if-< -142 pixel screen, x, y, 0/black -143 } -144 } -145 x-f <- add 0x100/1 -146 loop -147 } -148 y-f <- add 0x100/1 -149 loop -150 } -151 } -152 -153 fn mandelbrot-pixel real-f: int, imaginary-f: int, max: int -> _/esi: int { -154 var x-f/esi: int <- copy 0 -155 var y-f/edi: int <- copy 0 -156 var iterations/ecx: int <- copy 0 -157 { -158 var done?/eax: boolean <- mandelbrot-done? x-f, y-f -159 compare done?, 0/false -160 break-if-!= -161 compare iterations, max -162 break-if->= -163 var x2-f/edx: int <- mandelbrot-x x-f, y-f, real-f -164 var y2-f/ebx: int <- mandelbrot-y x-f, y-f, imaginary-f -165 x-f <- copy x2-f -166 y-f <- copy y2-f -167 iterations <- increment -168 loop -169 } -170 return iterations -171 } -172 -173 fn mandelbrot-done? x-f: int, y-f: int -> _/eax: boolean { -174 # x*x + y*y > 4 -175 var tmp-f/eax: int <- multiply-fixed x-f, x-f -176 var result-f/ecx: int <- copy tmp-f -177 tmp-f <- multiply-fixed y-f, y-f -178 result-f <- add tmp-f -179 compare result-f, 0x400/4 -180 { -181 break-if-> -182 return 0/false -183 } -184 return 1/true +114 var y/ecx: int <- copy 0 +115 { +116 compare y, height-f +117 break-if->= +118 var imaginary-f/ebx: int <- viewport-to-imaginary-f y, width-f, height-f +119 var x/eax: int <- copy 0 +120 { +121 compare x, width-f +122 break-if->= +123 var real-f/edx: int <- viewport-to-real-f x, width-f +124 var iterations/esi: int <- mandelbrot-iterations-for-point real-f, imaginary-f, 0x400/max +125 compare iterations, 0x400/max +126 { +127 break-if->= +128 pixel screen, x, y, 0xf/white +129 } +130 compare iterations, 0x400/max +131 { +132 break-if-< +133 pixel screen, x, y, 0/black +134 } +135 x <- increment +136 loop +137 } +138 y <- increment +139 loop +140 } +141 } +142 +143 fn mandelbrot-iterations-for-point real-f: int, imaginary-f: int, max: int -> _/esi: int { +144 var x-f/esi: int <- copy 0 +145 var y-f/edi: int <- copy 0 +146 var iterations/ecx: int <- copy 0 +147 { +148 var done?/eax: boolean <- mandelbrot-done? x-f, y-f +149 compare done?, 0/false +150 break-if-!= +151 compare iterations, max +152 break-if->= +153 var x2-f/edx: int <- mandelbrot-x x-f, y-f, real-f +154 var y2-f/ebx: int <- mandelbrot-y x-f, y-f, imaginary-f +155 x-f <- copy x2-f +156 y-f <- copy y2-f +157 iterations <- increment +158 loop +159 } +160 return iterations +161 } +162 +163 fn mandelbrot-done? x-f: int, y-f: int -> _/eax: boolean { +164 # x*x + y*y > 4 +165 var tmp-f/eax: int <- multiply-fixed x-f, x-f +166 var result-f/ecx: int <- copy tmp-f +167 tmp-f <- multiply-fixed y-f, y-f +168 result-f <- add tmp-f +169 compare result-f, 0x400/4 +170 { +171 break-if-> +172 return 0/false +173 } +174 return 1/true +175 } +176 +177 fn mandelbrot-x x-f: int, y-f: int, real-f: int -> _/edx: int { +178 # x*x - y*y + real +179 var tmp-f/eax: int <- multiply-fixed x-f, x-f +180 var result-f/ecx: int <- copy tmp-f +181 tmp-f <- multiply-fixed y-f, y-f +182 result-f <- subtract tmp-f +183 result-f <- add real-f +184 return result-f 185 } 186 -187 fn mandelbrot-x x-f: int, y-f: int, real-f: int -> _/edx: int { -188 # x*x - y*y + real -189 var tmp-f/eax: int <- multiply-fixed x-f, x-f -190 var result-f/ecx: int <- copy tmp-f -191 tmp-f <- multiply-fixed y-f, y-f -192 result-f <- subtract tmp-f -193 result-f <- add real-f -194 return result-f -195 } -196 -197 fn mandelbrot-y x-f: int, y-f: int, imaginary-f: int -> _/ebx: int { -198 # 2*x*y + imaginary -199 var result-f/eax: int <- copy x-f -200 result-f <- shift-left 1/log2 -201 result-f <- multiply-fixed result-f, y-f -202 result-f <- add imaginary-f -203 return result-f -204 } -205 -206 fn mandelbrot-min-x x-f: int, width-f: int -> _/edx: int { -207 # (x - width/2)*4/width -208 var result-f/eax: int <- copy x-f -209 var half-width-f/ecx: int <- copy width-f -210 half-width-f <- shift-right-signed 1/log2 -211 result-f <- subtract half-width-f -212 result-f <- shift-left 2/log4 -213 result-f <- divide-fixed result-f, width-f -214 return result-f -215 } -216 -217 fn mandelbrot-min-y y-f: int, width-f: int, height-f: int -> _/ebx: int { -218 # (y - height/2)*4/width -219 var result-f/eax: int <- copy y-f -220 shift-right-signed height-f, 1/log2 -221 result-f <- subtract height-f -222 result-f <- shift-left 2/log4 -223 result-f <- divide-fixed result-f, width-f -224 return result-f -225 } +187 fn mandelbrot-y x-f: int, y-f: int, imaginary-f: int -> _/ebx: int { +188 # 2*x*y + imaginary +189 var result-f/eax: int <- copy x-f +190 result-f <- shift-left 1/log2 +191 result-f <- multiply-fixed result-f, y-f +192 result-f <- add imaginary-f +193 return result-f +194 } +195 +196 # Scale (x, y) pixel coordinates to a complex plane where the viewport width +197 # ranges from -2 to +2. Viewport height just follows the viewport's aspect +198 # ratio. +199 +200 fn viewport-to-real-f x: int, width-f: int -> _/edx: int { +201 # (x - width/2)*4/width +202 var result-f/eax: int <- int-to-fixed x +203 var half-width-f/ecx: int <- copy width-f +204 half-width-f <- shift-right-signed 1/log2 +205 result-f <- subtract half-width-f +206 result-f <- shift-left 2/log4 +207 result-f <- divide-fixed result-f, width-f +208 return result-f +209 } +210 +211 fn viewport-to-imaginary-f y: int, width-f: int, height-f: int -> _/ebx: int { +212 # (y - height/2)*4/width +213 var result-f/eax: int <- int-to-fixed y +214 shift-right-signed height-f, 1/log2 +215 result-f <- subtract height-f +216 result-f <- shift-left 2/log4 +217 result-f <- divide-fixed result-f, width-f +218 return result-f +219 } diff --git a/html/mandelbrot.mu.html b/html/mandelbrot.mu.html index ea235774..ee2b8483 100644 --- a/html/mandelbrot.mu.html +++ b/html/mandelbrot.mu.html @@ -18,7 +18,6 @@ a { color:inherit; } .Special { color: #ff6060; } .LineNr { } .Constant { color: #008787; } -.CommentedCode { color: #8a8a8a; } .Delimiter { color: #c000c0; } .muFunction { color: #af5f00; text-decoration: underline; } .muComment { color: #005faf; } @@ -80,132 +79,124 @@ if ('onhashchange' in window) { 21 { 22 compare y, height 23 break-if->= - 24 #? var new-x/eax: int <- render-float-decimal 0/screen, imaginary, 3, 0/x, 0/y, 7/fg, 0/bg - 25 var imaginary/xmm1: float <- mandelbrot-min-y y, width, height - 26 var x/edx: int <- copy 0 - 27 { - 28 compare x, width - 29 break-if->= - 30 var real/xmm0: float <- mandelbrot-min-x x, width - 31 var new-x/eax: int <- copy 0 - 32 new-x <- render-float-decimal 0/screen, real, 3, new-x, 0/y, 7/fg, 0/bg - 33 new-x <- increment - 34 new-x <- render-float-decimal 0/screen, imaginary, 3, new-x, 0/y, 7/fg, 0/bg - 35 var iterations/eax: int <- mandelbrot-pixel real, imaginary, 0x400/max - 36 set-cursor-position 0/screen 0/x 1/y - 37 draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, iterations, 7/fg, 0/bg - 38 compare iterations, 0x400/max - 39 { - 40 break-if->= - 41 pixel screen, x, y, 0xf/white - 42 } - 43 compare iterations, 0x400/max - 44 { - 45 break-if-< - 46 pixel screen, x, y, 0/black - 47 } - 48 x <- increment - 49 loop - 50 } - 51 y <- increment - 52 loop - 53 } - 54 } - 55 - 56 fn mandelbrot-pixel real: float, imaginary: float, max: int -> _/eax: int { - 57 var zero: float - 58 var x/xmm0: float <- copy zero - 59 var y/xmm1: float <- copy zero - 60 var iterations/ecx: int <- copy 0 - 61 { - 62 var done?/eax: boolean <- mandelbrot-done? x, y - 63 compare done?, 0/false - 64 break-if-!= - 65 compare iterations, max - 66 break-if->= - 67 var newx/xmm2: float <- mandelbrot-x x, y, real - 68 var newy/xmm3: float <- mandelbrot-y x, y, imaginary - 69 x <- copy newx - 70 y <- copy newy - 71 iterations <- increment - 72 loop - 73 } - 74 return iterations - 75 } - 76 - 77 fn mandelbrot-done? x: float, y: float -> _/eax: boolean { - 78 # x*x + y*y > 4 - 79 var x2/xmm0: float <- copy x - 80 #? var new-x/eax: int <- render-float-decimal 0/screen, x2, 3, 0/x, 2/y, 4/fg, 0/bg - 81 x2 <- multiply x - 82 var y2/xmm1: float <- copy y - 83 y2 <- multiply y - 84 var sum/xmm0: float <- copy x2 - 85 sum <- add y2 - 86 var four/eax: int <- copy 4 - 87 var four-f/xmm1: float <- convert four - 88 compare sum, four-f - 89 { - 90 break-if-float> - 91 return 0/false - 92 } - 93 return 1/true - 94 } - 95 - 96 fn mandelbrot-x x: float, y: float, real: float -> _/xmm2: float { - 97 # x*x - y*y + real - 98 var x2/xmm0: float <- copy x - 99 x2 <- multiply x -100 var y2/xmm1: float <- copy y -101 y2 <- multiply y -102 var result/xmm0: float <- copy x2 -103 result <- subtract y2 -104 result <- add real -105 return result -106 } -107 -108 fn mandelbrot-y x: float, y: float, imaginary: float -> _/xmm3: float { -109 # 2*x*y + imaginary -110 var two/eax: int <- copy 2 -111 var result/xmm0: float <- convert two -112 result <- multiply x -113 result <- multiply y -114 result <- add imaginary -115 return result -116 } -117 -118 fn mandelbrot-min-x x: int, width: int -> _/xmm0: float { -119 # (x - width/2)*4/width -120 var result/xmm0: float <- convert x -121 var width-f/xmm1: float <- convert width -122 var two/eax: int <- copy 2 -123 var two-f/xmm2: float <- convert two -124 var half-width-f/xmm2: float <- reciprocal two-f -125 half-width-f <- multiply width-f -126 result <- subtract half-width-f -127 var four/eax: int <- copy 4 -128 var four-f/xmm2: float <- convert four -129 result <- multiply four-f -130 result <- divide width-f -131 return result -132 } -133 -134 fn mandelbrot-min-y y: int, width: int, height: int -> _/xmm1: float { -135 # (y - height/2)*4/width -136 var result/xmm0: float <- convert y -137 var height-f/xmm1: float <- convert height -138 var half-height-f/xmm1: float <- copy height-f -139 var two/eax: int <- copy 2 -140 var two-f/xmm2: float <- convert two -141 half-height-f <- divide two-f -142 result <- subtract half-height-f -143 var four/eax: int <- copy 4 -144 var four-f/xmm1: float <- convert four -145 result <- multiply four-f -146 var width-f/xmm1: float <- convert width -147 result <- divide width-f -148 return result -149 } + 24 var imaginary/xmm1: float <- viewport-to-imaginary y, width, height + 25 var x/edx: int <- copy 0 + 26 { + 27 compare x, width + 28 break-if->= + 29 var real/xmm0: float <- viewport-to-real x, width + 30 var iterations/eax: int <- mandelbrot-iterations-for-point real, imaginary, 0x400/max + 31 compare iterations, 0x400/max + 32 { + 33 break-if->= + 34 pixel screen, x, y, 0xf/white + 35 } + 36 compare iterations, 0x400/max + 37 { + 38 break-if-< + 39 pixel screen, x, y, 0/black + 40 } + 41 x <- increment + 42 loop + 43 } + 44 y <- increment + 45 loop + 46 } + 47 } + 48 + 49 fn mandelbrot-iterations-for-point real: float, imaginary: float, max: int -> _/eax: int { + 50 var zero: float + 51 var x/xmm0: float <- copy zero + 52 var y/xmm1: float <- copy zero + 53 var iterations/ecx: int <- copy 0 + 54 { + 55 var done?/eax: boolean <- mandelbrot-done? x, y + 56 compare done?, 0/false + 57 break-if-!= + 58 compare iterations, max + 59 break-if->= + 60 var newx/xmm2: float <- mandelbrot-x x, y, real + 61 var newy/xmm3: float <- mandelbrot-y x, y, imaginary + 62 x <- copy newx + 63 y <- copy newy + 64 iterations <- increment + 65 loop + 66 } + 67 return iterations + 68 } + 69 + 70 fn mandelbrot-done? x: float, y: float -> _/eax: boolean { + 71 # x*x + y*y > 4 + 72 var x2/xmm0: float <- copy x + 73 x2 <- multiply x + 74 var y2/xmm1: float <- copy y + 75 y2 <- multiply y + 76 var sum/xmm0: float <- copy x2 + 77 sum <- add y2 + 78 var four/eax: int <- copy 4 + 79 var four-f/xmm1: float <- convert four + 80 compare sum, four-f + 81 { + 82 break-if-float> + 83 return 0/false + 84 } + 85 return 1/true + 86 } + 87 + 88 fn mandelbrot-x x: float, y: float, real: float -> _/xmm2: float { + 89 # x*x - y*y + real + 90 var x2/xmm0: float <- copy x + 91 x2 <- multiply x + 92 var y2/xmm1: float <- copy y + 93 y2 <- multiply y + 94 var result/xmm0: float <- copy x2 + 95 result <- subtract y2 + 96 result <- add real + 97 return result + 98 } + 99 +100 fn mandelbrot-y x: float, y: float, imaginary: float -> _/xmm3: float { +101 # 2*x*y + imaginary +102 var two/eax: int <- copy 2 +103 var result/xmm0: float <- convert two +104 result <- multiply x +105 result <- multiply y +106 result <- add imaginary +107 return result +108 } +109 +110 fn viewport-to-real x: int, width: int -> _/xmm0: float { +111 # (x - width/2)*4/width +112 var result/xmm0: float <- convert x +113 var width-f/xmm1: float <- convert width +114 var two/eax: int <- copy 2 +115 var two-f/xmm2: float <- convert two +116 var half-width-f/xmm2: float <- reciprocal two-f +117 half-width-f <- multiply width-f +118 result <- subtract half-width-f +119 var four/eax: int <- copy 4 +120 var four-f/xmm2: float <- convert four +121 result <- multiply four-f +122 result <- divide width-f +123 return result +124 } +125 +126 fn viewport-to-imaginary y: int, width: int, height: int -> _/xmm1: float { +127 # (y - height/2)*4/width +128 var result/xmm0: float <- convert y +129 var height-f/xmm1: float <- convert height +130 var half-height-f/xmm1: float <- copy height-f +131 var two/eax: int <- copy 2 +132 var two-f/xmm2: float <- convert two +133 half-height-f <- divide two-f +134 result <- subtract half-height-f +135 var four/eax: int <- copy 4 +136 var four-f/xmm1: float <- convert four +137 result <- multiply four-f +138 var width-f/xmm1: float <- convert width +139 result <- divide width-f +140 return result +141 } -- cgit 1.4.1-2-gfad0