newgraf.c File Reference

#include "spice.h"
#include "ftedefs.h"
#include "newgraf.h"
#include "plotdev.h"
#include "plotext.h"

Include dependency graph for newgraf.c:

Go to the source code of this file.

Macros
#define	LOGTST   50
#define	NUMOUTPTS   1001

Functions
static bool	is_monotonic ()
static void	free_graf ()
static GRDATA	copygraf ()
static void	init_viewport ()
static void	graf_display ()
static int	alpha_only ()
static void	what_now ()
static int	interval ()
static void	interpolateX ()
static void	interpolateY ()
static void	proc_option ()
static void	displ ()
static int	newscale ()
static void	displxy ()
static void	minmax ()
static void	draw ()
static void	axes ()
static void	set_scale ()
static void	set_scale_4 ()
static void	writef ()
static void	writeg ()
static char *	ecvt12 ()
static void	help ()
static void	fpick ()
static void	graf_setmark ()
static void	ghost_mark ()
static int	ymap ()
static void	xy_pick ()
static int	set_cursor ()
static void	addplot ()
static void	extpts ()
static void	combin ()
static void	plpts ()
static void	mp_display ()
static void	mp_free ()
static void	chkpts_free ()
static GRDATA	mp_copy ()
static void	init ()
static void	addit ()
static void	ebox ()
static void	xbox ()
static void	pbox ()
void	com_graf (wordlist *wl)
static bool	is_monotonic (struct dvec *v)
static void	free_graf (GRDATA grafp)
static GRDATA	copygraf (GRDATA grafp)
static void	init_viewport (struct screen *scr)
static void	graf_display (GRAPH *graph)
static int	alpha_only (char *s)
int	iplot_begin (struct dvlist *dl0, struct plot *pl)
bool	iplot_point ()
void	iplot_end ()
static void	what_now (char *q)
static void	interpolateX (struct gplot *graf, struct dvec *d)
static void	interpolateY (struct gplot *graf, int ind, struct dvec *d)
static void	proc_option (struct gplot *graf, char *q)
static void	displ (struct gplot *graf)
static int	newscale (struct gplot *graf)
static void	displxy (struct gplot *graf)
static void	minmax (struct gplot *graf, int *c)
static void	draw (struct gplot *graf, int trace, double fl, double fh)
static void	axes (struct gplot *graf, int nx, int ny)
static void	set_scale (double l, double u, double *lnew, double *unew, int *n)
static void	set_scale_4 (double l, double u, double *lnew, double *unew)
static void	writef (double d, int x, int y)
static void	writeg (double d, int x, int y, char j)
static char *	ecvt12 (double d)
static void	help (struct gplot *graf)
static void	fpick (GRAPH *graph)
static void	graf_setmark (struct gplot *graf, int x)
static void	ghost_mark (int x, int y, int refx, int refy)
static int	ymap (struct gplot *graf, double *y, int m, int nmin, int nmax, int j)
static void	addplot (struct gplot *graf)
void	com_mplot (wordlist *wl)
static void	extpts (FILE *fp, struct chkpts **p0)
static void	combin (struct chkpts *p0)
static void	plpts (struct mdata *md)
static void	mp_display (GRAPH *graph)
static void	mp_free (GRDATA mdp)
static void	chkpts_free (struct chkpts *p)
static GRDATA	mp_copy (GRDATA mdp)
int	mp_init (int delta1, int delta2, double v1min, double v1max, double v2min, double v2max)
int	mp_where (int id, int d1, int d2)
int	mp_mark (int id, char pf)
int	mp_done (int id)
static void	init (struct mdata *md)
static void	addit (struct chkpts *p, int v1, int v2, char pf)
static void	ebox (int xl, int yl, int xu, int yu)
static void	xbox (int xl, int yl, int xu, int yu)
static void	pbox (int xl, int yl, int xu, int yu)
void	com_echo (wordlist *wlist)
void	WARNmsg (char *msg)

Variables
GRAPH *	EchoGraph
static bool	Running
static char	INBUF [128]
static char *	errmsg_scale = "Error: scale not monotonically increasing\n"
static char *	errmsg_gralloc = "Error: can't allocate new graph\n"
static char *	errmsg_newvp = "Error: can't open viewport for graphics\n"
static bool	DOIPLOT

Macro Definition Documentation

#define LOGTST   50

Definition at line 56 of file newgraf.c.

#define NUMOUTPTS   1001

Definition at line 59 of file newgraf.c.

Function Documentation

static void addit ( )

static

static void addit ( struct chkpts *  p, int  v1, int  v2, char  pf  )

static

Definition at line 2927 of file newgraf.c.

{
    if (p->size == 0) {
        p->rsize = 100;
        p->v1 = tmalloc(p->rsize);
        p->v2 = tmalloc(p->rsize);
        p->pf = tmalloc(p->rsize);
    }
    if (p->size > p->rsize) {
        p->rsize += 100;
        p->v1 = trealloc(p->v1,p->rsize);
        p->v2 = trealloc(p->v2,p->rsize);
        p->pf = trealloc(p->pf,p->rsize);
    }
    p->v1[p->size] = (char) v1;
    p->v2[p->size] = (char) v2;
    p->pf[p->size] = pf;
    p->size++;
}

static void addplot ( )

static

static void addplot ( struct gplot *  graf )

static

Definition at line 2259 of file newgraf.c.

{
    float *dp;
    int i, j, m, n, rem;
    FILE *fptr;

    fptr = fopen("plotdt","a");
    if (!fptr) return;
    n = graf->numtr;
    m = graf->numpt;
    fprintf(fptr,"%s\n%d %s %s\n",graf->plot->pl_title,n,"27.0",
        graf->plot->pl_date);
    for (i = 0; i < n; i++)
        fprintf(fptr,"%d\n%s\n",1,graf->tdata[i].name);
    fprintf(fptr,"%s\n%d\n",graf->plot->pl_scale->v_name,m);
    rem = m % 10;
    m /= 10;
    for (i = 0; i < n; i++) {
        fprintf(fptr,"%s%s\n",ecvt12(*graf->tdata[i].scale),
            ecvt12(*(graf->tdata[i].scale + 1)));
        fflush(fptr);
        dp = graf->tdata[i].data;
        for (j = 0; j < m; j++, dp += 10)

fprintf(fptr,"%s%s%s%s%s%s%s%s%s%s\n",
ecvt12(*dp),ecvt12(*(dp+1)),ecvt12(*(dp+2)),ecvt12(*(dp+3)),ecvt12(*(dp+4)),
ecvt12(*(dp+5)),ecvt12(*(dp+6)),ecvt12(*(dp+7)),ecvt12(*(dp+8)),
ecvt12(*(dp+9)));
             
        for (j = 0; j < rem; j++, dp++)
            fprintf(fptr,"%s",ecvt12(*dp));
        if (rem)
            fprintf(fptr,"\n");
    }
    dp = graf->xdata;
    for (j = 0; j < m; j++, dp += 10)

fprintf(fptr,"%s%s%s%s%s%s%s%s%s%s\n",
ecvt12(*dp),ecvt12(*(dp+1)),ecvt12(*(dp+2)),ecvt12(*(dp+3)),ecvt12(*(dp+4)),
ecvt12(*(dp+5)),ecvt12(*(dp+6)),ecvt12(*(dp+7)),ecvt12(*(dp+8)),
ecvt12(*(dp+9)));

    for (j = 0; j < rem; j++, dp++)
        fprintf(fptr,"%s",ecvt12(*dp));
    if (rem)
        fprintf(fptr,"\n");

    fclose(fptr);
}

static int alpha_only ( )

static

static int alpha_only ( char *  s )

static

Definition at line 522 of file newgraf.c.

{
    while (*s) {
        if (!isalpha(*s)) return 0;
        s++;
    }
    return 1;
}

static void axes ( )

static

static void axes ( struct gplot *  graf, int  nx, int  ny  )

static

Definition at line 1670 of file newgraf.c.

{
    int x, y;

    graf->scr.X   = (graf->scr.X/nx)*nx;
    graf->scr.Y   = (graf->scr.Y/ny)*ny;
    graf->scr.XC  = graf->scr.XL + graf->scr.X/2;
    graf->scr.YC  = graf->scr.YL + graf->scr.Y/2;
    graf->scr.XU  = graf->scr.XL + graf->scr.X;
    graf->scr.YU  = graf->scr.YL + graf->scr.Y;
    if (!graf->iniplot)
        DevClear();
    DevSetLinestyle(0);
    DevSetColor(8);
    ebox(graf->scr.XL,graf->scr.YL,graf->scr.XU,graf->scr.YU);
    DevDefineLinestyle(1,0xcc);
    DevSetLinestyle(1);
    for (x = graf->scr.X/nx; x <= graf->scr.X - graf->scr.X/nx;
            x += graf->scr.X/nx)
        DevLine(x + graf->scr.XL,graf->scr.YL,x + graf->scr.XL,graf->scr.YU);
    for (y = graf->scr.Y/ny; y <= graf->scr.Y - graf->scr.Y/ny;
            y += graf->scr.Y/ny)
        DevLine(graf->scr.XL,y + graf->scr.YL,graf->scr.XU,y + graf->scr.YL);
    DevSetLinestyle(0);
}

static void chkpts_free ( )

static

static void chkpts_free ( struct chkpts *  p )

static

Definition at line 2645 of file newgraf.c.

{
    txfree(p->v1);
    txfree(p->v2);
    txfree(p->pf);
    txfree((char*)p);
}

void com_echo

(

wordlist *

wlist

)

Definition at line 2995 of file newgraf.c.

{
    char *s, *ss, buf[BSIZE_SP];
    bool nl = true;
    int i = 0;

    if (wlist && eq(wlist->wl_word, "-n")) {
        wlist = wlist->wl_next;
        nl = false;
    }

    while (wlist) {
        ss = s = copy(wlist->wl_word);
        cp_unquote(s);
        while (*s && (i < BSIZE_SP-1))
            buf[i++] = *s++;
        tfree(ss);
        if (wlist->wl_next && (i < BSIZE_SP-3))
            buf[i++] = ' ';
        wlist = wlist->wl_next;
    }
    buf[i] = '\0';

    if (dispdev) {
        /* a little tricky */
        if (!dispdev->windows) {
            if (EchoGraph) {
                /* doing iplot, covers full screen
                 * send text to it
                 */
                goto tograf;
            }
            else if (SCEDactive()) {
                ShowPrompt(buf);
                return;
            }
        }
        else {
            if (SCEDactive()) {
                ShowPrompt(buf);
                return;
            }
            if (DOIPLOT && EchoGraph != NULL) {
                /* send text to interactive mplot only */
                goto tograf;
            }
        }
    }
    fputs(buf, cp_out);
    if (nl)
        fputs("\n", cp_out);
    return;

tograf:
    buf[64] = '\0';
    PushGraphContext(EchoGraph);
    DevSetColor(0);
    DevBox(0,0,EchoGraph->fontwidth*64,EchoGraph->fontheight);
    DevSetColor(5);
    DevText(buf,0,0);
    DevUpdate();
    PopGraphContext();
    return;
}

void com_graf

(

wordlist *

wl

)

Definition at line 159 of file newgraf.c.

