void
focusprev(Arg *arg) {
Client *c;
if(!sel)
return;
if(!(c = getprev(sel->prev))) {
for(c = clients; c && c->next; c = c->next);
c = getprev(c);
}
if(c) {
focus(c);
restack();
}
}
static void post(Agraph_t * g)
{
Agnode_t *v;
Agnode_t *prev;
char buf[256];
char dflt[256];
Agsym_t *sym;
Agsym_t *psym;
double dist, oldmax;
double maxdist = 0.0; /* maximum "finite" distance */
sym = agattr(g, AGNODE, "dist", "");
if (doPath)
psym = agattr(g, AGNODE, "prev", "");
if (setall)
sprintf(dflt, "%.3lf", HUGE);
for (v = agfstnode(g); v; v = agnxtnode(g, v)) {
dist = getdist(v);
if (dist) {
dist--;
sprintf(buf, "%.3lf", dist);
agxset(v, sym, buf);
if (doPath && (prev = getprev(v)))
agxset(v, psym, agnameof(prev));
if (maxdist < dist)
maxdist = dist;
} else if (setall)
agxset(v, sym, dflt);
}
sym = agattrsym(g, "maxdist");
if (sym) {
if (!setall) {
/* if we are preserving distances in other components,
* check previous value of maxdist.
*/
oldmax = atof(agxget(g, sym));
if (oldmax > maxdist)
maxdist = oldmax;
}
sprintf(buf, "%.3lf", maxdist);
agxset(g, sym, buf);
} else {
sprintf(buf, "%.3lf", maxdist);
agattr(g, AGRAPH, "maxdist", buf);
}
agclean(g, AGNODE, "dijkstra");
agclean(g, AGEDGE, "dijkstra");
}
int
input_line(char *string, int length)
{
char curline[2000]; /* edit buffer */
int noline;
unsigned c;
int more;
int i;
if (first) {
poolinit(); /* build line pool */
first = 0;
}
noline = 1; /* no line fetched yet */
for (cl=cp=0; cl<length && cl<(int)sizeof(curline); ) {
if (usrbrk()) {
clrbrk();
break;
}
switch (c=input_char()) {
case F_RETURN: /* CR */
t_sendl("\r\n", 2); /* yes, print it and */
goto done; /* get out */
case F_CLRSCRN: /* clear screen */
asclrs();
t_sendl(curline, cl);
ascurs(0, cp);
break;
case F_CSRUP:
if (noline) { /* no line fetched yet */
getnext(); /* getnext so getprev gets current */
noline = 0; /* we now have line */
}
bstrncpy(curline, getprev(), sizeof(curline));
prtcur(curline);
break;
case F_CSRDWN:
noline = 0; /* mark line fetched */
bstrncpy(curline, getnext(), sizeof(curline));
prtcur(curline);
break;
case F_INSCHR:
insert_space(curline, sizeof(curline));
break;
case F_DELCHR:
delchr(1, curline, sizeof(curline)); /* delete one character */
break;
case F_CSRLFT: /* Backspace */
backup(curline);
break;
case F_CSRRGT:
forward(curline, sizeof(curline));
break;
case F_ERSCHR: /* Rubout */
backup(curline);
delchr(1, curline, sizeof(curline));
if (cp == 0) {
t_char(' ');
t_char(0x8);
}
break;
case F_DELEOL:
t_clrline(0, t_width);
if (cl > cp)
cl = cp;
break;
case F_NXTWRD:
i = next_word(curline);
while (i--) {
forward(curline, sizeof(curline));
}
break;
case F_PRVWRD:
i = prev_word(curline);
while (i--) {
backup(curline);
}
break;
case F_DELWRD:
delchr(next_word(curline), curline, sizeof(curline)); /* delete word */
break;
case F_NXTMCH: /* Ctl-X */
if (cl==0) {
*string = EOS; /* terminate string */
return(c); /* give it to him */
}
/* Note fall through */
case F_DELLIN:
case F_ERSLIN:
while (cp > 0) {
backup(curline); /* backup to beginning of line */
}
t_clrline(0, t_width); /* erase line */
cp = 0;
cl = 0; /* reset cursor counter */
t_char(' ');
t_char(0x8);
break;
case F_SOL:
while (cp > 0) {
backup(curline);
}
break;
case F_EOL:
while (cp < cl) {
forward(curline, sizeof(curline));
}
while (cp > cl) {
backup(curline);
}
break;
case F_TINS: /* toggle insert mode */
mode_insert = !mode_insert; /* flip bit */
break;
default:
if (c > 255) { /* function key hit */
if (cl==0) { /* if first character then */
*string = EOS; /* terminate string */
return c; /* return it */
}
t_honk_horn(); /* complain */
} else {
if ((c & 0xC0) == 0xC0) {
if ((c & 0xFC) == 0xFC) {
more = 5;
} else if ((c & 0xF8) == 0xF8) {
more = 4;
} else if ((c & 0xF0) == 0xF0) {
more = 3;
} else if ((c & 0xE0) == 0xE0) {
more = 2;
} else {
more = 1;
}
} else {
more = 0;
}
if (mode_insert) {
insert_space(curline, sizeof(curline));
}
curline[cp++] = c; /* store character in line being built */
t_char(c); /* echo character to terminal */
while (more--) {
c= input_char();
insert_hole(curline, sizeof(curline));
curline[cp++] = c; /* store character in line being built */
t_char(c); /* echo character to terminal */
}
if (cp > cl) {
cl = cp; /* keep current length */
curline[cp] = 0;
}
}
break;
} /* end switch */
}
/* If we fall through here rather than goto done, the line is too long
simply return what we have now. */
done:
curline[cl++] = EOS; /* terminate */
bstrncpy(string,curline,length); /* return line to caller */
/* Save non-blank lines. Note, put line zaps curline */
if (curline[0] != EOS) {
putline(curline,cl); /* save line for posterity */
}
return 0; /* give it to him/her */
}
int bsolve(
int m,
double *sy,
int *iy,
int *pny
)
{
int i, j, jr, ny=*pny;
int k, row, row2, consistent=TRUE;
double beta;
double eps;
static double *y=NULL, *yy=NULL;
static int *tag=NULL;
static int currtag=1;
double starttime, endtime;
starttime = (double) clock();
if ( y == NULL) CALLOC( y, m, double);
if ( yy == NULL) CALLOC( yy, m, double);
if ( tag == NULL) CALLOC( tag, m, int);
if ( newcol == NULL) MALLOC( newcol, m, double );
if (inewcol == NULL) MALLOC( inewcol, m, int );
for (k=0; k<ny; k++) {
i = irowperm[iy[k]];
y[i] = sy[k];
tag[i] = currtag;
addtree(i);
}
if (rank < m) eps = EPSSOL * maxv(sy,ny);
/*------------------------------------------------------+
| -1 |
| y <- L y */
for (i=getfirst(); i < rank && i != -1; i=getnext()) {
beta = y[i];
for (k=0; k<degL[i]; k++) {
row = L[i][k].i;
if (tag[row] != currtag) {
y[row] = 0.0;
tag[row] = currtag;
addtree(row);
}
y[row] -= L[i][k].d * beta;
}
}
/*------------------------------------------------------+
| Apply refactorization row operations. */
for (jr=0; jr<nr; jr++) {
/*--------------------------------------------------+
| Gather sparse vector. */
k=0;
for (j=col_outs[jr]; j<=imaxs[jr]; j++) {
if (tag[j] == currtag) {
sy[k] = y[j];
iy[k] = j;
k++;
tag[j]--;
deltree(j);
}
}
ny = k;
/*--------------------------------------------------+
| Scatter and permute. */
for (k=0; k<ny; k++) {
i = iperm[jr][iy[k]];
y[i] = sy[k];
tag[i] = currtag;
addtree(i);
}
/*--------------------------------------------------+
| Apply row operations. */
row = rows[jr];
for (k=0; k<ngauss[jr]; k++) {
row2 = row_list[jr][k];
if (tag[row] != currtag) {
y[row] = 0.0;
tag[row] = currtag;
addtree(row);
}
if (tag[row2] == currtag) {
y[row] -= gauss[jr][k] * y[row2];
}
}
}
/*------------------------------------------------------+
| -1 |
| Set aside sparse intermediate vector L P a for |
| j |
| refactorization routine. */
nnewcol = 0;
for (i=getfirst(); i != -1; i=getnext()) {
if ( ABS(y[i]) > EPS ) {
newcol [nnewcol] = y[i];
inewcol[nnewcol] = i;
nnewcol++;
}
}
/*------------------------------------------------------+
| -1 |
| y <- U y */
for (i=getlast(); i >= rank && i != -1; i=getprev()) {
if ( ABS( y[i] ) > eps ) consistent = FALSE;
y[i] = 0.0;
}
for ( ; i>=0; i=getprev()) {
beta = y[i]/diag[i];
for (k=0; k<degU[i]; k++) {
row = U[i][k].i;
if (tag[row] != currtag) {
y[row] = 0.0;
tag[row] = currtag;
addtree(row);
}
y[row] -= U[i][k].d * beta;
}
y[i] = beta;
}
ny = 0;
for (i=getfirst(); i != -1; i=getnext()) {
if ( ABS(y[i]) > EPS ) {
sy[ny] = y[i];
iy[ny] = colperm[i];
ny++;
}
}
*pny = ny;
currtag++;
killtree();
endtime = (double) clock();
cumtime += endtime - starttime;
return consistent;
}
