void defaultsetgraph(int gno, int setno)
{
double xmax, xmin, ymax, ymin;
getsetminmax(gno, setno, &xmin, &xmax, &ymin, &ymax);
if (xmin != xmax)
{
g[gno].w.xg2 = xmax;
g[gno].w.xg1 = xmin;
}
else
{
if ((xmin == 0.0) && (xmax == 0.0))
{
xmin = 1.0;
}
g[gno].w.xg1 = xmin - 0.1 * fabs(xmin);
g[gno].w.xg2 = xmin + 0.1 * fabs(xmin);
}
if (ymin != ymax)
{
g[gno].w.yg2 = ymax;
g[gno].w.yg1 = ymin;
}
else
{
if ((ymin == 0.0) && (ymax == 0.0))
{
ymin = 1.0;
}
g[gno].w.yg1 = ymin - 0.1 * fabs(ymin);
g[gno].w.yg2 = ymin + 0.1 * fabs(ymin);
}
}
static void autorange_bysets(Quark **sets, int nsets, int autos_type)
{
Quark *gr;
world w;
double xmax, xmin, ymax, ymin;
int scale;
if (autos_type == AUTOSCALE_NONE || nsets <= 0) {
return;
}
gr = get_parent_graph(sets[0]);
graph_get_world(gr, &w);
if (graph_get_type(gr) == GRAPH_SMITH) {
if (autos_type == AUTOSCALE_X || autos_type == AUTOSCALE_XY) {
w.xg1 = -1.0;
w.yg1 = -1.0;
}
if (autos_type == AUTOSCALE_Y || autos_type == AUTOSCALE_XY) {
w.xg2 = 1.0;
w.yg2 = 1.0;
}
graph_set_world(gr, &w);
return;
}
xmin = w.xg1;
xmax = w.xg2;
ymin = w.yg1;
ymax = w.yg2;
if (autos_type == AUTOSCALE_XY) {
getsetminmax(sets, nsets, &xmin, &xmax, &ymin, &ymax);
} else if (autos_type == AUTOSCALE_X) {
getsetminmax_c(sets, nsets, &xmin, &xmax, &ymin, &ymax, 2);
} else if (autos_type == AUTOSCALE_Y) {
getsetminmax_c(sets, nsets, &xmin, &xmax, &ymin, &ymax, 1);
}
if (autos_type == AUTOSCALE_X || autos_type == AUTOSCALE_XY) {
scale = graph_get_xscale(gr);
round_axis_limits(&xmin, &xmax, scale);
w.xg1 = xmin;
w.xg2 = xmax;
}
if (autos_type == AUTOSCALE_Y || autos_type == AUTOSCALE_XY) {
scale = graph_get_yscale(gr);
round_axis_limits(&ymin, &ymax, scale);
w.yg1 = ymin;
w.yg2 = ymax;
}
graph_set_world(gr, &w);
}
void defaultx(int gno, int setno)
{
int i, first = 1;
double xgmin, xgmax, xmax, xmin, tmp;
xgmin = xgmax = 0.0;
if (setno < 0)
{
for (i = 0; i < g[gno].maxplot; i++)
{
if (isactive_set(gno, i))
{
getsetminmax(gno, i, &xmin, &xmax, &tmp, &tmp);
if (first)
{
xgmin = xmin;
xgmax = xmax;
first = 0;
}
else
{
xgmin = (xmin < xgmin) ? xmin : xgmin;
xgmax = (xmax > xgmax) ? xmax : xgmax;
}
}
}
}
else
{
if (isactive_set(gno, setno))
{
getsetminmax(gno, setno, &xgmin, &xgmax, &tmp, &tmp);
}
else
{
return;
}
}
if (xgmin != xgmax)
{
g[gno].w.xg2 = xgmax;
g[gno].w.xg1 = xgmin;
}
else
{
if ((xgmin == 0.0) && (xgmax == 0.0))
{
xgmin = 1.0;
}
g[gno].w.xg1 = xgmin - 0.1 * fabs(xgmin);
g[gno].w.xg2 = xgmin + 0.1 * fabs(xgmin);
}
switch (g[gno].type)
{
case BAR:
case STACKEDBAR:
g[gno].w.xg1 -= 0.5;
g[gno].w.xg2 += 0.5;
if (g[gno].w.yg1 > 0.0)
{
g[gno].w.yg1 = 0.0;
}
break;
case HBAR:
case STACKEDHBAR:
if (g[gno].w.xg1 > 0.0)
{
g[gno].w.xg1 = 0.0;
}
break;
case LOGX:
if (g[gno].w.xg1 <= 0.0)
{
errwin("can't set graph type to log-linear, X minimum = 0.0");
g[gno].type = XY;
}
break;
case LOGY:
if (g[gno].w.yg1 <= 0.0)
{
errwin("can't set graph type to linear-log, Y minimum = 0.0");
g[gno].type = XY;
}
break;
case LOGXY:
if (g[gno].w.xg1 <= 0.0)
{
errwin("can't set graph to log-log, X minimum <= 0.0");
g[gno].type = XY;
}
else if (g[gno].w.yg1 <= 0.0)
{
errwin("can't set graph type to log-log, Y minimum <= 0.0");
g[gno].type = XY;
}
break;
}
}
void defaultgraph(int gno)
{
double x1, x2, y1, y2;
double xgmax, xgmin, ygmax, ygmin;
int i, first = 1;
xgmax = xgmin = ygmax = ygmin = 0.0;
for (i = 0; i < g[gno].maxplot; i++)
{
if (isactive_set(gno, i))
{
getsetminmax(gno, i, &x1, &x2, &y1, &y2);
if (g[gno].type == STACKEDBAR)
{
if (first)
{
xgmin = x1;
xgmax = x2;
ygmin = y1;
ygmax = y2;
first = 0;
}
else
{
xgmin = (x1 < xgmin) ? x1 : xgmin;
xgmax = (x2 > xgmax) ? x2 : xgmax;
ygmin = (y1 < ygmin) ? y1 : ygmin;
ygmax += y2;
}
}
else if (g[gno].type == STACKEDHBAR)
{
if (first)
{
xgmin = x1;
xgmax = x2;
ygmin = y1;
ygmax = y2;
first = 0;
}
else
{
ygmin = (y1 < ygmin) ? y1 : ygmin;
ygmax = (y2 > ygmax) ? y2 : ygmax;
xgmin = (x1 < xgmin) ? x1 : xgmin;
xgmax += x2;
}
}
else
{
if (first)
{
xgmin = x1;
xgmax = x2;
ygmin = y1;
ygmax = y2;
first = 0;
}
else
{
xgmin = (x1 < xgmin) ? x1 : xgmin;
xgmax = (x2 > xgmax) ? x2 : xgmax;
ygmin = (y1 < ygmin) ? y1 : ygmin;
ygmax = (y2 > ygmax) ? y2 : ygmax;
}
}
}
}
if (xgmin != xgmax)
{
g[gno].w.xg2 = xgmax;
g[gno].w.xg1 = xgmin;
}
else
{
g[gno].w.xg1 = xgmin - 1.0;
g[gno].w.xg2 = xgmin + 1.0;
}
if (ygmin != ygmax)
{
g[gno].w.yg2 = ygmax;
g[gno].w.yg1 = ygmin;
}
else
{
g[gno].w.yg1 = ygmin - 1.0;
g[gno].w.yg2 = ygmin + 1.0;
}
switch (g[gno].type)
{
case BAR:
g[gno].w.xg1 -= (g[gno].w.xg2 - g[gno].w.xg1) * 0.05;
g[gno].w.xg2 += (g[gno].w.xg2 - g[gno].w.xg1) * 0.05;
if (g[gno].w.yg1 > 0.0)
{
g[gno].w.yg1 = 0.0;
}
break;
case HBAR:
g[gno].w.yg1 -= (g[gno].w.yg2 - g[gno].w.yg1) * 0.05;
g[gno].w.yg2 += (g[gno].w.yg2 - g[gno].w.yg1) * 0.05;
if (g[gno].w.xg1 > 0.0)
{
g[gno].w.xg1 = 0.0;
}
break;
case STACKEDBAR:
g[gno].w.xg1 -= (g[gno].w.xg2 - g[gno].w.xg1) * 0.05;
g[gno].w.xg2 += (g[gno].w.xg2 - g[gno].w.xg1) * 0.05;
if (g[gno].w.yg1 > 0.0)
{
g[gno].w.yg1 = 0.0;
}
break;
case STACKEDHBAR:
g[gno].w.yg1 -= (g[gno].w.yg2 - g[gno].w.yg1) * 0.05;
g[gno].w.yg2 += (g[gno].w.yg2 - g[gno].w.yg1) * 0.05;
if (g[gno].w.xg1 > 0.0)
{
g[gno].w.xg1 = 0.0;
}
break;
case LOGX:
if (g[gno].w.xg1 <= 0.0)
{
errwin("can't set graph type to log-linear, X minimum = 0.0");
g[gno].type = XY;
}
break;
case LOGY:
if (g[gno].w.yg1 <= 0.0)
{
errwin("can't set graph type to linear-log, Y minimum = 0.0");
g[gno].type = XY;
}
break;
case LOGXY:
if (g[gno].w.xg1 <= 0.0)
{
errwin("can't set graph to log-log, X minimum <= 0.0");
g[gno].type = XY;
}
else if (g[gno].w.yg1 <= 0.0)
{
errwin("can't set graph type to log-log, Y minimum <= 0.0");
g[gno].type = XY;
}
break;
}
}
void defaulty(int gno, int setno)
{
int i, first = 1;
double ygmax, ygmin, ymin, ymax, tmp;
ygmin = ygmax = 0.0;
if (setno < 0)
{
for (i = 0; i < g[gno].maxplot; i++)
{
if (isactive_set(gno, i))
{
if (g[gno].type == STACKEDBAR)
{
}
else
{
getsetminmax(gno, i, &tmp, &tmp, &ymin, &ymax);
if (first)
{
ygmin = ymin;
ygmax = ymax;
first = 0;
}
else
{
ygmin = (ymin < ygmin) ? ymin : ygmin;
ygmax = (ymax > ygmax) ? ymax : ygmax;
}
}
}
}
}
else
{
if (isactive_set(gno, setno))
{
getsetminmax(gno, setno, &tmp, &tmp, &ygmin, &ygmax);
}
else
{
return;
}
}
if (ygmin != ygmax)
{
g[gno].w.yg2 = ygmax;
g[gno].w.yg1 = ygmin;
}
else
{
if ((ygmin == 0.0) && (ygmax == 0.0))
{
ygmin = 1.0;
}
g[gno].w.yg1 = ygmin - 0.1 * fabs(ygmin);
g[gno].w.yg2 = ygmin + 0.1 * fabs(ygmin);
}
switch (g[gno].type)
{
case BAR:
case STACKEDBAR:
if (g[gno].w.yg1 > 0.0)
{
g[gno].w.yg1 = 0.0;
}
break;
case HBAR:
case STACKEDHBAR:
g[gno].w.yg1 -= 0.5;
g[gno].w.yg2 += 0.5;
if (g[gno].w.xg1 > 0.0)
{
g[gno].w.xg1 = 0.0;
}
break;
case LOGX:
if (g[gno].w.xg1 <= 0.0)
{
errwin("can't set graph type to log-linear, X minimum = 0.0");
g[gno].type = XY;
}
break;
case LOGY:
if (g[gno].w.yg1 <= 0.0)
{
errwin("can't set graph type to linear-log, Y minimum = 0.0");
g[gno].type = XY;
}
break;
case LOGXY:
if (g[gno].w.xg1 <= 0.0)
{
errwin("can't set graph to log-log, X minimum <= 0.0");
g[gno].type = XY;
}
else if (g[gno].w.yg1 <= 0.0)
{
errwin("can't set graph type to log-log, Y minimum <= 0.0");
g[gno].type = XY;
}
break;
}
if (g[gno].type == BAR || g[gno].type == STACKEDBAR)
{
if (g[gno].w.yg1 > 0.0)
{
g[gno].w.yg1 = 0.0;
}
}
}