{
    struct pnode *names;
    struct dvec *d, *lv, *scale;
    struct dvlist *dl0, *dl;
    char *s, q[8];
    int i, numtr;
    static wordlist *oldwl;
    static char oldq[8];
    struct gplot *graf;
    GRAPH *graph;

    *q = '\0';
    if (wl) {
        s = wl->wl_word;
        if (*s == '-' && alpha_only(s+1)) {
            strncpy(q,s+1,7);
            q[7] = '\0';
            strcpy(oldq,q);
            wl = wl->wl_next;
        }
    }
    if (!wl && !oldwl) {
        fprintf(cp_err, "Error: no vectors given\n");
        return;
    }
    if (wl) {
        if (oldwl) wl_free(oldwl);
        oldwl = wl_copy(wl);
    }
    else {
        wl = oldwl;
        strcpy(q,oldq);
    }
    wl->wl_prev = NULL;
    if ((names = ft_getpnames(wl, false)) == NULL)
        return;
    if ((dl0 = ft_dvlist(names)) == NULL)
        return;

    /* Now check for vectors we can't handle. */
    for (dl = dl0; dl; dl = dl->dl_next) {
        if (dl->dl_dvec->v_length < 2) {
            fprintf(cp_err, "Error: %s: too few points to plot\n",
                dl->dl_dvec->v_name);
            vec_dlfree(dl0);
            return;
        }
    }

    scale = dl0->dl_dvec->v_plot->pl_scale;
    if (!scale)
        scale = dl0->dl_dvec->v_scale;
    if (!scale)
        scale = dl0->dl_dvec;

    if (!is_monotonic(scale)) {
        fprintf(cp_err,errmsg_scale);
        vec_dlfree(dl0);
        return;
    }

    /* If we are plotting scalars, make sure there is enough
     * data to fit on the screen.
     * Fill in the scales for vectors who aren't already fixed up.
     */
    numtr = 0;
    for (dl = dl0; dl; dl = dl->dl_next) {
        d = dl->dl_dvec;
        numtr++;
        d->v_scale = scale;
        if (d->v_length != d->v_scale->v_length)
            plot_extend(d, d->v_scale->v_length);
    }    

    if (numtr > PNUM) {
        fprintf(cp_err,"Error: more than %d traces\n",PNUM);
        vec_dlfree(dl0);
        return;
    }

    graf = (struct gplot *) tmalloc(sizeof(struct gplot));
    graf->scale = (struct gscale *) tmalloc(sizeof(struct gscale));
    graf->plot = dl0->dl_dvec->v_plot;
    graf->plot->pl_active++;
    graf->numtr = numtr;
    graf->numpt = NUMOUTPTS;

    for (dl = dl0, i = 0; dl; dl = dl->dl_next) {
        d = dl->dl_dvec;
        strncpy(graf->tdata[i].name,d->v_name,FIELD+1);
        graf->tdata[i].name[FIELD+1] = '\0';

        if (ciprefix("i",graf->tdata[i].name) ||
                strchr(graf->tdata[i].name,'#'))
            graf->tdata[i].type = GRAF_I;
        else if (ciprefix("v",graf->tdata[i].name))
            graf->tdata[i].type = GRAF_V;
        else
            graf->tdata[i].type = GRAF_O;
        interpolateY(graf,i,d);
        i++;
    }
    interpolateX(graf,dl0->dl_dvec);

    vec_dlfree(dl0);

    Running = true;
    graf->iniplot = false;
    proc_option(graf,q);

    if (!(graph = NewGraph())) {
        fprintf(cp_err, errmsg_gralloc);
        free_graf((GRDATA)graf);
        return;
    }

    graph->graphtype = GR_GRAF;
    graph->plotdata = (GRDATA)graf;
    graph->destroy = free_graf;
    graph->copydata = copygraf;
    graph->redraw = graf_display;

    if (graf->opt & OPT_hcpy) {
        graf->opt &= ~OPT_hcpy;
        graf->opt &= ~OPT_help;
        graf->opt &= ~OPT_add;
        graf->opt &= ~OPT_mark;
        graf->opt &= ~OPT_Xx;
        graf->opt &= ~OPT_X;
        graf->opt &= ~OPT_x;
        ft_hardcopy(NULL,graph,false,NULL,false);
        return;
    }

    if (DevNewViewport(graph)) {
        fprintf(cp_err, errmsg_newvp);
        DestroyGraph(graph->graphid);
        return;
    }

    if (!dispdev->windows) {

        PushGraphContext(graph);
        while (Running) {
            graf_display(graph);
            if (dispdev->hardcopy)
                break;
            what_now(q);
            proc_option(graf,q);
        }
        DevHalt();
        PopGraphContext();
        DestroyGraph(graph->graphid);
    }
}

void com_mplot

(

wordlist *

wl

)

Definition at line 2323 of file newgraf.c.

{
    FILE *fp;
    wordlist *ww;
    struct chkpts *p, *p0 = NULL;
    struct mdata *md;
    char c = 0, d = 0;
    char buf[BSIZE_SP];
    GRAPH *graph;
    extern char *kw_mplot_cur;

    if (!wl) {
        if (cp_getvar(kw_mplot_cur,VT_STRING,buf))
            fp = fopen(buf,"r");
        else
            fp = fopen("check.dat","r");
        if (!fp) {
            fprintf(cp_err,"Error: No margin analysis data file found\n");
            return;
        }
        extpts(fp,&p0);
        fclose(fp);
    }
    for (ww = wl; ww; ww = ww->wl_next) {
        if (*ww->wl_word == '-' && *(ww->wl_word+1) == 'c') {
            c = 1;
            continue;
        }    
        if (*ww->wl_word == '-' && *(ww->wl_word+1) == 'o' &&
            *(ww->wl_word+2) == 'n') {
            DOIPLOT = true;
            fprintf(cp_out,"Will display plot during margin analysis.\n");
            continue;
        }    
        if (*ww->wl_word == '-' && *(ww->wl_word+1) == 'o' &&
            *(ww->wl_word+2) == 'f') {
            DOIPLOT = false;
            fprintf(cp_out,"Will not display plot during margin analysis.\n");
            continue;
        }    
        fp = fopen(ww->wl_word,"r");
        if (!fp) {
            fprintf(cp_err,
                "Error: Margin analysis data file \"%s\" not found\n",
                ww->wl_word);
            continue;
        }
        d = 1;
        extpts(fp,&p0);
        fclose(fp);
    }
    if (!p0) {
        if (d)
            fprintf(cp_err,"Error: Nothing in file to plot.\n");
        return;
    }
    if (c) combin(p0);

    for (p = p0; p; p = p0) {
        p0 = p->next;

        if (!(graph = NewGraph())) {
            fprintf(cp_err, errmsg_gralloc);
            for (; p; p = p0) {
                p0 = p->next;
                chkpts_free(p);
            }
            return;
        }
        md = alloc(struct mdata);
        md->pts = p;

        graph->graphtype = GR_MPLT;
        graph->plotdata = (GRDATA)md;
        graph->copydata = mp_copy;
        graph->redraw = mp_display;
        graph->destroy = mp_free;

        if (DevNewViewport(graph)) {
            fprintf(cp_err, errmsg_newvp);
            DestroyGraph(graph->graphid);
            continue;
        }

        if (!dispdev->windows) {
            mp_display(graph);
            PushGraphContext(graph);
            if (!dispdev->hardcopy) {
                DevSetColor(0);
                DevBox(0,0,md->scr.XS,md->scr.H);
                DevSetColor(8);
                DevText("Hit any key to continue, 'p' for hardcopy",
                    p->xc + p->d/2 - 20*md->scr.W - md->scr.W2,0);
                DevUpdate();
                if (DevGetchar(NULL) == 'p') {
                    DevSetColor(0);
                    DevBox(0,0,md->scr.XS,md->scr.H);
                    ft_hardcopy(NULL,graph,true,NULL,false);
                }
            }
            DevHalt();
            PopGraphContext();
            DestroyGraph(graph->graphid);
        }
    }
}

static void combin ( )

static

static void combin ( struct chkpts *  p0 )

static

Definition at line 2504 of file newgraf.c.

{
    struct chkpts *p, *q;
    double maxv1, minv1, maxv2, minv2, d1, d2, temp;
    int i, o1, o2, o3, o4;
    char *p1, *p2, *p3;
    
    d1 = (p0->maxv1 - p0->minv1)/(p0->delta1 - 1);
    d2 = (p0->maxv2 - p0->minv2)/(p0->delta2 - 1);
    for (p = p0->next; p; p = q) {
        maxv1 = (p->maxv1 - p->minv1)/(p->delta1 - 1);
        maxv2 = (p->maxv2 - p->minv2)/(p->delta2 - 1);
        if (fabs((d1-maxv1)/(d1+maxv1)) + fabs((d2-maxv2)/(d2+maxv2)) > 1e-6) {
            fprintf(cp_err,"Error: can't combine, incompatible data.\n");
            getchar();
            q = p->next;
            chkpts_free(p);
            continue;
        }
        maxv1 = (p0->maxv1 > p->maxv1 ? p0->maxv1 : p->maxv1);
        minv1 = (p0->minv1 < p->minv1 ? p0->minv1 : p->minv1);
        maxv2 = (p0->maxv2 > p->maxv2 ? p0->maxv2 : p->maxv2);
        minv2 = (p0->minv2 < p->minv2 ? p0->minv2 : p->minv2);
        temp =  -(maxv1 + minv1)/d1 + 2*p->minv1/d1 + p->delta1 - 1;
        if (temp > 0) temp += .5;
        else temp -= .5;
        o1 = temp;
        if (o1 & 1) o1--;
        o1 >>= 1;
        temp =  -(maxv2 + minv2)/d2 + 2*p->minv2/d2 + p->delta2 - 1;
        if (temp > 0) temp += .5;
        else temp -= .5;
        o2 = temp;
        if (o2 & 1) o2--;
        o2 >>= 1;
        temp =  -(maxv1 + minv1)/d1 + 2*p0->minv1/d1 + p0->delta1 - 1;
        if (temp > 0) temp += .5;
        else temp -= .5;
        o3 = temp;
        if (o3 & 1) o3--;
        o3 >>= 1;
        temp =  -(maxv2 + minv2)/d2 + 2*p0->minv2/d2 + p0->delta2 - 1;
        if (temp > 0) temp += .5;
        else temp -= .5;
        o4 = temp;
        if (o4 & 1) o4--;
        o4 >>= 1;
        p0->delta1 = (maxv1 - minv1)/d1 + 1.5;
        p0->delta2 = (maxv2 - minv2)/d2 + 1.5;
        for (i = 0; i < p0->size; i++) {
            p0->v1[i] += o3;
            p0->v2[i] += o4;
        }
        p0->v1 = (char *) trealloc(p0->v1,p0->size + p->size);
        p0->v2 = (char *) trealloc(p0->v2,p0->size + p->size);
        p0->pf = (char *) trealloc(p0->pf,p0->size + p->size);
        p1 = p0->v1 + p0->size;
        p2 = p0->v2 + p0->size;
        p3 = p0->pf + p0->size;
        p0->size += p->size;
        for (i = 0; i < p->size; i++) {
            *p1++ = p->v1[i] + o1;
            *p2++ = p->v2[i] + o2;
            *p3++ = p->pf[i];
        }
        p0->minv1 = minv1;
        p0->maxv1 = maxv1;
        p0->minv2 = minv2;
        p0->maxv2 = maxv2;
        q = p->next;
        chkpts_free(p);
    }
    p0->next = NULL;
}

static GRDATA copygraf ( )

static

static GRDATA copygraf ( GRDATA  grafp )

static

Definition at line 384 of file newgraf.c.

{
    struct gplot *graf = (struct gplot *)grafp;
    struct gplot *newgraf;
    int i, size, size1;

    newgraf = (struct gplot *) tmalloc(sizeof(struct gplot));
    newgraf->numtr = graf->numtr;
    newgraf->numpt = graf->numpt;
    newgraf->opt = graf->opt;
    newgraf->scale = (struct gscale *) tmalloc(sizeof(struct gscale));
    *newgraf->scale = *graf->scale;
    newgraf->plot = graf->plot;
    newgraf->plot->pl_active++;
    size = graf->numpt*sizeof(float);
    newgraf->xdata = (float *) tmalloc(size);
    memcpy(newgraf->xdata,graf->xdata,size);

    for (i = 0; i < graf->numtr; i++) {
        newgraf->tdata[i] = graf->tdata[i];
        size1 = size * graf->tdata[i].cycles;
        newgraf->tdata[i].data = (float *) tmalloc(size1);
        memcpy(newgraf->tdata[i].data,graf->tdata[i].data,size1);
    }

    return ((GRDATA)newgraf);
}

