Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
Hi Basile, Thank you for your code, it allowed me to grasp a little bit more about how to do things in D. Vincent
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 23:03:32 UTC, Picaud Vincent wrote:
I need:
1/ a way to detect compile-time constant vs "dynamic" values
/**
* Indicates if something is a value known at compile time.
*
* Params:
* V = The value to test.
* T = Optional, the expected value type.
*/
template isCompileTimeValue(alias V, T...)
if (T.length == 0 || (T.length == 1 && is(T[0])))
{
enum isKnown = is(typeof((){enum v = V;}));
static if (!T.length)
enum isCompileTimeValue = isKnown;
else
enum isCompileTimeValue = isKnown && is(typeof(V) ==
T[0]);
}
///
unittest
{
string a;
enum b = "0";
enum c = 0;
static assert(!isCompileTimeValue!a);
static assert(isCompileTimeValue!b);
static assert(isCompileTimeValue!c);
static assert(isCompileTimeValue!(b,string));
static assert(isCompileTimeValue!(c,int));
static assert(!isCompileTimeValue!(c,char));
static assert(!isCompileTimeValue!(char));
}
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 23:07:27 UTC, Picaud Vincent wrote: typo... auto capacity = max(0,(size_-1)*stride_+1); To be more correct I have something like: alias IntergralConstant!(int,0) Zero_c; alias IntergralConstant!(int,1) One_c; auto capacity = max(Zero_c,(size_-One_c)*stride_+One_c); with "smooth" implicit conversion IntegralConstant -> int for cases where size_ or stride_ are "int" and not both IntegralConstant types.
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 22:18:56 UTC, Jerry wrote:
On Monday, 7 November 2016 at 21:37:50 UTC, Picaud Vincent
wrote:
static if ( isIntegralConstant!(typeof(required_capacity())
)
{
}
else
{
}
}
Premature post send by error sorry Well something like:
static if ( isIntegralConstant!(typeof(required_capacity())
)
ElementType[required_capacity()] data_;
else
ElementType[] data_;
}
For that, at least in C++, I need integral_constant<> type
with compile-time arithmetic and smooth integration with
"usual" size_t/ptrdiff_t types.
2/ I also would like to test some implementations concerning
automatic differentiation.
I have my own C++ libs, inspired, but ~20% faster than Adept:
http://www.met.reading.ac.uk/clouds/adept/
and I would like to know how I can do that in D
Well... That is the idea... I hope I will get some results and
I will be happy to share if it is something interesting.
Vincent
Ah I get what you mean, you can do that without using a special
type.
struct Vector(T, Args...) if(Args.length == 1)
{
static if(is(Args[0] == size_t))
{
size_t size;
}
else static if(Args[0] != 0) // would error if it's a
type that's not size_t
{
enum size = Args[0];
}
else
{
static assert(0);
}
}
Vector!(int, 10) a;
Vector!(int, size_t) b; // both work with IntegralConstant
could use __traits(compiles) to see if it's not a type, for
that second static if. Which would probably be better, so if
you pass a float or something, it won't give a weird error.
Thank you again Jerry!
For sure my way of thinking is twisted by my C++ habits! :-/
The positive point is that D seems to offer much shorter
solutions (this is my hope).
However I still need some investigations and/or some guidance:
-> not sure that it is ok for me as I really want to track
"static constants" all the
way long.
That is the reason why I introduced the IntegralConstant type
(with operator overloading, work in progress)
For instance, the code:
enum int a=1,b=2;
auto c = a+b;
pragma(msg,typeof(c)); // prints "int"
static assert(c==3); // compilation fails: "variable c
cannot be read at compile time"
To implement my vector structs I need:
1/ a way to detect compile-time constant vs "dynamic" values
2/ to perform and to propagate compile-time constants across
"arithmetic" computations.
For instance to compute the required capacity to store vector
data, I need something
like
auto capacity = max(0,(size_-1)*stride_);
and this expression must make sense for both "dynamic" values and
compile-time constant.
In one case I expect
typeof(capacity) -> int,
in the other
typeof(capacity) -> IntegralConst
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 21:37:50 UTC, Picaud Vincent wrote:
static if ( isIntegralConstant!(typeof(required_capacity()) )
{
}
else
{
}
}
Premature post send by error sorry Well something like:
static if ( isIntegralConstant!(typeof(required_capacity()) )
ElementType[required_capacity()] data_;
else
ElementType[] data_;
}
For that, at least in C++, I need integral_constant<> type with
compile-time arithmetic and smooth integration with "usual"
size_t/ptrdiff_t types.
2/ I also would like to test some implementations concerning
automatic differentiation.
I have my own C++ libs, inspired, but ~20% faster than Adept:
http://www.met.reading.ac.uk/clouds/adept/
and I would like to know how I can do that in D
Well... That is the idea... I hope I will get some results and
I will be happy to share if it is something interesting.
Vincent
Ah I get what you mean, you can do that without using a special
type.
struct Vector(T, Args...) if(Args.length == 1)
{
static if(is(Args[0] == size_t))
{
size_t size;
}
else static if(Args[0] != 0) // would error if it's a
type that's not size_t
{
enum size = Args[0];
}
else
{
static assert(0);
}
}
Vector!(int, 10) a;
Vector!(int, size_t) b; // both work with IntegralConstant
could use __traits(compiles) to see if it's not a type, for that
second static if. Which would probably be better, so if you pass
a float or something, it won't give a weird error.
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 21:23:37 UTC, Picaud Vincent wrote:
On Monday, 7 November 2016 at 18:59:24 UTC, Jerry wrote:
On Monday, 7 November 2016 at 18:42:37 UTC, Picaud Vincent
wrote:
template isIntegralConstant(ANY)
{
enum bool
isIntegralConstant=__traits(identifier,ANY)=="IntegralConstant";
}
A bit more elegant way of doing that would be:
enum isIntegralConstant(T) = is(T : IntegralConstant!U, U...);
I would be very graceful for any help/advice that explains
the right way to implement C++ std::integral_constant in the D language.
Vincent
Now the question is, do you really need IntegralConstant? I've
never used it in C++ so I don't really know any of the use
cases for it. But generally in D if you need something to be a
compile time constant value you can just use "enum". It can be
any type as well, so long as it can be evaluated at compile
time.
enum long someConstant = 1 << 32;
Hi Jerry,
Thank you so much for your quick answer! I tried your
suggestion and it works.
My main interest is numerical computations. I have some C++
libs using meta-programming and I want to see how I can
translate some parts in D. The goal is to check: productivity &
code readability & performance. I will try to implement 2 toy
examples:
1/ A basic example of strided dense vector structure dealing
with the dynamic/static size in an uniform way. In D I thing
this can be done with something like this (not tried yet to
compile it, but that is the idea to mimick my C++
implementation)
struct Vector(T,SIZE,STRIDE) if(
(is(SIZE==size_t)||isIntegralConstant!SIZE) ...)
{
alias T ElementType;
private SIZE size_;
private STRIDE stride_;
...
auto required_capacity() { return size_*stride_; } // return
a size_t or a IntegralConst
static if ( isIntegralConstant!(typeof(required_capacity()) )
{
}
else
{
}
}
Premature post send by error sorry Well something like:
static if ( isIntegralConstant!(typeof(required_capacity()) )
ElementType[required_capacity()] data_;
else
ElementType[] data_;
}
For that, at least in C++, I need integral_constant<> type with
compile-time arithmetic and smooth integration with "usual"
size_t/ptrdiff_t types.
2/ I also would like to test some implementations concerning
automatic differentiation.
I have my own C++ libs, inspired, but ~20% faster than Adept:
http://www.met.reading.ac.uk/clouds/adept/
and I would like to know how I can do that in D
Well... That is the idea... I hope I will get some results and I
will be happy to share if it is something interesting.
Vincent
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 18:59:24 UTC, Jerry wrote:
On Monday, 7 November 2016 at 18:42:37 UTC, Picaud Vincent
wrote:
template isIntegralConstant(ANY)
{
enum bool
isIntegralConstant=__traits(identifier,ANY)=="IntegralConstant";
}
A bit more elegant way of doing that would be:
enum isIntegralConstant(T) = is(T : IntegralConstant!U, U...);
I would be very graceful for any help/advice that explains the
right way to implement C++ std::integral_constant
in the D language.
Vincent
Now the question is, do you really need IntegralConstant? I've
never used it in C++ so I don't really know any of the use
cases for it. But generally in D if you need something to be a
compile time constant value you can just use "enum". It can be
any type as well, so long as it can be evaluated at compile
time.
enum long someConstant = 1 << 32;
Hi Jerry,
Thank you so much for your quick answer! I tried your suggestion
and it works.
My main interest is numerical computations. I have some C++ libs
using meta-programming and I want to see how I can translate some
parts in D. The goal is to check: productivity & code readability
& performance. I will try to implement 2 toy examples:
1/ A basic example of strided dense vector structure dealing with
the dynamic/static size in an uniform way. In D I thing this can
be done with something like this (not tried yet to compile it,
but that is the idea to mimick my C++ implementation)
struct Vector(T,SIZE,STRIDE) if(
(is(SIZE==size_t)||isIntegralConstant!SIZE) ...)
{
alias T ElementType;
private SIZE size_;
private STRIDE stride_;
...
auto required_capacity() { return size_*stride_; } // return a
size_t or a IntegralConst
static if ( isIntegralConstant!(typeof(required_capacity()) )
{
}
else
{
}
}
Re: New to D and mimicking C++ : how to implement std::integral_constant<>?
On Monday, 7 November 2016 at 18:42:37 UTC, Picaud Vincent wrote:
template isIntegralConstant(ANY)
{
enum bool
isIntegralConstant=__traits(identifier,ANY)=="IntegralConstant";
}
A bit more elegant way of doing that would be:
enum isIntegralConstant(T) = is(T : IntegralConstant!U, U...);
I would be very graceful for any help/advice that explains the
right way to implement C++ std::integral_constant in
the D language.
Vincent
Now the question is, do you really need IntegralConstant? I've
never used it in C++ so I don't really know any of the use cases
for it. But generally in D if you need something to be a compile
time constant value you can just use "enum". It can be any type
as well, so long as it can be evaluated at compile time.
enum long someConstant = 1 << 32;
