Add mandelbrot code

Author: roguh

mandelbrot/.gitignore

@@ -0,0 +1,54 @@
+*.bin
+
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf

mandelbrot/LICENSE

@@ -0,0 +1,16 @@
+#!/bin/sh
+COMPILER="${COMPILER:-tcc}"
+
+# $1  - input .c file
+# -o  - Output filename
+# -W  - Turn on various types of warnings
+
+set -x
+if [ "$COMPILER" = "gcc" ]; then
+    # -Oz - Optimize for code size
+    # -g  - Debug symbols
+    # -fsanitize... - Show lots of nice colorful info when stack smashing is detected
+    gcc "${1}" -o "${1%.c}.bin" -Wall -Wpedantic -Oz -g -fsanitize=address
+else
+    tcc "${1}" -o "${1%.c}.bin" -Wall -Wpedantic -Oz -g
+fi

mandelbrot/README.md

@@ -0,0 +1,34 @@
+#define S 3321
+int main(i, x, y, t) {
+    // Size is width=81, height=41, total is S=3321
+    float r, m, R[S] = {0}, M[S] = {0}, C[S], D[S];
+
+    // y is imaginary, x is real
+    for (i = 0; i < S; i++) {
+        // The boundaries go from x=real=-2 to 0.5, y=imag=-1 to 1
+        // x = i % width
+        C[i] = 2.5 * (i % 81) / 80. - 2;
+        // y = i / width
+        D[i] = 2 * (i / 81) / 40. - 1;
+    }
+
+    t = 0;
+    while (t++ < 1063) {
+        for (i = 0; i < S; i++) {
+            // Compute previous_latice**2 + c
+            // c**2 = (r + im)**2 = r**2 - m**2 + 2irm
+            r = R[i];
+            m = M[i];
+            R[i] = r * r - m * m + C[i];
+            M[i] = 2 * r * m + D[i];
+        }
+    }
+
+    for (i = 0; i < S; i++) {
+        // Compute the magnitude of this point
+        // |c|**2 = r**2 + m**2
+        // If the magnitude is less than 4, the point did not diverge
+        printf(R[i] * R[i] + M[i] * M[i] < 4 ? "█" : "▒");
+        i % 81 == 80 && puts("");
+    }
+}

mandelbrot/color.png

@@ -0,0 +1,2 @@
+#define S 3321
+main(i,x,y,t){float r,m,R[S]={0},M[S]={0},C[S],D[S];for(i=0;i<S;i++){C[i]=2.5*(i%81)/80.-2;D[i]=2*(i/81)/40.-1;}t=0;while(t++<1063){for(i=0;i<S;i++){r=R[i];m=M[i];R[i]=r*r-m*m+C[i];M[i]=2*r*m+D[i];}}for(i=0;i<S;i++){printf(R[i]*R[i]+M[i]*M[i]<4?"█":"▒");i%81==80&&puts("");}}

mandelbrot/compile.sh