static void displ ( )

static

static void displ ( struct gplot *  graf )

static

Definition at line 1168 of file newgraf.c.

{
    double fl, fh, *al, *ah, full_scale[2];
    int ny = 4;
    int i, n, m;
    int cflgs[3];    /* existence flags, v,i,other */
    int spa, dely;

    m = graf->numpt;
    n = graf->numtr;
    al = graf->scale->ymin;
    ah = graf->scale->ymax;

    graf->scale->numpts =
        (int) (m*(graf->scale->xcurr.end - graf->scale->xcurr.beg)/
        (graf->scale->xfull.end - graf->scale->xfull.beg) + .5);
    graf->scale->strtpt =
        (int) (m*(graf->scale->xcurr.beg - graf->scale->xfull.beg)/
        (graf->scale->xfull.end - graf->scale->xfull.beg) + .5);

    if (graf->opt & OPT_x) {
        minmax(graf,cflgs);
        for (i = 0; i < n; i++)
            set_scale_4(al[i],ah[i],al+i,ah+i);
    }
    else {
        cflgs[0] = cflgs[1] = cflgs[2] = 0;
        al[n] = al[n+1] = al[n+2] = al[n+3] = 1;
        ah[n] = ah[n+1] = ah[n+2] = ah[n+3] = -1;
        for (i = 0; i < n; i++) {
            al[i] = fl = *graf->tdata[i].scale;
            ah[i] = fh = *(graf->tdata[i].scale + 1);
            if (al[n] > ah[n]) {
                al[n] = fl;
                ah[n] = fh;
            }
            else {
                if (fl < al[n]) al[n] = fl;
                if (fh > ah[n]) ah[n] = fh;
            }
            switch (graf->tdata[i].type) {
                case GRAF_V:
                    if (al[n+1] > ah[n+1]) {
                        al[n+1] = fl;
                        ah[n+1] = fh;
                    }
                    else {
                        if (fl < al[n+1]) al[n+1] = fl;
                        if (fh > ah[n+1]) ah[n+1] = fh;
                    }
                    cflgs[0] = 1;
                    break;
                case GRAF_I:
                    if (al[n+2] > ah[n+2]) {
                        al[n+2] = fl;
                        ah[n+2] = fh;
                    }
                    else {
                        if (fl < al[n+2]) al[n+2] = fl;
                        if (fh > ah[n+2]) ah[n+2] = fh;
                    }
                    cflgs[1] = 1;
                    break;
                default:
                    if (al[n+3] > ah[n+3]) {
                        al[n+3] = fl;
                        ah[n+3] = fh;
                    }
                    else {
                        if (fl < al[n+3]) al[n+3] = fl;
                        if (fh > ah[n+3]) ah[n+3] = fh;
                    }
                    cflgs[2] = 1;
            }
        }
    }

    if (graf->opt & OPT_b) {
        displxy(graf);
        return;
    }

    if (cflgs[0]) { set_scale_4(al[n+1],ah[n+1],al+n+1,ah+n+1); }
    if (cflgs[1]) { set_scale_4(al[n+2],ah[n+2],al+n+2,ah+n+2); }
    if (cflgs[2]) { set_scale_4(al[n+3],ah[n+3],al+n+3,ah+n+3); }
    if (graf->opt & OPT_N) set_scale(al[n],ah[n],al+n,ah+n,&ny);

    axes(graf,graf->scale->ncells, ((graf->opt & OPT_t) && n > 1) ? n : ny);
    dely = 3*graf->scr.H + graf->scr.H2;
    if (graf->opt & OPT_t) {
        if (n)
            spa = graf->scr.Y/n;
        else
            spa = graf->scr.Y;
        if (spa < dely)
            spa = dely;
    }
    else
        spa = dely;
    dely -= graf->scr.H2/2;
    for (i = 0; i < n; i++) {
        int ix;
        double amx, amn;
        int scrx = graf->scr.XL - 13*graf->scr.W - graf->scr.W2;

        DevSetColor(1);
        DevText(graf->tdata[i].name,scrx,
            graf->scr.YU - i*spa - graf->scr.H - 2);
        if (graf->opt & OPT_N)
            ix = n;
        else if (graf->opt & OPT_n) {
            if (graf->tdata[i].type == GRAF_V)
                ix = n+1;
            else if (graf->tdata[i].type == GRAF_I)
                ix = n+2;
            else
                ix = n+3;
        }
        else
            ix = i;
        if (!(graf->opt & OPT_mark)) {
            if (!(graf->opt & OPT_N) || i == 0) {
                writef(ah[ix], scrx,
                    graf->scr.YU - i*spa - 2*graf->scr.H - 2);
                writef(al[ix], scrx,
                    graf->scr.YU - i*spa - 3*graf->scr.H - 2);
            }
        }
        amx = ((graf->opt & OPT_t) && n > 1) ?
            ((ah[ix]+al[ix])+(ah[ix]-al[ix])*(2*i+1))/2 : ah[ix];
        amn = ((graf->opt & OPT_t) && n > 1) ?
            ((ah[ix]+al[ix])-(ah[ix]-al[ix])*(2*(n-i)-1))/2 : al[ix];
        DevSetColor(i+2);
        if (dispdev->numcolors == 2 && !(graf->opt & OPT_p) &&
                !(graf->opt & OPT_t))
            DevSetLinestyle(i);
        ebox(scrx - graf->scr.W2, graf->scr.YU - i*spa - dely,
            scrx - graf->scr.W2 + 13*graf->scr.W, graf->scr.YU - i*spa);
        draw(graf,i,amn,amx);
        if (dispdev->numcolors == 2 && !(graf->opt & OPT_p) &&
                !(graf->opt & OPT_t))
            DevSetLinestyle(0);
    }
    DevSetColor(1);
    if (!graf->iniplot)
        DevText(graf->plot->pl_title,
            graf->scr.XL,graf->scr.YU + graf->scr.H3);
    strcpy(INBUF,graf->plot->pl_scale->v_name);
    if (graf->scale->lflg) strcat(INBUF," (log)");
    DevText(INBUF,graf->scr.XC - ((int)strlen(INBUF)*graf->scr.W)/2,
        graf->scr.YL - graf->scr.H3);
    writeg(graf->scale->xcurr.min,
        graf->scr.XL,graf->scr.YL - graf->scr.H - 1,'l');
    writeg(graf->scale->xcurr.max,
        graf->scr.XU,graf->scr.YL - graf->scr.H - 1,'r');
    DevSetColor(8);
    if (!graf->iniplot) {
        DevText(graf->plot->pl_name,graf->scr.XL,graf->scr.YU + graf->scr.H2);
        if (graf->scr.X > ((int)strlen(graf->plot->pl_name) +
                (int)strlen(graf->plot->pl_date))*graf->scr.W)
            DevText(graf->plot->pl_date,
                graf->scr.XU - (int)strlen(graf->plot->pl_date)*graf->scr.W,
                graf->scr.YU + graf->scr.H2);
    }
}

static void displxy ( )

static

static void displxy ( struct gplot *  graf )

static

Definition at line 1417 of file newgraf.c.

{
    double xi, xx, yi, yx;
    int i, j, k, num, spa, scrx, cy;
    int ix, iy, ixo, iyo, len, extra;
    float *px, *py;

    if (graf->numtr < 2) return;
    axes(graf,2,2);
    scrx = graf->scr.XL - 13*graf->scr.W - graf->scr.W2;
    num = (graf->numtr >> 1) << 1;
    spa = (num*graf->scr.H) >> 1;
    DevSetColor(8);
    DevText("X",scrx,graf->scr.YC + spa);
    DevText("Y",scrx,graf->scr.YC + spa - graf->scr.H);
    for (i = 0; i < num; i += 2) {
        DevSetColor(i/2 + 2);
        xi = graf->scale->ymin[i];
        xx = graf->scale->ymax[i];
        yi = graf->scale->ymin[i+1];
        yx = graf->scale->ymax[i+1];
        DevText(graf->tdata[i].name,
            scrx,graf->scr.YC + spa - (i+2)*graf->scr.H);
        DevText(graf->tdata[i+1].name,
            scrx,graf->scr.YC + spa - (i+3)*graf->scr.H);
        if (!(graf->opt & OPT_mark)) {
            writef(yx,scrx,graf->scr.YU - graf->scr.H*(i/2+1));
            writef(yi,scrx,graf->scr.YL + spa - graf->scr.H*(i/2 + 1));
            if (num <= 4) {
                writef(xi,graf->scr.XL,graf->scr.YL - graf->scr.H*(i/2+1));
                writef(xx,graf->scr.XU - FIELD*graf->scr.W,
                    graf->scr.YL - graf->scr.H*(i/2+1));
            }
            else if (i >= 4) {
                writef(xi,graf->scr.XL + (FIELD+1)*graf->scr.W,
                    graf->scr.YL - graf->scr.H*(i/2-1));
                writef(xx,graf->scr.XU - FIELD*graf->scr.W,
                    graf->scr.YL - graf->scr.H*(i/2-1));
            }
            else {
                writef(xi,graf->scr.XL,graf->scr.YL - graf->scr.H*(i/2+1));
                writef(xx,graf->scr.XU - (2*FIELD+1)*graf->scr.W,
                    graf->scr.YL - graf->scr.H*(i/2+1));
            }
        }
        if (dispdev->numcolors == 2 && !(graf->opt & OPT_p))
            DevSetLinestyle(i);

        cy = graf->tdata[i].cycles;
        if (cy > graf->tdata[i+1].cycles)
            cy = graf->tdata[i+1].cycles;
        extra = graf->tdata[i].extra;
        if (extra > graf->tdata[i+1].extra)
            extra = graf->tdata[i+1].extra;

        px = graf->tdata[i].data + graf->scale->strtpt;
        py = graf->tdata[i+1].data + graf->scale->strtpt;
        len = graf->scale->numpts;
        while (cy--) {
            if (!cy && extra) {
                if (graf->scale->strtpt > extra)
                    break;
                if (len + graf->scale->strtpt > extra)
                    len = extra - graf->scale->strtpt;
            }
            for (j = 0; j < len; j++) {
                ix = graf->scr.XL +
                    (.5 + graf->scr.X*(*(px+j) - xi)/(xx - xi));
                iy = graf->scr.YL +
                    (.5 + graf->scr.Y*(*(py+j) - yi)/(yx - yi));
                if (graf->opt & OPT_p)
                    DevPixel(ix,iy);
                else if (j)
                    DevLine(ix,iy,ixo,iyo);
                ixo = ix;
                iyo = iy;
            }
            py += graf->numpt;
        }
        if (dispdev->numcolors == 2 && !(graf->opt & OPT_p))
            DevSetLinestyle(0);
    }
    DevSetColor(1);
    DevText(graf->plot->pl_title,graf->scr.XL,graf->scr.YU + graf->scr.H3);
    DevSetColor(8);
    DevText(graf->plot->pl_name,graf->scr.XL,graf->scr.YU + graf->scr.H2);
    if (graf->scr.X > ((int)strlen(graf->plot->pl_name) +
            (int)strlen(graf->plot->pl_date))*graf->scr.W)
        DevText(graf->plot->pl_date,
            graf->scr.XU - (int)strlen(graf->plot->pl_date)*graf->scr.W,
            graf->scr.YU + graf->scr.H2);
    DevUpdate();
    return;
}

static void draw ( )

static

static void draw ( struct gplot *  graf, int  trace, double  fl, double  fh  )

static

Definition at line 1610 of file newgraf.c.

