MATLAB: Visdiff, Can you include a tolerance

compare valuesMATLABtolerancevisdiff

I'm trying to use visdiff to compare the output of two versions of a software, and make sure that the changes I made are not altering the result. I've saved the outputs to a .mat file and have several different .mat files which I would like to compare to their corresponding previous versions.

The problem is visdiff will return variables not matching even if they are very close. I would like to find some way to compare the two files, while allowing for a tolerance. For instance, the following two numbers are pulled from corresponding .mat files from the two versions, and visdiff says they're "different"

Old Version: 84.972465581755998 New Version: 84.972465581758897

My application is not concerned with how well these match at the 12th decimal point.

Thanks for any help!

Best Answer

isclose = @(x,y)isequal(size(x),size(y))&&all(abs(x(:)-y(:))<10^-10)
isclose(84.97246558175599,84.972465581758897)

Edit Per Comments

x = magic(3); %sample data
y = rand(10,1);
z = 'hello world';
save('ans427.mat','x','y','z')  %save it twice
save('ans4272.mat','x','y','z')
S1 = importdata('ans427.mat');  %load the stuff
S2 = importdata('ans4272.mat');
fns1 = fieldnames(S1);  %get fields.
fns2 = fieldnames(S2);
for ii = 1:length(fns1) %compare every field
  bool = isclose(S1.(fns1{ii}),S2.(fns2{ii}));
  if ~bool
      break
  end  
end

obviously you add more checks to make this faster: are there the same number of field names? do the field names have to be the same?

This is just a simple example.

Related Solutions

MATLAB: Renaming large variables programmatically

Are you sure that "y=x" creates a copy? In all cases I've tested, a shared dat copy is created, which creates just about 100 bytes overhead to the header of the variable. Try this:

format debug
x = 1:100
y = x
clear('x');

The shown "pr=xyz" is the pointer to the data array. It is identical for x and y, because both point to the same data. Only this would create a deep copy of the data:

x = 1:100
y = x       % x and y use the same data

y(2) = 27;  % now x and y must be different
clear('x');

But:

x = 1:100
y = x       % x and y use the same data
clear('x');
y(2) = 27;  % y still points to the same data as x did

This means that renaming a large array works directly without any tricks as long as the original is cleared before any values are changed.

But: I cannot imagine a situation which demands for renaming a variable! It is only a name, so what might be the advantage of using another one??? If it concerns EVAL, EVALIN or ASSIGNIN: Do not use them if you want to work efficiently with large arrays! If it concerns LOAD and SAVE, there are smarter solutions by using LOAD with an output argument instead of writing directly to the workspace.

MATLAB: How to add tolerance for isequal

If you had asked for tolerances for regular arrays this would've been reasonably straightforward. Something like this:

isapproximatelyequal = @(x1,x2,tol) all(abs(real(x1(:)-x2(:)))<tol) & all(abs(imag(x1(:)-x2(:)))<tol);

But for structs this is a too unspecified operation, in my opinion. What with a pair of structs where one has an additional field 'OK' that is just a simple flag. Are those structs similar enough if everything else i identical? Perhaps you can wrap the isapproximatelyequal above into a function that compares fields in your structs. Something like this:

function OK = isapproximatelyequal_structs(S1,S2,tol)
OK = 0;
fields2 = fieldnames(S2);
fields1 = fieldnames(S1);
toCheck = intersect(fields1,fields2); % for example
for iField = numel(toCheck):-1:1
  curr_field = toCheck(iField)';
  OK(iField) = isapproximatelyequal(S1.(curr_field{:}),S2.(curr_field{:}),tol);
end
if all(OK)
  OK = 1;
else
  OK = 0;
end
function OK = isapproximatelyequal(x1,x2,tol)
OK = 0;
try
  OK = all(abs(real(x1-x2))<tol) & all(abs(imag(x1-x2))<tol);
catch
  OK = 0;
end

This function will not work for structs with more complicated structure, for that you'll have to call the function recursively untill you reach fields that are arrays where isapproximatelyequal will work as you want. You should also have checks on array-sizes since the new implicit expansion might give false positives in isapproximatelyequal.

HTH

Best Answer

Related Solutions

MATLAB: Renaming large variables programmatically

MATLAB: How to add tolerance for isequal

Related Question