Hello.
> > [...]
> >
> >>
> >> Also looking at Complex it would benefit from:
> >>
> >> public Complex subtractFrom(double minuend) {
> >> return new Complex(minuend - real, imaginary);
> >> }
> >
> > Is it part of the "standard"?
> > IMHO, it's fairly confusing, as nothing in the name indicates
> > that the operation only applies to the real part.
>
> The same applies for the add(real) and subtract(real) methods.
>
> What is confusing is the unconventional reverse ordering of z.subtractFrom(a)
> == a - z. I’m not happy about it but the javadoc can explain the outcome.
Actually, what confuses me is that the above equality does not hold:
double a = 5;
Complex z = Complex.of(1, 3);
Complex z2 = z.subtractFrom(a);
would yield
4 + 3 i
whereas
Complex z2 = Complex.of(a).subtract(z);
would yield
4 - 3 i
Regards,
Gilles
> It is possible in C:
>
> #include <stdio.h>
> #include <complex.h>
> #include <math.h>
> #include <float.h>
>
> int main( int argc, const char* argv[] ) {
> double a = 5.0;
> complex double z = 1 + 3 * I;
> complex double z2 = a - z;
> printf("%.17g + %.17g i\n", creal(z2), cimag(z2));
> complex double z3 = z - a;
> printf("%.17g + %.17g i\n", creal(z3), cimag(z3));
> }
>
> And C++:
>
> #include <complex>
> #include <math.h>
> #include <float.h>
>
> int main( int argc, const char* argv[] ) {
> const double a = 5.0;
> std::complex<double> z(1, 3);
> std::complex<double> z2 = a - z;
> printf("%.17g + %.17g i\n", z2.real(), z2.imag());
> std::complex<double> z3 = z - a;
> printf("%.17g + %.17g i\n", z3.real(), z3.imag());
> }
>
> Both yield:
>
> 4 + -3 i
> -4 + 3 i
>
> Note that Complex::add(double) exists. This needs no alternative as the
> addition of the real to the real component is commutative:
>
> double a
> complex z
> a + z = z + a
>
> The subtraction is not commutative (as shown above):
> a - z != z - a
>
> So given the Complex has a subtract(double) it would be fair to have a
> subtractFrom(double).
>
> The complex subtraction is also not commutative:
>
> complex y
> complex z
> y - z != z - y
>
> But in this case you can achieve the same with the API by swapping the
> arguments.
>
> >
> >>
> >> This would avoid:
> >>
> >> Complex a = …;
> >> double b = …;
> >> Complex c = Complex.ofCartesian(b - a.real(), a.imag());
> >
> > This is clear.
> >
> >> Complex d = Complex.ofReal(b).subtract(a).conj();
> >
> > This even more, but, I get it, with 3 instantiations instead of 1.
> >
> >>
> >> With
> >>
> >> Complex a = …;
> >> double b = …;
> >> Complex c = a.subtractFrom(b);
> >
> > Looks ambiguous... But if it's standard naming.
> >
> > Regards,
> > Gilles
> >
> >>
> >>>
> >>>>
> >>>>
> >>>> [1] http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
> >>>> <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf>
> >>>>
> >>>> [2] http://www.open-std.org/JTC1/SC22/WG14/www/standards
> >>>> <http://www.open-std.org/JTC1/SC22/WG14/www/standards>
> >>>
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
