/* display the current generation */
display()
{
int i,j,k,j9;
char c;
if(minx && prow(minx-1)) minx--;
if(miny && pcol(miny-1)) miny--;
if ((maxx < (XSIZE-1)) && prow(maxx+1)) maxx++;
if((maxy<(YSIZE-1)) && pcol(maxy+1))maxy++;
while (!prow(minx)) minx++;
while (!prow(maxx)) maxx--;
while (!pcol(miny)) miny++;
while (!pcol(maxy)) maxy--;
printf("\n\ngeneration = %1d population = %1d ",
gen,pop);
++gen;
putchar('\n');
j9 = maxy - miny + 1;
for (i = minx; i<=maxx; i++) {
if (CENTER && j9<WIDTH)
for (k=0; k<(WIDTH-j9)/2; k++) putchar(' ');
for (j=miny; j<=maxy; j++) {
switch(cell[i][j]) {
case 1: cell[i][j] = 2;
case 2: putchar('*');
break;
case 3: cell[i][j] = 0;
case 0: putchar(' ');
}
}
if (i != maxx) putchar('\n');
}
}
int uformat(BW *bw)
{
long indent;
unsigned char *indents;
B *buf;
P *b;
long curoff;
int c;
P *p, *q;
p = pdup(bw->cursor, USTR "uformat");
p_goto_bol(p);
/* Do nothing if we're not on a paragraph line */
if (pisnpara(bw, p)) {
prm(p);
return 0;
}
/* Move p to beginning of paragraph, bw->cursor to end of paragraph and
* set curoff to original cursor offset within the paragraph */
pbop(bw, p);
curoff = bw->cursor->byte - p->byte;
pset(bw->cursor, p);
peop(bw, bw->cursor);
/* Ensure that paragraph ends on a beginning of a line */
if (!pisbol(bw->cursor))
binsc(bw->cursor, '\n'), pgetc(bw->cursor);
/* Record indentation of second line of paragraph, of first line if there
* is only one line */
q = pdup(p, USTR "uformat");
pnextl(q);
if (q->line != bw->cursor->line) {
P *r = pdup(q, USTR "uformat");
indent = nindent(bw, q, 0);
pcol(r, indent);
indents = brs(q, r->byte - q->byte);
prm(r);
} else {
P *r = pdup(p, USTR "uformat");
int x, y;
indent = nindent(bw, p, 1); /* allowing * and - here */
pcol(r, indent);
indents = brs(p, r->byte - p->byte);
prm(r);
if (!bw->o.autoindent) {
/* Don't indent second line of single-line paragraphs if autoindent is off */
int x = zlen(indents);
while (x && (indents[x - 1] == ' ' || indents[x - 1] == '\t'))
indents[--x] = 0;
if (x) {
indents[x++] = ' ';
indents[x] = 0;
}
indent = txtwidth1(bw->o.charmap, bw->o.tab, indents, x);
}
for (x = 0; indents[x] && (indents[x] == ' ' || indents[x] == '\t'); ++x);
y = zlen(indents);
while (y && (indents[y - 1] == ' ' || indents[y - 1] == '\t'))
--y;
/* Don't duplicate if it looks like a bullet */
/* if (y && (indents[y - 1] == '*' || indents[y - 1] == '-') &&
(y == 1 || indents[y - 2] == ' ' || indents[y - 2] == '\t'))
indents[y - 1] = ' '; */
/* Fix C comment */
if (indents[x] == '/' && indents[x + 1] == '*')
indents[x] = ' ';
}
prm(q);
/* But if the left margin is greater, we use that instead */
if (bw->o.lmargin > indent) {
int x;
for (x = 0; indents[x] == ' ' || indents[x] == '\t'; ++x);
if (!indents[x]) {
joe_free(indents);
indent = bw->o.lmargin;
indents = joe_malloc(indent+1);
for (x = 0; x != indent; ++x)
indents[x] = ' ';
indents[x] = 0;
}
}
/* Cut paragraph into new buffer */
/* New buffer needs to inherit UTF-8 and CR-LF options */
buf = bcpy(p, bw->cursor);
buf->o.crlf = p->b->o.crlf;
buf->o.charmap = p->b->o.charmap;
bdel(p, bw->cursor);
/* text is in buffer. insert it at cursor */
/* Do first line */
b = pdup(buf->bof, USTR "uformat");
while (!piseof(b)) {
/* Set cursor position if we're at original offset */
if (b->byte == curoff)
pset(bw->cursor, p);
/* Get character from buffer */
c = pgetc(b);
/* Stop if we found end of line */
if (c == '\n') {
prgetc(b);
break;
}
/* Stop if we found white-space followed by end of line */
if (joe_isblank(b->b->o.charmap, c) && piseolblank(b)) {
prgetc(b);
break;
}
/* Insert character, advance pointer */
binsc(p, c);
pgetc(p);
/* Do word wrap if we reach right margin */
if (piscol(p) > bw->o.rmargin && !joe_isblank(p->b->o.charmap,c)) {
wrapword(bw, p, indent, bw->o.french, 1, indents);
break;
}
}
/* Do rest */
while (!piseof(b)) {
c = brch(b);
if (joe_isblank(b->b->o.charmap,c) || c == '\n') {
int f = 0;
P *d;
int g;
/* Set f if there are two spaces after . ? or ! instead of one */
/* (What is c was '\n'?) */
d=pdup(b, USTR "uformat");
g=prgetc(d);
if (g=='.' || g=='?' || g=='!') {
f = 1;
/* pset(d,b);
pgetc(d);
if (c == '\n' || piseol(d) || joe_isspace(bw->b->o.charmap,brch(d))) {
f = 1;
}
*/
}
prm(d);
/* Skip past the whitespace. Skip over indentations */
loop:
c = brch(b);
if (c == '\n') {
if (b->byte == curoff)
pset(bw->cursor, p);
pgetc(b);
while (cpara(bw, (c=brch(b)))) {
if (b->byte == curoff)
pset(bw->cursor, p);
pgetc(b);
}
}
if (joe_isblank(b->b->o.charmap,c)) {
if(b->byte == curoff)
pset(bw->cursor, p);
pgetc(b);
goto loop;
}
/* Insert proper amount of whitespace */
if (!piseof(b)) {
if (f && !bw->o.french)
binsc(p, ' '), pgetc(p);
binsc(p, ' ');
pgetc(p);
}
} else {
/* Insert characters of word and wrap if necessary */
if (b->byte == curoff)
pset(bw->cursor, p);
binsc(p, pgetc(b));
pgetc(p);
if (piscol(p) > bw->o.rmargin)
wrapword(bw, p, indent, bw->o.french, 1, indents);
}
}
binsc(p, '\n');
prm(p);
brm(buf);
joe_free(indents);
return 0;
}
void wrapword(BW *bw, P *p, long int indent, int french, int no_over, unsigned char *indents)
{
P *q;
P *r;
P *s;
int rmf = 0;
int c;
long to = p->byte;
int my_indents = 0;
/* autoindent when called by utype */
if (!indents) {
/* Get indentation prefix from beginning of line */
s = pdup(p, USTR "wrapword");
p_goto_bol(s);
pbop(bw, s);
/* Record indentation of second line of paragraph, of first
* line if there is only one line */
q = pdup(s, USTR "wrapword");
pnextl(q);
if (q->line < p->line) {
/* Second line */
P *r = pdup(q, USTR "wrapword");
indent = nindent(bw, q, 0);
pcol(r, indent);
indents = brs(q, r->byte - q->byte);
prm(r);
} else {
/* First line */
P *r = pdup(s, USTR "uformat");
int x, y;
indent = nindent(bw, s, 1);
pcol(r, indent);
indents = brs(s, r->byte - s->byte);
prm(r);
if (!bw->o.autoindent) {
/* Don't indent second line of single-line paragraphs if autoindent is off */
int x = zlen(indents);
while (x && (indents[x - 1] == ' ' || indents[x - 1] == '\t'))
indents[--x] = 0;
if (x) {
indents[x++] = ' ';
indents[x] = 0;
}
indent = txtwidth1(bw->o.charmap, bw->o.tab, indents, x);
}
for (x = 0; indents[x] && (indents[x] == ' ' || indents[x] == '\t'); ++x);
y = zlen(indents);
while (y && (indents[y - 1] == ' ' || indents[y - 1] == '\t'))
--y;
/* Don't duplicate bullet */
/* if (y && (indents[y - 1] == '*' || indents[y - 1] == '-') &&
(y == 1 || indents[y - 2] == ' ' || indents[y - 2] == '\t'))
indents[y - 1] = ' '; */
/* Fix C comment */
if (indents[x] == '/' && indents[x + 1] == '*')
indents[x] = ' ';
}
if (bw->o.lmargin > indent) {
int x;
for (x = 0; indents[x] == ' ' || indents[x] == '\t'; ++x);
if (!indents[x]) {
joe_free(indents);
indent = bw->o.lmargin;
indents = joe_malloc(indent+1);
for (x = 0; x != indent; ++x)
indents[x] = ' ';
indents[x] = 0;
}
}
my_indents = 1;
prm(q);
prm(s);
}
/*
if(!indents) {
int f = 0;
P *r = pdup(p);
p_goto_bol(r);
q = pdup(r);
while(cpara(c = brc(q))) {
if(!joe_isblank(c))
f = 1;
pgetc(q);
}
if(f) {
indents = brs(r, q->byte-r->byte);
rmf = 1;
if(indents[0] == '/' && indents[1] == '*')
indents[0] = ' ';
}
prm(r);
prm(q);
}
*/
/* Get to beginning of word */
while (!pisbol(p) && piscol(p) > indent && !joe_isblank(p->b->o.charmap, prgetc(p)))
/* do nothing */;
/* If we found the beginning of a word... */
if (!pisbol(p) && piscol(p) > indent) {
/* Move q to two (or one if 'french' is set) spaces after end of previous
word */
q = pdup(p, USTR "wrapword");
while (!pisbol(q))
if (!joe_isblank(p->b->o.charmap, (c = prgetc(q)))) {
pgetc(q);
if ((c == '.' || c == '?' || c == '!')
&& q->byte != p->byte && !french)
pgetc(q);
break;
}
pgetc(p);
/* Delete space between start of word and end of previous word */
to -= p->byte - q->byte;
bdel(q, p);
prm(q);
if (bw->o.flowed) {
binsc(p, ' ');
pgetc(p);
++to;
}
/* Move word to beginning of next line */
binsc(p, '\n');
/* When overtype is on, do not insert lines */
if (!no_over && p->b->o.overtype){
/* delete the next line break which is unnecessary */
r = pdup(p, USTR "wrapword");
/* p_goto_eol(r); */
pgetc(r);
p_goto_eol(r);
s = pdup(r, USTR "wrapword");
pgetc(r);
bdel(s,r);
binsc(r, ' ');
/* Now we got to take care that all subsequent lines are not longer than the right margin */
/* Move cursor to right margin */
pfwrd(r, r->b->o.rmargin - r->col);
/* Make a copy of the cursor and move the copied cursor to the end of the line */
prm(s);
s = pdup(r, USTR "wrapword");
p_goto_eol(s);
/* If s is located behind r then the line goes beyond the right margin and we need to call wordwrap() for that line. */
/*
if (r->byte < s->byte){
wrapword(bw, r, indent, french, 1, indents);
}
*/
prm(r);
prm(s);
}
++to;
if (p->b->o.crlf)
++to;
pgetc(p);
/* Indent to left margin */
if (indents) {
binss(p, indents);
to += zlen(indents);
} else
while (indent--) {
binsc(p, ' ');
++to;
}
if (rmf)
joe_free(indents);
}
/* Move cursor back to original position */
pfwrd(p, to - p->byte);
if (my_indents)
joe_free(indents);
}
long
ARPACKEigenSolver::solveSparse(int nev, bool shift_invert, double sigma, char * which, int ncv, double tol, int maxit,
double * resid, bool AutoShift)
{
#ifdef THEA_HAVE_SUPERLU
MatrixWrapper<double>::SparseColumnMatrix const & scm = matrix.getSparseColumnMatrix();
if (scm.isEmpty())
{
THEA_WARNING << getName() << ": Attempting to compute eigenvalues of an empty matrix -- no eigenpairs computed";
return 0;
}
// Create the matrix
alwaysAssertM(MatrixUtil::isSquare(scm), std::string(getName()) + ": Operator matrix is not square");
alwaysAssertM(scm.isValid(), std::string(getName()) + ": Operator matrix has invalid internal state");
TheaArray<int> irow(scm.getRowIndices().begin(), scm.getRowIndices().end());
TheaArray<int> pcol(scm.getColumnIndices().begin(), scm.getColumnIndices().end());
int nnz = (int)scm.numSetElements();
// Repeat the isValid() checks to check if something got screwed up during the conversion
alwaysAssertM(irow.size() == scm.getValues().size(),
std::string(getName()) + ": irow and nzval arrays should have same size");
alwaysAssertM(pcol.size() == (array_size_t)scm.numRows() + 1,
getName() + format(": pcol array should have %d + 1 = %d entries, instead has %d entries", scm.numRows(),
scm.numRows() + 1, (int)pcol.size()));
alwaysAssertM(nnz == pcol[pcol.size() - 1],
std::string(getName()) + ": (n + 1)th entry of pcol array should be number of non-zeros");
ARluNonSymMatrix<double, double> arm(scm.numRows(), nnz, const_cast<double *>(&scm.getValues()[0]), &irow[0], &pcol[0]);
// Setup the problem
shared_ptr< ARluNonSymStdEig<double> > eig =
shift_invert ? shared_ptr< ARluNonSymStdEig<double> >(new ARluNonSymStdEig<double>(nev, arm, sigma, which, ncv, tol,
maxit, resid, AutoShift))
: shared_ptr< ARluNonSymStdEig<double> >(new ARluNonSymStdEig<double>(nev, arm, which, ncv, tol, maxit,
resid, AutoShift));
eig->Trace();
// Find eigenpairs
array_size_t nconv = (array_size_t)eig->FindEigenvectors();
eigenvalues.resize(nconv);
eigenvectors.resize(nconv);
array_size_t n = (array_size_t)scm.numRows();
for (array_size_t i = 0; i < nconv; ++i)
{
eigenvalues[i] = Eigenvalue(eig->EigenvalueReal((int)i), eig->EigenvalueImag((int)i));
eigenvectors[i].resize(n);
for (array_size_t j = 0; j < n; ++j)
eigenvectors[i][j] = std::complex<double>(eig->EigenvectorReal((int)i, (int)j), eig->EigenvectorImag((int)i, (int)j));
}
return (long)nconv;
#else
throw Error(std::string(getName()) + ": Sparse linear solver (SuperLU) not available");
#endif
}
void Geometry::MoperatorGeneralBlochFill(Mat A, int b[3][2], int DimPeriod, double k[3], int ih){
int N[3];
for(int i=0; i<3; i++) N[i] = gN.x(i);
double blochbc[3];
for(int i=0; i<3; i++) blochbc[i] = k[i]*N[i]*h[i];
int NC = 3, offset = ih*(Nxyzcr()+2);
int ns, ne;
double hh;
int bc[3][2][3]; /* bc[x/y/z direction][lo/hi][Ex/Ey/Ez] */
dcomp val, magicnum, mucp[2], mulcp[2];
dcomp cidu_phase, cpidu_phase[2], cpidl_phase[2];
/* set up b ... */
for(int ic=0; ic<3; ic++) for(int j=0; j<2; j++) for(int k=0; k<3; k++)
bc[ic][j][k] = b[ic][j]*( k==ic ? -1 :1);
MatGetOwnershipRange(A, &ns, &ne);
for (int itrue = ns; itrue < ne && itrue < 2*Nxyzc(); ++itrue) {
Point p(itrue, Grid(N, Nc, 2)); p.project(3); int i = p.xyzcr();
int cp[2], icp[2], cidu, cpidu[2],cpidl[2], cid, cpid[2];
for(int j=0; j<2;j++){
cp[j] = (p.c()+1+j) % NC;
icp[j] = i + (cp[j]-p.c() ) *Nxyz();
cpidu[j] = cyclic(p, 2-j, N);
cpidl[j] = cyclic(p, 2-j, N);
cpid[j] = cyclic(p, 2-j, N);
cpidu_phase[j] = 1.0;
cpidl_phase[j] = 1.0;
}
cidu = cyclic(p, 0, N);
cid = cyclic(p, 0, N);
cidu_phase = 1.0;
for(int jr=0; jr<2; jr++) { /* column real/imag parts */
int jrd = (jr-p.r())*NC*Nxyz();
magicnum = (p.r()==jr)*1.0 + (p.r()<jr)*1.0*ComplexI - (p.r()>jr)*1.0* ComplexI;
//=====================================================================
Point prow(i, Grid(N,3,2)); prow.project(Nc);
for(int ib=0; ib<2; ib++){
if(p.x(p.c()) == N[p.c()]-1){
int per = periodic(p.c(), DimPeriod );
cidu = per ? (1-N[p.c()])*cid : 0;
cidu_phase = per? std::exp(ComplexI*blochbc[p.c()]) : bc[p.c()][1][cp[ib]];
}
if(p.x(cp[ib]) == 0){
int per = periodic(cp[ib], DimPeriod );
cpidl[ib] = per ? (1-N[cp[ib]])*cpid[ib] : 0;
cpidl_phase[ib] = per ? std::exp(-ComplexI*blochbc[cp[ib]]) : bc[cp[ib]][0][cp[ib]];
}
mucp[1-ib] = pmlval(icp[1-ib], N, Npml, h, LowerPML, 1);
mulcp[1-ib] = pmlval(icp[1-ib]-cpidl[ib], N, Npml, h, LowerPML, 1);
double c[4];
hh = h[p.c()]*h[cp[ib]];
val = mucp[1-ib] * magicnum /hh; c[1] = val.real();
val *= cidu_phase; c[0] = -val.real();
val = cpidl_phase[ib] * mulcp[1-ib] * magicnum/hh; c[3] = -val.real();
val *= -cidu_phase; c[2] = -val.real();
int dcol[4];
dcol[0] = cidu;
dcol[1] = 0;
dcol[2] = cidu-cpidl[ib];
dcol[3] = -cpidl[ib];
for(int w=0;w<4;w++){
Point pcol(icp[ib] + jrd+dcol[w], Grid(N,3,2) );
pcol.project(Nc);
if(pcol.c()!=-1) MatSetValue(A, prow.xyzcr()+offset, pcol.xyzcr()+offset, c[w], ADD_VALUES);
}
if(p.x(cp[ib]) == N[cp[ib]]-1){
int per = periodic(cp[ib], DimPeriod );
cpidu[ib] = per ? (1-N[cp[ib]])*cpid[ib] : 0;
cpidu_phase[ib] = per? std::exp(ComplexI*blochbc[cp[ib]]) : bc[cp[ib]][1][p.c()];
}
if(p.x(cp[ib]) == 0){
int per = periodic(cp[ib], DimPeriod );
cpidl[ib] = per ? (1-N[cp[ib]])*cpid[ib] : -cpidu[ib];
cpidl_phase[ib] = per? std::exp(-ComplexI*blochbc[cp[ib]]) : bc[cp[ib]][0][p.c()];
}
hh = h[cp[ib]]*h[cp[ib]];
val = -(cpidu_phase[ib] * mucp[1-ib] * magicnum)/hh; c[0] = -val.real();
val = +( (mucp[1-ib] + mulcp[1-ib]) * magicnum)/hh;c[1] = -val.real();
val = -(cpidl_phase[ib] * mulcp[1-ib] * magicnum)/hh;c[2] = -val.real();
dcol[0] = cpidu[ib];
dcol[1] = 0;
dcol[2] = -cpidl[ib];
for(int w=0;w<3;w++){
Point pcol(i + jrd+dcol[w], Grid(N,3,2) );
pcol.project(Nc);
if(pcol.c()!=-1) MatSetValue(A, prow.xyzcr()+offset, pcol.xyzcr()+offset, c[w], ADD_VALUES);
}
}
}
}
}
