Fixing the imaginary/complex mess

dsimcha dsimcha at yahoo.com
Thu Apr 30 12:29:34 PDT 2009


== Quote from Don (nospam at nospam.com)'s article
> D currently allows some conversions between complex/imaginary types and
> real types, which are highly dubious.
> Given creal z, ireal y, these casts are legal:
> real x = cast(real)z;
> x = cast(real)y; // always sets x==0, regardless of the value of y.
> But I believe that should not be legal.
> For the first case, it should be written as:   real x = z.re;
> (which is shorter and clearer), and the second case is probably a bug,
> and should be x = y.im; (unless the intention really was to set x=0!).
> By the same logic, we could have sqrt(-1)==0, since the real part is 0.
> The most important effect of disallowing these casts would be to fix a
> host of bugs and wierd behaviour. All the A op= B operations involve a
> cast to A. If those nonsensical casts become illegal, the nonsensical
> op= operations become illegal automatically.
> Eg, ireal y;
> y *= y; // mathematically nonsense, y*y is real, so can't be stored in a
> pure imaginary type!
> There are a few segfault/ICE bugs (eg 718, 2839) which involve
> int/=complex, an operation which never makes any sense anyway.
> I think we're just making problems for ourselves by allowing these
> useless operations. I think they should be killed.
> Does anyone object? (If not, I'll create a patch to do it; it's not very
> difficult).

I'm totally ok with you creating such a patch and applying it, as I don't use
complex numbers anyhow, but if we're going to look at fixing complex numbers,
shouldn't we discuss whether they even still belong in the core language?  IMHO
they don't because D's user defined types have advanced pretty significantly since
the decision was made to put them in, and they're a *very* niche feature.  The
only people who need complex and imaginary numbers are scientific computing
people, and not all or even most scientific computing people need them.

Show of hands, how many people here actually use D's complex numbers on a regular
enough basis that you would miss them if they were removed from the core language
completely?



More information about the Digitalmars-d mailing list