View difference between Paste ID: dZEZvpUj and FjKyRuyX

 /**
  * Author: F. Philipp
  *
  * Translation of
  * https://benchmarksgame.alioth.debian.org/u64q/program.php?test=mandelbrot&lang=rust&id=4
  * with minor changes
  *
  * Contains a bug resulting in slightly different results
  */
 
-#include <array>
+#include <Eigen/Dense>
-// using std::array
+
 
 #include <vector>
-#include <tuple>
+
-// using std::tuple
+
 // using std::stoi
 #include <iostream>
 // using std::cout
 #include <algorithm>
 // using std::transform
-// using std::transform, std::all_of
+
-#include <functional>
+
-// using std::bind, std::placeholders, std::multiplies, std::plus, std::minus
+
 
 namespace {
 
   constexpr int MAX_ITER = 50;
   constexpr int VLEN = CHAR_BIT;
   using double_t = double;
 
   using Vecf64 = Eigen::Array<double_t, VLEN, 1>;
-  typedef double double_t;
+
   template<class T>
-  struct Vecf64
+  using vector = std::vector<T, Eigen::aligned_allocator<T> >;
 
-    using array_type = std::array<double_t, VLEN>;
+
-    array_type array;
+
     Vecf64 cr, cr2;
-    Vecf64() = default;
+
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-    explicit Vecf64(double_t s) noexcept
+
-    { array.fill(s); }
+
   class Mandelbrot8
-    Vecf64& operator=(const Vecf64&) = default;
+
     Vecf64 zr, zi, tr, ti, cr;
-    Vecf64& operator=(double_t s) noexcept
+
 
-      array.fill(s);
+
-      return *this;
+
       for(int i = 0; i < iterations; ++i) {
-    double_t& operator[](int idx) noexcept
+
-    { return array[idx]; }
+
         tr = zr.square();
-    double_t operator[](int idx) const noexcept
+
-    { return array[idx]; }
+
     }
-    template<class BinaryFunctor>
+
-    Vecf64& inplace_transform(const Vecf64& o, BinaryFunctor f)
+
       return ((tr + ti) > 4).all();
-      array_type::iterator first = array.begin();
+
-      std::transform(first, array.end(), o.array.begin(), first, f);
+
-      return *this;
+
       const Vecf64 trti = tr + ti;
-    template<class BinaryFunctor>
+
-    Vecf64 transform(const Vecf64& o, BinaryFunctor f) const
+
         if(trti[i] <= 4.)
-      Vecf64 rtrn;
+
-      std::transform(array.begin(), array.end(), o.array.begin(),
+
-                     rtrn.array.begin(), f);
+
-      return rtrn;
+
   public:
-    template<class UnaryFunctor>
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
-    Vecf64& inplace_transform(UnaryFunctor f)
+
     explicit Mandelbrot8(double_t ci) noexcept
-      array_type::iterator first = array.begin();
+
-      std::transform(first, array.end(), first, f);
+
-      return *this;
+
     unsigned char operator()(const CrCr2Chunk& col_invariant) noexcept
-    template<class UnaryFunctor>
+
-    Vecf64 transform(UnaryFunctor f) const
+
       zi = ci;
-      Vecf64 rtrn;
+
-      std::transform(array.begin(), array.end(), rtrn.array.begin(), f);
+
-      return rtrn;
+
       advance(4);
       constexpr int n = MAX_ITER / 5 - 1;
-    Vecf64& operator*=(const Vecf64& o) noexcept
+
-    { return inplace_transform(o, std::multiplies<double_t>{}); }
+
           return 0;
-    Vecf64 operator*(const Vecf64& o) const noexcept
+
-    { return transform(o, std::multiplies<double_t>{}); }
+
       return to_byte();
-    Vecf64& operator*=(double_t s) noexcept
+
   };
-      return inplace_transform(std::bind(std::multiplies<double_t>{},
+
-                                         std::placeholders::_1, s));
+  vector<CrCr2Chunk> make_column_invariant(int bytes_per_line)
   {
-    Vecf64 operator*(double_t s) const noexcept
+
     const double_t inv = 2. / pixels_per_line;
-      return transform(std::bind(std::multiplies<double_t>{},
+    vector<CrCr2Chunk> rtrn(bytes_per_line);
-                                 std::placeholders::_1, s));
+
     for(int col_byte = 0; col_byte < bytes_per_line; ++col_byte) {
-    friend Vecf64 operator*(double_t left, const Vecf64& right) noexcept
+
-    { return right * left; }
+
         const int col = col_byte * VLEN + bit;
-    Vecf64& operator+=(const Vecf64& o) noexcept
+
-    { return inplace_transform(o, std::plus<double_t>{}); }
+
       chunk.cr2 = chunk.cr.square();
-    Vecf64 operator+(const Vecf64& o) const noexcept
+
-    { return transform(o, std::plus<double_t>{}); }
+
   }
-    Vecf64& operator+=(double_t s) noexcept
+
   std::vector<unsigned char>
-      return inplace_transform(std::bind(std::plus<double_t>{},
+  make_bitmap(const vector<CrCr2Chunk>& column_invariants)
-                                         std::placeholders::_1, s));
+
     const int bytes_per_line = static_cast<int>(column_invariants.size());
-    Vecf64 operator+(double_t s) const noexcept
+
     const double_t inv = 2. / pixels_per_line;
-      return transform(std::bind(std::plus<double_t>{},
+
-                                 std::placeholders::_1, s));
+
     for(int row = 0; row < pixels_per_line; ++row) {
-    friend Vecf64 operator+(double_t left, const Vecf64& right) noexcept
+
-    { return right + left; }
+
       std::transform(column_invariants.begin(), column_invariants.end(),
-    Vecf64& operator-=(const Vecf64& o) noexcept
+
-    { return inplace_transform(o, std::minus<double_t>{}); }
+
     }
-    Vecf64 operator-(const Vecf64& o) const noexcept
+
-    { return transform(o, std::minus<double_t>{}); }
+
   void print_pbm(const std::vector<unsigned char>& bitmap,
-    Vecf64& operator-=(double_t s) noexcept
+
                  std::ostream& binary_output)
-      return inplace_transform(std::bind(std::minus<double_t>{},
+
-                                         std::placeholders::_1, s));
+
                   << ' ' << pixels_per_line
-    Vecf64 operator-(double_t s) const noexcept
+
     binary_output.write(reinterpret_cast<const char*>(bitmap.data()),
-      return transform(std::bind(std::minus<double_t>{},
+
-                                 std::placeholders::_1, s));
+
   }
-    friend Vecf64 operator-(double_t left, const Vecf64& right) noexcept
+
 
-      return right.transform(std::bind(std::minus<double_t>{},
+
-                                       left, std::placeholders::_1));
+
   /* number of pixels in each dimension */
-    Vecf64& inplace_square() noexcept
+
   if(argc > 1)
-      return inplace_transform(std::bind(std::multiplies<double_t>{},
+
-                                         std::placeholders::_1,
+
-                                         std::placeholders::_1));
+
   const vector<CrCr2Chunk> column_invariants =
-    Vecf64 square() const noexcept
+
   const std::vector<unsigned char> bitmap = make_bitmap(column_invariants);
-      return transform(std::bind(std::multiplies<double_t>{},
+
-                                 std::placeholders::_1,
+