Mathematics Stack Exchange is a question and answer site for people studying math at any level and professionals in related fields. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

I know these 12 values, which are derivative from the same unknown complex variable z:

re1  := noise(Re(z), N1);
re2  := noise(Re(z), N2);
re3  := noise(Re(z), N3);
im1  := noise(Im(z), N1);
im2  := noise(Im(z), N4);
im3  := noise(Im(z), N5);
mod1 := noise(|z|, N2);
mod2 := noise(|z|, N4);
mod3 := noise(|z|, N6);
arg1 := noise(Arg(Z), N3);
arg2 := noise(Arg(Z), N5);
arg3 := noise(Arg(Z), N6);

N1..N6 are also known, and are real variables calculated from attendant data.

noise function is abstract "distortion function", that takes real argument and returns its noised version, where amount of noise is proportional to second argument. I have declared it for modelling as following:

noise(v, n) := v * (1 + uniform(-n, n)) + uniform(-n, n)

But in real usage, nature of noise will be hardly determinable, as re*, im*, mod* and arg* values come already noised from outer world - I know only the abstract value of measure of distortion.

I have to find z from given values of N* and re*, im*, mod* and arg* with smallest possible error.

For the case of N1=N2=N3=N4=N5=N6 I've empirically found these formulas (in order of decreasing error) to provide better results, than straightforward decoding using any of re-im-mod-arg pairs:

Z1 := from_re_im((re1 + re2 + re3) / 3, (im1 + im2 + im3) / 3);
Z2 := from_mod_arg((mod1 + mod2 + mod3) / 3, (arg1 + arg2 + arg3) / 3);
Z3 := from_re_im((re1 + re2 + re3 + Re(Z2)) / 4, (im1 + im2 + im3 + Im(Z2)) / 4);
Z4 := from_mod_arg((mod1 + mod2 + mod3 + |Z1|) / 4, (arg1 + arg2 + arg3 + Arg(Z1)) / 4);

Utility functions mentioned above:

from_re_im(re, im) := re + im * 1i;
from_mod_arg(mod, arg) := mod * cos(arg) + mod * sin(arg) * 1i;

Unfortunately, when noise coefficients become unbalanced, Z4 becomes suboptimal. For example, increasing N6 among others significantly raises Z4's error, and it becomes less optimal than Z1.

So, my question is - Is there way to reliably recover z from present information with smallest possible error, without need to repeatedly rerequest data (noised different way)?

Thanks in advance.

share|cite|improve this question

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Browse other questions tagged or ask your own question.