{
    float *dp;
    int i, k, l, ok, ol, cy, numpts;
    double atof(), s, o;

    if (fl == fh)
        return;
    s = (graf->scale->xcurr.end - graf->scale->xcurr.beg) /
        (graf->scale->xcurr.max - graf->scale->xcurr.min);
    o = (graf->scale->xcurr.beg - graf->scale->xcurr.min) /
        (graf->scale->xcurr.max - graf->scale->xcurr.min);

    cy = graf->tdata[trace].cycles;
    dp = graf->tdata[trace].data + graf->scale->strtpt;
    numpts = graf->scale->numpts;

    while (cy--) {
        if (!cy && graf->tdata[trace].extra) {
            if (graf->scale->strtpt > graf->tdata[trace].extra)
                break;
            if (numpts + graf->scale->strtpt > graf->tdata[trace].extra)
                numpts = graf->tdata[trace].extra - graf->scale->strtpt;
        }
        k = graf->scr.XL + (int) (.5 + o*graf->scr.X);
        l = graf->scr.YL + (int) (.5 + graf->scr.Y*(*dp - fl)/(fh - fl));
        if (graf->opt & OPT_p)
            DevPixel(k,l);
        ok = k;
        ol = l;
        for (i = 1; i < numpts; i++) {
            k = graf->scr.XL +
                (int) (.5 + o*graf->scr.X +
                s*graf->scr.X*i/(graf->scale->numpts - 1));
            l = graf->scr.YL +
                (int) (.5 + graf->scr.Y*(*(dp + i) - fl)/(fh - fl));
            if (graf->opt & OPT_p)
                DevPixel(k,l);
            else
                DevLine(ok,ol,k,l);
            ok = k;
            ol = l;
        }
        dp += graf->numpt;
    }
    /* have to keep track of the last point plotted for iplot */
    graf->lastx = k;
    graf->tdata[trace].lasty = l;
    return;
}

static void ebox ( )

static

static void ebox ( int  xl, int  yl, int  xu, int  yu  )

static

Definition at line 2954 of file newgraf.c.

{
    DevLine(xl,yl,xu,yl);
    DevLine(xu,yl,xu,yu);
    DevLine(xu,yu,xl,yu);
    DevLine(xl,yu,xl,yl);
}

static char* ecvt12 ( )

static

static char* ecvt12 ( double  d )

static

Definition at line 1847 of file newgraf.c.

{
    static char s[10][20];
    static int num;
    int xp, sn;
    char *ss;

    num++;
    if (num > 9)
        num = 0;
    sprintf(s[num],"%+.5e",d);
    ss = strchr(s[num],'e');
    if (ss[1] == '-')
        sn = -1;
    else
        sn = 1;
    xp = atoi(ss+2);

    if (xp > 99) {
        if (sn > 0)
            xp = 99;
        else {
            strcpy(s[num]," 0.00000e+00");
            return (s[num]);
        }
    }

    /* make sure we print . and trailing 0's */
    if (ss - s[num] == 2)
        *ss++ = '.';
    while (ss - s[num] < 8)
        *ss++ = '0';
    *ss++ = 'e';
    if (sn < 0)
        *ss++ = '-';
    else
        *ss++ = '+';
    *ss++ = '0' + (xp/10);
    *ss++ = '0' + (xp%10);
    *ss++ = '\0';
    if (*s[num] == '+')
        *s[num] = ' ';
    return (s[num]);
}

static void extpts ( )

static

static void extpts ( FILE *  fp, struct chkpts **  p0  )

static

Definition at line 2435 of file newgraf.c.

{
    int i, j, x, y, d1, d2;
    double v1, v2, maxv1, minv1, maxv2, minv2;
    struct chkpts *p, *q;
    char buf[80];

    i = 0;
    while (fgets(buf,80,fp)) {
        if (strchr(buf,'p') || strchr(buf,'f')) i++;
    }
    rewind(fp);

    p = alloc(struct chkpts);
    p->v1 =  (char *) tmalloc(i);
    p->v2 =  (char *) tmalloc(i);
    p->pf =  (char *) tmalloc(i);
    p->size = i;
    p->next = NULL;

    i = 0;
    fgets(buf,80,fp);
    sscanf(buf,"%d %d %le %le",&d1,&d2,&v1,&v2);
    maxv1 = minv1 = v1;
    maxv2 = minv2 = v2;
    p->delta1 = -2*d1 + 1;
    p->delta2 = -2*d2 + 1;
    
    while (fgets(buf,80,fp)) {
        if (*buf != '\t') {
            sscanf(buf,"%d %d %le %le",&d1,&d2,&v1,&v2);

            if (v1 > maxv1) maxv1 = v1;
            if (v1 < minv1) minv1 = v1;
            if (v2 > maxv2) maxv2 = v2;
            if (v2 < minv2) minv2 = v2;
        }

        else if (strchr(buf,'p')) {
            (p->v1)[i] = d1;
            (p->v2)[i] = d2;
            (p->pf)[i] = 1;
            i++;
        }
        else if (strchr(buf,'f')) {
            (p->v1)[i] = d1;
            (p->v2)[i] = d2;
            (p->pf)[i] = 0;
            i++;
        }
    }
    p->minv1 = minv1;
    p->maxv1 = maxv1;
    p->minv2 = minv2;
    p->maxv2 = maxv2;
    if (!*p0)
         *p0 = p;
    else {
        for (q = *p0; q->next; q = q->next) ;
        q->next = p;
    }
}

static void fpick ( )

static

static void fpick ( GRAPH *  graph )

static

Definition at line 1966 of file newgraf.c.

{
    struct gplot *graf = (struct gplot *)graph->plotdata;
    int i, spa, dely, scrx;
    int num, fw, fy;
    REQUEST request;
    RESPONSE response;

    if (dispdev->hardcopy) return;

    scrx = graf->scr.XL - 13*graf->scr.W - graf->scr.W2;
    fw = FIELD*graf->scr.W;

    DevSetColor(0);

    if (graf->opt & OPT_b) {

        num = (graf->numtr >> 1);
        spa = num*graf->scr.H;

        DevBox(scrx,graf->scr.YU - graf->scr.H*num,
            scrx + fw,graf->scr.YU);
        DevBox(scrx,graf->scr.YL + spa - graf->scr.H*num,
            scrx + fw,graf->scr.YL + spa);

        for (i = 0; i < num; i++) {

            fy = graf->scr.H*i;

            if (num <= 2) {

                DevBox(graf->scr.XL,graf->scr.YL - fy - graf->scr.H,
                    graf->scr.XL + fw,graf->scr.YL - fy - 1);
                DevBox(graf->scr.XU - fw,graf->scr.YL - fy - graf->scr.H,
                    graf->scr.XU, graf->scr.YL - fy - 1);
            }
            else if (i >= 2) {
                DevBox(graf->scr.XL + fw + graf->scr.W,
                    graf->scr.YL - fy + graf->scr.H,
                    graf->scr.XL + 2*fw + graf->scr.W,
                    graf->scr.YL - fy + 2*graf->scr.H - 1);
                DevBox(graf->scr.XU - fw,graf->scr.YL - fy + graf->scr.H,
                    graf->scr.XU, graf->scr.YL - fy + 2*graf->scr.H - 1);
            }
            else {
                DevBox(graf->scr.XL,graf->scr.YL - fy - graf->scr.H,
                    graf->scr.XL + fw, graf->scr.YL - fy - 1);
                DevBox(graf->scr.XU - 2*fw - graf->scr.W,
                    graf->scr.YL - fy - graf->scr.H,
                    graf->scr.XU - fw - graf->scr.H, graf->scr.YL - fy - 1);
            }
        }
    }
    else {
        dely = 3*graf->scr.H + graf->scr.H2;
        if (graf->opt & OPT_t) {
            if (graf->numtr)
                spa = graf->scr.Y/graf->numtr;
            else
                spa = graf->scr.Y;
            if (spa < dely)
                spa = dely;
        }
        else
            spa = dely;
        for (i = 0; i < graf->numtr; i++) {
            DevBox(scrx,graf->scr.YU - i*spa - 3*graf->scr.H - 2,
                scrx + fw, graf->scr.YU - i*spa - graf->scr.H - 1);
        }
    }

    DevSetColor(1);
    DevSetGhost(ghost_mark,0,0);
    if (!dispdev->windows) {
        request.option = point_option;
        DevInput(&request,&response);
        DevSetGhost(NULL,0,0);
        graf->opt &= ~OPT_mark;
        displ(graf);
    }
}

static void free_graf ( )

static

static void free_graf ( GRDATA  grafp )

static

Definition at line 357 of file newgraf.c.

{
    struct gplot *graf = (struct gplot *)grafp;
    struct dvlist *dl;

    tfree(graf->scale);
    while (graf->numtr--)
        tfree(graf->tdata[graf->numtr].data);
    tfree(graf->xdata);

    /* This is non-null only if we killed an iplot
     * before it finished.
     */
    for (dl = graf->dlist; dl; dl = graf->dlist) {
        graf->dlist = dl->dl_next;
        txfree((char*)dl);
    }
    if (graf->plot)
        graf->plot->pl_active--;

    tfree(graf);
}

static void ghost_mark ( )

static

static void ghost_mark ( int  x, int  y, int  refx, int  refy  )

static

Definition at line 2101 of file newgraf.c.

{
    struct gplot *graf = (struct gplot *)currentgraph->plotdata;
    int i, num, scrx, spa, dely;
    int nmin, nmax;
    int fw, fy;
    double xx, x0, yy, y0;

    fw = FIELD*graf->scr.W;
    scrx = graf->scr.XL - fw - graf->scr.W - graf->scr.W2;

    if (graf->opt & OPT_b) {

        if (x < graf->scr.XL || x > graf->scr.XU)
            return;
        if (y < graf->scr.YL || y > graf->scr.YU)
            return;

        DevLine(x,graf->scr.YL,x,graf->scr.YU);
        DevLine(graf->scr.XL,y,graf->scr.XU,y);

        num = (graf->numtr >> 1) << 1;
        for (i = 0; i < num; i += 2) {

            fy = graf->scr.H*i/2;

            xx = graf->scale->ymin[i] +
                ((graf->scale->ymax[i]-graf->scale->ymin[i])*
                (x-graf->scr.XL))/graf->scr.X;
            yy = graf->scale->ymin[i+1] +
                ((graf->scale->ymax[i+1]-graf->scale->ymin[i+1])*
                (y-graf->scr.YL))/graf->scr.Y;

            writef(yy,scrx,graf->scr.YU - fy - graf->scr.H);

            if (num <= 4) {
                writef(xx,graf->scr.XU - fw,
                    graf->scr.YL - fy - graf->scr.H);
            }
            else if (i >= 4) {
                writef(xx,graf->scr.XU - fw,
                    graf->scr.YL - fy + graf->scr.H);
            }
            else {
                writef(xx,graf->scr.XU - 2*fw - graf->scr.W,
                    graf->scr.YL - fy - graf->scr.H);
            }
        }
        return;
    }

    nmin = graf->scr.XL + (int)
        ((graf->scale->xcurr.beg - graf->scale->xcurr.min)*graf->scr.X/
        (graf->scale->xcurr.max - graf->scale->xcurr.min)+.5);
    nmax = graf->scr.XL + (int)
        ((graf->scale->xcurr.end - graf->scale->xcurr.min)*graf->scr.X/
        (graf->scale->xcurr.max - graf->scale->xcurr.min)+.5);

    if (x < nmin || x > nmax)
        return;

    DevLine(x,graf->scr.YL,x,graf->scr.YU);

    dely = 3*graf->scr.H + graf->scr.H2;
    if (graf->opt & OPT_t) {
        if (graf->numtr)
            spa = graf->scr.Y/graf->numtr;
        else
            spa = graf->scr.Y;
        if (spa < dely)
            spa = dely;
    }
    else
        spa = dely;

    for (i = 0; i < graf->numtr; i++) {
        ymap(graf,&yy,x,nmin,nmax,i);
        if (graf->ref.set) {
            ymap(graf,&y0,graf->ref.x,nmin,nmax,i);
            yy -= y0;
        }
        writef(yy, scrx, graf->scr.YU - i*spa - 2*graf->scr.H - 2);
    }
    xx = graf->scale->xcurr.beg + (x - nmin)*
            (graf->scale->xcurr.end - graf->scale->xcurr.beg)/(nmax-nmin);
    if (graf->ref.set) {
        x0 = graf->scale->xcurr.beg + (graf->ref.x - nmin)*
            (graf->scale->xcurr.end - graf->scale->xcurr.beg)/(nmax-nmin);
        xx -= x0;
        sprintf(INBUF,"dX = %s",ecvt12(xx));
    }
    else
        sprintf(INBUF,"X = %s",ecvt12(xx));
    DevText(INBUF,graf->scr.XU - strlen(INBUF)*graf->scr.W,
        graf->scr.YL - 3*graf->scr.H);
}

