is it possible to customize writeStruct for a data type?

I am using writeStruct to write a structure in XML format. I then need to read it for c++ unit tests.

The problem is, writeStruct writes complex numbers in a way it makes parsing the XML difficult. Is there a way I can customize how writeStruct prints complex numbers?

Answer 1

[Madheswaran]

Hello,

Currently, the 'writestruct' function does not provide built-in customization for formatting complex numbers in XML. However, you can implement a workaround by preprocessing the data before writing it to XML. This involves converting complex numbers into a desired format for C++ unit test cases.

The below function preprocesses a structure by converting all complex values into a sub-structure containing two fields: ‘real’ and ‘imag’.

function modifiedStruct = preProcessComplex(inputStruct)
    modifiedStruct = inputStruct;
    fields = fieldnames(inputStruct);
    for i = 1:numel(fields)
        if isnumeric(inputStruct.(fields{i})) && ~isreal(inputStruct.(fields{i}))
            modifiedStruct.(fields{i}) = struct('real', real(inputStruct.(fields{i})), ...
                'imag', imag(inputStruct.(fields{i})));
        elseif isstruct(inputStruct.(fields{i}))
            modifiedStruct.(fields{i}) = preProcessComplex(inputStruct.(fields{i}));
        end
    end
end

You can customize how imaginary numbers are handled to fit your requirements for C++ unit test. The above code uses 'writestruct' function which was introduced in R2020b. For more details, refer to the MathWorks documentation on 'writestruct' : https://mathworks.com/help/matlab/ref/writestruct.html

Hope this helps!

Answer 2

[Shlok]

Hi,

There’s a small correction. The function 'writeStruct' doesn't exist in R2018a, which is the version mentioned in the question. I believe you meant to refer to 'writestruct’, which was introduced in R2020b.

To write complex numbers using the “writestruct” function, you can implement a workaround. The idea is to iterate through the structure and convert any complex numbers into custom key-value pairs under a substructure. Follow the following steps to achieve the same:

• Traverse the structure using “fieldnames()” to locate complex numbers.
• For scalar complex numbers, wrap them in a substructure with real and imaginary keys.
• For arrays of complex numbers, create a substructure with multiple “complexValue” tags.
• Recursively process nested structures to handle any complex numbers within them.
• Use “writestruct” to export the modified structure as XML.

I have created the following function to preprocess complex numbers within the structure before dumping it into XML:

function s = markComplexNumbers(s)
    fnames = fieldnames(s);
    for i = 1:numel(fnames)
        fd = s.(fnames{i});
        if isnumeric(fd) && ~isreal(fd)
            if isscalar(fd)
                % Single complex number, wrap real and imag as attributes to complexValue tag
                s.(fnames{i}) = struct('complexValue', struct('real', real(fd), 'imag', imag(fd)));
            else
                % Array of complex numbers, create multiple complexValue tags with attributes
                arrStruct = [];
                for j = 1:numel(fd)
                    arrStruct = [arrStruct; struct('complexValue', struct('real', real(fd(j)), 'imag', imag(fd(j))))];
                end
                s.(fnames{i}) = arrStruct;
            end
        elseif isstruct(fd)
            % Recursively preprocess nested structures
            s.(fnames{i}) = markComplexNumbers(fd);
        end
    end
end 

This code isolates real and imaginary part within the “complexValue” tag, making it an atomic entity. For example, in the following array, complexArray = [1+2i, 3+4i]; above function gives the following output: