super basic

Author: glasss13

.gitignore

@@ -11,3 +11,4 @@ CMakeLists.txt.user
 compile_commands.json
 conan_cache_*.tgz
 CMakeUserPresets.json
+.cache

CMakeLists.txt

@@ -30,7 +30,9 @@ target_include_directories(
 target_compile_features(fractal-generator_lib PUBLIC cxx_std_20)
 
 find_package(fmt REQUIRED)
-target_link_libraries(fractal-generator_lib PRIVATE fmt::fmt)
+find_package(argparse REQUIRED)
+target_link_libraries(fractal-generator_lib PUBLIC fmt::fmt)
+target_link_libraries(fractal-generator_lib PUBLIC argparse::argparse)
 
 find_package(SFML REQUIRED graphics CONFIG)
 target_link_libraries(fractal-generator_lib PUBLIC sfml-graphics)

CMakePresets.json

@@ -83,7 +83,7 @@
     {
       "name": "ci-darwin",
       "inherits": ["flags-appleclang", "ci-std"],
-      "generator": "Xcode",
+      "generator": "Unix Makefiles",
       "hidden": true,
       "cacheVariables": {
         "CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE": "PRE_TEST"

conanfile.py

@@ -11,6 +11,7 @@ def layout(self):
     def requirements(self):
         self.requires("fmt/11.0.2")
         self.requires("sfml/2.6.1")
+        self.requires("argparse/3.1")
 
     def build_requirements(self):
         self.test_requires("catch2/3.7.0")

source/main.cpp

@@ -1,11 +1,88 @@
 #include "graphics/basic_display.hpp"
 
-int main()
+void display_line()
 {
     fractal::BasicDisplay display;
     for (std::size_t i = 0; i < 100; i++) {
         display.set_pixel(100, 100 + i, 255);
     }
     display.display_window();
+}
+
+#include "lib.hpp"
+
+#include <argparse/argparse.hpp>
+
+#include <complex>
+
+#include <exception>
+#include <iostream>
+#include <string>
+
+constexpr double divergence_norm = 4;
+constexpr double x_dim = 2;
+constexpr double y_dim = 2;
+constexpr int max_iterations = 50;
+
+// https://en.wikipedia.org/wiki/Mandelbrot_set#Formal_definition
+std::complex<double> step(std::complex<double> z_n, std::complex<double> constant)
+{
+    return z_n * z_n + constant;
+}
+
+int compute_iterations(
+    std::complex<double> z_0, std::complex<double> constant, int max_iters
+)
+{
+    int iterations = 0;
+    std::complex<double> z_n = z_0;
+
+    while (iterations < max_iters && std::norm(z_n) < divergence_norm) {
+        z_n = step(z_n, constant);
+        ++iterations;
+    }
+
+    return iterations;
+}
+
+int main(int argc, char** argv)
+{
+    auto const lib = library{};
+    argparse::ArgumentParser program(lib.name);
+
+    program.add_argument("width")
+        .help("Horizontal resolution")
+        .default_value(800)
+        .scan<'i', int>();
+
+    program.add_argument("height")
+        .help("Vertical resolution")
+        .default_value(600)
+        .scan<'i', int>();
+
+    try {
+        program.parse_args(argc, argv);
+    } catch (const std::exception& err) {
+        std::cerr << err.what() << std::endl;
+        std::cerr << program;
+        return 1;
+    }
+
+    auto width = static_cast<double>(program.get<int>("width"));
+    auto height = static_cast<double>(program.get<int>("height"));
+
+    auto x_step = x_dim * 2 / width;
+    auto y_step = y_dim * 2 / height;
+
+    std::complex<double> constant = {1.0 / 4, 0};
+
+    for (auto y = -y_dim; y < y_dim; y += y_step) {
+        for (auto x = -x_dim; x < x_dim; x += x_step) {
+            auto iterations = compute_iterations({x, y}, constant, max_iterations);
+            std::cout << iterations << ' ';
+        }
+        std::cout << '\n';
+    }
+
     return 0;
 }