How to plot very low negative values in Matlab - matlab

Question

I want to plot the following - see below.
The reason that I want to use semilogy - or something else, maybe you have suggestions? - is that the data goes so low that the scale is such that all the positive data appears to be zero.
Of course semilogy doesn't work with negative data. But what can I do? The goal is that positive and negative data are somehow visible in the plot as different from zero.
I saw this question (Positive & Negitive Log10 Scale Y axis in Matlab), but is there a simpler way?
Another issue I have with the semilogy command is that the data are plotted as if they go from November to April, whereas they really go from January to June!
%% Date vector
Y = [];
for year = 2008:2016
Y = vertcat(Y,[year;year]);
end
M = repmat([01;07],9,1);
D = [01];
vector = datetime(Y,M,D);
%% Data
operatingValue=...
1.0e+05 *...
[0.020080000000000, 0.000010000000000, 0.000430446606112, 0.000286376498540, 0.000013493575572, 0.000008797774209;...
0.020080000000000, 0.000020000000000, 0.000586846360023, 0.000445575962649, 0.000118642085670, 0.000105982759202;...
0.020090000000000, 0.000010000000000, 0.000304503221392, 0.000168068072591, -0.000004277640797, 0.000006977580173;...
0.020090000000000, 0.000020000000000, 0.000471819542315, 0.000318827321824, 0.000165018495621, 0.000188500216550;...
0.020100000000000, 0.000010000000000, 0.000366527395452, 0.000218539902929, 0.000032265798656, 0.000038839492621;...
0.020100000000000, 0.000020000000000, 0.000318807172600, 0.000170892065948, -0.000093830970932, -0.000096575559444;...
0.020110000000000, 0.000010000000000, 0.000341114962826, 0.000187311222835, -0.000118595282218, -0.000135188693035;...
0.020110000000000, 0.000020000000000, 0.000266317725166, 0.000128625220303, -0.000314547081599, -0.000392868178754;...
0.020120000000000, 0.000010000000000, 0.000104302824558, -0.000000079359646, -0.001817533087893, -0.002027417507676;...
0.020120000000000, 0.000020000000000, 0.000093484465168, -0.000019260661622, -0.002180826237198, -0.001955577709102;...
0.020130000000000, 0.000010000000000, 0.000052921606827, -0.000175185193313, -4.034665389612666, -4.573270848282296;...
0.020130000000000, 0.000020000000000, 0.000027218083520, -0.000167098897097, 0, 0;...
0.020140000000000, 0.000010000000000, 0.000044907412504, -0.000106127286095, -0.012248660549809, -0.010693498138601;...
0.020140000000000, 0.000020000000000, 0.000061663936450, -0.000070280400096, -0.015180683545658, -0.008942771925367;...
0.020150000000000, 0.000010000000000, 0.000029214681162, -0.000190870890021, 0, 0;...
0.020150000000000, 0.000020000000000, 0.000082672707169, -0.000031566292849, -0.003226048850797, -0.003527284081616;...
0.020160000000000, 0.000010000000000, 0.000084562787728, -0.000024916156477, -0.001438488940835, -0.000954872893879;...
0.020160000000000, 0.000020000000000, 0.000178181932848, 0.000054988621755, -0.000172520970578, -0.000139835312255]
figure;
semilogy( datenum(vector), operatingValue(:,3), '-+', datenum(vector), operatingValue(:,4), '-o',...
datenum(vector), operatingValue(:,5), '-*', datenum(vector), operatingValue(:,6), '-x',...
'LineWidth',1.2 ), grid on;
dateaxis('x', 12);

Answer 1

