How to find the command by which certain struct done in Matlab? - matlab

Question

Suppose a is defined as the struct below. I tried to find equivalent command to R's dput but errs here. For example, I know that the below must be of the form struct('const',1,'terms',{{struct(),struct()}}) but I don't know what is stored inside the structure without going to check it with commands like here, time-consuming.
So by which command I can see the original command to generate a struct in Matlab?
>> a
a =
const: 1
terms: {[1x1 struct] [1x1 struct]}

Answer 1

Comment
Is it possible for you to switch from using a structure to a class? If so you could make one that mimics the struct, and each time it is modified call stack = dbstack to get the stack - then store the stack along with the change. The command that made the change could then be retrieved automatically later from the line numbers in the stack.
As a follow-up request to this in the comment, here is an example of a class that provides struct functionality and also keeps a record of its assignments:
classdef utstruct
properties (SetAccess = private)
modifications
end
properties (Dependent, SetAccess = private)
myStruct
end
properties (Access = private)
m_struct
end
methods
function self = utstruct(varargin)
if nargin > 0
self.m_struct = builtin('struct', varargin{:});
else
self.m_struct = builtin('struct');
end
% Should update self.modifications here
end
function B = subsref(self, s)
if any(strcmp(s(1).subs, properties(self)))
B = builtin('subsref', self, s);
else
B = subsref(self.m_struct, s);
end
end
function A = subsasgn(self, s, b)
self.m_struct = subsasgn(self.m_struct, s, b);
newMod = builtin('struct');
newMod.type = 'subsasgn';
newMod.modData = {s b};
newMod.stack = dbstack;
self.modifications = [self.modifications; newMod];
A = self;
end
function disp(self)
disp(self.m_struct);
end
function names = fieldnames(self, varargin)
names = fieldnames(self.m_struct, varargin{:});
end
function C = cat(self, dim, varargin)
uts = cellfun(#(x)isa(x, 'utstruct'), varargin);
varargin{uts} = cellfun(#(x)x.m_struct, varargin(uts));
varargin = [{self.m_struct} varargin];
self.m_struct = cat(dim, varargin{:});
% Should update self.modifications here
C = self;
end
function C = horzcat(self, varargin)
C = self.cat(1, varargin{:});
end
function C = vertcat(self, varargin)
C = self.cat(2, varargin{:});
end
function value = get.myStruct(self)
value = self.m_struct;
end
end
end
You should add some code to update the modifications array when initialisation / concatenation operations occur.
The subsref and subsasgn overrides are the key points here that make it behave like a struct (by deferring all their activity to an actual struct), but other overrides like fieldnames and disp do the same thing. In subsasgn a record of all the assignments to the struct is kept, along with the stack that generated the assignment.
Note: for this to be fully compatible with the built-in struct you probably should override a few more methods, but this should be enough to get you started. See Subclassing MATLAB Built-In Types.
Edit: I made the example a bit more robust. It's now a value class - as it should be - and works with concatenation.
Edit: You can avoid using a find-and-replace to refactor existing struct(...) calls by redefining the function struct:
function s = struct(varargin)
% STRUCT Overrides default struct function to provide unit-testable structs
%
% Set global variable unitTestStructEnabled to true to enable this
% function.
%
global unitTestStructEnabled;
if isempty(unitTestStructEnabled)
unitTestStructEnabled = false;
end
if unitTestStructEnabled
s = utstruct(varargin{:});
else
s = builtin('struct', varargin{:});
end
You probably don't want that hanging around on your path the whole time, as you will get a warning when you first create a struct (you could turn it off, but that might hide other problems), so you should probably put it in a folder that's not normally in the path, and temporarily add it to the path for unit testing (addpath / rmpath).

Answer 2

Here's the skeleton of a dumpvar function, i.e. something along the idea of tashuhka
function str = dumpvar(a)
switch class(a)
case 'double'
if isempty(a)
str = '[]'; % bug when "a" is multidimensional and empty
elseif isscalar(a)
str = num2str(a);
elseif isrow(a)
str = strcat('[', dumpvar(a(1)));
for k = 2:size(a,2)
str = strcat(str,',',dumpvar(a(k)));
end;
str = strcat(str, ']');
elseif numel(size(a)) == 2
str = strcat('[', dumpvar(a(1,:)));
for k = 2:size(a,1)
str = strcat(str,';',dumpvar(a(k,:)));
end;
str = strcat(str, ']');
else
do_what_i_mean();
end;
case 'struct'
fn = fieldnames(a);
if isempty(fn)
str = 'struct()';
elseif isscalar(a)
str = strcat('struct(''', fn{1},''',', dumpvar(a.(fn{1})));
for k=2:numel(fn)
str = strcat(str,',''',fn{k},''',', dumpvar(a.(fn{k})));
end;
str = strcat(str, ')');
else
do_what_i_mean();
end;
otherwise
do_what_i_mean();
end;
function do_what_i_mean()
throwAsCaller(MException(...
'beingLazy:onSaturday:Fault', ...
'Storage of class "%s" and arity %d is not implemented yet. Would you?', ...
class(a), numel(size(a))...
));
end;
end
Save it in a dumpvar.m file somewhere in Matlab's path, then test it with this code snippet:
a = struct(...
'field1', 1,...
'field2', [],...
'field10', struct(...
'field3', [1 2;2 3;3 4],...
'field4', struct()...
)...
);
disp(dumpvar(a));
eval(sprintf('b=%s;', dumpvar(a)));
Please note that this function is still in a toy stage: it's anywhere near exhaustive (lacks treatment of struct arrays, cells, char, logical and other fundamental types, not to mention user-defined classes --- hehe, those would be a pickle) and it is meant to be completed by you with whatever functionality you need.

Answer 3

Although it does not answer completely your question, vsize() by Urs can help you:
% Create some complicated variable
v(1).a{1}=sparse(magic(3)+2i*magic(3));
v(2).a{2}={struct('FA',{'a','bb'},'FB',{magic(5),{}})};
v(2).b{2}=#(x) sind(x);
% Dissect
P = vsize(v);
% -------------------------
% 1998 1998 B * v = 2:1x2:struct.(2)
% CELL ----- 360 B v[].a = 2:1x1:cell
% 1750 248 B - v[].a{} = 2:3x3:double.sparse.complex
% CELL ----- 1014 B v[].a = 2:1x2:cell
% 1750 0 B - v[].a{} = 2:0x0:double
% CELL ----- 894 B v[].a{} = 2:1x1:cell
% STRUCT --- 782 B v[].a{}{} = 2:1x2:struct.(2)
% 1748 2 B - v[].a{}{}[].FA = 2:1x1:char
% 1744 4 B - v[].a{}{}[].FA = 2:1x2:char
% 1544 200 B - v[].a{}{}[].FB = 2:5x5:double
% CELL ----- 0 B v[].a{}{}[].FB = 2:0x0:cell
% 1544 0 B - v[].b = 2:0x0:double
% CELL ----- 152 B v[].b = 2:1x2:cell
% 1544 0 B - v[].b{} = 2:0x0:double
% 1512 32 B - v[].b{} = 2:1x1:function_handle