Hi Boost Users, I use Boost.Multiprecision's wrappers for MPFR, particularly the boost::multiprecision::mpfr_float. I've had good success with this library and its types so far, enjoying performance gains because of expression templates, and easy access to mpfr and gmp for floats, ints, and rationals. However, in my complex number type, I am struggling with named real temporaries in arithmetic operators. I am looking for help with multiplication, and I can generalize to all other operations needing a real temporary later. Here's my current code for multiplication, implemented in terms of *=. /** Complex multiplication. uses a single temporary variable 1 temporary, 4 multiplications */ complex& operator*=(const complex & rhs) { mpfr_float re_cache(real_*rhs.real_ - imag_*rhs.imag_); // cache the real part of the result imag_ = real_*rhs.imag_ + imag_*rhs.real_; real_ = re_cache; return *this; } I am using the naive evaluation formula, for better or worse. But the particular method of evaluation doesn't matter to me right now, it's the temporary variable re_cache used to cache the real part is killing me. Profiling using Allinea, gprof, and Callgrind reveals that a significant percentage of time in the program is consumed creating and destroying re_cache, as well as other temporaries scattered throughout my code. In an effort to eliminate heap allocations, I first tried replacing my using mpfr_float = boost::multiprecision::number, boost::multiprecision::et_off>; with allocate_stack, just for these named temporary variables. However, the documentation http://www.boost.org/doc/libs/1_60_0/libs/multiprecision/doc/html/boost_mult... states that allocate_stack only works in fixed precision, so the 0 digits indicating variable precision should cause problems? I expected 0 digits to fail to compile, but compile it does. The conversion from the type with allocate_stack to allocate_dynamic is not provided by the = operator, so I can write re_cache.convert_to(). But using variable precision with stack allocation appears to cause all sorts of problems. Everything depending on complex multiplication in my program breaks, indicated by massive failures in my test suite. Thus, I currently regard allocate_stack as a non-solution. My question fundamentally regards how to deal with re_cache and the *= operator for complex multiplication. Anyone have ideas on how to get rid of constant heap de/allocation of re_cache without inducing a ton more arithmetic? Using a static for it is not a solution, both because I anticipate multithreading in this application in the future, and the fact that precision will vary though the run, so I'd have to check the precision of re_cache on every evaluation. The C version of the program I am re-implementing used OpenMP for threads, and used a thread-id-indexed global for re_cache. That solution then forces OpenMP onto anyone wanting to use the complex class in multiple threads. Hence, I view this as a non-solution, too. Again, my initial thought was 'heap allocation is the problem here, so I'll use the stack allocated backend'. But variable precision doesn't appear to work with allocate_stack. And statics are no good. Any thoughts? Thanks for your time, Daniel Brake Postdoc University of Notre Dame Applied and Computational Math and Stats