Thanks for sharing it.
look to ...
... just my point of view
Post by mathias_magdowskiI have extended the given example in a way that the left and right y axis get
some kind of intelligent equal scaling, so that a joined grid for both axes
would fit. If one of the axes includes the value of y = 0, both axes will
also share the same "base line".
// Function for plotting a diagram with two y axes
// x - x values -> vector
// y1 - y values for the for the left y axis -> vector
// y2 - y values for the right y axis -> vector
// a1, a2 - axes -> handle
function [a1,a2]=plotyy(x,y1,y2)
// example for a diagram with two y axes
https://commons.wikimedia.org/wiki/File:Trace_ln_sqrt_1_2_deux_echelles_scilab.svg
http://mailinglists.scilab.org/Scilab-users-Plots-on-second-Y-axis-td4025895.html
// generation of the right y axis
a1=newaxes();
a1.tight_limits=["on","off","off"];
// plot of the first function
plot(x,y1);
// generation of the right y axis
a2=newaxes();
// no background for this plot
a2.filled="off";
// hide second x axis
a2.axes_visible(1)="off";
a2.y_location = "right";
a2.tight_limits = "on";
// plot of the second function
plot(x,y2,"r");
// set font size
a1.font_size=3;
a2.font_size=3;
// delete tick marks of the first x axis
a1.x_ticks=tlist(["ticks","locations","labels"],[],[])
// add a grid
a1.grid=[1,1];
a2.grid=[1,1];
// end of plotting
// algorithm to equally scale the axes
// minimum of the first function -> scalar
y1min=min(y1);
// maximum of the first function -> scalar
y1max=max(y1);
// minimum of the second function -> scalar
y2min=min(y2);
// maximum of the second function -> scalar
y2max=max(y2);
// divider for the first function -> scalar
division1=find_division(y1min,y1max);
// divider for the second function -> scalar
division2=find_division(y2min,y2max);
// lower axis left y axis the first function (normalized) -> scalar
y1axismin=floor(y1min/division1)
// upper axis left y axis the first function (normalized) -> scalar
y1axismax=ceil(y1max/division1)
// lower axis left y axis the second function (normalized) -> scalar
y2axismin=floor(y2min/division2)
// upper axis left y axis the second function (normalized) -> scalar
y2axismax=ceil(y2max/division2)
// distinction of cases
if y1axismin*y1axismax>0 & y2axismin*y2axismax>0 then
// both axes don't go over the value of zero
// preset variable
addupper=1;
// start a loop, until both axes have the same number of dividers
while y1axismax-y1axismin>y2axismax-y2axismin
// left y axis has more dividers than the right y axis
if addupper==1 & y2axismax~=-1
// move the upper limit of the right y axis up
y2axismax=y2axismax+1;
end
if addupper==-1 & y2axismin~=1
// move the lower limit of the right y axis down
y2axismin=y2axismin+1;
end
// toggle variable
addupper=adduper*(-1);
end
// preset variable
addupper=1;
// start a loop, until both axes have the same number of dividers
while y1axismax-y1axismin<y2axismax-y2axismin
// left y axis hat weniger optimum rounded divider als right y
axis
if addupper==1 & y1axismax~=-1
// move the upper limit of the left y axis up
y1axismax=y1axismax+1;
end
if addupper==-1 & y1axismin~=1
// move the lower limit of the left y axis down
y1axismin=y1axismin+1;
end
// toggle variable
addupper=adduper*(-1);
end
// rescale axes
// lower limit of the left y axis
a1.data_bounds(1,2)=y1axismin*division1;
// lower limit of the left y axis
a1.data_bounds(2,2)=y1axismax*division1;
// lower limit of the left y axis
a2.data_bounds(1,2)=y2axismin*division2;
// lower limit of the left y axis
a2.data_bounds(2,2)=y2axismax*division2;
else
// at least one of the axes goes over zero, or starts or ends at
zero
// find joint lower limit of both axes -> scalar
ymin=min(y1axismin,y2axismin);
// find joint upper limit of both axes -> scalar
ymax=max(y1axismax,y2axismax);
// rescale axes
// lower limit of the left y axis
a1.data_bounds(1,2)=ymin*division1;
// lower limit of the left y axis
a1.data_bounds(2,2)=ymax*division1;
// lower limit of the left y axis
a2.data_bounds(1,2)=ymin*division2;
// lower limit of the left y axis
a2.data_bounds(2,2)=ymax*division2;
end
endfunction
// Function to find a good division for the grid of a diagram
// axismin: minimum of the data to display -> scalar
// axismax: maximum of the data to display -> scalar
// division: optimum rounded divider to divide the axis into 5 to 10 parts
function division=find_division(axismin,axismax)
// distance between maximum and minimum -> scalar
distance=axismax-axismin;
// preset exponent -> scalar
exponent=0;
// loop, until the distance is between 1 and 10
while 1
if distance>10 then
// decrease distance -> scalar
distance=distance/10;
// increase exponent -> scalar
exponent=exponent+1;
elseif distance<1 then
// increase distance -> scalar
distance=distance*10;
// decrease exponent -> scalar
exponent=exponent-1;
else
// exit loop
break;
end
end
// distinction of cases, so that there will be 5 to 10 dividers at the
end
if distance==1 then
// optimum rounded divider -> scalar
division=0.1;
elseif distance<=2 then
// optimum rounded divider -> scalar
division=0.2;
elseif distance<=5 then
// optimum rounded divider -> scalar
division=0.5;
else
// optimum rounded divider -> scalar
division=1;
end
// adjust the scaling -> scalar
division=division*10^exponent;
endfunction
--
http://mailinglists.scilab.org/Scilab-users-Plots-on-second-Y-axis-tp4025895p4036055.html
Sent from the Scilab users - Mailing Lists Archives mailing list archive at Nabble.com.
_______________________________________________
users mailing list
http://lists.scilab.org/mailman/listinfo/users