From: Andy Little (andy_at_[hidden])
Date: 2005-05-10 14:10:04
"Daniel Frey" <d.frey_at_[hidden]> wrote
> Andy Little wrote:
>>
>> "Tobias Schwinger" <tschwinger_at_[hidden]> wrote
>>
>>> Btw. Daniel Frey's library looks very interesting - did you take a
>>> look at it
>>> ?
>>
>> I looked at it during the math constants review. I didnt look at the latest
>> version, but I have now. Unfortunately it doesnt compile on VC7.1 but
>> looks like
>> a smarter version of my offering. (I guess that 's where the idea for
>> mine came
>> from.) OTOH it doesnt do eg double(pi) which syntax I happen to like.
>
> Me too, but it doesn't work for generic types T. If T has several ctors
> that take different types (e.g. float, double, T), pi has no way to
> decide which cast would be appropriate.
I got around this ( I thought) in my quickie by using a traits class, but its
messy... I guess.
However IMO it shouldnt be convertible to anything. There needs to be some
concept that it models. FWIW I would be content with , float, double long
double. IOW numeric types. But ... eg FWIW my version still fails in
boost::numeric::interval. This is always going to be the problem when
trying to make one type maquerade as another :-(
>>> It uses expression templates to allow "constant expressions" e.g: 'pi
>>> * two'
>>> or 'pow(two,one / twelve)'
>
> Hm... I just had the idea of allowing a simple 'constant_<2> two;' to
> declare integer constants, but immediately ran into a more subtle
> problem involving two_value. Seems there's still something to redesign,
> so I have to play with this idea for some time...
A 'math constant' is expected to be pretty unexciting, which this doesnt
deliver. Maybe if it was repackaged as say a quirky 'smart constant', rather
than The std::math_constant it would be more gratefully received.
IOW The big hurdle is that its slightly weird and dont always act like the type
its supposed to replace. ( Which is why I am pretty content with my original
solution.eg template <typename T> struct constant{ T const & pi; T const &
e;... etc}Ok.... its not extensible (re higher in the thread) but it is simple
and acts
exactly as you would expect a T to always, (because it is a T);)
The alternative is just a function eg pi<T>(); I guess.
>> Thats interesting . I need this type of thing , but its clumsy in use.
>
> What is clumsy, what would be an improvement? Or a better syntax? Even
> if it seems impossible, I would like to know what others consider
> intuitive. If you have an idea how it should look like, please share it.
>
>> In an ideal world I guess one would be able to say e.g pow(my_num, n
>> ,d );
>> and get the function template <typename T, int N, int D > T pow(T,N, D);
>
> Here, I'm at a loss. Can you elaborate, please?
sure .. .... but of course it isnt doable in the language.
(BTW the pi * pi stuff is cool !. Sorry... it appears I have been
dismissive of that.)
int val = my::pow(9,3,2); eg replaces std::pow( static_cast<double>(9)
,3./2) with the above signature.
( val --> 27 )
today you might do this as my::pow<9,3,2>();
Another example of using compile time constants directly in expressions
point + point --> affine_point_combination<2>
point + point + point --> affine_point_combination<3> etc..
point p = affine_combination<N>() / n ; //( where n == N and the exact
function depends on whether n is a compile time constant and the runtime version
throws an exception if n !=N )
affine_combination<N> / x ( where x is a compile time evaluable constant And
x!=N) ---> Compile time Error
I guess however, that this would require figuring out the type of constness of
n.
regards
Andy Little