static void graf_display ( )

static

static void graf_display ( GRAPH *  graph )

static

Definition at line 463 of file newgraf.c.

{
    struct gplot *graf = (struct gplot *)graph->plotdata;
    struct _keyed *k;

    if (graf == NULL || graph->graphtype != GR_GRAF)
        return;
    PushGraphContext(graph);
    init_viewport(&graf->scr);

    if (!(graf->opt & OPT_mark)) {
        DevSetGhost(NULL,0,0);
    }
    graf->ref.set = false;

    if (graf->opt & OPT_help) {
        help(graf);
        if (!dispdev->windows)
            graf->opt &= ~OPT_help;
        goto quit;
    }

    if (graf->opt & OPT_add) {
        addplot(graf);
        graf->opt &= ~OPT_add;
        goto quit;
    }

    if (graf->opt & OPT_hcpy) {
        graf->opt &= ~OPT_hcpy;
        ft_hardcopy(NULL,graph,true,NULL,false);
        goto quit;
    }

    if (graf->opt & OPT_Xx) {
        /* never used in X */
        if (newscale(graf))
            goto quit;
        graf->opt &= ~OPT_Xx;
    }
    displ(graf);
    for (k = graph->keyed; k; k = k->next) {
        DevSetColor(k->colorindex);
        DevText(k->text, k->x, k->y);
    }

    if (graf->opt & OPT_mark) {
        fpick(graph);
    }

quit:
    PopGraphContext();
    return;
}

static void graf_setmark ( )

static

static void graf_setmark ( struct gplot *  graf, int  x  )

static

Definition at line 2053 of file newgraf.c.

{
    int nmin, nmax;
    int i, spa, dely, scrx, fw;

    if (graf->opt & (OPT_help | OPT_b))
        return;
    nmin = graf->scr.XL + (int)
        ((graf->scale->xcurr.beg - graf->scale->xcurr.min)*graf->scr.X/
        (graf->scale->xcurr.max - graf->scale->xcurr.min)+.5);
    nmax = graf->scr.XL + (int)
        ((graf->scale->xcurr.end - graf->scale->xcurr.min)*graf->scr.X/
        (graf->scale->xcurr.max - graf->scale->xcurr.min)+.5);
    if (x < nmin || x > nmax)
        return;
    DevSetGhost(NULL,0,0);
    DevSetColor(0);
    scrx = graf->scr.XL - 13*graf->scr.W - graf->scr.W2;
    fw = FIELD*graf->scr.W;
    dely = 3*graf->scr.H + graf->scr.H2;
    if (graf->opt & OPT_t) {
        if (graf->numtr)
            spa = graf->scr.Y/graf->numtr;
        else
            spa = graf->scr.Y;
        if (spa < dely)
            spa = dely;
    }
    else
        spa = dely;
    for (i = 0; i < graf->numtr; i++) {
        DevBox(scrx,graf->scr.YU - i*spa - 3*graf->scr.H - 2,
                scrx + fw, graf->scr.YU - i*spa - graf->scr.H - 1);
    }
    DevBox(graf->scr.XL, graf->scr.YL - 3*graf->scr.H,
        graf->scr.XS-1, graf->scr.YL - 2*graf->scr.H);

    graf->ref.set = true;
    graf->ref.x = x;
    DevSetGhost(ghost_mark,0,0);
}

static void help ( )

static

static void help ( struct gplot *  graf )

static

Definition at line 1899 of file newgraf.c.

{
    int x, y, h;
    int maxline = 0;

    DevClear();
    x = graf->scr.XL - 10*graf->scr.W;
    y = graf->scr.YS - 2*graf->scr.H;
    h = graf->scr.H;
    DevSetColor(8);

    DevText("Display mode options are as follows :",x,y);

    DevText("a     Append current plot to file \"plotdt\".",
        x,y-=(3*h)/2);
    DevText("b     Plot data in X-Y mode, taking 2 traces at a time.",
        x,y-=h);
    DevText("c     Enable the marker.  The marker prints the trace",
        x,y-=h);
    DevText("      coordinates, and is retired when ENTER is struck.",
        x,y-=h);
    DevText("n     Use similar scales for three classes of traces: those",
        x,y-=h);
    DevText("      with names beginning with V,I, and otherwise.",
        x,y-=h);
    DevText("N     Plot all traces on the same vertical scale",
        x,y-=h);
    DevText("p     Plot data as points.",
        x,y-=h);
    DevText("P     Generate a hardcopy.",
        x,y-=h);
    DevText("q     Quit.",
        x,y-=h);
    DevText("t     Display each trace on a separate axis, no overlap.",
        x,y-=h);
    DevText("x     Change the horizontal scale, thus display a portion of the graph.",
        x,y-=h);
    DevText("X     Same as \"x\" but use the whole curve to generate the y scales.",
        x,y-=h);
    DevText("y     Use separate scales for each trace.",
        x,y-=h);
    DevText("Options p and t toggle, therefore enter a second time to return to the",
        x,y-=(3*h)/2);
    DevText("original display mode.  Options can also be input from the command line.",
        x,y-=h);
    DevText("When using the x option, ENTER as response to the scale min max prompt",
        x,y-=(3*h)/2);
    DevText("will reset to full scale values, and a space followed by ENTER will leave",
        x,y-=h);
    DevText("the previous values unchanged.",
        x,y-=h);
    DevText("Options may be entered after each plot is displayed.",
        x,y-=h);
    y -= (3*h)/2;
    maxline = 74;

    DevSetColor(2);
    ebox(x - graf->scr.W,y - graf->scr.H2,
        x + maxline*graf->scr.W,graf->scr.YS - graf->scr.H2);

    DevUpdate();
}

static void init ( )

static

static void init ( struct mdata *  md )

static

Definition at line 2832 of file newgraf.c.

{
    struct chkpts *p = md->pts;
    int d, dd1, dd2, xc, yc, x1, y1;
    int xx, yy, spa;
    char s[64];
    char *msg = "Operating Range Analysis";
    double dx;
    double dy;

    xx = md->scr.XS - 10*md->scr.W;
    yy = md->scr.YS - 9*md->scr.H;
    dx = (1.0 + (double)p->delta1)/xx;
    dy = (1.0 + (double)p->delta2)/yy;

    if (dx > dy)
        d = 1/dx;
    else
        d = 1/dy;

    dd1 = ((p->delta1-1)*d) >> 1;
    dd2 = ((p->delta2-1)*d) >> 1;
    p->d = d;
    p->xc = xc = 8*md->scr.W + xx/2;
    p->yc = yc = 6*md->scr.H + yy/2;
    if (!(p->delta1 & 1)) p->xc += d/2;
    if (!(p->delta2 & 1)) p->yc += d/2;
    spa = md->scr.H2/2;
    x1 = xc-dd1-spa;
    y1 = yc-dd2-spa;

    DevSetLinestyle(0);
    DevSetColor(4);
    ebox(x1,y1,xc+dd1+d+spa,yc+dd2+d+spa);

    yy = y1 - md->scr.H3;
    xx = x1;

    DevSetColor(1);
    DevText(msg,xx,yy);

    yy = y1 - 3*md->scr.H;

    DevSetColor(3);
    pbox(xx,yy,xx + md->scr.H,yy + md->scr.H);
    DevSetColor(8);
    DevText("pass",xx + md->scr.H3,yy);

    xx += md->scr.H3 + 7*md->scr.W;

    DevSetColor(2);
    xbox(xx,yy,xx + md->scr.H,yy + md->scr.H);
    DevSetColor(8);
    DevText("fail",xx + md->scr.H3,yy);

    yy = y1 - 3*md->scr.H - md->scr.H3;

    *s = '\0';
    if (dd1 && !dd2)
        sprintf(s,"Incr1 = %g",(p->maxv1-p->minv1)/(p->delta1-1));
    if (!dd1 && dd2)
        sprintf(s,"Incr2 = %g",(p->maxv2-p->minv2)/(p->delta2-1));
    if (dd1 && dd2)
        sprintf(s,"Incr1 = %g, Incr2 = %g",(p->maxv1-p->minv1)/
            (p->delta1-1),(p->maxv2-p->minv2)/(p->delta2-1));

    if (*s) {
        /* don't print if just 1 point */
        DevSetColor(1);
        DevText(s,x1,yy);
    }

    DevSetColor(8);
    writeg(p->maxv2,x1-md->scr.W,yc+dd2+d/2-md->scr.H2,'r');
    if (dd2)
        writeg(p->minv2,x1-md->scr.W,yc-dd2+d/2-md->scr.H2,'r');

    writeg(p->minv1,x1,yc+dd2+d+md->scr.H2,'l');
    if (dd1)
        if (dd1 < 2)
            writeg(p->maxv1,xc+dd1+d,yc+dd2+d+md->scr.H2,'l');
        else
            writeg(p->maxv1,xc+dd1+d,yc+dd2+d+md->scr.H2,'r');

    DevSetColor(1);
    DevText("Param 2",
        x1-8*md->scr.W-md->scr.W2,yc+d/2-(dd2 ? md->scr.H2 : md->scr.H3));
    DevText("Param 1",xc+d/2-3*md->scr.W-md->scr.W2,yc+dd2+d+md->scr.H3);
    DevUpdate();
}

static void init_viewport ( )

static

static void init_viewport ( struct screen *  scr )

static

Definition at line 417 of file newgraf.c.

{
    int fwidth, fheight, edge;
    int oldXL, oldYL, oldX, oldY;
    struct _keyed *k;

    oldXL = scr->XL;
    oldYL = scr->YL;
    oldX = scr->X;
    oldY = scr->Y;

    fheight = currentgraph->fontheight;
    fwidth  = currentgraph->fontwidth;
#ifdef HAVE_X11
    edge = 2*fwidth;
#else
    edge = 0;
#endif
    scr->W   = fwidth;
    scr->H   = fheight;
    scr->W2  = fwidth/2;
    scr->H2  = fheight/2;
    scr->H3  = scr->H + scr->H2;
    scr->XL  = 14*fwidth + edge;
    scr->YL  = 3*fheight + edge;
    scr->XS  = currentgraph->absolute.width;
    scr->YS  = currentgraph->absolute.height;
    scr->X   = scr->XS - scr->XL - 2*fwidth - edge;
    scr->Y   = scr->YS - scr->YL - 3*fheight - edge;
    scr->XC  = scr->XL + scr->X/2;
    scr->YC  = scr->YL + scr->Y/2;
    scr->XU  = scr->XL + scr->X;
    scr->YU  = scr->YL + scr->Y;

    if (oldX && oldY) {
        for (k = currentgraph->keyed; k; k = k->next) {
            k->x = (k->x - oldXL)*((double)scr->X)/oldX + scr->XL;
            k->y = (k->y - oldYL)*((double)scr->Y)/oldY + scr->YL;
        }
    }
}

static void interpolateX ( )

static

static void interpolateX ( struct gplot *  graf, struct dvec *  d  )

static

Definition at line 936 of file newgraf.c.

