Annotation of OpenXM_contrib2/asir2018/plot/plotf.c, Revision 1.3
1.1 noro 1: /*
2: * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
3: * All rights reserved.
4: *
5: * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
6: * non-exclusive and royalty-free license to use, copy, modify and
7: * redistribute, solely for non-commercial and non-profit purposes, the
8: * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
9: * conditions of this Agreement. For the avoidance of doubt, you acquire
10: * only a limited right to use the SOFTWARE hereunder, and FLL or any
11: * third party developer retains all rights, including but not limited to
12: * copyrights, in and to the SOFTWARE.
13: *
14: * (1) FLL does not grant you a license in any way for commercial
15: * purposes. You may use the SOFTWARE only for non-commercial and
16: * non-profit purposes only, such as academic, research and internal
17: * business use.
18: * (2) The SOFTWARE is protected by the Copyright Law of Japan and
19: * international copyright treaties. If you make copies of the SOFTWARE,
20: * with or without modification, as permitted hereunder, you shall affix
21: * to all such copies of the SOFTWARE the above copyright notice.
22: * (3) An explicit reference to this SOFTWARE and its copyright owner
23: * shall be made on your publication or presentation in any form of the
24: * results obtained by use of the SOFTWARE.
25: * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
26: * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
27: * for such modification or the source code of the modified part of the
28: * SOFTWARE.
29: *
30: * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
31: * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
32: * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
33: * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
34: * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
35: * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
36: * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
37: * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
38: * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
39: * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
40: * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
41: * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
42: * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
43: * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
44: * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
45: * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
46: * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
47: *
1.3 ! noro 48: * $OpenXM: OpenXM_contrib2/asir2018/plot/plotf.c,v 1.2 2018/09/28 08:20:29 noro Exp $
1.1 noro 49: */
50: #include "ca.h"
51: #include "parse.h"
52: #include "ox.h"
53: #include "ifplot.h"
54:
55: int validate_ox_plot_stream(int);
56: void ListCheck(char *,LIST);
57: void Pplot(NODE,Obj *);
58: void Ppolarplot(NODE,Z *);
59: void Pobj_cp(NODE,Obj *),Parrayplot(NODE,Obj*),Pdrawcircle(NODE,Obj*);
60: void Pifplot(NODE,Obj *),Pconplot(NODE,Obj *),Pplotover(NODE,Obj *);
61: void Pmemory_ifplot(NODE,Obj *),Pmemory_conplot(NODE,Obj *);
62: void Pmemory_plot(NODE,Obj *);
63: void ifplot_main(NODE,int,char *,Obj *);
64: void plot_main(NODE,int,char *,Obj *);
65: void conplot_main(NODE,int,Obj *);
66:
67: void Popen_canvas(NODE,Obj *),Pclear_canvas(NODE,Obj *),Pdraw_obj(NODE,Obj *);
68: void Pdraw_string(NODE,Obj *);
69: void Pox_rpc(NODE,Obj *), Pox_cmo_rpc(NODE,Obj *);
70:
71: //NG
72: #if defined(INTERVAL)
73: void Pitvifplot(NODE, Obj *);
74: #endif
75: void PifplotD(NODE,Obj *),PifplotQ(NODE,Obj *),PifplotB(NODE,Obj *);
76: void PineqnD(NODE,Obj *), PineqnQ(NODE,Obj *), PineqnB(NODE,Obj *);
77: void PineqnandD(NODE,Obj *), PineqnandQ(NODE,Obj *), PineqnandB(NODE,Obj *);
78: void PineqnorD(NODE,Obj *), PineqnorQ(NODE,Obj *), PineqnorB(NODE,Obj *);
79: void PineqnxorD(NODE,Obj *), PineqnxorQ(NODE,Obj *), PineqnxorB(NODE,Obj *);
80: void PconplotD(NODE,Obj *),PconplotQ(NODE,Obj *),PconplotB(NODE,Obj *);
81: void PpolarplotD(NODE,Obj *);
82: void PplotoverD(NODE,Obj *),PplotoverQ(NODE,Obj *),PplotoverB(NODE,Obj *);
83: void ifplot_mainNG(NODE,char *,Obj *);
84: void conplot_mainNG(NODE,char *,Obj *);
85: void plotover_mainNG(NODE,char *,Obj *);
86:
87: struct ftab plot_tab[]={
88: {PLOT,Pplot,-7},
89: #if defined(INTERVAL)
90: {ITVIFPLOT,Pitvifplot,-8},
91: #endif
92: {OBJ_CP,Pobj_cp,4},
93: {POLARPLOT,Ppolarplot,-6},
94: {POLARPLOTD,PpolarplotD,-7},
95: {IFPLOT,Pifplot,-7},
96: {IFPLOTD,PifplotD,-8},
97: {IFPLOTQ,PifplotQ,-8},
98: {IFPLOTB,PifplotB,-8},
99: {INEQN,PineqnD,-8},
100: {INEQND,PineqnD,-8},
101: {INEQNQ,PineqnQ,-8},
102: {INEQNB,PineqnB,-8},
103: {INEQNAND,PineqnandD,-4},
104: {INEQNDAND,PineqnandD,-4},
105: {INEQNQAND,PineqnandQ,-4},
106: {INEQNBAND,PineqnandB,-4},
107: {INEQNOR,PineqnorD,-4},
108: {INEQNDOR,PineqnorD,-4},
109: {INEQNQOR,PineqnorQ,-4},
110: {INEQNBOR,PineqnorB,-4},
111: {INEQNXOR,PineqnxorD,-4},
112: {INEQNDXOR,PineqnxorD,-4},
113: {INEQNQXOR,PineqnxorQ,-4},
114: {INEQNBXOR,PineqnxorB,-4},
115: {CONPLOT,Pconplot,-7},
116: {CONPLOTD,PconplotD,-8},
117: {CONPLOTB,PconplotB,-8},
118: {CONPLOTQ,PconplotQ,-8},
119: {PLOTOVER,Pplotover,-4},
120: {PLOTOVERD,PplotoverD,-4},
121: {PLOTOVERQ,PplotoverQ,-4},
122: {PLOTOVERB,PplotoverB,-4},
123: {MEMORY_IFPLOT,Pmemory_ifplot,-7},
124: {MEMORY_CONPLOT,Pmemory_conplot,-7},
125: {MEMORY_PLOT,Pmemory_plot,-7},
126: {DRAWCIRCLE,Pdrawcircle,6},
127: {OPEN_CANVAS,Popen_canvas,-3},
128: {CLEAR_CANVAS,Pclear_canvas,2},
129: {DRAW_OBJ,Pdraw_obj,-4},
130: {DRAW_STRING,Pdraw_string,-5},
131: {0,0,0},
132: };
133: char *pfn[]={
134: IFPLOT,CONPLOT,PLOT,INTERACTIVE,POLARPLOT,PLOTOVER,
135: IFPLOTD,IFPLOTQ,IFPLOTB,INEQND,INEQNQ,INEQNB,
136: INEQNDAND,INEQNQAND,INEQNBAND,
137: INEQNDOR,INEQNQOR,INEQNBOR,
138: INEQNDXOR,INEQNQXOR,INEQNBXOR,
139: CONPLOTD,CONPLOTQ,CONPLOTB,ITVIFPLOT,
140: PLOTOVERD,PLOTOVERQ,PLOTOVERB,
141: MEMORY_IFPLOT,MEMORY_CONPLOT,MEMORY_PLOT,ARRAYPLOT,OPEN_CANVAS,
142: DRAWCIRCLE,DRAW_OBJ,DRAW_STRING,OBJ_CP,CLEAR_CANVAS,POLARPLOTD};
143: /*
144: IFPLOT:0,CONPLOT:1,PLOT:2,INTERACTIVE:3,POLARPLOT:4,PLOTOVER:5,
145: IFPLOTD:6,IFPLOTQ:7,IFPLOTB:8,INEQND:9,INEQNQ:10,INEQNB:11,
146: INEQNDAND:12,INEQNQAND:13,INEQNBAND:14,
147: INEQNDOR:15,INEQNQOR:16,INEQNBOR:17,
148: INEQNDXOR:18,INEQNQXOR:19,INEQNBXOR:20,
149: CONPLOTD:21,CONPLOTQ:22,CONPLOTB:23,ITVIFPLOT:24,
150: PLOTOVERD:25,PLOTOVERQ:26,PLOTOVERB:27,
151: MEMORY_IFPLOT:28,MEMORY_CONPLOT:29,MEMORY_PLOT:30,ARRAYPLOT:31,
152: OPEN_CANVAS:32,DRAWCIRCLE:33,DRAW_OBJ:34,DRAW_STRING:35,OBJ_CP:36,
153: CLEAR_CANVAS:37,POLARPLOTD:38
154: */
155: int modeNO(char *fn){
156: int i;
157: char **z;
158: for(i=0,z=pfn;*z!=NULL;z++,i++)if(!strcmp(fn,*z))return i;
159: return -1;
160: }
161:
162: void Popen_canvas(NODE arg,Obj *rp){
163: Z w300,s_id;
164: LIST geom;
165: int stream;
166: NODE n,n0;
167: STRING fname,wname;
168:
169: geom=0;wname=0;stream=-1;
170: for(;arg;arg=NEXT(arg))
171: if(!BDY(arg)) stream=0;
172: else switch (OID(BDY(arg))){
173: case O_LIST:
174: geom=(LIST)BDY(arg);
175: break;
176: case O_N:
1.2 noro 177: stream=ZTOS((Q)BDY(arg));
1.1 noro 178: break;
179: case O_STR:
180: wname=(STRING)BDY(arg);
181: break;
182: default:
183: error("open_canvas : invalid argument");
184: break;
185: }
186: stream=validate_ox_plot_stream(stream);
1.2 noro 187: STOZ(stream,s_id);
1.1 noro 188: if(!geom){
1.2 noro 189: STOZ(300,w300);
1.1 noro 190: MKNODE(n0,w300,0);
191: MKNODE(n,w300,n0);
192: MKLIST(geom,n);
193: }
194: MKSTR(fname,OPEN_CANVAS);
195: arg=mknode(4,s_id,fname,geom,wname);
196: Pox_cmo_rpc(arg,rp);
197: *rp=(Obj)s_id;
198: }
199:
200: void Pifplot(NODE arg,Obj *rp){ifplot_main(arg,0,IFPLOT,rp);}
201: void Pmemory_ifplot(NODE arg,Obj *rp){ifplot_main(arg,1,IFPLOT,rp);}
202:
203: void ifplot_main(NODE arg,int is_memory,char *fn,Obj *rp){
204: Z m2,p2,w300,s_id;
205: NODE defrange;
206: LIST xrange,yrange,zrange,range[2],list,geom=0;
207: VL vl,vl0;
208: V v[2],av[2];
209: int stream,ri,i,sign;
210: Obj poly;
211: P var;
212: NODE n,n0;
213: STRING fname,wname;
214: Obj t;
215: int found_f;
216:
1.2 noro 217: STOZ(-2,m2);STOZ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
1.1 noro 218: poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;xrange=0;yrange=0;zrange=0;
219: v[0]=v[1]=0;
220: found_f = 0;
221: for(;arg;arg=NEXT(arg))
222: if(!BDY(arg)){
223: if ( !found_f ) {
224: poly = 0;
225: found_f = 1;
226: } else stream=0;
227: } else
228: switch(OID(BDY(arg))){
229: case O_P:
230: poly=(Obj)BDY(arg);
231: get_vars_recursive((Obj)poly,&vl);
232: for(vl0=vl,i=0;vl0;vl0=NEXT(vl0)){
233: if(vl0->v->attr==(pointer)V_IND){
234: if(i>=2)error("ifplot : invalid argument");
235: else v[i++]=vl0->v;
236: }
237: }
238: found_f = 1;
239: break;
240: case O_LIST:
241: list=(LIST)BDY(arg);
242: if(OID(BDY(BDY(list)))==O_P)
243: if(ri>1) error("ifplot : invalid argument");
244: else range[ri++]=list;
245: else if ( geom )
246: error("ifplot : Two geometries are specified. Probably a variable is missing.");
247: else
248: geom=list;
249: break;
250: case O_N:
251: if ( !found_f ) {
252: poly = (Obj)BDY(arg);
253: found_f = 1;
1.2 noro 254: } else stream=ZTOS((Q)BDY(arg));
1.1 noro 255: break;
256: case O_STR:
257: wname=(STRING)BDY(arg);break;
258: default:
259: error("ifplot : invalid argument");break;
260: }
261: if(!found_f) error("ifplot : invalid argument");
262: switch(ri){
263: case 0:
264: if(!v[1]) error("ifplot : please specify all variables");
265: MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
266: MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
267: break;
268: case 1:
269: if(!v[1]) error("ifplot : please specify all variables");
270: av[0]=VR((P)BDY(BDY(range[0])));
271: if(!poly || NUM(poly) || v[0]==av[0]){
272: xrange=range[0];
273: MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
274: } else if(v[1]==av[0]){
275: MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
276: yrange=range[0];
277: } else error("ifplot : invalid argument");
278: break;
279: case 2:
280: av[0]=VR((P)BDY(BDY(range[0])));
281: av[1]=VR((P)BDY(BDY(range[1])));
282: if(!poly || NUM(poly) || (((v[0]==av[0])&&(!v[1]||v[1]==av[1]))||
283: ((v[0]==av[1])&&(!v[1]||v[1]==av[0])))){
284: xrange=range[0];yrange=range[1];
285: } else error("ifplot : invalid argument");
286: break;
287: default:
288: error("ifplot : cannot happen");break;
289: }
290: /* ifplot in ox_plot requires
291: [s_id (Q),
292: formula (Obj),
293: xrange=[x,xmin,xmax] (LIST),
294: yrange=[y,ymin,ymax] (LIST),
295: zrange=0,
296: geom=[xsize,ysize] (LIST),
297: wname=name (STRING)]
298: */
299: stream=validate_ox_plot_stream(stream);
1.2 noro 300: STOZ(stream,s_id);
1.1 noro 301: if(!geom){
1.2 noro 302: STOZ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
1.1 noro 303: }
304: if(is_memory){
305: MKSTR(fname,MEMORY_PLOT);
306: arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom);
307: Pox_rpc(arg,&t);
308: arg=mknode(1,s_id);
309: Pox_pop_cmo(arg,rp);
310: } else {
311: MKSTR(fname,fn);
312: arg=mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
313: Pox_rpc(arg,&t);
314: *rp=(Obj)s_id;
315: }
316: }
317:
318: void Pconplot(NODE arg,Obj *rp){conplot_main(arg, 0, rp);}
319: void Pmemory_conplot(NODE arg,Obj *rp){conplot_main(arg,1,rp);}
320:
321: void conplot_main(NODE arg,int is_memory,Obj *rp){
322: Z m2,p2,w300,s_id;
323: NODE defrange;
324: LIST xrange,yrange,zrange,range[3],list,geom;
325: VL vl,vl0;
326: V v[2],av[2];
327: int stream,ri,i;
328: P poly;
329: P var;
330: NODE n,n0;
331: STRING fname,wname;
332: Obj t;
333:
1.2 noro 334: STOZ(-2,m2); STOZ(2,p2);
1.1 noro 335: MKNODE(n,p2,0); MKNODE(defrange,m2,n);
336: poly = 0; vl = 0; geom = 0; wname = 0; stream = -1; ri = 0;
337: v[0] = v[1] = 0;
338: for ( ; arg; arg = NEXT(arg) )
339: if ( !BDY(arg) )
340: stream = 0;
341: else
342: switch ( OID(BDY(arg)) ) {
343: case O_P:
344: poly = (P)BDY(arg);
345: get_vars_recursive((Obj)poly,&vl);
346: for ( vl0 = vl, i = 0; vl0; vl0 = NEXT(vl0) )
1.3 ! noro 347: if ( vl0->v->attr == (pointer)V_IND ) {
1.1 noro 348: if ( i >= 2 )
349: error("ifplot : invalid argument");
350: else
351: v[i++] = vl0->v;
1.3 ! noro 352: }
1.1 noro 353: break;
354: case O_LIST:
355: list = (LIST)BDY(arg);
356: if ( OID(BDY(BDY(list))) == O_P ) {
357: if ( ri > 2 )
358: error("ifplot : invalid argument");
359: else
360: range[ri++] = list;
361: } else if ( geom )
362: error("conplot : Two geometries are specified. Probably a variable is missing.");
363: else
364: geom = list;
365: break;
366: case O_N:
1.2 noro 367: stream = ZTOS((Q)BDY(arg)); break;
1.1 noro 368: case O_STR:
369: wname = (STRING)BDY(arg); break;
370: default:
371: error("ifplot : invalid argument"); break;
372: }
373: if ( !poly )
374: error("ifplot : invalid argument");
375: switch ( ri ) {
376: case 0:
377: if ( !v[1] )
378: error("ifplot : please specify all variables");
379: MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
380: MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
381: MKNODE(n,0,defrange); MKLIST(zrange,n);
382: break;
383: case 1:
384: if ( !v[1] )
385: error("ifplot : please specify all variables");
386: av[0] = VR((P)BDY(BDY(range[0])));
387: if ( v[0] == av[0] ) {
388: xrange = range[0];
389: MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
390: MKNODE(n,0,defrange); MKLIST(zrange,n);
391: } else if ( v[1] == av[0] ) {
392: MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
393: yrange = range[0];
394: MKNODE(n,0,defrange); MKLIST(zrange,n);
395: } else {
396: MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(xrange,n);
397: MKV(v[1],var); MKNODE(n,var,defrange); MKLIST(yrange,n);
398: zrange = range[0];
399: }
400: break;
401: case 2: case 3:
402: av[0] = VR((P)BDY(BDY(range[0])));
403: av[1] = VR((P)BDY(BDY(range[1])));
404: if ( ((v[0] == av[0]) && (!v[1] || v[1] == av[1])) ||
405: ((v[0] == av[1]) && (!v[1] || v[1] == av[0])) ) {
406: xrange = range[0]; yrange = range[1];
407: if ( ri == 3 )
408: zrange = range[2];
409: else {
410: MKNODE(n,0,defrange); MKLIST(zrange,n);
411: }
412: } else
413: error("ifplot : invalid argument");
414: break;
415: default:
416: error("ifplot : cannot happen"); break;
417: }
418: /* conplot in ox_plot requires
419: [s_id (Q),
420: formula (Obj),
421: xrange=[x,xmin,xmax] (LIST),
422: yrange=[y,ymin,ymax] (LIST),
423: zrange=[z,zmin,zmax] (LIST),
424: geom=[xsize,ysize] (LIST),
425: wname=name (STRING)]
426: */
427:
428: stream = validate_ox_plot_stream(stream);
1.2 noro 429: STOZ(stream,s_id);
1.1 noro 430: if ( !geom ) {
1.2 noro 431: STOZ(300,w300);
1.1 noro 432: MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);
433: }
434: if ( is_memory ) {
435: MKSTR(fname,"memory_plot");
436: arg = mknode(7,s_id,fname,poly,xrange,yrange,zrange,geom);
437: Pox_rpc(arg,&t);
438: arg = mknode(1,s_id);
439: Pox_pop_cmo(arg,rp);
440: } else {
441: MKSTR(fname,CONPLOT);
442: arg = mknode(8,s_id,fname,poly,xrange,yrange,zrange,geom,wname);
443: Pox_rpc(arg,&t);
444: *rp = (Obj)s_id;
445: }
446: }
447:
448: void Pplot(NODE arg,Obj *rp){plot_main(arg,0,PLOT,rp);}
449: void Pmemory_plot(NODE arg,Obj *rp){plot_main(arg,1,PLOT,rp);}
450:
451: int plot_by_bigfloat;
452:
453: void plot_main(NODE arg,int is_memory,char *fn,Obj *rp){
454: Z m2,p2,w300,s_id;
455: NODE defrange;
456: LIST xrange,range[1],list,geom;
457: VL vl,vl0;
458: V v[1],av[1];
459: int stream,ri,i,found_f;
460: Obj func;
461: P var;
462: NODE n,n0;
463: STRING fname,wname;
464: Obj t;
465: Z prec;
466:
1.2 noro 467: STOZ(-2,m2);STOZ(2,p2);
1.1 noro 468: MKNODE(n,p2,0);MKNODE(defrange,m2,n);
469: func=0;vl=0;geom=0;wname=0;stream=-1;ri=0;
470: v[0]=0;
471: found_f = 0;
472: for(;arg;arg=NEXT(arg) ) {
473: if(!BDY(arg) )
474: if ( !found_f ) {
475: makevar("x",&var);
476: v[0] = VR(var);
477: found_f = 1;
478: } else
479: stream=0;
480: else
481: switch ( OID(BDY(arg)) ){
482: case O_P: case O_R:
483: func = (Obj)BDY(arg);
484: get_vars_recursive(func,&vl);
485: for(vl0=vl, i=0;vl0;vl0=NEXT(vl0) ){
486: if(vl0->v->attr==(pointer)V_IND ){
487: if(i >= 1 ) error("plot : function must be univariate");
488: else v[i++]=vl0->v;
489: }
490: }
491: found_f = 1;
492: break;
493: case O_LIST:
494: list=(LIST)BDY(arg);
495: if(OID(BDY(BDY(list)))==O_P ){
496: if(ri > 0 ) error("plot : too many intervals");
497: else range[ri++]=list;
498: } else geom=list;
499: break;
500: case O_N:
501: if ( !found_f ) {
502: func = (Obj)BDY(arg);
503: makevar("x",&var);
504: v[0] = VR(var);
505: found_f = 1;
506: } else
1.2 noro 507: stream=ZTOS((Q)BDY(arg));
1.1 noro 508: break;
509: case O_STR:
510: wname=(STRING)BDY(arg);break;
511: default:
512: error("plot : invalid argument");break;
513: }
514: }
515: if(!found_f )
516: error("plot : invalid argument");
517: switch ( ri ){
518: case 0:
519: MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
520: break;
521: case 1:
522: av[0]=VR((P)BDY(BDY(range[0])));
523: if(!func || NUM(func) || v[0]==av[0] )
524: xrange=range[0];
525: else
526: error("plot : invalid argument");
527: break;
528: default:
529: error("plot : cannot happen");break;
530: }
531: /* conplot in ox_plot requires
532: [s_id (Q),
533: formula (Obj),
534: xrange=[x,xmin,xmax] (LIST),
535: yrange=0,
536: zrange=0,
537: geom=[xsize,ysize] (LIST),
538: wname=name (STRING)]
539: */
540: stream=validate_ox_plot_stream(stream);
1.2 noro 541: STOZ(stream,s_id);
1.1 noro 542: if(!geom ){
1.2 noro 543: STOZ(300,w300);
1.1 noro 544: MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
545: }
546: if(plot_by_bigfloat)
1.2 noro 547: STOZ(plot_by_bigfloat,prec);
1.1 noro 548: else
549: prec = 0;
550: if(is_memory ){
551: MKSTR(fname,MEMORY_PLOT);
552: arg=mknode(8,s_id,fname,func,xrange,NULLP,NULLP,geom,prec);
553: Pox_rpc(arg,&t);
554: arg=mknode(1,s_id);
555: Pox_pop_cmo(arg,rp);
556: } else {
557: MKSTR(fname,fn);
558: arg=mknode(9,s_id,fname,func,xrange,NULLP,NULLP,geom,wname,prec);
559: Pox_rpc(arg,&t);
560: *rp=(Obj)s_id;
561: }
562: }
563:
564: #define Pi 3.14159265358979323846264
565:
566: void Ppolarplot(NODE arg,Z *rp){
567: Z m2,p2,w300,s_id;
568: NODE defrange,n,n0;
569: LIST zrange,range[1],geom,list;
570: VL vl,vl0;
571: V v[1],av[1];
572: int stream,ri,i;
573: P poly,var;
574: STRING fname,wname;
575: Real pi2;
576: Obj t;
577:
578: MKReal(2*Pi,pi2);MKNODE(n,pi2,0); MKNODE(defrange,0,n);
579: poly=0;vl=0;geom=0;wname=0;stream=-1;ri=0;v[0]=0;
580: for(;arg;arg=NEXT(arg)){
581: if(!BDY(arg)) stream=0;
582: else switch(OID(BDY(arg))){
583: case O_P: case O_R://formula
584: poly=(P)BDY(arg);
585: get_vars_recursive((Obj)poly,&vl);
586: for(vl0=vl,i=0;vl0;vl0=NEXT(vl0))
1.3 ! noro 587: if(vl0->v->attr==(pointer)V_IND) {
1.1 noro 588: if(i>=1)error("polarplot : invalid argument");
1.3 ! noro 589: else v[i++]=vl0->v;
! 590: }
1.1 noro 591: if(i!=1)error("polarplot : invalid argument");
592: break;
593: case O_LIST://range,geomerty
594: list=(LIST)BDY(arg);
595: if(OID(BDY(BDY(list)))==O_P)
596: if(ri>0)error("polarplot : invalid argument");
597: else range[ri++]=list;
598: else geom=list;
599: break;
600: case O_N:
1.2 noro 601: stream=ZTOS((Q)BDY(arg));
1.1 noro 602: break;
603: case O_STR://wname
604: wname=(STRING)BDY(arg);
605: break;
606: default:
607: error("polarplot : invalid argument");
608: break;
609: }
610: }
611: //formular check
612: if(!poly)error("polarplot : invalid argument");
613: switch (ri){
614: case 0:
615: MKV(v[0],var); MKNODE(n,var,defrange); MKLIST(zrange,n);
616: break;
617: case 1:
618: av[0]=VR((P)BDY(BDY(range[0])));
619: if(v[0]==av[0]) zrange = range[0];
620: else error("polarplot : invalid argument");
621: break;
622: default:
623: error("polarplot : cannot happen");
624: break;
625: }
626: stream=validate_ox_plot_stream(stream);
1.2 noro 627: STOZ(stream,s_id);
1.1 noro 628: if(!geom){
1.2 noro 629: STOZ(300,w300);
1.1 noro 630: MKNODE(n0,w300,0); MKNODE(n,w300,n0); MKLIST(geom,n);
631: }
632: MKSTR(fname,POLARPLOT);
633: arg=mknode(8,s_id,fname,poly,NULLP,NULLP,zrange,geom,wname);
634: Pox_rpc(arg,&t);
635: *rp=s_id;
636: }
637:
638: void Pplotover(NODE arg,Obj *rp){
639: Q s_id,w_id,color;
640: P poly;
641: STRING fname;
642: Obj t;
643: poly=(P)ARG0(arg);
644: s_id=(Q)ARG1(arg);
645: w_id=(Q)ARG2(arg);
646: if(argc(arg)==4)color=(Q)ARG3(arg);
647: else color=0;
648: MKSTR(fname,PLOTOVER);
649: arg=mknode(5,s_id,fname,w_id,poly,color);
650: Pox_rpc(arg,&t);
651: *rp=(Obj)s_id;
652: }
653:
654: void Pdrawcircle(NODE arg,Obj *rp){
655: Q s_id,index;
656: Obj x,y,r,c,t;
657: STRING fname;
658: NODE n;
659: LIST pos;
660:
661: x=(Obj)ARG0(arg);
662: y=(Obj)ARG1(arg);
663: r=(Obj)ARG2(arg);
664: c=(Obj)ARG3(arg);
665: s_id=(Q)ARG4(arg);
666: index=(Q)ARG5(arg);
667: MKSTR(fname,DRAWCIRCLE);
668: n=mknode(3,x,y,r,c);
669: MKLIST(pos,n);
670: arg=mknode(5,s_id,fname,index,pos,c);
671: Pox_rpc(arg,&t);
672: *rp=(Obj)s_id;
673: }
674:
675: void Pdraw_obj(NODE arg,Obj *rp){
676: static STRING fname;
677: Q s_id,index;
678: LIST obj;
679: Obj t;
680:
681: if(!fname)MKSTR(fname,DRAW_OBJ);
682: s_id=(Q)ARG0(arg);
683: index=(Q)ARG1(arg);
684: obj=(LIST)ARG2(arg);
685: // ARG3(arg)=color
686: if(argc(arg)==4) arg=mknode(5,s_id,fname,index,obj,ARG3(arg));
687: else arg=mknode(4,s_id,fname,index,obj);
688: Pox_cmo_rpc(arg,&t);
689: *rp=(Obj)s_id;
690: }
691:
692: void Pdraw_string(NODE arg,Obj *rp){
693: static STRING fname;
694: STRING str;
695: Q s_id,index;
696: LIST pos;
697: Obj t;
698:
699: if(!fname)MKSTR(fname,DRAW_STRING);
700: s_id=(Q)ARG0(arg);
701: index=(Q)ARG1(arg);
702: pos=(LIST)ARG2(arg);
703: str=(STRING)ARG3(arg);
704: // ARG4(arg)=color
705: if(argc(arg)==5) arg=mknode(6,s_id,fname,index,pos,str,ARG4(arg));
706: else arg=mknode(5,s_id,fname,index,pos,str);
707: Pox_cmo_rpc(arg,&t);
708: *rp=(Obj)s_id;
709: }
710:
711: void Pclear_canvas(NODE arg,Obj *rp){
712: static STRING fname;
713: Q s_id,index;
714: Obj t;
715:
716: if(!fname) MKSTR(fname,CLEAR_CANVAS);
717: s_id=(Q)ARG0(arg);
718: index=(Q)ARG1(arg);
719: arg=mknode(3,s_id,fname,index);
720: Pox_cmo_rpc(arg,&t);
721: *rp=(Obj)s_id;
722: }
723: //****************************ifplotNG
724: /*
725: * name ifplot,ineqn,ineqnor,ineqnand,ineqnxor,conplot
726: * type
727: * D:sign character using double
728: * Q:sign character use rational
729: * B:Boundary character use sturm theorem
730: */
731: void ListCheck(char * head,LIST list){
732: int i;
733: NODE n;
734: if(!list){
735: printf("%s zero \n",head);
736: return;
737: }
738: for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n));
739: printf("%s length %d\n",head,i);
740: for(i=0,n=(NODE)BDY(list);n;i++,n=NEXT(n)){
741: if(!BDY(n))printf("%d 0\n",i);
742: else if(OID(BDY(n))==O_P) printf("%d poly\n",i);
743: else if(OID(BDY(n))==O_R) printf("%d real\n",i);
1.3 ! noro 744: else if(OID(BDY(n))==O_N) printf("%d %ld\n",i,ZTOS((Q)BDY(n)));
1.1 noro 745: }
746: }
747:
748: void PifplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTD,rp);}
749: void PifplotQ(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTQ,rp);}
750: void PifplotB(NODE arg,Obj *rp){ifplot_mainNG(arg,IFPLOTB,rp);}
751:
752: void PconplotD(NODE arg,Obj *rp){ifplot_mainNG(arg,CONPLOTD,rp);}
753: void PconplotQ(NODE arg,Obj *rp){ifplot_mainNG(arg,CONPLOTQ,rp);}
754: void PconplotB(NODE arg,Obj *rp){ifplot_mainNG(arg,CONPLOTB,rp);}
755:
756: void PineqnD(NODE arg,Obj *rp){ifplot_mainNG(arg,INEQND,rp);}
757: void PineqnQ(NODE arg,Obj *rp){ifplot_mainNG(arg,INEQNQ,rp);}
758: void PineqnB(NODE arg,Obj *rp){ifplot_mainNG(arg,INEQNB,rp);}
759:
760: #if defined(INTERVAL)
761: void Pitvifplot(NODE arg,Obj *rp){ifplot_mainNG(arg,ITVIFPLOT,rp);}
762: #endif
763:
764: void PineqnorD(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNDOR,rp);}
765: void PineqnorQ(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNQOR,rp);}
766: void PineqnorB(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNBOR,rp);}
767:
768: void PineqnandD(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNDAND,rp);}
769: void PineqnandQ(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNQAND,rp);}
770: void PineqnandB(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNBAND,rp);}
771:
772: void PineqnxorD(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNDXOR,rp);}
773: void PineqnxorQ(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNQXOR,rp);}
774: void PineqnxorB(NODE arg,Obj *rp){plotover_mainNG(arg,INEQNBXOR,rp);}
775:
776: void PplotoverD(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERD,rp);}
777: void PplotoverQ(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERQ,rp);}
778: void PplotoverB(NODE arg,Obj *rp){plotover_mainNG(arg,PLOTOVERB,rp);}
779:
780: void Pobj_cp(NODE arg,Obj *rp){
781: //copy canvas
782: //1:and,3:copy,6:xor,7:or
783: Q sysid,index_A,index_B,op_code;
784: STRING fname;
785: Obj t;
786: sysid=(Q)ARG0(arg);
787: index_A=(Q)ARG1(arg);
788: index_B=(Q)ARG2(arg);
789: op_code=(Q)ARG3(arg);
790: MKSTR(fname,OBJ_CP);
791: arg=mknode(5,sysid,fname,index_A,index_B,op_code);
792: Pox_rpc(arg,&t);
793: *rp=(Obj)sysid;
794: }
795:
796: void PpolarplotD(NODE arg,Obj *rp){
797: Z m2,p2,w300,defstep,s_id,color;
798: NODE defrange,n,n0,n1,n2;
799: LIST range,geom,list[2];
800: VL vl,vl0;
801: V v[1],av;
802: int stream,ri,i,len,iNo,lNo,vNo,sNo,pfine,findG;
803: P poly,var;
804: STRING fname,wname;
805: Real pi2;
806: Obj t,frst,sec,thr;
807: char ebuf[BUFSIZ];
808:
809: iNo=lNo=sNo=findG=0;pfine=TRUE;
810: poly=0;vl=0;geom=0;wname=0;color=0;stream=-1;ri=0;v[0]=0;
811: for(;arg;arg=NEXT(arg)){
812: if(!BDY(arg)) iNo++;
813: else switch(OID(BDY(arg))){
814: case O_P: case O_R://formular
815: poly=(P)BDY(arg);
816: get_vars_recursive((Obj)poly,&vl);
817: for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){
818: if(vl0->v->attr==(pointer)V_IND){
819: if(vNo>=1){
820: sprintf(ebuf,"%s : invalaid argument",POLARPLOT);
821: error(ebuf);
822: } else v[vNo++]=vl0->v;
823: }
824: }
825: if(vNo!=1){
826: sprintf(ebuf,"%s : only uni-variate formular",POLARPLOT);
827: error(ebuf);
828: }
829: break;
830: case O_N://color,id,idx,division
831: switch (iNo){
832: case 0://color arg
833: color=(Z)BDY(arg);
834: iNo++;
835: break;
836: case 1://stream arg
1.2 noro 837: stream=ZTOS((Q)BDY(arg));
1.1 noro 838: iNo++;
839: break;
840: default://error
841: sprintf(ebuf,"%s : invalid number arguments",POLARPLOT);
842: error(ebuf);
843: break;
844: }
845: break;
846: case O_LIST://range,geomerty
847: if(lNo<2)list[lNo++]=(LIST)BDY(arg);
848: else {
849: sprintf(ebuf,"%s : invalid list argument",POLARPLOT);
850: error(ebuf);
851: }
852: break;
853: case O_STR://wname
854: wname=(STRING)BDY(arg);
855: sNo++;
856: break;
857: default:
858: break;
859: }
860: }
861: //formular check
862: if(!poly){
863: sprintf(ebuf,"%s : invalid plot argument",POLARPLOT);
864: error(ebuf);
865: }
866: //vars check
867: get_vars_recursive((Obj)poly,&vl);
868: for(vl0=vl,vNo=0;vl0;vNo++,vl0=NEXT(vl0)){
869: if(vl0->v->attr==(pointer)V_IND){
870: if(vNo>=2){
871: sprintf(ebuf,"%s : invalid plot argument",POLARPLOT);
872: error(ebuf);
873: } else v[vNo]=vl0->v;
874: }
875: }
876: //list check
877: for(i=0;i<lNo;i++){
878: if(OID(BDY(BDY(list[i])))!=O_P){
879: // list first value is number (geometry)
880: for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){
881: if(len==0) frst=BDY(n);
882: else if(len==1) sec=BDY(n);
883: else {
884: sprintf(ebuf,"%s : geometry list too long",POLARPLOT);
885: error(ebuf);
886: }
887: }
888: if(len!=2){
889: sprintf(ebuf,"%s : geometry requierd 2 numbers", POLARPLOT);
890: error(ebuf);
891: } else geom=list[i];
892: } else {
893: //list first value is var (range)
894: av=VR((P)BDY(BDY(list[i])));
895: if(v[0]==av)range=list[i];
896: else {
897: sprintf(ebuf,"%s : invalid list length",POLARPLOT);
898: error(ebuf);
899: }
900: }
901: }
902: // set default
903: if(!range){
1.2 noro 904: STOZ(DEFAULTPOLARSTEP,defstep);MKReal(2*Pi,pi2);MKV(v[0],var);
1.1 noro 905: MKNODE(n,defstep,0);MKNODE(n1,pi2,n);MKNODE(n2,0,n1);
906: MKNODE(defrange,var,n2);MKLIST(range,defrange);
907: }
908: if(!geom){
1.2 noro 909: STOZ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
1.1 noro 910: }
911: stream=validate_ox_plot_stream(stream);
1.2 noro 912: STOZ(stream,s_id);
1.1 noro 913: MKSTR(fname,POLARPLOTD);
914: arg=mknode(7,s_id,fname,poly,color,range,geom,wname);
915: Pox_rpc(arg,&t);
916: *rp=(Obj)s_id;
917: }
918:
919: void ifplot_mainNG(NODE arg,char *fn,Obj *rp){
920: Z m2,p2,w300,mxgc,s_id,color;
921: NODE defrange,n,n0,n1,n2;
922: P poly,var;
923: VL vl,vl0;
924: V v[2],av;
925: LIST xrange,yrange,zrange,geom,range[2],list[4];
926: int stream,ri,i,j,sign,llen,len,iNo,lNo,vNo,sNo,pfine,findG;
927: STRING fname,wname;
928: Obj t,frst,sec,thr;
929: char ebuf[BUFSIZ];
930:
931: iNo=lNo=sNo=findG=0;pfine=TRUE;
932: poly=0;stream=-1;wname=0;color=0;stream=0;
1.2 noro 933: STOZ(-2,m2);STOZ(2,p2);MKNODE(n,p2,0);MKNODE(defrange,m2,n);
934: STOZ(MAXGC,mxgc);
1.1 noro 935: for(;arg;arg=NEXT(arg)){
936: if(!BDY(arg)) iNo++;
937: else switch(OID(BDY(arg))){
938: case O_P://formular
939: if(pfine){
940: poly=(P)BDY(arg);
941: pfine=FALSE;
942: } else {
943: sprintf(ebuf,"%s : to many plot arguments",fn);
944: error(ebuf);
945: }
946: break;
947: case O_N://color,id,idx,division
948: switch (iNo){
949: case 0: //color arg
950: color=(Z)BDY(arg);
951: iNo++;
952: break;
953: case 1: //stream arg
1.2 noro 954: stream=ZTOS((Q)BDY(arg));
1.1 noro 955: iNo++;
956: break;
957: default:
958: sprintf(ebuf,"%s : invalid number arguments",fn);
959: error(ebuf);
960: break;
961: }
962: break;
963: case O_LIST://xrange,yrange,zrange,geometry
964: if(lNo<4) list[lNo++]=(LIST)BDY(arg);
965: else {
966: sprintf(ebuf,"%s : invalid list argument",fn);
967: error(ebuf);
968: }
969: break;
970: case O_STR://wname
971: wname=(STRING)BDY(arg);
972: sNo++;
973: break;
974: default:
975: break;
976: }
977: }
978: // formular check
979: if(!poly){
980: sprintf(ebuf,"%s : invalid plot argument",fn);
981: error(ebuf);
982: }
983: // vars check
984: get_vars_recursive((Obj)poly,&vl);
985: for(vl0=vl,vNo=0;vl0;vl0=NEXT(vl0)){
986: if(vl0->v->attr==(pointer)V_IND){
987: if(vNo>=2){
988: sprintf(ebuf,"%s : invalid plot argument",fn);
989: error(ebuf);
990: } else v[vNo++]=vl0->v;
991: }
992: }
993: //list check
994: xrange=yrange=zrange=geom=0;frst=sec=thr=0;
995: for(i=0;i<lNo;i++){
996: for(llen=0,n=(NODE)BDY(list[i]);n;llen++,n=NEXT(n));
997: if(llen>4){
998: sprintf(ebuf,"%s : invalid list length",fn);
999: error(ebuf);
1000: }
1001: if(OID(BDY(BDY(list[i])))!=O_P){
1002: // First list value is number
1003: for(len=0,n=(NODE)BDY(list[i]);n;len++,n=NEXT(n)){
1004: if(len==0)frst=BDY(n);
1005: else if(len==1)sec=BDY(n);
1006: else thr=BDY(n);
1007: }
1008: switch(len){
1009: case 2:
1010: if(!strcmp(fn,CONPLOT)){
1011: if(thr==0)thr=(Obj)mxgc;
1012: MKNODE(n,thr,0);MKNODE(n1,sec,n);MKNODE(n2,frst,n1);MKLIST(zrange,n2);
1013: } else geom=list[i];
1014: break;
1015: case 3:
1016: zrange=list[i];
1017: break;
1018: case 0:
1019: case 1:
1020: default:
1021: sprintf(ebuf,"%s : invalid list length",fn);
1022: error(ebuf);
1023: break;
1024: }
1025: } else {
1026: //xrange,yrange
1027: av=VR((P)BDY(BDY(list[i])));
1028: if(v[0]==av)xrange=list[i];
1029: else if(v[1]==av)yrange=list[i];
1030: else {
1031: MKLIST(zrange,NEXT(BDY(list[i])));
1032: }
1033: }
1034: }
1035: //set default
1036: if(!xrange){
1037: MKV(v[0],var);MKNODE(n,var,defrange);MKLIST(xrange,n);
1038: }
1039: if(!yrange){
1040: MKV(v[1],var);MKNODE(n,var,defrange);MKLIST(yrange,n);
1041: }
1042: if(!geom){
1.2 noro 1043: STOZ(300,w300);MKNODE(n0,w300,0);MKNODE(n,w300,n0);MKLIST(geom,n);
1.1 noro 1044: }
1045: if(!(strcmp(fn,CONPLOTD)&strcmp(fn,CONPLOTQ)&strcmp(fn,CONPLOTB))&!zrange){
1046: MKNODE(n,mxgc,0);MKNODE(n1,m2,n);MKNODE(n2,m2,n1);MKLIST(zrange,n2);
1047: }
1048: /*new ifplot in ox_plot requires
1049: [s_id (Q),
1050: formula (Obj),
1051: color (Q),
1052: geom=[xsize,ysize] (LIST optional),
1053: xrange=[x,xmin,xmax] (LIST optional),
1054: yrange=[y,ymin,ymax] (LIST optional),
1055: zrange=[zmin,zmax,zstep] (LIST optional),
1056: wname=name (STRING optional)],
1057: itvstep (Q) if ITVIFPLOT */
1058: stream=validate_ox_plot_stream(stream);
1.2 noro 1059: STOZ(stream,s_id);
1.1 noro 1060: MKSTR(fname,fn);
1061: arg=mknode(9,s_id,fname,poly,color,xrange,yrange,zrange,geom,wname);
1062: Pox_rpc(arg,&t);
1063: *rp=(Obj)s_id;
1064: }
1065:
1066: void plotover_mainNG(NODE arg,char *fn,Obj *rp){
1067: Q s_id,w_id,color;
1068: P poly;
1069: STRING fname;
1070: Obj t;
1071: int iNo,pfine,sfine;
1072: char ebuf[BUFSIZ];
1073:
1074: pfine=sfine=TRUE;
1075: iNo=0;poly=0;color=s_id=w_id=0;
1076: for(;arg;arg=NEXT(arg)){
1077: if(!BDY(arg)) iNo++;
1078: else switch(OID(BDY(arg))){
1079: case O_P://formular
1080: if(pfine){
1081: poly=(P)BDY(arg);
1082: pfine=FALSE;
1083: } else {
1084: sprintf(ebuf,"%s : to many plot arguments",fn);
1085: error(ebuf);
1086: }
1087: break;
1088: case O_N://color,s_id,w_id
1089: switch(iNo){
1090: case 0://color arg
1091: color=(Q)BDY(arg);
1092: iNo++;
1093: break;
1094: case 1://stream arg
1095: s_id=(Q)BDY(arg);
1096: iNo++;
1097: break;
1098: case 2://window arg
1099: w_id=(Q)BDY(arg);
1100: iNo++;
1101: break;
1102: default://error
1103: sprintf(ebuf,"%s : to many numbers",fn);
1104: error(ebuf);
1105: break;
1106: }
1107: break;
1108: default:
1109: sprintf(ebuf,"%s : arguments type miss match",fn);
1110: error(ebuf);
1111: }
1112: }
1113: MKSTR(fname,fn);
1114: //[s_id (Q), w_id (Q), formula (Obj), color (Q)]
1115: arg=mknode(5,s_id,fname,w_id,poly,color);
1116: Pox_rpc(arg,&t);
1117: *rp=(Obj)s_id;
1118: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to plotf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2018 / plot