Save the function symlog in your directory.
function symlog(varargin)
% SYMLOG bi-symmetric logarithmic axes scaling
% SYMLOG applies a modified logarithm scale to the specified or current
% axes that handles negative values while maintaining continuity across
% zero. The transformation is defined in an article from the journal
% Measurement Science and Technology (Webber, 2012):
%
% y = sign(x)*(log10(1+abs(x)/(10^C)))
%
% where the scaling constant C determines the resolution of the data
% around zero. The smallest order of magnitude shown on either side of
% zero will be 10^ceil(C).
%
% SYMLOG(ax=gca, var='xyz', C=0) applies this scaling to the axes named
% by letter in the specified axes using the default C of zero. Any of the
% inputs can be ommitted in which case the default values will be used.
%
% SYMLOG uses the UserData attribute of the specified axes to record the
% current transformation applied so that subsequent calls to symlog
% operate on the original data rather than the newly transformed data.
%
% Example:
% x = linspace(-50,50,1e4+1);
% y1 = x;
% y2 = sin(x);
%
% subplot(2,4,1)
% plot(x,y1,x,y2)
%
% subplot(2,4,2)
% plot(x,y1,x,y2)
% set(gca,'XScale','log') % throws warning
%
% subplot(2,4,3)
% plot(x,y1,x,y2)
% set(gca,'YScale','log') % throws warning
%
% subplot(2,4,4)
% plot(x,y1,x,y2)
% set(gca,'XScale','log','YScale','log') % throws warning
%
% subplot(2,4,6)
% plot(x,y1,x,y2)
% symlog('x')
%
% s = subplot(2,4,7);
% plot(x,y1,x,y2)
% symlog(s,'y') % can but don't have to provide s.
%
% subplot(2,4,8)
% plot(x,y1,x,y2)
% symlog() % no harm in letting symlog operate in z axis, too.
%
% Created by:
% Robert Perrotta
%
% Referencing:
% Webber, J. Beau W. "A Bi-Symmetric Log Transformation for Wide-Range
% Data." Measurement Science and Technology 24.2 (2012): 027001.
% Retrieved 6/28/2016 from
% https://kar.kent.ac.uk/32810/2/2012_Bi-symmetric-log-transformation_v5.pdf
% default values
ax = []; % don't call gca unless needed
var = 'xyz';
C = 0;
% user-specified values
for ii = 1:length(varargin)
switch class(varargin{ii})
case 'matlab.graphics.axis.Axes'
ax = varargin{ii};
case 'char'
var = varargin{ii};
case {'double','single'}
C = varargin{ii};
otherwise
error('Don''t know what to do with input %d (type %s)!',ii,class(varargin{ii}))
end
end
if isempty(ax) % user did not specify a value
ax = gca;
end
% execute once per axis
if length(var) > 1
for ii = 1:length(var)
symlog(ax,var(ii),C);
end
return
end
% From here on we redefine C to be 10^C
C = 10^C;
% Axes must be in linear scaling
set(ax,[var,'Scale'],'linear')
% Check for existing transformation
userdata = get(ax,'UserData');
if isfield(userdata,'symlog') && isfield(userdata.symlog,lower(var))
lastC = userdata.symlog.(lower(var));
else
lastC = [];
end
userdata.symlog.(lower(var)) = C; % update with new value
set(ax,'UserData',userdata)
if strcmpi(get(ax,[var,'LimMode']),'manual')
lim = get(ax,[var,'Lim']);
lim = sign(lim).*log10(1+abs(lim)/C);
set(ax,[var,'Lim'],lim)
end
% transform all objects in this plot into logarithmic coordiates
transform_graph_objects(ax, var, C, lastC);
% transform axes labels to match
t0 = max(abs(get(ax,[var,'Lim']))); % MATLAB's automatically-chosen limits
t0 = sign(t0)*C*(10.^(abs(t0))-1);
t0 = sign(t0).*log10(abs(t0));
t0 = ceil(log10(C)):ceil(t0); % use C to determine lowest resolution
t1 = 10.^t0;
mt1 = nan(1,8*(length(t1))); % 8 minor ticks between each tick
for ii = 1:length(t0)
scale = t1(ii)/10;
mt1(8*(ii-1)+(1:8)) = t1(ii) - (8:-1:1)*scale;
end
% mirror over zero to get the negative ticks
t0 = [fliplr(t0),-inf,t0];
t1 = [-fliplr(t1),0,t1];
mt1 = [-fliplr(mt1),mt1];
% the location of our ticks in the transformed space
t1 = sign(t1).*log10(1+abs(t1)/C);
mt1 = sign(mt1).*log10(1+abs(mt1)/C);
lbl = cell(size(t0));
for ii = 1:length(t0)
if t1(ii) == 0
lbl{ii} = '0';
% uncomment to display +/- 10^0 as +/- 1
% elseif t0(ii) == 0
% if t1(ii) < 0
% lbl{ii} = '-1';
% else
% lbl{ii} = '1';
% end
elseif t1(ii) < 0
lbl{ii} = ['-10^{',num2str(t0(ii)),'}'];
elseif t1(ii) > 0
lbl{ii} = ['10^{',num2str(t0(ii)),'}'];
else
lbl{ii} = '0';
end
end
set(ax,[var,'Tick'],t1,[var,'TickLabel'],lbl)
set(ax,[var,'MinorTick'],'on',[var,'MinorGrid'],'on')
rl = get(ax,[var,'Ruler']);
try
set(rl,'MinorTick',mt1)
catch err
if strcmp(err.identifier,'MATLAB:datatypes:onoffboolean:IncorrectValue')
set(rl,'MinorTickValues',mt1)
else
rethrow(err)
end
end
function transform_graph_objects(ax, var, C, lastC)
% transform all lines in this plot
lines = findobj(ax,'Type','line');
for ii = 1:length(lines)
x = get(lines(ii),[var,'Data']);
if ~isempty(lastC) % undo previous transformation
x = sign(x).*lastC.*(10.^abs(x)-1);
end
x = sign(x).*log10(1+abs(x)/C);
set(lines(ii),[var,'Data'],x)
end
% transform all Patches in this plot
patches = findobj(ax,'Type','Patch');
for ii = 1:length(patches)
x = get(patches(ii),[var,'Data']);
if ~isempty(lastC) % undo previous transformation
x = sign(x).*lastC.*(10.^abs(x)-1);
end
x = sign(x).*log10(1+abs(x)/C);
set(patches(ii),[var,'Data'],x)
end
% transform all Retangles in this plot
rectangles = findobj(ax,'Type','Rectangle');
for ii = 1:length(rectangles)
q = get(rectangles(ii),'Position'); % [x y w h]
switch var
case 'x'
x = [q(1) q(1)+q(3)]; % [x x+w]
case 'y'
x = [q(2) q(2)+q(4)]; % [y y+h]
end
if ~isempty(lastC) % undo previous transformation
x = sign(x).*lastC.*(10.^abs(x)-1);
end
x = sign(x).*log10(1+abs(x)/C);
switch var
case 'x'
q(1) = x(1);
q(3) = x(2)-x(1);
case 'y'
q(2) = x(1);
q(4) = x(2)-x(1);
end
set(rectangles(ii),'Position',q)
end
Plot your functions including symlog(gca,'y',-1.7) in the end:
plot( datenum(vector), operatingValue(:,3), '-+', datenum(vector), operatingValue(:,4), '-o',...
datenum(vector), operatingValue(:,5), '-*', datenum(vector), operatingValue(:,6), '-x',...
'LineWidth',1.2 ), grid on;
symlog(gca,'y',-1.7)
Here is your plot with positive and negative values:
Hope this solves your problem.