{
    double xl, xu, dx;
    float *v;
    int i, len;
    struct dvec *xs = graf->plot->pl_scale;

    if (xs->v_numdims > 1)
        len = xs->v_dims[xs->v_numdims-1];
    else
        len = xs->v_length;

    if (isreal(xs)) {
        xl = *(xs->v_realdata);
        xu = *(xs->v_realdata + len - 1);
        dx = (xu - xl)/(graf->numpt-1);
    }
    else {
        xl = realpart(&xs->v_compdata[0]);
        xu = realpart(&xs->v_compdata[len - 1]);
        dx = (xu - xl)/(graf->numpt-1);
    }
    txfree((char*)graf->xdata);
    graf->xdata = (float *) tmalloc(graf->numpt*sizeof(float));
    v = graf->xdata;
    for (i = 0; i < graf->numpt; i++) {
        *(v++) = (float) xl;
        xl += dx;
    }
    graf->scale->xfull.beg = *graf->xdata;
    graf->scale->xfull.end  = *(graf->xdata + graf->numpt - 1);
    if (graf->scale->lflg) {
        graf->scale->xfull.beg = log10(graf->scale->xfull.beg);
        graf->scale->xfull.end = log10(graf->scale->xfull.end);
        graf->scale->xfull.min = floor(graf->scale->xfull.beg);
        graf->scale->xfull.max = ceil(graf->scale->xfull.end);
        graf->scale->ncells = graf->scale->xfull.max -
            graf->scale->xfull.min;
    }
    else {
        set_scale(graf->scale->xfull.beg,graf->scale->xfull.end,
            &graf->scale->xfull.min,&graf->scale->xfull.max,
            &graf->scale->ncells);
    }
    graf->scale->xcurr = graf->scale->xfull;
}

static void interpolateY ( )

static

static void interpolateY ( struct gplot *  graf, int  ind, struct dvec *  d  )

static

Definition at line 989 of file newgraf.c.

{
    double xl, xu, ymax, ymin, dx, xi, xj, yi, yj, xl0;
    double *xd, *yd;
    complex *xc, *yc;
    float *v;
    int i, j, len, cy, extra, ird, irs;
    struct dvec *xs = graf->plot->pl_scale;

    if (xs->v_numdims > 1)
        len = xs->v_dims[xs->v_numdims-1];
    else
        len = xs->v_length;

    if (isreal(xs)) {
        xl = *(xs->v_realdata);
        xu = *(xs->v_realdata + len - 1);
        dx = (xu - xl)/(graf->numpt-1);
    }
    else {
        xl = realpart(&xs->v_compdata[0]);
        xu = realpart(&xs->v_compdata[len - 1]);
        dx = (xu - xl)/(graf->numpt-1);
    }
    if (ciprefix("freq",xs->v_name)
            && xl > 0 && fabs(xu/xl) > LOGTST) {
        xu = log10(xu);        /* rescale x factors */
        xl = log10(xl);        /* for log plot */
        dx = (xu - xl)/(graf->numpt-1);
        graf->scale->lflg = 1;
    }

    if (xs->v_numdims > 1) {

        /* how many dimensions hath d? (length = scale) */
        for (j = 1, i = 0; i < d->v_numdims - 1; i++)
            j *= d->v_dims[i];

        graf->tdata[ind].cycles = j;
        extra = xs->v_length % len;
        if (extra)
            (graf->tdata[ind].cycles)++;
        else
            graf->tdata[ind].extra = 0;
    }
    else {
        graf->tdata[ind].cycles = 1;
        extra = 0;
        graf->tdata[ind].extra = 0;
    }

    txfree((char*)graf->tdata[ind].data);
    graf->tdata[ind].data =
        (float *) tmalloc(graf->numpt*graf->tdata[ind].cycles*sizeof(float));
    v = graf->tdata[ind].data;
    
    ird = isreal(d);
    irs = isreal(xs);
    xl0 = xl;
    xd = xs->v_realdata;
    xc = xs->v_compdata;
    yd = d->v_realdata;
    yc = d->v_compdata;
    ymin = ymax = ird ? *yd : realpart(&yc[0]);
    cy = graf->tdata[ind].cycles;
    while (cy--) {
        xi = xl = xl0;
        yi = ird ? *yd : realpart(&yc[0]);

        if (!cy && extra)
            len = extra;

        j = 0;
        for (i = 1; i < len; i++) {
            xj = irs ? *(xd + i) : realpart(&xc[i]);
            if (graf->scale->lflg) {
                xj = log10(xj);
            }

            yj = ird ? *(yd + i) : realpart(&yc[i]);
            if (yj > ymax) ymax = yj;
            if (yj < ymin) ymin = yj;

            if (graf->opt & OPT_step) {
                while (xl < xj && j < graf->numpt) {
                    *(v++) = yi;
                    xl += dx;
                    j++;
                }
            }
            else {
                while (xl < xj && j < graf->numpt) {
                    *(v++) =
                        (float) (yi + (yj - yi)*(xl - xi)/(xj - xi));
                    xl += dx;
                    j++;
                }
            }
            xi = xj;
            yi = yj;
        }
        if (!cy && extra) {
            graf->tdata[ind].extra = j;
            break;
        }
        while (j < graf->numpt) {
            *(v++) = (float) yj;
            j++;
        }
        if (irs)
            xd += len;
        else
            xc += len;
        if (ird)
            yd += len;
        else
            yc += len;
    }
    
    set_scale_4(ymin,ymax,graf->tdata[ind].scale,
        graf->tdata[ind].scale+1);
}

static int interval ( )

static

int iplot_begin	(	struct dvlist *	dl0,
		struct plot *	pl
	)

Definition at line 533 of file newgraf.c.

{
    int i;
    struct gplot *graf;
    struct dvlist *dl;
    GRAPH *graph;

    graf = (struct gplot *) tmalloc(sizeof(struct gplot));
    graf->scale = (struct gscale *) tmalloc(sizeof(struct gscale));

    graf->iniplot = false;  /* for initial draw */
    graf->plot = pl;
    pl->pl_active++;
    graf->dlist = dl0;
    graf->numpt = NUMOUTPTS;

    if (is_monotonic(pl->pl_scale)) {
        for (dl = dl0, i = 0; dl; dl = dl->dl_next, i++) {
            strncpy(graf->tdata[i].name,dl->dl_dvec->v_name,FIELD+1);
            graf->tdata[i].name[FIELD+1] = '\0';
            interpolateY(graf,i,dl->dl_dvec);
        }
        graf->numtr = i;
        interpolateX(graf,pl->pl_scale);
    }

    /* set option t */
    graf->opt |= OPT_t;

    if (!(graph = NewGraph())) {
        fprintf(cp_err,errmsg_gralloc);
        free_graf((GRDATA)graf);
        return (0);
    }

    graph->graphtype = GR_GRAF;
    graph->plotdata = (GRDATA)graf;
    graph->destroy = free_graf;
    graph->copydata = copygraf;
    graph->redraw = graf_display;

    /* can call DestroyGraph() here without messing up debug list */
    if (!is_monotonic(pl->pl_scale)) {
        fprintf(cp_err,errmsg_scale);
        DestroyGraph(graph->graphid);
        return (0);
    }    
    if (DevNewViewport(graph)) {
        fprintf(cp_err,errmsg_newvp);
        DestroyGraph(graph->graphid);
        return (0);
    }

    if (!dispdev->windows) {
        PushGraphContext(graph);
        init_viewport(&graf->scr);
        displ(graf);
        PopGraphContext();
    }

    return (graph->graphid);
}

void iplot_end

(

)

Definition at line 709 of file newgraf.c.

{
    int i;
    char q[8];
    struct gplot *graf = (struct gplot *)currentgraph->plotdata;
    struct dvlist *dl, *dl0;
    struct dvec *scale;

    if (graf == NULL || currentgraph->graphtype != GR_GRAF)
        return;

    dl0 = graf->dlist;
    if (dl0) {
        scale = graf->plot->pl_scale;

        for (dl = dl0, i = 0; dl; dl = dl->dl_next, i++) {
            interpolateY(graf,i,dl->dl_dvec);
        }
        interpolateX(graf,graf->plot->pl_scale);

        /* free the dvlist, not the dvecs! */
        for (dl = dl0; dl; dl = dl0) {
            dl0 = dl->dl_next;
            txfree((char*)dl);
        }
        graf->dlist = NULL;
    }

    DevClear();
    Running = true;
    graf->iniplot = false;

    for (i = 0; Running; ) {
        graf_display(currentgraph);
        if (dispdev->windows || dispdev->hardcopy)
            break;
        what_now(q);
        if (i == 0 && *q == '\0') break;
        i = 1;
        proc_option(graf,q);
    }
}

bool iplot_point

(

)

Definition at line 602 of file newgraf.c.

{
    struct dvlist *dl0, *dl;
    struct dvec *d, *xs;
    int i, k, l, n;
    bool newdim;
    double *ah, *al, xx, xl, yy, dy, amx, amn;
    struct gplot *graf = (struct gplot *)currentgraph->plotdata;

    if (graf == NULL || currentgraph->graphtype != GR_GRAF)
        return (true);

    xs = graf->plot->pl_scale;
    if (isreal(xs)) {
        xx = xs->v_realdata[xs->v_length-1];
        xl = xs->v_realdata[xs->v_length-2];
    }
    else {
        xx = realpart(&xs->v_compdata[xs->v_length-1]);
        xl = realpart(&xs->v_compdata[xs->v_length-2]);
    }
    if (xx < xl)
        newdim = true;
    else
        newdim = false;

    if (xs->v_numdims <= 1 && newdim) {
        /* error, free the dvlist, not the dvecs! */
        for (dl = graf->dlist; dl; dl = dl0) {
            dl0 = dl->dl_next;
            txfree((char*)dl);
        }
        graf->dlist = NULL;
        graf->iniplot = false;
        DevSetColor(8);
        DevText("Monotonicity error, partial plot",graf->scr.XU,
            graf->scr.YL - 3*graf->scr.H);
        return (true);
    }    
    if (graf->scale->lflg)
        xx = log10(xx);

    init_viewport(&graf->scr);
    dl0 = graf->dlist;
    if (xx > graf->scale->xcurr.max +
        .001*(graf->scale->xcurr.max - graf->scale->xcurr.min)) goto redraw;

    for (dl = dl0, i = 0; dl; dl = dl->dl_next, i++) {

        d = dl->dl_dvec;
        if (isreal(d))
            yy = d->v_realdata[d->v_length-1];
        else
            yy = realpart(&d->v_compdata[d->v_length-1]);

        dy = .001*(graf->tdata[i].scale[1] - graf->tdata[i].scale[0]);
        if (yy > graf->tdata[i].scale[1] + dy ||
            yy < graf->tdata[i].scale[0] - dy) goto redraw;
    }

    ah = graf->scale->ymax;
    al = graf->scale->ymin;
    n  = graf->numtr;

    k = graf->scr.X*(xx - graf->scale->xcurr.min) /
        (graf->scale->xcurr.max - graf->scale->xcurr.min);

    for (dl = dl0, i = 0; dl; dl = dl->dl_next, i++) {
    
        d = dl->dl_dvec;
        amx = ((ah[i]+al[i])+(ah[i]-al[i])*(2*i+1))/2;
        amn = ((ah[i]+al[i])-(ah[i]-al[i])*(2*(n-i)-1))/2;
        if (amx == amn)
            continue;

        if (isreal(d))
            yy = d->v_realdata[d->v_length-1];
        else
            yy = realpart(&d->v_compdata[d->v_length-1]);

        l = (int) (.5 + graf->scr.Y*(yy - amn)/(amx - amn));
        if (!newdim) {
            DevSetColor(i+2);
            DevLine(graf->lastx,graf->tdata[i].lasty,
                graf->scr.XL + k,graf->scr.YL + l);
        }
        graf->tdata[i].lasty = graf->scr.YL + l;
    }
    graf->lastx = graf->scr.XL + k;
    return (false);

redraw:
    graf->iniplot = true;
    for (dl = dl0, i = 0; dl; dl = dl->dl_next, i++) {
        interpolateY(graf,i,dl->dl_dvec);
    }
    interpolateX(graf,xs);
    DevSetColor(0);
    DevBox(0,0,graf->scr.XU,graf->scr.YU);
    displ(graf);
    return (false);
}

