OpenXM_contrib2/asir2000/plot/calc.c - diff

Return to calc.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / plot

Diff for /OpenXM_contrib2/asir2000/plot/calc.c between version 1.1 and 1.6

version 1.1, 1999/12/03 07:39:12

version 1.6, 2002/08/02 08:59:47

Line 1

/* $OpenXM: OpenXM/src/asir99/plot/calc.c,v 1.1.1.1 1999/11/10 08:12:34 noro Exp $ */

* FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,

* non-exclusive and royalty-free license to use, copy, modify and

* redistribute, solely for non-commercial and non-profit purposes, the

* computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and

* conditions of this Agreement. For the avoidance of doubt, you acquire

* only a limited right to use the SOFTWARE hereunder, and FLL or any

* third party developer retains all rights, including but not limited to

* copyrights, in and to the SOFTWARE.

* (1) FLL does not grant you a license in any way for commercial

* purposes. You may use the SOFTWARE only for non-commercial and

* non-profit purposes only, such as academic, research and internal

* business use.

* (2) The SOFTWARE is protected by the Copyright Law of Japan and

* international copyright treaties. If you make copies of the SOFTWARE,

* with or without modification, as permitted hereunder, you shall affix

* to all such copies of the SOFTWARE the above copyright notice.

* (3) An explicit reference to this SOFTWARE and its copyright owner

* shall be made on your publication or presentation in any form of the

* results obtained by use of the SOFTWARE.

* (4) In the event that you modify the SOFTWARE, you shall notify FLL by

* e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification

* for such modification or the source code of the modified part of the

* SOFTWARE.

* THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL

* MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND

* EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS

* FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'

* RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY

* MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.

* UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,

* OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY

* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL

* DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES

* ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES

* FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY

* DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF

* SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART

* OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY

* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/plot/calc.c,v 1.5 2001/10/09 01:36:27 noro Exp $

#include "ca.h"

#include "parse.h"

#include "ifplot.h"

#include <math.h>

#if PARI

#include "genpari.h"

#endif

double usubstrp(P,double);

#ifndef MAXSHORT

#define MAXSHORT ((short)0x7fff)

#endif

void calc(tab,can)

void calc(double **tab,struct canvas *can,int nox)

double **tab;

struct canvas *can;

{

double x,y,xmin,ymin,xstep,ystep;

int ix,iy;

Line 20 struct canvas *can;

Line 69 struct canvas *can;

V vx,vy;

Obj t,s;

initmarker(can,"Evaluating...");

if ( !nox ) initmarker(can,"Evaluating...");

MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);

vx = can->vx;

vy = can->vy;

Line 31 struct canvas *can;

Line 80 struct canvas *can;