@@ -0,0 +1,122 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef float num;
+
+num magnitude(num real, num imag) {
+    return real * real + imag * imag;
+}
+
+num squared_re(num real, num imag) {
+    return real * real - imag * imag;
+}
+
+num squared_im(num real, num imag) {
+    return 2 * real * imag;
+}
+
+typedef struct args_t {
+    size_t width;
+    size_t height;
+    size_t max_iterations;
+    size_t color;
+    num min_re;
+    num max_re;
+    num min_im;
+    num max_im;
+} args_t;
+
+#define AE "\033["
+const char* BCOLORS[16] = {
+    AE "40m", AE "41m", AE "42m", AE "43m", AE "44m", AE "45m", AE "46m", AE "47m", AE "100m", AE "101m", AE "102m", AE "103m", AE "104m", AE "105m", AE "106m", AE "107m"
+};
+const char* FCOLORS[16] = {
+    AE "30m", AE "31m", AE "32m", AE "33m", AE "34m", AE "35m", AE "36m", AE "37m", AE "90m", AE "91m", AE "92m", AE "93m", AE "94m", AE "95m", AE "96m", AE "97m"
+};
+const char* CLEAR_COLOR = AE "0m";
+
+void mandelbrot(args_t args) {
+    size_t size = args.width * args.height;
+    num* lattice_re = calloc(size, sizeof(num));
+    num* lattice_im = calloc(size, sizeof(num));
+    num* c_re = calloc(size, sizeof(num));
+    num* c_im = calloc(size, sizeof(num));
+    // An array of unsigned ints
+    size_t* iter_to_diverge = calloc(size, sizeof(size_t));
+
+    // y is imaginary, x is real
+    for (size_t y = 0; y < args.height; y++) {
+        for (size_t x = 0; x < args.width; x++) {
+            c_re[x + y * args.width] = (args.max_re - args.min_re) * x / (args.width - 1) + args.min_re;
+            c_im[x + y * args.width] = (args.max_im - args.min_im) * y / (args.height - 1) + args.min_im;
+        }
+    }
+
+    size_t iteration = 0;
+    while (iteration < args.max_iterations) {
+        for (size_t i = 0; i < size; i++) {
+            num new_re = squared_re(lattice_re[i], lattice_im[i]) + c_re[i];
+            num new_im = squared_im(lattice_re[i], lattice_im[i]) + c_im[i];
+            lattice_re[i] = new_re;
+            lattice_im[i] = new_im;
+            if (magnitude(new_re, new_im) >= 2 * 2 && iter_to_diverge[i] == 0) {
+                iter_to_diverge[i] = iteration;
+            }
+        }
+        iteration++;
+    }
+
+    for (size_t y = 0; y < args.height; y++) {
+        for (size_t x = 0; x < args.width; x++) {
+            num r = lattice_re[x + y * args.width];
+            num m = lattice_im[x + y * args.width];
+            // Test if the value at the given point diverged
+            if (magnitude(r, m) < 2 * 2) {
+                if (args.color) {
+                    // TODO: render higher resolution with braille chars
+                    printf("%s█%s", FCOLORS[0], CLEAR_COLOR);
+                } else {
+                    printf("█");
+                }
+            } else {
+                if (args.color) {
+                    size_t i = iter_to_diverge[x + y * args.width] % 16;
+                    // printf("%s%lx%s", BCOLORS[i], i, CLEAR_COLOR);
+                    printf("%s%s %s", FCOLORS[(i + 2) % 16], BCOLORS[i], CLEAR_COLOR);
+                } else {
+                    printf("▒");
+                }
+            }
+                //printf("%10.5f+%10.5fi  |c|=%10.5f\n", r, m, magnitude(r, m));
+        }
+        puts("");
+    }
+    
+    free(lattice_re);
+    free(lattice_im);
+    free(c_re);
+    free(c_im);
+    free(iter_to_diverge);
+}
+
+int main(int argc, char* argv[]) {
+    args_t args = {
+        .width = 81,
+        .height = 41,
+        .max_iterations = 1063,
+        .color = 1,
+        .min_re = -2,
+        .max_re = 0.5,
+        .min_im = -1,
+        .max_im = 1,
+        // .min_re = -2 / 2,
+        // .max_re = 0.5 / 2,
+        // .min_im = -1,
+        // .max_im = 0,
+   };
+    if (argc >= 3) args.width = strtol(argv[1], NULL, 0);
+    if (argc >= 3) args.height = strtol(argv[2], NULL, 0);
+    if (argc >= 4) args.max_iterations = strtol(argv[3], NULL, 0);
+    mandelbrot(args);
+    return 0;
+}

mandelbrot/golf2.c

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--map-fname", "-m", required=True)
+parser.add_argument("--src-fname", "-s", required=True)
+parser.add_argument("--replace", "-r", default="▒")
+parser.add_argument("--new-char", "-w", type=str, default=None)
+parser.add_argument("--step", type=int, default=1)
+
+def main():
+    args = parser.parse_args()
+    with open(args.map_fname) as mfile, open(args.src_fname) as sfile:
+        mapcontents = mfile.read()
+        source = sfile.read().replace('\n', '\\n')
+        out = []
+        i = 0
+        replace_chars = 0
+        for char in mapcontents:
+            if char in args.replace:
+                if replace_chars % args.step == 0 and i < len(source):
+                    out.append(source[i])
+                    i += 1
+                else:
+                    out.append(args.new_char or char)
+                replace_chars += 1
+            else:
+                out.append(char)
+        print(''.join(out))
+
+if __name__ == "__main__":
+    main()