static bool is_monotonic ( )

static

static bool is_monotonic ( struct dvec *  v )

static

Definition at line 321 of file newgraf.c.

{
    bool inc;
    int i, len;

    if (v->v_numdims > 1)
        len = v->v_dims[v->v_numdims - 1];
    else
        len = v->v_length;

    if (isreal(v)) {
        inc = v->v_realdata[0] < v->v_realdata[1];
        if (!inc)
            return (false);
        for (i = 2; i < len; i++) {
            if (inc != (v->v_realdata[i-1] < v->v_realdata[i]))
                return (false);
        }
    }
    else {
        inc = realpart(&v->v_compdata[0]) < realpart(&v->v_compdata[1]);
        if (!inc)
            return (false);
        for (i = 2; i < len; i++) {
            if (inc != (realpart(&v->v_compdata[i-1]) <
                    realpart(&v->v_compdata[i])))
                return (false);
        }
    }
    return (true);
}

static void minmax ( )

static

static void minmax ( struct gplot *  graf, int *  c  )

static

Definition at line 1517 of file newgraf.c.

{

    float *dp;
    int i, j, n, cy, numpts;
    double f, atof(), *al, *ah;

    c[0] = c[1] = c[2] = 0;
    al = graf->scale->ymin;
    ah = graf->scale->ymax;
    n = graf->numtr;
    al[n] = al[n+1] = al[n+2] = al[n+3] = 1;
    ah[n] = ah[n+1] = ah[n+2] = ah[n+3] = -1;
    for (i = 0; i < n; i++) {
        al[i] = 1;
        ah[i] = -1;
        cy = graf->tdata[i].cycles;
        dp = graf->tdata[i].data + graf->scale->strtpt;
        numpts = graf->scale->numpts;
        while (cy--) {
            if (!cy && graf->tdata[i].extra) {
                if (graf->scale->strtpt > graf->tdata[i].extra)
                    break;
                if (numpts + graf->scale->strtpt > graf->tdata[i].extra)
                    numpts = graf->tdata[i].extra - graf->scale->strtpt;
            }

            for (j = 0; j < numpts; j++) {

                f = (double) *(dp + j);
                if (al[i] > ah[i]) {
                    al[i] = f;
                    ah[i] = f;
                }
                else {
                    if (f < al[i]) al[i] = f;
                    if (f > ah[i]) ah[i] = f;
                }
                switch (graf->tdata[i].type) {
                    case GRAF_V:
                        if (al[n+1] > ah[n+1]) {
                            al[n+1] = f;
                            ah[n+1] = f;
                        }
                        else {
                            if (f < al[n+1]) al[n+1] = f;
                            if (f > ah[n+1]) ah[n+1] = f;
                        }
                        c[0] = 1;
                        break;
                    case GRAF_I:
                        if (al[n+2] > ah[n+2]) {
                            al[n+2] = f;
                            ah[n+2] = f;
                        }
                        else {
                            if (f < al[n+2]) al[n+2] = f;
                            if (f > ah[n+2]) ah[n+2] = f;
                        }
                        c[1] = 1;
                        break;
                    default:
                        if (al[n+3] > ah[n+3]) {
                            al[n+3] = f;
                            ah[n+3] = f;
                        }
                        else {
                            if (f < al[n+3]) al[n+3] = f;
                            if (f > ah[n+3]) ah[n+3] = f;
                        }
                        c[2] = 1;
                        break;
                }
            }
            dp += graf->numpt;
        }
        if (al[n] > ah[n]) {
            al[n] = al[i];
            ah[n] = ah[i];
        }
        else {
            if (al[i] < al[n]) al[n] = al[i];
            if (ah[i] > ah[n]) ah[n] = ah[i];
        }
    }
}

static GRDATA mp_copy ( )

static

static GRDATA mp_copy ( GRDATA  mdp )

static

Definition at line 2656 of file newgraf.c.

{
    struct mdata *md = (struct mdata *)mdp;
    struct mdata *new;

    new = alloc(struct mdata);
    *new = *md;
    new->pts = alloc(struct chkpts);
    *new->pts = *md->pts;
    new->pts->v1 = tmalloc(new->pts->size);
    new->pts->v2 = tmalloc(new->pts->size);
    new->pts->pf = tmalloc(new->pts->size);
    memcpy(new->pts->v1,md->pts->v1,new->pts->size);
    memcpy(new->pts->v2,md->pts->v2,new->pts->size);
    memcpy(new->pts->pf,md->pts->pf,new->pts->size);
    return (GRDATA) new;
}

static void mp_display ( )

static

static void mp_display ( GRAPH *  graph )

static

Definition at line 2611 of file newgraf.c.

{
    struct mdata *md = (struct mdata *)graph->plotdata;
    struct _keyed *k;

    PushGraphContext(graph);
    init_viewport(&md->scr);
    plpts(md);
    for (k = graph->keyed; k; k = k->next) {
        DevSetColor(k->colorindex);
        DevText(k->text, k->x, k->y);
    }
    PopGraphContext();
}

int mp_done

(

int

id

)

Definition at line 2793 of file newgraf.c.

{
    struct mdata *md;
    struct chkpts *p;
    struct gpoint *graf;

    EchoGraph = NULL;
    if (!DOIPLOT || !id) return (1);
    if (dispdev->windows) return (0);

    PushGraphContext(FindGraph(id));
    md = (struct mdata *)currentgraph->plotdata;
    p = md->pts;

    if (!dispdev->hardcopy) {
        DevSetColor(0);
        DevBox(0,0,md->scr.XS,md->scr.H);
        DevSetColor(8);
        DevText("Hit any key to continue, 'p' for hardcopy",
            p->xc + p->d/2 - 20*md->scr.W - md->scr.W2,0);
        DevUpdate();
        if (DevGetchar(NULL) == 'p') {
            DevSetColor(0);
            DevBox(0,0,md->scr.XS,md->scr.H);
            ft_hardcopy(NULL,currentgraph,true,NULL,false);
        }
    }
    DevHalt();
    PopGraphContext();
    DestroyGraph(id);

    return (0);
}

static void mp_free ( )

static

static void mp_free ( GRDATA  mdp )

static

Definition at line 2631 of file newgraf.c.

{
    struct mdata *md = (struct mdata *)mdp;
    struct chkpts *p = md->pts;

    chkpts_free(p);
    txfree((char*)md);
}

int mp_init	(	int	delta1,
		int	delta2,
		double	v1min,
		double	v1max,
		double	v2min,
		double	v2max
	)

Definition at line 2681 of file newgraf.c.

{
    int d, dd1, dd2, xc, yc, x1, y1;
    char s[64];
    char *msg = "Operating Range Analysis";
    GRAPH *graph;
    struct chkpts *p0;
    struct mdata *md;

    if (!DOIPLOT) return (0);
    if (!(graph = NewGraph())) {
        fprintf(cp_err, errmsg_gralloc);
        return (0);
    }
    p0 = alloc(struct chkpts);
    p0->delta1 = delta1;
    p0->delta2 = delta2;
    p0->minv1 = v1min;
    p0->maxv1 = v1max;
    p0->minv2 = v2min;
    p0->maxv2 = v2max;

    md = alloc(struct mdata);
    md->pts = p0;

    graph->graphtype = GR_MPLT;
    graph->plotdata = (GRDATA)md;
    graph->destroy = mp_free;
    graph->copydata = mp_copy;
    graph->redraw = mp_display;

    if (DevNewViewport(graph)) {
        fprintf(cp_err, errmsg_newvp);
        DestroyGraph(graph->graphid);
        return (0);
    }
    
    if (!dispdev->windows) {
        PushGraphContext(graph);
        init_viewport(&md->scr);
        init(md);
        PopGraphContext();
    }
    EchoGraph = graph;

    return (graph->graphid);
}

int mp_mark	(	int	id,
		char	pf
	)

Definition at line 2758 of file newgraf.c.

{
    int x, y;
    void (*box)();
    struct chkpts *p;
    struct mdata *md;

    if (!DOIPLOT || !id) return (1);

    PushGraphContext(FindGraph(id));
    md = (struct mdata *)currentgraph->plotdata;
    p = md->pts;
    addit(p,p->d1,p->d2,pf);
    if (pf) {
        DevSetColor(3);
        box = pbox;
    }
    else {
        DevSetColor(2);
        box = xbox;
    }
    x = p->xc + p->d1*p->d;
    y = p->yc + p->d2*p->d;
    box(x+1,y+1,x+p->d-1,y+p->d-1);
    DevUpdate();
    PopGraphContext();
    return (0);
}

int mp_where	(	int	id,
		int	d1,
		int	d2
	)

Definition at line 2737 of file newgraf.c.

{
    struct mdata *md;
    struct chkpts *p;

    if (!DOIPLOT || !id) return (1);

    PushGraphContext(FindGraph(id));
    md = (struct mdata *)currentgraph->plotdata;
    p = md->pts;
    p->d1 = d1;
    p->d2 = d2;
    PopGraphContext();
    return (0);
}

static int newscale ( )

static

static int newscale ( struct gplot *  graf )

static

Definition at line 1339 of file newgraf.c.

{
    char s[128], *c;
    int j;

    DevClear();
    DevSetColor(8);
    strcpy(s,graf->plot->pl_scale->v_name);
    if (graf->scale->lflg) strcat(s," (log)");
    DevSetColor(2);
    sprintf(INBUF,"Scale type: %s",s);
    DevText(INBUF,0,graf->scr.Y);
    DevSetColor(8);
    sprintf(INBUF,"The  full  range of x is:  %s %s",
        ecvt12(graf->scale->xfull.beg),ecvt12(graf->scale->xfull.end));
    DevText(INBUF,0,graf->scr.Y - 2*graf->scr.H);
    sprintf(INBUF,"Currently, the range  is:  %s %s",
        ecvt12(graf->scale->xcurr.beg),ecvt12(graf->scale->xcurr.end));
    DevText(INBUF,0,graf->scr.Y - 3*graf->scr.H);
    DevSetColor(1);
    sprintf(INBUF,"Enter new range min max or <CR> for full scale : ");
    DevText(INBUF,0,graf->scr.Y - 5*graf->scr.H);
    for (;;) {
        char *c;
        DevSetColor(11);
        DevBox((int)strlen(INBUF)*graf->scr.W,
            graf->scr.Y - 5*graf->scr.H,graf->scr.XU,
            graf->scr.Y - 4*graf->scr.H);
        c = KbEdit(NULL,(int)strlen(INBUF)*graf->scr.W,
            graf->scr.Y - 5*graf->scr.H,11,1,13);
        if (!c) break;  /* ESC entered */
        j = strlen(c);
        if (!j) {
            graf->scale->xcurr.end = graf->scale->xfull.end;
            graf->scale->xcurr.beg = graf->scale->xfull.beg;
            graf->opt &= ~(OPT_x|OPT_X);
            break;
        }
        if (strchr(c,'q'))
            return 1;
        if ((j == 1) && (*c == ' ')) break;
        if (sscanf(c,"%le %le",
            &graf->scale->xcurr.beg,&graf->scale->xcurr.end) == 1) {
            graf->scale->xcurr.end = graf->scale->xcurr.beg;
            graf->scale->xcurr.beg = graf->scale->xfull.beg;
        }
        if (graf->scale->xcurr.end > graf->scale->xfull.end)
            graf->scale->xcurr.end = graf->scale->xfull.end;
        if (graf->scale->xcurr.beg < graf->scale->xfull.beg)
            graf->scale->xcurr.beg = graf->scale->xfull.beg;
        if (graf->scale->xcurr.beg >= graf->scale->xfull.beg &&
            graf->scale->xcurr.end <= graf->scale->xfull.end &&
            graf->scale->xcurr.beg < graf->scale->xcurr.end) break;
        DevSetColor(0);
        DevBox(0,graf->scr.Y - 5*graf->scr.H,graf->scr.XU,
            graf->scr.Y - 4*graf->scr.H);
        sprintf(INBUF,"Error:    Please reenter the new range min max : ");
        DevSetColor(1);
        DevText(INBUF,0,graf->scr.Y - 5*graf->scr.H);
    }
    if (graf->scale->lflg) {
        graf->scale->xcurr.min = floor(graf->scale->xcurr.beg);
        graf->scale->xcurr.max = ceil(graf->scale->xcurr.end);
        graf->scale->ncells = graf->scale->xcurr.max - graf->scale->xcurr.min;
    }
    else {
        set_scale(graf->scale->xcurr.beg,graf->scale->xcurr.end,
            &graf->scale->xcurr.min,&graf->scale->xcurr.max,
            &graf->scale->ncells);
    }
    DevUpdate();
    return 0;
}

