Re: [eigen] How to raise double to array powers in Eigen

```On 19.08.2014 15:05, Mark Borgerding wrote:
```
```Correction below: "+=" changed to "*="
```
```
And you should return accum;

```
```
On 08/19/2014 09:03 AM, Mark Borgerding wrote:
```
```    pow(x,k) can be accomplished on O(log2(k)) time by

y = x;
accum = 1;
while (k) {
if (k&1)
accum *= y;
k>>=1;
y = y*y;
}
return y

e.g.  pow(x,11) = x^8 * x^2 * x^1

On 08/18/2014 01:30 PM, Ian Bell wrote:
```
```Chen-Pang,

Can you provide a bit more detail on the exponentiation by squaring?
How would I re-write my simple c++ loop above using your method?

Thanks,
Ian

On Mon, Aug 18, 2014 at 2:30 PM, Chen-Pang He <jdh8@xxxxxxxxxxxxxx
<mailto:jdh8@xxxxxxxxxxxxxx>> wrote:

If you need no optimization and want functional programming,
ArrayBase::unaryExpr with a homemade functor is enough.

If you need optimization, because all exponents are integers,
binary powering (aka exponentiation by squaring) is *the*
algorithm.   We can reuse `pow(delta, (1 << k))`.

Cheers,
Chen-Pang

在 2014 八月 18 週一 13:42:46，Ian Bell 寫道:
> On Mon, Aug 18, 2014 at 1:28 PM, Christoph Hertzberg <
> chtz@xxxxxxxxxxxxxxxxxxxxxxxx
<mailto:chtz@xxxxxxxxxxxxxxxxxxxxxxxx>> wrote:
>
> > On 18.08.2014 00:23, Ian Bell wrote:
> >
> >> cross-posted to stack overflow...
> >>
> >
> > If you cross-post, could you post a link as well?
>
>

http://stackoverflow.com/questions/25354205/how-to-raise-double-to-array-powers-in-eigen

>
> >
> >
> >  I need to raise a double value to an array of integer
powers, in c++ this
> >> would look something like
> >>
> >
> > Could you be a bit more specific about the "array of integer
powers" (I
> > guess 'exponents')?
> > If they are a sequence 0,1,2,3,... your proposed solution is
definitely
> > very inefficient. If they are of great range, with no
apparent pattern, I
> > would say the exp(log(delta)*exponent) approach is basically
the most
> > efficient solution (maybe using log2 and exp2 would be more
efficient, if
> > they were available).
> >
>
> The exponents are typically in the range [0, 10), and can be
sorted if that
> is of use.  They are not necessarily linearly increasing, we
might have
> exponents 0,0,0,1,1,1,1,2,2 for instance. Obviously it would be
better to
> short-circuit the 0 powers as well since they yield 1 again
(x^0=1).  This
> method with the exp(log(delta)*exponent) also doesn't allow you
to skip
> those powers.  I think that the >0 comparison should be cheaper
than doing
> pow(x, 0) when 0 is integer.  Especially this will be true when
using exp().
--
何震邦 | jdh8@xxxxxxxxxxxxxx <mailto:jdh8@xxxxxxxxxxxxxx> |
http://jdh8.org

```
```
```
```

```
```

--
----------------------------------------------
Dipl.-Inf., Dipl.-Math. Christoph Hertzberg
Cartesium 0.049
Universität Bremen
Enrique-Schmidt-Straße 5
28359 Bremen

Tel: +49 (421) 218-64252
----------------------------------------------

```

 Mail converted by MHonArc 2.6.19+ http://listengine.tuxfamily.org/