for( ix = 0, x = xmin; ix < w ; ix++, x += xstep ) {

#if 0

MKReal(x,r); substp(CO,fr,vx,(P)r,&g);

marker(can,DIR_X,ix);

if ( !nox ) marker(can,DIR_X,ix);

for( iy = 0, y = ymin; iy < h ; iy++, y += ystep )

tab[ix][iy] = usubstrp(g,y);

#endif

BDY(rx) = x; substr(CO,0,fr,vx,x?(P)rx:0,&t); devalr(CO,t,&g);

BDY(rx) = x; substr(CO,0,fr,vx,x?(Obj)rx:0,&t);

marker(can,DIR_X,ix);

devalr(CO,t,&g);

if ( !nox ) marker(can,DIR_X,ix);

for( iy = 0, y = ymin; iy < h ; iy++, y += ystep ) {

BDY(ry) = y;

substr(CO,0,g,vy,y?(P)ry:0,&t); devalr(CO,t,&s);

substr(CO,0,g,vy,y?(Obj)ry:0,&t);

devalr(CO,t,&s);

tab[ix][iy] = ToReal(s);

}

double usubstrp(p,r)

double usubstrp(P p,double r)

P p;

double r;

{

double t;

DCP dc;

Line 70 double r;

Line 119 double r;

return t;

}

void qcalc(tab,can)

void qcalc(char **tab,struct canvas *can)

char **tab;

struct canvas *can;

{

Q dx,dy,w,h,xstep,ystep,c,q1,q2;

Q dx,dy,w,h,xstep,ystep,c,q1;

P g,g1,f1,f2,x,y,t,s;

DCP dc;

int ix,iy;

int *a,*pa;

char *px;

VECT ss;

Line 99 struct canvas *can;

Line 144 struct canvas *can;

for ( iy = 0; iy < can->height; iy++ )

tab[ix][iy] = 1;

else if ( !NUM(g1) ) {

strum(CO,g1,&ss); seproot(ss,0,can->height,a);

sturmseq(CO,g1,&ss); seproot(ss,0,can->height,a);

for ( iy = 0, pa = a; iy < can->height; iy++, pa++ )

if ( *pa < 0 || (*(pa+1) >= 0 && (*pa > *(pa+1))) )

tab[ix][iy] = 1;

Line 113 struct canvas *can;

Line 158 struct canvas *can;

for ( ix = 0; ix < can->width; ix++ )

tab[ix][iy] = 1;

else if ( !NUM(g1) ) {

strum(CO,g1,&ss); seproot(ss,0,can->width,a);

sturmseq(CO,g1,&ss); seproot(ss,0,can->width,a);

for ( ix = 0, pa = a; ix < can->width; ix++, pa++ )

if ( *pa < 0 || (*(pa+1) >= 0 && (*pa > *(pa+1))) )

tab[ix][iy] = 1;

Line 121 struct canvas *can;

Line 166 struct canvas *can;

}

strum(vl,p,rp)

void sturmseq(VL vl,P p,VECT *rp)

VL vl;

P p;

VECT *rp;

{

P g1,g2,q,r,s;

P *t;

Line 165 VECT *rp;

Line 207 VECT *rp;

*rp = ret;

}

seproot(s,min,max,ar)

void seproot(VECT s,int min,int max,int *ar)

VECT s;

int min,max;

int *ar;

{

P f;

P *ss;

Line 208 int *ar;

Line 247 int *ar;

seproot(s,k,j,ar);

}

numch(s,n,a0)

int numch(VECT s,Q n,Q a0)

VECT s;

Q n,a0;

{

int len,i,c;

Q a;

Line 228 Q n,a0;

Line 265 Q n,a0;

return c;

}

usubstqp(p,r,v)

void usubstqp(P p,Q r,Q *v)

P p;

Q r;

Q *v;

{

Q d,d1,a,b,t;

DCP dc;

Line 254 Q *v;

Line 288 Q *v;

}

void plotcalc(can)

void plotcalc(struct canvas *can)

struct canvas *can;

{

double x,xmin,xstep,ymax,ymin,dy;

int ix;

Line 276 struct canvas *can;

Line 309 struct canvas *can;

for( ix = 0, x = xmin; ix < w ; ix++, x += xstep ) {

/* full substitution */

BDY(rx) = x;

substr(CO,0,fr,can->vx,x?(P)rx:0,&s); devalr(CO,(Obj)s,&t);

substr(CO,0,fr,can->vx,x?(Obj)rx:0,&s);

devalr(CO,(Obj)s,&t);

if ( t && (OID(t)!=O_N || NID((Num)t)!=N_R) )

error("plotcalc : invalid evaluation");

tab[ix] = ToReal((Num)t);

Line 300 struct canvas *can;

Line 334 struct canvas *can;

can->pa[0].length = w;

can->pa[0].pos = pa = (POINT *)MALLOC(w*sizeof(POINT));

for ( ix = 0; ix < w; ix++ ) {

#ifndef MAXSHORT

#define MAXSHORT ((short)0x7fff)

#endif

double t;

XC(pa[ix]) = ix;

Line 312 struct canvas *can;

Line 343 struct canvas *can;

else if ( t < -MAXSHORT )

YC(pa[ix]) = -MAXSHORT;

else

YC(pa[ix]) = t;

YC(pa[ix]) = (long)t;

}

void polarplotcalc(struct canvas *can)

{

double xmax,xmin,ymax,ymin,dx,dy,pmin,pstep;

int i,nstep;

double usubstrp();

int w,h;

double tr,p;

double *tabx,*taby;

POINT *pa;

Real r;

Obj fr,t,s;

MKReal(1.0,r); mulr(CO,(Obj)can->formula,(Obj)r,&fr);

w = can->width; h = can->height; nstep = can->nzstep;

pmin = can->zmin; pstep = (can->zmax-can->zmin)/nstep;

tabx = (double *)ALLOCA(nstep*sizeof(double));

taby = (double *)ALLOCA(nstep*sizeof(double));

MKReal(1,r); /* dummy real number */

for( i = 0, p = pmin; i < nstep ; i++, p += pstep ) {

/* full substitution */

BDY(r) = p;

substr(CO,0,fr,can->vx,p?(Obj)r:0,&s);

devalr(CO,(Obj)s,&t);

if ( t && (OID(t)!=O_N || NID((Num)t)!=N_R) )

error("polarplotcalc : invalid evaluation");

tr = ToReal((Num)t);

tabx[i] = tr*cos(p);

taby[i] = tr*sin(p);

}

xmax = xmin = tabx[0];

ymax = ymin = taby[0];

for ( i = 1; i < nstep; i++ ) {

if ( tabx[i] > xmax ) xmax = tabx[i];

if ( tabx[i] < xmin ) xmin = tabx[i];

if ( taby[i] > ymax ) ymax = taby[i];

if ( taby[i] < ymin ) ymin = taby[i];

}

can->xmax = xmax; can->xmin = xmin;

can->ymax = ymax; can->ymin = ymin;

dx = xmax-xmin;

dy = ymax-ymin;

can->pa = (struct pa *)MALLOC(sizeof(struct pa));

can->pa[0].length = nstep;

can->pa[0].pos = pa = (POINT *)MALLOC(w*sizeof(POINT));

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

XC(pa[i]) = (w-1)*(tabx[i]-xmin)/dx;

YC(pa[i]) = (h-1)*(ymax-taby[i])/dy;

}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>