Complex matrix , make certain elements of real and imaginary as zero in a single line without storage

Suppose I have the following complex matrix

s = rng;
A = complex(randn(5,5),randn(5,5));
T = 0.15

How do I make both the real part corresponding to less than T equal to zero and how do I make imaginary part less than T equal to zero in the same step It is like making the following in one single line

1. realA = real(A);
2. imagA = imag(A);
3. realA(realA<T) = 0
4. imagA(imagA<T) = 0
5. A = complex(realA,imagA)

How do I convert the five steps above in a single line only using A , and no storing of real part of A and imaginary part of A in realA and imagA respectively.

Answer 1

[Walter Roberson]

   A = complex( real(A) .* (real(A) >= T), imag(A) .* (imag(A) >= T));

However, this will fail for real or complex part equal to -infinity, creating NaN in those locations, because 0 (false) times infinity is NaN instead of 0.

[madhan ravi]

accept the answer if it is working

[D_coder]

It works but the issue is mutliplication. is there any other way to do without using the element by element multiplication.

[Walter Roberson]

What is your actual goal here? Why is it important to write this without storing values and written all on one line? And when you say "one line", do you mean "one statement" or one continuous line with semi-colon separators would be acceptable?

When you impose artificial conditions about not storing values and using only one line, then you reduce your opportunities to improve efficiency.

[D_coder]

My aim is to execute the command with minimal storage and computation requirements. One line means one statement of code. if you can provide me a better and an efficient way (both in terms of saving cost of multiplications and storage) , it would be well and good.Can you execute the command with minimum storage and no multiplications?

[Walter Roberson]

Coding as one statement is rarely minimal storage or computation. For example the line

A = complex( real(A) .* (real(A) >= T), imag(A) .* (imag(A) >= T));

would be computed more efficiently as

realA = real(A);
imagA = imag(A);
A = complex( realA .* (realA >= T), imagA .* (imagA >= T));
clear realA imagA

You should not assume that an expression that occurs twice will be cached.

[Walter Roberson]

Note that each time you calculate on a vector, such as real(A), MATLAB allocates memory to store all of the results and puts a header on it with type information and size. It then counts on the fact that when the reference count goes 0 that some later step will clean up. The only difference between this and the case of storing into a variable is that a variable is entered into the symbol table. The storage used by the symbol table entry is small,possibly only 72 bytes.

MATLAB does not convert

A = f(x) + g(x)

into

allocate A
for K = 1 : numel(x) 
  A(K) = f(x(K)) + g(x(K)) ;
end

It cannot generally do that because f or g might need all of the information in x in order to do the calculation, and do not necessarily reply with an output the same size as the input. For example f might calculate statistical information such mean() and std().

[D_coder]

I don't want any .* multiplications in the command as it will defeat the purpose of my work which is to save multiplications

[Walter Roberson]

Again I have to ask about your actual goals here. When I asked earlier it was about performance, but now it is about reducing multiplications. Reducing multiplications does not necessarily improve performance. The overhead of being selective to reduce the multiplication count as much as possible can easily overwhelm the savings of reducing the count of multiplications.

The only circumstances in which I can see it as being worth the effort would be if you were doing "soft" real-time work on a FPGA, where reducing the number of multiplications to put through the bottleneck multiplier could make the difference in meeting the soft target, and yet that the case where everything had to be multiplied could be acceptable as long as it didn't happen often. But in that particular case you would replace the single statement with a for loop, as compilers can do often much better optimization for FPGA with straightforward code.

[D_coder]

our final aim is to implement the code on FPGA, so we need to save multiplications as much as possible without significant reduction in performance.

[Walter Roberson]

If your goal is FPGA then give up on writing as single statement and just do in-place for loop.

[Walter Roberson]

for k=1:length(A)
  Ar = real(A);
  Ai = imag(A);
  if Ar < T; Ar = 0; end
  if Ai < T; Ai = 0; end
  A(K) = complex(Ar,Ai);
end

Extra storage: minimal.

Multiplications: none.

If you want to improve performance at the expense of additional die space, have your compiler do automatic loop unrolling.