void implicit_1Dx(double *phi, double *xx,
double nu, double gamma, double h, double beta, double dt, int L,
int use_delj_trick) {
int ii;
double *dx = malloc((L-1) * sizeof(*dx));
double *dfactor = malloc(L * sizeof(*dfactor));
double *xInt = malloc((L-1) * sizeof(*xInt));
double Mfirst, Mlast;
double *MInt = malloc((L-1) * sizeof(*MInt));
double *V = malloc(L * sizeof(*V));
double *VInt = malloc((L-1) * sizeof(*VInt));
double *delj = malloc((L-1) * sizeof(*delj));
double *a = malloc(L * sizeof(*a));
double *b = malloc(L * sizeof(*b));
double *c = malloc(L * sizeof(*c));
double *r = malloc(L * sizeof(*r));
compute_dx(xx, L, dx);
compute_dfactor(dx, L, dfactor);
compute_xInt(xx, L, xInt);
Mfirst = Mfunc1D(xx[0], gamma, h);
Mlast = Mfunc1D(xx[L-1], gamma, h);
for(ii=0; ii < L; ii++)
V[ii] = Vfunc_beta(xx[ii], nu, beta);
for(ii=0; ii < L-1; ii++) {
MInt[ii] = Mfunc1D(xInt[ii], gamma, h);
VInt[ii] = Vfunc_beta(xInt[ii], nu, beta);
}
compute_delj(dx, MInt, VInt, L, delj, use_delj_trick);
compute_abc_nobc(dx, dfactor, delj, MInt, V, dt, L, a, b, c);
for(ii = 0; ii < L; ii++)
r[ii] = phi[ii]/dt;
/* Boundary conditions */
if(Mfirst <= 0)
b[0] += (0.5/nu - Mfirst)*2./dx[0];
if(Mlast >= 0)
b[L-1] += -(-0.5/nu - Mlast)*2./dx[L-2];
tridiag(a, b, c, r, phi, L);
free(dx);
free(dfactor);
free(xInt);
free(MInt);
free(V);
free(VInt);
free(delj);
free(a);
free(b);
free(c);
free(r);
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
/* Declaration of input and output arguments. */
double *x, *u, **p, *dx, *y, *t;
int i, np, nu, nx;
const mxArray *auxvar = NULL; /* Cell array of additional data. */
if (nrhs < 3) {
mexErrMsgIdAndTxt("IDNLGREY:ODE_FILE:InvalidSyntax",
"At least 3 inputs expected (t, u, x).");
}
/* Determine if auxiliary variables were passed as last input. */
if ((nrhs > 3) && (mxIsCell(prhs[nrhs-1]))) {
/* Auxiliary variables were passed as input. */
auxvar = prhs[nrhs-1];
np = nrhs - 4; /* Number of parameters (could be 0). */
} else {
/* Auxiliary variables were not passed. */
np = nrhs - 3; /* Number of parameters. */
}
/* Determine number of inputs and states. */
nx = mxGetNumberOfElements(prhs[1]); /* Number of states. */
nu = mxGetNumberOfElements(prhs[2]); /* Number of inputs. */
/* Obtain double data pointers from mxArrays. */
t = mxGetPr(prhs[0]); /* Current time value (scalar). */
x = mxGetPr(prhs[1]); /* States at time t. */
u = mxGetPr(prhs[2]); /* Inputs at time t. */
p = mxCalloc(np, sizeof(double*));
for (i = 0; i < np; i++) {
p[i] = mxGetPr(prhs[3+i]); /* Parameter arrays. */
}
/* Create matrix for the return arguments. */
plhs[0] = mxCreateDoubleMatrix(nx, 1, mxREAL);
plhs[1] = mxCreateDoubleMatrix(NY, 1, mxREAL);
dx = mxGetPr(plhs[0]); /* State derivative values. */
y = mxGetPr(plhs[1]); /* Output values. */
/*
Call the state and output update functions.
Note: You may also pass other inputs that you might need,
such as number of states (nx) and number of parameters (np).
You may also omit unused inputs (such as auxvar).
For example, you may want to use orders nx and nu, but not time (t)
or auxiliary data (auxvar). You may write these functions as:
compute_dx(dx, nx, nu, x, u, p);
compute_y(y, nx, nu, x, u, p);
*/
/* Call function for state derivative update. */
compute_dx(dx, t[0], x, u, p, auxvar);
/* Call function for output update. */
compute_y(y, t[0], x, u, p, auxvar);
/* Clean up. */
mxFree(p);
}
void implicit_2Dy(double *phi, double *xx, double *yy,
double nu2, double m21, double gamma2, double h2,
double dt, int L, int M, int use_delj_trick){
int ii, jj;
double *dy = malloc((M-1) * sizeof(*dy));
double *dfactor = malloc(M * sizeof(*dfactor));
double *yInt = malloc((M-1) * sizeof(*yInt));
double Mfirst, Mlast;
double *MInt = malloc((M-1) * sizeof(*MInt));
double *V = malloc(M * sizeof(*V));
double *VInt = malloc((M-1) * sizeof(*VInt));
double *delj = malloc((M-1) * sizeof(*delj));
double *a = malloc(M * sizeof(*a));
double *b = malloc(M * sizeof(*b));
double *c = malloc(M * sizeof(*c));
double *r = malloc(M * sizeof(*r));
double x;
compute_dx(yy, M, dy);
compute_dfactor(dy, M, dfactor);
compute_xInt(yy, M, yInt);
for(jj=0; jj < M; jj++)
V[jj] = Vfunc(yy[jj], nu2);
for(jj=0; jj < M-1; jj++)
VInt[jj] = Vfunc(yInt[jj], nu2);
tridiag_malloc(M);
for(ii=0; ii < L; ii++){
x = xx[ii];
Mfirst = Mfunc2D(yy[0], x, m21, gamma2, h2);
Mlast = Mfunc2D(yy[M-1], x, m21, gamma2, h2);
for(jj=0; jj < M-1; jj++)
MInt[jj] = Mfunc2D(yInt[jj], x, m21, gamma2, h2);
compute_delj(dy, MInt, VInt, M, delj, use_delj_trick);
compute_abc_nobc(dy, dfactor, delj, MInt, V, dt, M, a, b, c);
for(jj = 0; jj < M; jj++)
r[jj] = phi[ii*M + jj]/dt;
if((ii==0) && (Mfirst <= 0))
b[0] += (0.5/nu2 - Mfirst)*2./dy[0];
if((ii==L-1) && (Mlast >= 0))
b[M-1] += -(-0.5/nu2 - Mlast)*2./dy[M-2];
tridiag_premalloc(a, b, c, r, &phi[ii*M], M);
}
tridiag_free();
free(dy);
free(dfactor);
free(yInt);
free(MInt);
free(V);
free(VInt);
free(delj);
free(a);
free(b);
free(c);
free(r);
}
int
gz_fill_trapezoid_fixed(fixed fx0, fixed fw0, fixed fy0,
fixed fx1, fixed fw1, fixed fh, int swap_axes,
const gx_device_color *pdevc, gs_state *pgs)
{ const fixed ymin = fixed_rounded(fy0) + fixed_half;
const fixed ymax = fixed_rounded(fy0 + fh);
int iy = fixed2int_var(ymin);
const int iy1 = fixed2int_var(ymax);
if ( iy >= iy1 ) return 0; /* no scan lines to sample */
{ trap_line l, r;
int rxl, rxr, ry;
const fixed dxl = fx1 - fx0;
const fixed dxr = dxl + fw1 - fw0;
const fixed yline = ymin - fy0; /* partial pixel offset to */
/* first line to sample */
int fill_direct = color_is_pure(pdevc);
gx_color_index cindex;
gx_device *dev;
dev_proc_fill_rectangle((*fill_rect));
int code;
if_debug2('z', "[z]y=[%d,%d]\n", iy, iy1);
if ( fill_direct )
cindex = pdevc->color1,
dev = pgs->device->info,
fill_rect = dev->procs->fill_rectangle;
gp_check_interrupts();
r.x = (l.x = fx0 + fixed_half) + fw0;
ry = iy;
/* If the rounded X values are the same on both sides, */
/* we can save ourselves a *lot* of work. */
if ( fixed_truncated(l.x) == fixed_rounded(fx1) &&
fixed_truncated(r.x) == fixed_rounded(fx1 + fw1)
)
{ rxl = fixed2int_var(l.x);
rxr = fixed2int_var(r.x);
iy = iy1;
if_debug2('z', "[z]rectangle, x=[%d,%d]\n", rxl, rxr);
goto last;
}
#define fill_trap_rect(x,y,w,h)\
(fill_direct ?\
(swap_axes ? (*fill_rect)(dev, y, x, h, w, cindex) :\
(*fill_rect)(dev, x, y, w, h, cindex)) :\
swap_axes ? gz_fill_rectangle(y, x, h, w, pdevc, pgs) :\
gz_fill_rectangle(x, y, w, h, pdevc, pgs))
/* Compute the dx/dy ratios. */
/* dx# = dx#i + (dx#f / fh). */
#define compute_dx(tl, d)\
if ( d >= 0 )\
{ if ( d < fh ) tl.di = 0, tl.df = d;\
else tl.di = (int)(d / fh), tl.df = d - tl.di * fh, tl.x += yline * tl.di;\
}\
else\
{ if ( (tl.df = d + fh) >= 0 /* d >= -fh */ ) tl.di = -1, tl.x -= yline;\
else tl.di = (int)-((fh - 1 - d) / fh), tl.df = d - tl.di * fh, tl.x += yline * tl.di;\
}
/* Compute the x offsets at the first scan line to sample. */
/* We need to be careful in computing yline * dx#f {/,%} fh */
/* because the multiplication may overflow. We know that */
/* all the quantities involved are non-negative, and that */
/* yline is less than 1 (as a fixed, of course); this gives us */
/* a cheap conservative check for overflow in the multiplication. */
#define ymult_limit (max_fixed / fixed_1)
#define ymult_quo(yl, dxxf)\
(dxxf < ymult_limit ? yl * dxxf / fh : fixed_mult_quo(yl, dxxf, fh))
#define ymult_rem(yl, dxxf)\
(dxxf < ymult_limit ? yl * dxxf % fh : fixed_mult_rem(yl, dxxf, fh))
/* It's worth checking for dxl == dxr, since this is the case */
/* for parallelograms (including stroked lines). */
compute_dx(l, dxl);
if ( dxr == dxl )
{ fixed fx = ymult_quo(yline, l.df);
l.x += fx;
if ( l.di == 0 )
r.di = 0, r.df = l.df;
else /* too hard to do adjustments right */
compute_dx(r, dxr);
r.x += fx;
}
else
{ l.x += ymult_quo(yline, l.df);
compute_dx(r, dxr);
r.x += ymult_quo(yline, r.df);
}
rxl = fixed2int_var(l.x);
rxr = fixed2int_var(r.x);
/* Compute one line's worth of dx/dy. */
/* dx# * fixed_1 = ld#i + (ld#f / fh). */
/* We don't have to bother with this if */
/* we're only sampling a single scan line. */
if ( iy1 - iy == 1 )
{ iy++;
goto last;
}
#define compute_ldx(tl)\
if ( tl.df < ymult_limit )\
tl.ldi = int2fixed(tl.di) + int2fixed(tl.df) / fh,\
tl.ldf = int2fixed(tl.df) % fh,\
tl.xf = yline * tl.df % fh - fh;\
else\
tl.ldi = int2fixed(tl.di) + fixed_mult_quo(fixed_1, tl.df, fh),\
tl.ldf = fixed_mult_rem(fixed_1, tl.df, fh),\
tl.xf = fixed_mult_rem(yline, tl.df, fh) - fh
compute_ldx(l);
if ( dxr == dxl )
r.ldi = l.ldi, r.ldf = l.ldf, r.xf = l.xf;
else
{ compute_ldx(r);
}
#undef compute_ldx
while ( ++iy != iy1 )
{ int ixl, ixr;
#define step_line(tl)\
tl.x += tl.ldi;\
if ( (tl.xf += tl.ldf) >= 0 ) tl.xf -= fh, tl.x++;
step_line(l);
step_line(r);
#undef step_line
ixl = fixed2int_var(l.x);
ixr = fixed2int_var(r.x);
if ( ixl != rxl || ixr != rxr )
{ code = fill_trap_rect(rxl, ry, rxr - rxl, iy - ry);
if ( code < 0 ) goto xit;
rxl = ixl, rxr = ixr, ry = iy;
}
}
last: code = fill_trap_rect(rxl, ry, rxr - rxl, iy - ry);
xit: gp_check_interrupts();
if ( code < 0 && fill_direct ) return_error(code);
return code;
}
}
void implicit_2Dx(double *phi, double *xx, double *yy,
double nu1, double m12, double gamma1, double h1,
double dt, int L, int M, int use_delj_trick){
int ii, jj;
double *dx = malloc((L-1) * sizeof(*dx));
double *dfactor = malloc(L * sizeof(*dfactor));
double *xInt = malloc((L-1) * sizeof(*xInt));
double Mfirst, Mlast;
double *MInt = malloc((L-1) * sizeof(*MInt));
double *V = malloc(L * sizeof(*V));
double *VInt = malloc((L-1) * sizeof(*VInt));
double *delj = malloc((L-1) * sizeof(*delj));
double *a = malloc(L * sizeof(*a));
double *b = malloc(L * sizeof(*b));
double *c = malloc(L * sizeof(*c));
double *r = malloc(L * sizeof(*r));
double *temp = malloc(L * sizeof(*temp));
double y;
compute_dx(xx, L, dx);
compute_dfactor(dx, L, dfactor);
compute_xInt(xx, L, xInt);
for(ii=0; ii < L; ii++)
V[ii] = Vfunc(xx[ii], nu1);
for(ii=0; ii < L-1; ii++)
VInt[ii] = Vfunc(xInt[ii], nu1);
tridiag_malloc(L);
for(jj=0; jj < M; jj++){
y = yy[jj];
Mfirst = Mfunc2D(xx[0], y, m12, gamma1, h1);
Mlast = Mfunc2D(xx[L-1], y, m12, gamma1, h1);
for(ii=0; ii < L-1; ii++)
MInt[ii] = Mfunc2D(xInt[ii], y, m12, gamma1, h1);
compute_delj(dx, MInt, VInt, L, delj, use_delj_trick);
compute_abc_nobc(dx, dfactor, delj, MInt, V, dt, L, a, b, c);
for(ii = 0; ii < L; ii++)
r[ii] = phi[ii*M + jj]/dt;
if((jj==0) && (Mfirst <= 0))
b[0] += (0.5/nu1 - Mfirst)*2./dx[0];
if((jj==M-1) && (Mlast >= 0))
b[L-1] += -(-0.5/nu1 - Mlast)*2./dx[L-2];
tridiag_premalloc(a, b, c, r, temp, L);
for(ii = 0; ii < L; ii++)
phi[ii*M + jj] = temp[ii];
}
tridiag_free();
free(dx);
free(dfactor);
free(xInt);
free(MInt);
free(V);
free(VInt);
free(delj);
free(a);
free(b);
free(c);
free(r);
free(temp);
}