static void pbox ( )

static

static void pbox ( int  xl, int  yl, int  xu, int  yu  )

static

Definition at line 2977 of file newgraf.c.

{
    ebox(xl,yl,xu,yu);
    DevLine(xl+(xu-xl)/4,yl+(yu-yl)/2,xu-(xu-xl)/4,yl+(yu-yl)/2);
    DevLine(xl+(xu-xl)/2,yl+(yu-yl)/4,xl+(xu-xl)/2,yu-(yu-yl)/4);
}

static void plpts ( )

static

static void plpts ( struct mdata *  md )

static

Definition at line 2584 of file newgraf.c.

{
    struct chkpts *p = md->pts;
    int j, x, y;
    void (*box)();

    init(md);
    for (j = 0; j < p->size; j++) {
        if (p->pf[j]) {
            DevSetColor(3);
            box = pbox;
        }
        else {
            DevSetColor(2);
            box = xbox;
        }
        x = p->xc + p->v1[j]*p->d;
        y = p->yc + p->v2[j]*p->d;
        box(x+1,y+1,x+p->d-1,y+p->d-1);
    }
}

static void proc_option ( )

static

static void proc_option ( struct gplot *  graf, char *  q  )

static

Definition at line 1119 of file newgraf.c.

{
#ifndef HAVE_X11
    if (strchr(q,'h')) graf->opt |= OPT_help;
    if (strchr(q,'q')) {
        /* does nothing in X */
        Running = false;
    }
    if (strchr(q,'P')) graf->opt |= OPT_hcpy;
    if (strchr(q,'a')) graf->opt |= OPT_add;
    if (strchr(q,'c')) graf->opt |= OPT_mark;
#endif
    if (strchr(q,'n')) {
        graf->opt |= OPT_n;
        graf->opt &= ~OPT_N;
    }
    if (strchr(q,'N')) {
        graf->opt |= OPT_N;
        graf->opt &= ~OPT_n;
    }
    if (strchr(q,'y')) graf->opt &= ~(OPT_n|OPT_N);

    if (!dispdev->windows) {
        if (strchr(q,'x')) {
            graf->opt |= OPT_x;
            graf->opt &= ~OPT_X;
            graf->opt |= OPT_Xx;
        }
        if (strchr(q,'X')) {
            graf->opt |= OPT_X;
            graf->opt &= ~OPT_x;
            graf->opt |= OPT_Xx;
        }
    }

    if (graf->numtr > 1) {
        if (strchr(q,'b')) graf->opt ^= OPT_b;
        if (strchr(q,'t')) graf->opt ^= OPT_t;
    }
    if (strchr(q,'p')) graf->opt ^= OPT_p;
    if (strchr(q,'s')) graf->opt ^= OPT_step;
}

static int set_cursor ( )

static

static void set_scale ( )

static

static void set_scale ( double  l, double  u, double *  lnew, double *  unew, int *  n  )

static

Definition at line 1702 of file newgraf.c.

{
    double x, e, m, del, s;
    double  fabs(), log10(), pow(), floor();
    int j = 0;
    *n = 4;
    if (u  < l) { x = l; l = u; u = x; }
    if (u == l) { l -= 0.1*fabs(l);  u += 0.1*fabs(u); }
    if (u == l) { *lnew = -0.5; *unew = 0.5; return; }
    x = u - l;
    l += x*.001;
    u -= x*.001;
    x = u - l;
    e = floor(log10(x));
    m = x / pow(10.0,e);

    if      (m <= 2) j = 1;
    else if (m <= 4) j = 2;
    else if (m <= 8) j = 4;
    else             j = 8;

    if      (m > j*1.75) *n = 8;
    else if (m > j*1.5)  *n = 7;
    else if (m > j*1.25) *n = 6;
    else if (m > j*1.0)  *n = 5;
    else                 *n = 4;

    s = *n * j * pow(10.0, e) / 4.0;
    if (*n == 8) *n = 4;
    del = s / *n;
    x = l / del;
    while (s + del*floor(x) < u) {
        s += del;
        *n += 1;
        if (*n == 8) *n = 4;
        del = s / *n;
        x =  l / del;
    }
    *lnew = del * floor(x);
    *unew = *lnew + s;
}

static void set_scale_4 ( )

static

static void set_scale_4 ( double  l, double  u, double *  lnew, double *  unew  )

static

Definition at line 1750 of file newgraf.c.

{
    double x, e, m, del, s;
    double  fabs(), log10(), pow(), floor();
    int n, j = 0;
    if (u  < l) { x = l; l = u; u = x; }
    if (u == l) { l -= 0.1*fabs(l);  u += 0.1*fabs(u); }
    if (u == l) { *lnew = -0.5; *unew = 0.5; return; }
    x = u - l;
    l += x*.001;
    u -= x*.001;
    x = u - l;
    e = floor(log10(x));
    m = x / pow(10.0,e);

    if      (m <= 2) j = 1;
    else if (m <= 4) j = 2;
    else if (m <= 8) j = 4;
    else             j = 8;

    if      (m > j*1.75) n = 8;
    else if (m > j*1.5)  n = 7;
    else if (m > j*1.25) n = 6;
    else if (m > j*1.0)  n = 5;
    else                 n = 4;

    s = n * j * pow(10.0, e) / 4.0;
    if (n == 8) n = 4;
    del = s / n;
    x = l / del;
    while (n != 4 || s + del*floor(x) < u) {
        s += del;
        n += 1;
        if (n == 8) n = 4;
        del = s / n;
        x =  l / del;
    }
    *lnew = del * floor(x);
    *unew = *lnew + s;
}

void WARNmsg

(

char *

msg

)

Definition at line 3065 of file newgraf.c.

{
    wordlist wl;

    wl.wl_next = NULL;
    wl.wl_prev = NULL;
    wl.wl_word = msg;
    com_echo(&wl);
}

static void what_now ( )

static

static void what_now ( char *  q )

static

Definition at line 756 of file newgraf.c.

{
    int x0,y0,x1,y1,xr0,xr1;
    struct gplot *graf = (struct gplot *)currentgraph->plotdata;
    char *qq;

    /* box to erase */
    x0 = graf->scr.XU - 33*graf->scr.W;
    y0 = graf->scr.YL - 3*graf->scr.H;
    x1 = graf->scr.XS;
    y1 = graf->scr.YL - 2*graf->scr.H;

    /* response box */
    xr0 = graf->scr.XU - 8*graf->scr.W;
    xr1 = graf->scr.XU;

    DevSetColor(0);
    DevBox(x0,y0,x1,y1);

    DevSetColor(11);
    DevBox(xr0,y0,xr1,y1);

    DevSetColor(8);
    DevText("What now? (h for help) :",x0,y0);
    qq = KbEdit(NULL,xr0,y0,11,1,13);
    if (qq) {
        strncpy(q,qq,7);
        q[7] = '\0';
    }
    else {
        /* quit if ESC entered */
        q[0] = 'q';
        q[1] = '\0';
    }
    DevSetColor(0);
    DevBox(x0,y0,x1,y1);
}

static void writef ( )

static

static void writef ( double  d, int  x, int  y  )

static

Definition at line 1796 of file newgraf.c.

{
    DevText(ecvt12(d),x,y);
}

static void writeg ( )

static

static void writeg ( double  d, int  x, int  y, char  j  )

static

Definition at line 1807 of file newgraf.c.

{
    char t[20], *tt;
    int xp, sn;

    sprintf(t,"%g",d);
    if ((tt = strchr(t,'e')) != NULL) {
        tt += 1;
        if (*tt == '-')
            sn = -1;
        else
            sn = 1;
        tt++;
        xp = atoi(tt);
        if (xp > 99) {
            if (sn > 0)
                xp = 99;
            else {
                if (j == 'r')
                    DevText("0",x - 2*currentgraph->fontwidth,y);
                else
                    DevText("0",x,y);
                return;
            }
        }
        sprintf(tt,"%02d",xp);
    }
    if (j == 'r')
        DevText(t,x - (int)strlen(t)*currentgraph->fontwidth,y);
    else
        DevText(t,x,y);
}

static void xbox ( )

static

static void xbox ( int  xl, int  yl, int  xu, int  yu  )

static

Definition at line 2966 of file newgraf.c.

{
    ebox(xl,yl,xu,yu);
    DevLine(xl,yl,xu,yu);
    DevLine(xl,yu,xu,yl);
}

static void xy_pick ( )

static

static int ymap ( )

static

static int ymap ( struct gplot *  graf, double *  y, int  m, int  nmin, int  nmax, int  j  )

static

Definition at line 2202 of file newgraf.c.

{
    double mm, mf, maxy, miny;
    int mi, yo, ys;

    mm = m - nmin;
    mm *= (graf->scale->numpts-1);
    mm /= (nmax - nmin);
    mm += graf->scale->strtpt;
    mi = (int) mm;
    mf = mm - mi;
    *y = graf->tdata[j].data[mi] +
        mf*(graf->tdata[j].data[mi+1]-graf->tdata[j].data[mi]);
    if (graf->opt & OPT_t) {
        ys = graf->scr.Y/graf->numtr;
        yo = graf->scr.YL + (graf->numtr-j-1)*ys;
    }
    else {
        ys = graf->scr.Y;
        yo = graf->scr.YL;
    }
    if (graf->opt & OPT_N) {
        miny = graf->scale->ymin[graf->numtr];
        maxy = graf->scale->ymax[graf->numtr];
    }
    else if (graf->opt & OPT_n) {
        switch (graf->tdata[j].type) {
            case GRAF_V:
                miny = graf->scale->ymin[graf->numtr+1];
                maxy = graf->scale->ymax[graf->numtr+1];
                break;
            case GRAF_I:
                miny = graf->scale->ymin[graf->numtr+2];
                maxy = graf->scale->ymax[graf->numtr+2];
                break;
            default:
                miny = graf->scale->ymin[graf->numtr+3];
                maxy = graf->scale->ymax[graf->numtr+3];
        }
    }
    else {
        miny = graf->scale->ymin[j];
        maxy = graf->scale->ymax[j];
    }
    return yo + (int) ((*y-miny)*ys/(maxy-miny)+.5);
}

Variable Documentation

bool DOIPLOT

static

Definition at line 2320 of file newgraf.c.

GRAPH* EchoGraph

Definition at line 53 of file newgraf.c.

char* errmsg_gralloc = "Error: can't allocate new graph\n"

static

Definition at line 155 of file newgraf.c.

char* errmsg_newvp = "Error: can't open viewport for graphics\n"

static

Definition at line 156 of file newgraf.c.

char* errmsg_scale = "Error: scale not monotonically increasing\n"

static

Definition at line 154 of file newgraf.c.

char INBUF[128]

static

Definition at line 63 of file newgraf.c.

bool Running

static

Definition at line 61 of file newgraf.c.