On 07/11/2019 11:45, Gilles Sadowski wrote:
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
You are right, I had my use of Complex incorrect. Sorry.
The imaginary part should also be subtracted from zero thus the code
should be an equivalent with an imaginary of 0:
public Complex subtractFrom(double minuend) {
return new Complex(minuend - real, 0 - imaginary);
}
Equivalent to (as you state):
double a = ...;
Complex z = ...;
Complex y = Complex.ofReal(a).subtract(z);
There is a matrix for real/imaginary/complex all-vs-all additive and
multiplicative operators in the standard (tables in G.5.1 and G.5.2).
The question is do we want to support the entire matrix:
Covered:
Complex.multiplyReal(double x) as Complex.multiply(double x)
Complex.divideReal(double x) as Complex.divide(double x)
Complex.addReal(double x) as Complex.add(double x)
Complex.subtractReal(double x) as Complex.subtract(double x)
Not covered:
Complex.multiplyImaginary(double x)
Complex.divideImaginary(double x)
Complex.addImaginary(double x)
Complex.subtractImaginary(double x)
Complex.subtractFromReal(double x)
Complex.subtractFromImaginary(double x)
I am going through Complex now to fix code coverage and make it in line
with the C.99 standard. I will push all the config changes with the
update to Complex. Should be done be end of today.
Then we can look at fixing checkstyle and PMD.
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: dev-unsubscr...@commons.apache.org
For additional commands, e-mail: dev-h...@commons.apache.org
