void dd (header *hd)
{ header *st=hd,*hd1,*result;
int c1,c2,i,j,r;
double *m1,*m2,*mr;
complex *mc1,*mc2,*mcr,hc1,hc2;
interval *mi1,*mi2,*mir,hi1,hi2;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if (c1!=c2) wrong_arg();
if (iscomplex(hd)) /* complex values */
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c1,""); if (error) return;
mcr=(complex *)matrixof(result);
memmove((char *)mcr,(char *)mc2,c1*sizeof(complex));
for (i=1; i<c1; i++)
{ for (j=c1-1; j>=i; j--)
{ if (mc1[j][0]==mc1[j-i][0] &&
mc1[j][1]==mc1[j-i][1]) wrong_arg();
c_sub(mcr[j],mcr[j-1],hc1);
c_sub(mc1[j],mc1[j-i],hc2);
c_div(hc1,hc2,mcr[j]);
}
}
}
else if (isinterval(hd)) /* complex values */
{ mi1=(complex *)m1; mi2=(complex *)m2;
result=new_imatrix(1,c1,""); if (error) return;
mir=(interval *)matrixof(result);
memmove((char *)mir,(char *)mi2,c1*sizeof(interval));
for (i=1; i<c1; i++)
{ for (j=c1-1; j>=i; j--)
{ i_sub(mir[j],mir[j-1],hi1);
if (hi1[0]<=0 && hi1[1]>=0)
{ output("Interval points coincide\n");
error=1; return;
}
i_sub(mi1[j],mi1[j-i],hi2);
i_div(hi1,hi2,mir[j]);
}
}
}
else if (isreal(hd))
{ result=new_matrix(1,c1,""); if (error) return;
mr=matrixof(result);
memmove((char *)mr,(char *)m2,c1*sizeof(double));
for (i=1; i<c1; i++)
{ for (j=c1-1; j>=i; j--)
{ if (m1[j]==m1[j-i]) wrong_arg();
mr[j]=(mr[j]-mr[j-1])/(m1[j]-m1[j-i]);
}
}
}
else wrong_arg();
moveresult(st,result);
}
void polymult (header *hd)
{ header *st=hd,*hd1,*result;
int c,c1,c2,i,r,j,k;
double *m1,*m2,*mr,x;
complex *mc1,*mc2,*mcr,xc,hc;
interval *mi1,*mi2,*mir,xi,hi;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if ((LONG)c1+c2-1>INT_MAX) wrong_arg();
c=c1+c2-1;
if (iscomplex(hd))
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c,""); if (error) return;
mcr=(complex *)matrixof(result);
c_copy(xc,*mc1); mc1++;
for (i=0; i<c2; i++) c_mult(xc,mc2[i],mcr[i]);
for (j=1; j<c1; j++)
{ c_copy(xc,*mc1); mc1++;
for (k=j,i=0; i<c2-1; i++,k++)
{ c_mult(xc,mc2[i],hc);
c_add(hc,mcr[k],mcr[k]);
}
c_mult(xc,mc2[i],mcr[k]);
}
}
else if (isinterval(hd))
{ mi1=(interval *)m1; mi2=(interval *)m2;
result=new_imatrix(1,c,""); if (error) return;
mir=(interval *)matrixof(result);
i_copy(xi,*mi1); mi1++;
for (i=0; i<c2; i++) i_mult(xi,mi2[i],mir[i]);
for (j=1; j<c1; j++)
{ i_copy(xi,*mi1); mi1++;
for (k=j,i=0; i<c2-1; i++,k++)
{ i_mult(xi,mi2[i],hi);
c_add(hi,mir[k],mir[k]);
}
c_mult(xi,mi2[i],mir[k]);
}
}
else if (isreal(hd))
{ result=new_matrix(1,c,""); if (error) return;
mr=matrixof(result);
x=*m1++;
for (i=0; i<c2; i++) mr[i]=x*m2[i];
for (j=1; j<c1; j++)
{ x=*m1++;
for (k=j,i=0; i<c2-1; i++,k++) mr[k]+=x*m2[i];
mr[k]=x*m2[i];
}
}
else wrong_arg();
moveresult(st,result);
}
void ddval (header *hd)
{ header *st=hd,*hdd,*hd1,*result;
int r,c,cd;
hdd=nextof(st);
hd1=nextof(hdd);
equal_params_3(&hd,&hdd,&hd1); if (error) return;
getmatrix(hd,&r,&c,&divx); if (r!=1 || c<1) wrong_arg();
getmatrix(hdd,&r,&cd,&divdif); if (r!=1 || c!=cd) wrong_arg();
degree=c-1;
if (isinterval(hd)) result=map1i(iddeval,hd1);
else result=map1(rddeval,cddeval,hd1);
if (error) return;
moveresult(st,result);
}
void mzeros1 (header *hd)
{ header *st=hd,*hd1,*result;
int r,c;
double *m,xr,xi;
hd1=nextof(hd);
hd=getvalue(hd); if (error) return;
if (hd->type==s_matrix)
{ make_complex(st); if (error) return;
hd=getvalue(st); if (error) return;
}
hd1=getvalue(hd1); if (error) return;
if (hd1->type==s_real)
{ xr=*realof(hd1); xi=0;
}
else if (hd1->type==s_complex)
{ xr=*realof(hd1); xi=*(realof(hd1)+1);
}
else
{ output("Need a starting value!\n"); error=300; return; }
if (hd->type!=s_cmatrix || dimsof(hd)->r!=1 || dimsof(hd)->c<2)
{ output("Need a complex polynomial\n"); error=300; return; }
getmatrix(hd,&r,&c,&m);
result=new_complex(0,0,""); if (error) return;
bauhuber(m,c-1,realof(result),0,xr,xi);
moveresult(st,result);
}
int main()
{
int used[12], i, j, res, m, n;
char te[12];
//while( scanf("%d%d\n", &m, &n)!=EOF )
// {
scanf("%d%d\n", &m, &n);
for(i=0; i<m; i++) scanf("%s",&geo[i]);
for(i=0; i<m; i++) used[i] = 0;
for(i=0; i<m; i++) for(j=i+1; j<m; j++)
{
if( in(i, j) ) used[j] = 1;
if( in(j, i) ) used[i] = 1;
}
memset(trie, 0, sizeof(trie));
memset(str, 0, sizeof(str));
for(tr_n=ma_n=i=0; i<m; i++)
if( !used[i] ) add( 0, geo[i] );
memset(matrix, 0, sizeof(matrix));
getmatrix();
multi(n);
res = 0;
for(i=0; i<=ma_n; i++) res=(res+tt[0][i])%MOD;
printf("%d\n", res);
//}
return 0;
}
void MaxStep1(FILE *in, int row, int column)
{
int i,multtem=0,mult=0;
long long tempsub,maxsub;
if(getmatrix(in,row,column)==0)
return ;
tempsub=0;
maxsub=matrix[0][0];
for(i=0;i<column;i++)
{
if(multtem>0||tempsub+matrix[0][i]>matrix[0][i])
tempsub=tempsub+matrix[0][i];
else
tempsub=matrix[0][i];
if(tempsub>Max)
{
tempsub-=Max;
multtem++;
}
if(tempsub<Min)
{
tempsub+=Max;
multtem--;
}
if(multtem>mult||tempsub>maxsub)
{
maxsub=tempsub;
mult=multtem;
}
}
printf("Step1--Multiplier:%d Remainder:%lld\n",mult,maxsub);
}
void polyadd (header *hd)
{ header *st=hd,*hd1,*result;
int c,c1,c2,i,r;
double *m1,*m2,*mr;
complex *mc1,*mc2,*mcr;
interval *mi1,*mi2,*mir;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
c=max(c1,c2);
if (iscomplex(hd)) /* complex values */
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c,""); if (error) return;
mcr=(complex *)matrixof(result);
for (i=0; i<c; i++)
{ if (i>=c1) { c_copy(*mcr,*mc2); mcr++; mc2++; }
else if (i>=c2) { c_copy(*mcr,*mc1); mcr++; mc1++; }
else { c_add(*mc1,*mc2,*mcr); mc1++; mc2++; mcr++; }
}
}
else if (isinterval(hd))
{ mi1=(interval *)m1; mi2=(interval *)m2;
result=new_imatrix(1,c,""); if (error) return;
mir=(interval *)matrixof(result);
for (i=0; i<c; i++)
{ if (i>=c1) { i_copy(*mir,*mi2); mir++; mi2++; }
else if (i>=c2) { i_copy(*mir,*mi1); mir++; mi1++; }
else { i_add(*mi1,*mi2,*mir); mi1++; mi2++; mir++; }
}
}
else if (isreal(hd))
{ result=new_matrix(1,c,""); if (error) return;
mr=matrixof(result);
for (i=0; i<c; i++)
{ if (i>=c1) { *mr++ = *m2++; }
else if (i>=c2) { *mr++ = *m1++; }
else { *mr++ = *m1++ + *m2++; }
}
}
else wrong_arg();
moveresult(st,result);
}
int main()
{
int m,n;
int a[20][20],b[20][20],c[20][20];
printf("Enter the number of rows for the first matrix");
scanf("%d",&m);
printf("Enter the number of columns for the first matrix");
scanf("%d",&n);
int p,q;
printf("Enter the number of rows for the second matrix");
scanf("%d",&p);
printf("Enter the number of columns for the second matrix");
scanf("%d",&q);
getmatrix(m,n,a);
getmatrix(p,q,b);
multiply(m,n,a,p,q,b,c);
showmatrix(m,n,c);
return 0;
}
static fz_matrix getmatrix(fz_node *node)
{
if (node->parent)
{
fz_matrix ptm = getmatrix(node->parent);
if (fz_istransformnode(node))
return fz_concat(((fz_transformnode*)node)->m, ptm);
return ptm;
}
if (fz_istransformnode(node))
return ((fz_transformnode*)node)->m;
return fz_identity();
}
void polyval (header *hd)
{ header *st=hd,*hd1,*result;
int r,c;
hd1=nextof(hd);
equal_params_2(&hd,&hd1);
getmatrix(hd,&r,&c,&polynom);
if (r!=1) wrong_arg();
degree=c-1;
if (degree<0) wrong_arg();
if (isinterval(hd)) result=map1i(ipeval,hd1);
else result=map1(peval,cpeval,hd1);
moveresult(st,result);
}
void polyzeros (header *hd)
{ header *st=hd,*result;
int i,j,r,c;
double *m,*mr,x;
complex *mc,*mcr,xc,hc;
hd=getvalue(hd); if (error) return;
if (hd->type==s_real || hd->type==s_matrix)
{ getmatrix(hd,&r,&c,&m);
if (r!=1) wrong_arg();
result=new_matrix(1,c+1,""); if (error) return;
mr=matrixof(result);
mr[0]=-m[0]; mr[1]=1.0;
for (i=1; i<c; i++)
{ x=-m[i]; mr[i+1]=1.0;
for (j=i; j>=1; j--) mr[j]=mr[j-1]+x*mr[j];
mr[0]*=x;
}
}
else if (hd->type==s_complex || hd->type==s_cmatrix)
{ getmatrix(hd,&r,&c,&m); mc=(complex *)m;
if (r!=1) wrong_arg();
result=new_cmatrix(1,c+1,""); if (error) return;
mcr=(complex *)matrixof(result);
mcr[0][0]=-mc[0][0]; mcr[0][1]=-mc[0][1];
mcr[1][0]=1.0; mcr[1][1]=0.0;
for (i=1; i<c; i++)
{ xc[0]=-mc[i][0]; xc[1]=-mc[i][1];
mcr[i+1][0]=1.0; mcr[i+1][1]=0.0;
for (j=i; j>=1; j--)
{ c_mult(xc,mcr[j],hc);
c_add(hc,mcr[j-1],mcr[j]);
}
c_mult(xc,mcr[0],mcr[0]);
}
}
else wrong_arg();
moveresult(st,result);
}
void polydd (header *hd)
{ header *st=hd,*hd1,*result;
int c1,c2,i,j,r;
double *m1,*m2,*mr,x;
complex *mc1,*mc2,*mcr,hc,xc;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if (c1!=c2) wrong_arg();
if (iscomplex(hd)) /* complex values */
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c1,""); if (error) return;
mcr=(complex *)matrixof(result);
c_copy(mcr[c1-1],mc2[c1-1]);
for (i=c1-2; i>=0; i--)
{ c_copy(xc,mc1[i]);
c_mult(xc,mcr[i+1],hc);
c_sub(mc2[i],hc,mcr[i]);
for (j=i+1; j<c1-1; j++)
{ c_mult(xc,mcr[j+1],hc);
c_sub(mcr[j],hc,mcr[j]);
}
}
}
else
{ result=new_matrix(1,c1,""); if (error) return;
mr=matrixof(result);
mr[c1-1]=m2[c1-1];
for (i=c1-2; i>=0; i--)
{ x=m1[i];
mr[i]=m2[i]-x*mr[i+1];
for (j=i+1; j<c1-1; j++) mr[j]=mr[j]-x*mr[j+1];
}
}
moveresult(st,result);
}
void mzeros (header *hd)
{ header *st=hd,*result;
int r,c;
double *m;
hd=getvalue(hd); if (error) return;
if (hd->type==s_matrix)
{ make_complex(st); if (error) return;
hd=getvalue(st); if (error) return;
}
if (hd->type!=s_cmatrix || dimsof(hd)->r!=1 || dimsof(hd)->c<2)
{ output("Need a complex polynomial\n"); error=300; return; }
getmatrix(hd,&r,&c,&m);
result=new_cmatrix(1,c-1,""); if (error) return;
bauhuber(m,c-1,matrixof(result),1,0,0);
moveresult(st,result);
}
void out_matrix (header *hd)
/***** out_matrix
print a matrix.
*****/
{ int c,r,i,j,c0,cend;
double *m,*x;
getmatrix(hd,&r,&c,&m);
for (c0=0; c0<c; c0+=linew)
{ cend=c0+linew-1;
if (cend>=c) cend=c-1;
if (c>linew) output2("Column %d to %d:\n",c0+1,cend+1);
for (i=0; i<r; i++)
{ x=mat(m,c,i,c0);
for (j=c0; j<=cend; j++) double_out(*x++);
output("\n");
if (test_key()==escape) return;
}
}
}
void out_imatrix (header *hd)
/***** out_matrix
print a complex matrix.
*****/
{ int c,r,i,j,c0,cend;
double *m,*x;
getmatrix(hd,&r,&c,&m);
for (c0=0; c0<c; c0+=ilinew)
{ cend=c0+ilinew-1;
if (cend>=c) cend=c-1;
if (c>ilinew) output2("Column %d to %d:\n",c0+1,cend+1);
for (i=0; i<r; i++)
{ x=imat(m,c,i,c0);
for (j=c0; j<=cend; j++) { interval_out(*x,*(x+1));
x+=2; }
output("\n");
if (test_key()==escape) return;
}
}
}
void mputulongword (header *hd)
{ header *st=hd,*result;
int n,i;
unsigned long *p,*start=(unsigned long *)newram;
double *m;
hd=getvalue(hd); if (error) return;
if (hd->type!=s_real && hd->type!=s_matrix)
wrong_arg_in("putchar(v)");
getmatrix(hd,&i,&n,&m);
if (i!=1 || n<1) wrong_arg_in("putchar(v)");
if (fa)
{ if (!freeramfrom(start,n*sizeof(unsigned long)))
{ output("Stack overflow in getchar(n).");
error=1; return;
}
for (p=start,i=0; i<n; i++) *p++=(unsigned long)*m++;
fwrite(start,sizeof(unsigned long),n,fa);
}
result=new_real(ferror(fa),""); if (error) return;
moveresult(st,result);
}
static fz_error *
addshadeshape(pdf_gstate *gs, fz_node *shape, fz_shade *shade)
{
fz_error *error;
fz_node *mask;
fz_node *color;
fz_node *xform;
fz_node *over;
fz_node *bgnd;
fz_matrix ctm;
fz_matrix inv;
ctm = getmatrix(gs->head);
inv = fz_invertmatrix(ctm);
error = fz_newtransformnode(&xform, inv);
if (error)
return fz_rethrow(error, "cannot create transform node");
error = fz_newmasknode(&mask);
if (error)
{
fz_dropnode(xform);
return fz_rethrow(error, "cannot create mask node");
}
error = fz_newshadenode(&color, shade);
if (error)
{
fz_dropnode(mask);
fz_dropnode(xform);
return fz_rethrow(error, "cannot create shade node");
}
if (shade->usebackground)
{
error = pdf_newovernode(&over, gs);
if (error)
{
fz_dropnode(color);
fz_dropnode(mask);
fz_dropnode(xform);
return fz_rethrow(error, "cannot create over node for background color");
}
error = fz_newsolidnode(&bgnd, 1.0f, shade->cs, shade->cs->n, shade->background);
if (error)
{
fz_dropnode(over);
fz_dropnode(color);
fz_dropnode(mask);
fz_dropnode(xform);
return fz_rethrow(error, "cannot create solid node for background color");;
}
fz_insertnodelast(mask, shape);
fz_insertnodelast(over, bgnd);
fz_insertnodelast(over, color);
fz_insertnodelast(xform, over);
fz_insertnodelast(mask, xform);
fz_insertnodelast(gs->head, mask);
}
else
{
fz_insertnodelast(mask, shape);
fz_insertnodelast(xform, color);
fz_insertnodelast(mask, xform);
fz_insertnodelast(gs->head, mask);
}
return fz_okay;
}
/*
* Draw a volumetric rendering of the grid for timestep it and variable ip.
* Input: it - timestep
* ip - variable
*/
void draw_volume( Context ctx, int it, int ip, unsigned int *ctable )
{
float *data;
static int prev_it[VIS5D_MAX_CONTEXTS];
static int prev_ip[VIS5D_MAX_CONTEXTS];
static int do_once = 1;
int dir;
float x, y, z, ax, ay, az;
MATRIX ctm, proj;
Display_Context dtx;
dtx = ctx->dpy_ctx;
if (do_once){
int yo;
for (yo=0; yo<VIS5D_MAX_CONTEXTS; yo++){
prev_it[yo] = -1;
prev_ip[yo] = -1;
}
do_once = 0;
}
/* Get 3rd column values from transformation matrix */
#if defined (HAVE_SGI_GL) || defined (DENALI)
/* Compute orientation of 3-D box with respect to current matrices */
/* with no assumptions about the location of the camera. This was */
/* done for the CAVE. */
mmode( MPROJECTION );
getmatrix( proj );
mmode( MVIEWING );
getmatrix( ctm );
#endif
#if defined(HAVE_OPENGL)
glGetFloatv( GL_PROJECTION_MATRIX, (GLfloat *) proj );
glGetFloatv( GL_MODELVIEW_MATRIX, (GLfloat *) ctm );
check_gl_error( "draw_volume" );
#endif
/* compute third column values in the product of ctm*proj */
x = ctm[0][0]*proj[0][2] + ctm[0][1]*proj[1][2]
+ ctm[0][2]*proj[2][2] + ctm[0][3]*proj[3][2];
y = ctm[1][0]*proj[0][2] + ctm[1][1]*proj[1][2]
+ ctm[1][2]*proj[2][2] + ctm[1][3]*proj[3][2];
z = ctm[2][0]*proj[0][2] + ctm[2][1]*proj[1][2]
+ ctm[2][2]*proj[2][2] + ctm[2][3]*proj[3][2];
/* examine values to determine how to draw slices */
ax = ABS(x);
ay = ABS(y);
az = ABS(z);
if (ax>=ay && ax>=az) {
/* draw x-axis slices */
dir = (x<0.0) ? WEST_TO_EAST : EAST_TO_WEST;
}
else if (ay>=ax && ay>=az) {
/* draw y-axis slices */
dir = (y<0.0) ? SOUTH_TO_NORTH : NORTH_TO_SOUTH;
}
else {
/* draw z-axis slices */
dir = (z<0.0) ? BOTTOM_TO_TOP : TOP_TO_BOTTOM;
}
/* If this is a new time step or variable then invalidate old volumes */
if (it!=prev_it[ctx->context_index] || ip!=prev_ip[ctx->context_index]) {
ctx->Volume->valid = 0;
prev_it[ctx->context_index] = it;
prev_ip[ctx->context_index] = ip;
}
/* Determine if we have to compute a set of slices for the direction. */
if (ctx->Volume->dir!=dir || ctx->Volume->valid==0) {
data = get_grid( ctx, it, ip );
if (data) {
if (ctx->GridSameAsGridPRIME){
compute_volume( ctx, data, it, ip, ctx->Nr, ctx->Nc, ctx->Nl[ip],
ctx->Variable[ip]->LowLev, ctx->Variable[ip]->MinVal, ctx->Variable[ip]->MaxVal,
dir, ctx->Volume );
}
else{
compute_volumePRIME( ctx, data, it, ip, dtx->Nr, dtx->Nc, dtx->Nl,
dtx->LowLev, ctx->Variable[ip]->MinVal, ctx->Variable[ip]->MaxVal,
dir, ctx->Volume );
}
release_grid( ctx, it, ip, data );
}
}
render_volume( ctx, ctx->Volume, ctable );
}
static fz_error *
addpatternshape(pdf_gstate *gs, fz_node *shape,
pdf_pattern *pat, fz_colorspace *cs, float *v)
{
fz_error *error;
fz_node *xform;
fz_node *over;
fz_node *mask;
fz_node *link;
fz_matrix ctm;
fz_matrix inv;
fz_matrix ptm;
fz_rect bbox;
int x, y, x0, y0, x1, y1;
/* patterns are painted in user space */
ctm = getmatrix(gs->head);
inv = fz_invertmatrix(ctm);
error = fz_newmasknode(&mask);
if (error)
return fz_rethrow(error, "cannot create mask node");
ptm = fz_concat(pat->matrix, fz_invertmatrix(ctm));
error = fz_newtransformnode(&xform, ptm);
if (error)
{
fz_dropnode(mask);
return fz_rethrow(error, "cannot create transform node");
}
error = pdf_newovernode(&over, gs);
if (error)
{
fz_dropnode(xform);
fz_dropnode(mask);
return fz_rethrow(error, "cannot create over node");
}
fz_insertnodelast(mask, shape);
fz_insertnodelast(mask, xform);
fz_insertnodelast(xform, over);
xform = nil;
/* over, xform, mask are now owned by the tree */
/* get bbox of shape in pattern space for stamping */
ptm = fz_concat(ctm, fz_invertmatrix(pat->matrix));
bbox = fz_boundnode(shape, ptm);
/* expand bbox by pattern bbox */
bbox.x0 += pat->bbox.x0;
bbox.y0 += pat->bbox.y0;
bbox.x1 += pat->bbox.x1;
bbox.y1 += pat->bbox.y1;
x0 = fz_floor(bbox.x0 / pat->xstep);
y0 = fz_floor(bbox.y0 / pat->ystep);
x1 = fz_ceil(bbox.x1 / pat->xstep);
y1 = fz_ceil(bbox.y1 / pat->ystep);
for (y = y0; y <= y1; y++)
{
for (x = x0; x <= x1; x++)
{
ptm = fz_translate(x * pat->xstep, y * pat->ystep);
error = fz_newtransformnode(&xform, ptm);
if (error)
return fz_rethrow(error, "cannot create transform node for stamp");
error = fz_newlinknode(&link, pat->tree);
if (error)
{
fz_dropnode(xform);
return fz_rethrow(error, "cannot create link node for stamp");
}
fz_insertnodelast(xform, link);
fz_insertnodelast(over, xform);
}
}
if (pat->ismask)
{
error = addcolorshape(gs, mask, 1.0, cs, v);
if (error)
return fz_rethrow(error, "cannot add colored shape");
return fz_okay;
}
fz_insertnodelast(gs->head, mask);
return fz_okay;
}
void polydiv (header *hd)
{ header *st=hd,*hd1,*result,*rest;
int c1,c2,i,r,j;
double *m1,*m2,*mr,*mh,x,l;
complex *mc1,*mc2,*mcr,*mch,xc,lc,hc;
interval *mi1,*mi2,*mir,*mih,xi,li,hi;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if (c1<c2)
{ result=new_real(0.0,"");
rest=(header *)newram;
moveresult(rest,hd1);
}
else if (iscomplex(hd))
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c1-c2+1,""); if (error) return;
mcr=(complex *)matrixof(result);
rest=new_cmatrix(1,c2,""); if (error) return;
mch=(complex *)newram;
if (!freeram(c1*sizeof(complex)))
{ output("Out of memory!\n"); error=190; return;
}
memmove((char *)mch,(char *)mc1,c1*sizeof(complex));
c_copy(lc,mc2[c2-1]);
if (lc[0]==0.0 && lc[1]==0.0) wrong_arg();
for (i=c1-c2; i>=0; i--)
{ c_div(mch[c2+i-1],lc,xc); c_copy(mcr[i],xc);
for(j=0; j<c2; j++)
{ c_mult(mc2[j],xc,hc);
c_sub(mch[i+j],hc,mch[i+j]);
}
}
memmove((char *)matrixof(rest),(char *)mch,c2*sizeof(complex));
}
else if (isinterval(hd))
{ mi1=(interval *)m1; mi2=(interval *)m2;
result=new_imatrix(1,c1-c2+1,""); if (error) return;
mir=(interval *)matrixof(result);
rest=new_imatrix(1,c2,""); if (error) return;
mih=(complex *)newram;
if (!freeram(c1*sizeof(complex)))
{ output("Out of memory!\n"); error=190; return;
}
memmove((char *)mih,(char *)mi1,c1*sizeof(interval));
i_copy(li,mi2[c2-1]);
if (li[0]<=0.0 && li[1]>=0.0) wrong_arg();
for (i=c1-c2; i>=0; i--)
{ i_div(mih[c2+i-1],li,xi); c_copy(mir[i],xi);
for(j=0; j<c2; j++)
{ i_mult(mi2[j],xi,hi);
i_sub(mih[i+j],hi,mih[i+j]);
}
}
memmove((char *)matrixof(rest),(char *)mih,c2*sizeof(interval));
}
else if (isreal(hd))
{ result=new_matrix(1,c1-c2+1,""); if (error) return;
mr=matrixof(result);
rest=new_matrix(1,c2,""); if (error) return;
mh=(double *)newram;
if (!freeram(c1*sizeof(double)))
{ output("Out of memory!\n"); error=190; return;
}
memmove((char *)mh,(char *)m1,c1*sizeof(double));
l=m2[c2-1];
if (l==0.0) wrong_arg();
for (i=c1-c2; i>=0; i--)
{ x=mh[c2+i-1]/l; mr[i]=x;
for(j=0; j<c2; j++) mh[i+j]-=m2[j]*x;
}
memmove((char *)matrixof(rest),(char *)mh,c2*sizeof(double));
}
else wrong_arg();
moveresult(st,result);
moveresult(nextof(st),rest);
}