Why 1f.iota(100f).array returns double[] not float[]?
import std.array : array;
import std.range : iota;
pragma(msg, typeof(iota(1f, 100f).array)); // why double[] not float[]?
void main()
{
}
Re: Why 1f.iota(100f).array returns double[] not float[]?
On 09/08/2015 12:00 AM, drug wrote:
import std.array : array;
import std.range : iota;
pragma(msg, typeof(iota(1f, 100f).array)); // why double[] not float[]?
void main()
{
}
It is probably because the type of floating point literals like 1.0 is
double. Probably there is a 1.0 in iota's implementation, converting the
element type to double according to rule number 2 here:
http://dlang.org/type.html#usual-arithmetic-conversions
Yep, here it is:
https://github.com/D-Programming-Language/phobos/blob/master/std/range/package.d#L4630
auto iota(B, E)(B begin, E end)
if (isFloatingPoint!(CommonType!(B, E)))
{
return iota(begin, end, 1.0);
}
Although any such expression can become double easily, I think the
literal should be 1.0f in this case.
Ali
Re: Why 1f.iota(100f).array returns double[] not float[]?
On Tuesday, 8 September 2015 at 07:17:01 UTC, Ali Çehreli wrote:
https://github.com/D-Programming-Language/phobos/blob/master/std/range/package.d#L4630
auto iota(B, E)(B begin, E end)
if (isFloatingPoint!(CommonType!(B, E)))
{
return iota(begin, end, 1.0);
}
Such kind of stuff would better be written as
auto iota(B, E)(B begin, E end)
{
return iota(begin, end, cast(CommonType!(B, E))1.0);
}
this doesn't need a constraint anymore, or maybe use
if(isNumeric!(CommonType!(B, E)))
I tend to use the above kind of cast often, because I like to
work with ubyte or ushort, and every f***ing number literal
changes the type to uint :-/
Re: Why 1f.iota(100f).array returns double[] not float[]?
On Tuesday, 8 September 2015 at 12:28:07 UTC, Dominikus Dittes
Scherkl wrote:
On Tuesday, 8 September 2015 at 07:17:01 UTC, Ali Çehreli wrote:
https://github.com/D-Programming-Language/phobos/blob/master/std/range/package.d#L4630
auto iota(B, E)(B begin, E end)
if (isFloatingPoint!(CommonType!(B, E)))
{
return iota(begin, end, 1.0);
}
Such kind of stuff would better be written as
auto iota(B, E)(B begin, E end)
{
return iota(begin, end, cast(CommonType!(B, E))1.0);
}
this doesn't need a constraint anymore, or maybe use
if(isNumeric!(CommonType!(B, E)))
I tend to use the above kind of cast often, because I like to
work with ubyte or ushort, and every f***ing number literal
changes the type to uint :-/
Even better, use D's universal construction feature.
auto iota(B, E)(B begin, E end)
{
return iota(begin, end, CommonType!(B, E)(1.0));
}
Re: Why 1f.iota(100f).array returns double[] not float[]?
On 9/8/15 3:17 AM, Ali Çehreli wrote:
On 09/08/2015 12:00 AM, drug wrote:
import std.array : array;
import std.range : iota;
pragma(msg, typeof(iota(1f, 100f).array)); // why double[] not float[]?
void main()
{
}
It is probably because the type of floating point literals like 1.0 is
double. Probably there is a 1.0 in iota's implementation, converting the
element type to double according to rule number 2 here:
http://dlang.org/type.html#usual-arithmetic-conversions
Yep, here it is:
https://github.com/D-Programming-Language/phobos/blob/master/std/range/package.d#L4630
auto iota(B, E)(B begin, E end)
if (isFloatingPoint!(CommonType!(B, E)))
{
return iota(begin, end, 1.0);
}
Although any such expression can become double easily, I think the
literal should be 1.0f in this case.
I think this warrants a bug report, iota with only floats as parameters
should result in floats.
-Steve
Re: Why 1f.iota(100f).array returns double[] not float[]?
On 09/08/2015 06:37 AM, Steven Schveighoffer wrote: I think this warrants a bug report, iota with only floats as parameters should result in floats. https://issues.dlang.org/show_bug.cgi?id=15033 Ali
Re: Why 1f.iota(100f).array returns double[] not float[]?
On Wednesday, 9 September 2015 at 06:37:17 UTC, Ali Çehreli wrote: https://issues.dlang.org/show_bug.cgi?id=15033 Ali https://github.com/D-Programming-Language/phobos/pull/3641
