Mandelbrot set in C++11(solarianprogrammer.com)
solarianprogrammer.com
Mandelbrot set in C++11
http://solarianprogrammer.com/2013/02/28/mandelbroot-set-cpp-11/
3 comments
That's unfair! The algorithm is in the function "escape", not the function "fractal".
escape's function signature is much simpler:
escape's function signature is much simpler:
int escape(std::complex<double> c, int iter_max, const std::function<std::complex<double>(std::complex<double>,
std::complex<double>)> &func)
auto func = [] (std::complex <double> z, std::complex<double> c) -> std::complex<double> {return z * z * z + c; };You could always let the compiler work it out for you.
template< typename Func > int escape(std::complex<double> c, int iter_max, Func& func)
template< typename Func > int escape(std::complex<double> c, int iter_max, Func& func)
Does slightly seem like some typedefs might have helped. Particularly the `func` type signature.
I looked at the first block of code of the article when the page loaded and thought "Hey! That's pretty expressive for C++- It's almost as compact now as Haskell for a mandelbrot program!"
...then I realized that it was only a baroque type declaration and that scrolling down the page reveals tons of additional code blocks... and those aren't actually all the code.
(C++ is still a great language for many problem domains... Code brevity/elegance is not its strength however.)
...then I realized that it was only a baroque type declaration and that scrolling down the page reveals tons of additional code blocks... and those aren't actually all the code.
(C++ is still a great language for many problem domains... Code brevity/elegance is not its strength however.)
It's a shame, actually i like C++11 and the new features but seeing the lambda is instantly pushing me away again:
auto func = [] (std::complex <double> z, std::complex<double> c) -> std::complex<double> {return z * z + c; };
Why isn't there some nicer and more readable syntax for some of that basic stuff?!
auto func = [] (std::complex <double> z, std::complex<double> c) -> std::complex<double> {return z * z + c; };
Why isn't there some nicer and more readable syntax for some of that basic stuff?!
You can leave out the explicit return type.
auto func = [] (std::complex<double> z, std::complex<double> c) { return z * z + c; };
typedef std::complex<double> Complex;
// ...
auto func = [] (Complex z, Complex c) { return z * z + c; };
I thought I've read somewhere that they are working for a lambda ala C# style. Can't find the paper though.
Edit: I found the following links concerning this topic:
http://root.cern.ch/drupal/content/c14 http://isocpp.org/blog/2012/12/an-implementation-of-generic-...
And the paper: http://open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3418.pd...
Edit: I found the following links concerning this topic:
http://root.cern.ch/drupal/content/c14 http://isocpp.org/blog/2012/12/an-implementation-of-generic-...
And the paper: http://open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3418.pd...
Maybe we have different aesthetic objections, but isn't all of the ugliness in that example due to the templated std::complex class, and unrelated to lambdas? If you make a typedef first, it becomes considerably nicer:
auto func = [](cdouble z, cdouble c) -> cdouble { return z * z + c; }
auto func = [](cdouble z, cdouble c) -> cdouble { return z * z + c; }
[deleted]
void fractal(window<int> &scr, window<double> &fract, int iter_max, std::vector<int> &colors, const std::function<std::complex<double(std::complex<double>, std::complex<double>)> &func, const char *fname, bool smooth_color);