summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/runpath.in
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/utils/asymptote/runpath.in')
-rw-r--r--Build/source/utils/asymptote/runpath.in450
1 files changed, 450 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/runpath.in b/Build/source/utils/asymptote/runpath.in
new file mode 100644
index 00000000000..63fb07612ab
--- /dev/null
+++ b/Build/source/utils/asymptote/runpath.in
@@ -0,0 +1,450 @@
+/*****
+ * runpath.in
+ *
+ * Runtime functions for path operations.
+ *
+ *****/
+
+pen => primPen()
+pair => primPair()
+path => primPath()
+transform => primTransform()
+realarray* => realArray()
+realarray2* => realArray2()
+patharray* => pathArray()
+penarray* => penArray()
+
+#include "path.h"
+#include "arrayop.h"
+#include "predicates.h"
+
+using namespace camp;
+using namespace vm;
+
+typedef array realarray;
+typedef array realarray2;
+typedef array patharray;
+
+using types::realArray;
+using types::realArray2;
+using types::pathArray;
+
+Int windingnumber(array *p, camp::pair z)
+{
+ size_t size=checkArray(p);
+ Int count=0;
+ for(size_t i=0; i < size; i++)
+ count += read<path *>(p,i)->windingnumber(z);
+ return count;
+}
+
+// Autogenerated routines:
+
+
+path :nullPath()
+{
+ return nullpath;
+}
+
+bool ==(path a, path b)
+{
+ return a == b;
+}
+
+bool !=(path a, path b)
+{
+ return !(a == b);
+}
+
+pair point(path p, Int t)
+{
+ return p.point((Int) t);
+}
+
+pair point(path p, real t)
+{
+ return p.point(t);
+}
+
+pair precontrol(path p, Int t)
+{
+ return p.precontrol((Int) t);
+}
+
+pair precontrol(path p, real t)
+{
+ return p.precontrol(t);
+}
+
+pair postcontrol(path p, Int t)
+{
+ return p.postcontrol((Int) t);
+}
+
+pair postcontrol(path p, real t)
+{
+ return p.postcontrol(t);
+}
+
+pair dir(path p, Int t, Int sign=0, bool normalize=true)
+{
+ return p.dir(t,sign,normalize);
+}
+
+pair dir(path p, real t, bool normalize=true)
+{
+ return p.dir(t,normalize);
+}
+
+pair accel(path p, Int t, Int sign=0)
+{
+ return p.accel(t,sign);
+}
+
+pair accel(path p, real t)
+{
+ return p.accel(t);
+}
+
+real radius(path p, real t)
+{
+ pair v=p.dir(t,false);
+ pair a=p.accel(t);
+ real d=dot(a,v);
+ real v2=v.abs2();
+ real a2=a.abs2();
+ real denom=v2*a2-d*d;
+ real r=v2*sqrt(v2);
+ return denom > 0 ? r/sqrt(denom) : 0.0;
+}
+
+path reverse(path p)
+{
+ return p.reverse();
+}
+
+path subpath(path p, Int a, Int b)
+{
+ return p.subpath((Int) a, (Int) b);
+}
+
+path subpath(path p, real a, real b)
+{
+ return p.subpath(a,b);
+}
+
+path nurb(pair z0, pair z1, pair z2, pair z3,
+ real w0, real w1, real w2, real w3, Int m)
+{
+ return nurb(z0,z1,z2,z3,w0,w1,w2,w3,m);
+}
+
+Int length(path p)
+{
+ return p.length();
+}
+
+bool cyclic(path p)
+{
+ return p.cyclic();
+}
+
+bool straight(path p, Int t)
+{
+ return p.straight(t);
+}
+
+path unstraighten(path p)
+{
+ return p.unstraighten();
+}
+
+bool piecewisestraight(path p)
+{
+ return p.piecewisestraight();
+}
+
+real arclength(path p)
+{
+ return p.arclength();
+}
+
+real arclength(pair z0, pair c0, pair c1, pair z1)
+{
+ return arcLength(z0,c0,c1,z1);
+}
+
+real arctime(path p, real L)
+{
+ return p.arctime(L);
+}
+
+real dirtime(path p, pair z)
+{
+ return p.directiontime(z);
+}
+
+realarray* intersect(path p, path q, real fuzz=-1)
+{
+ bool exact=fuzz <= 0.0;
+ if(fuzz < 0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(q.max()),length(q.min())));
+ std::vector<real> S,T;
+ real s,t;
+ if(intersections(s,t,S,T,p,q,fuzz,true,exact)) {
+ array *V=new array(2);
+ (*V)[0]=s;
+ (*V)[1]=t;
+ return V;
+ }
+ return new array(0);
+}
+
+realarray2* intersections(path p, path q, real fuzz=-1)
+{
+ bool exact=fuzz <= 0.0;
+ if(fuzz < 0.0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(q.max()),length(q.min())));
+ real s,t;
+ std::vector<real> S,T;
+ intersections(s,t,S,T,p,q,fuzz,false,true);
+ size_t n=S.size();
+ if(n == 0 && !exact) {
+ if(intersections(s,t,S,T,p,q,fuzz,true,false)) {
+ array *V=new array(1);
+ array *Vi=new array(2);
+ (*V)[0]=Vi;
+ (*Vi)[0]=s;
+ (*Vi)[1]=t;
+ return V;
+ }
+ }
+ array *V=new array(n);
+ for(size_t i=0; i < n; ++i) {
+ array *Vi=new array(2);
+ (*V)[i]=Vi;
+ (*Vi)[0]=S[i];
+ (*Vi)[1]=T[i];
+ }
+ stable_sort(V->begin(),V->end(),run::compare2<real>());
+ return V;
+}
+
+realarray* intersections(path p, explicit pair a, explicit pair b, real fuzz=-1)
+{
+ if(fuzz < 0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(a),length(b)));
+ std::vector<real> S;
+ intersections(S,p,a,b,fuzz);
+ sort(S.begin(),S.end());
+ size_t n=S.size();
+ array *V=new array(n);
+ for(size_t i=0; i < n; ++i)
+ (*V)[i]=S[i];
+ return V;
+}
+
+// Return the intersection point of the extensions of the line segments
+// PQ and pq.
+pair extension(pair P, pair Q, pair p, pair q)
+{
+ pair ac=P-Q;
+ pair bd=q-p;
+ real det=ac.getx()*bd.gety()-ac.gety()*bd.getx();
+ if(det == 0) return pair(infinity,infinity);
+ return P+((p.getx()-P.getx())*bd.gety()-(p.gety()-P.gety())*bd.getx())*ac/det;
+}
+
+Int size(path p)
+{
+ return p.size();
+}
+
+path &(path p, path q)
+{
+ return camp::concat(p,q);
+}
+
+pair min(explicit path p)
+{
+ return p.min();
+}
+
+pair max(explicit path p)
+{
+ return p.max();
+}
+
+Int size(patharray *p)
+{
+ size_t size=checkArray(p);
+ Int count=0;
+ for (size_t i = 0; i < size; i++)
+ count += read<path *>(p,i)->size();
+ return count;
+}
+
+pair min(patharray *p)
+{
+ size_t size=checkArray(p);
+
+ if(size == 0)
+ error(nopoints);
+
+ path *g = p->read<path *>(0);
+ pair z = g->min();
+ double minx = z.getx(), miny = z.gety();
+
+ for (size_t i = 1; i < size; ++i) {
+ path *g = p->read<path *>(i);
+ pair z = g->min();
+ double x = z.getx(), y = z.gety();
+ if (x < minx)
+ minx = x;
+ if (y < miny)
+ miny = y;
+ }
+
+ return pair(minx, miny);
+}
+
+pair max(patharray *p)
+{
+ size_t size=checkArray(p);
+
+ if(size == 0)
+ error(nopoints);
+
+ path *g = p->read<path *>(0);
+ pair z = g->max();
+ double maxx = z.getx(), maxy = z.gety();
+
+ for (size_t i = 1; i < size; ++i) {
+ path *g = p->read<path *>(i);
+ pair z = g->max();
+ double x = z.getx(), y = z.gety();
+ if (x > maxx)
+ maxx = x;
+ if (y > maxy)
+ maxy = y;
+ }
+
+ return pair(maxx, maxy);
+}
+
+pair minAfterTransform(transform t, patharray *p)
+{
+ size_t size=checkArray(p);
+
+ if(size == 0)
+ error(nopoints);
+
+ path g = p->read<path *>(0)->transformed(t);
+ pair z = g.min();
+ double minx = z.getx(), miny = z.gety();
+
+ for (size_t i = 1; i < size; ++i) {
+ path g = p->read<path *>(i)->transformed(t);
+ pair z = g.min();
+ double x = z.getx(), y = z.gety();
+ if (x < minx)
+ minx = x;
+ if (y < miny)
+ miny = y;
+ }
+
+ return pair(minx, miny);
+}
+
+pair maxAfterTransform(transform t, patharray *p)
+{
+ size_t size=checkArray(p);
+
+ if(size == 0)
+ error(nopoints);
+
+ path g = p->read<path *>(0)->transformed(t);
+ pair z = g.max();
+ double maxx = z.getx(), maxy = z.gety();
+
+ for (size_t i = 1; i < size; ++i) {
+ path g = p->read<path *>(i)->transformed(t);
+ pair z = g.max();
+ double x = z.getx(), y = z.gety();
+ if (x > maxx)
+ maxx = x;
+ if (y > maxy)
+ maxy = y;
+ }
+
+ return pair(maxx, maxy);
+}
+
+realarray *mintimes(path p)
+{
+ array *V=new array(2);
+ pair z=p.mintimes();
+ (*V)[0]=z.getx();
+ (*V)[1]=z.gety();
+ return V;
+}
+
+realarray *maxtimes(path p)
+{
+ array *V=new array(2);
+ pair z=p.maxtimes();
+ (*V)[0]=z.getx();
+ (*V)[1]=z.gety();
+ return V;
+}
+
+real relativedistance(real theta, real phi, real t, bool atleast)
+{
+ return camp::velocity(theta,phi,tension(t,atleast));
+}
+
+Int windingnumber(patharray *p, pair z)
+{
+ return windingnumber(p,z);
+}
+
+bool inside(explicit patharray *g, pair z, pen fillrule=CURRENTPEN)
+{
+ return fillrule.inside(windingnumber(g,z));
+}
+
+bool inside(path g, pair z, pen fillrule=CURRENTPEN)
+{
+ return fillrule.inside(g.windingnumber(z));
+}
+
+// Return a positive (negative) value if a--b--c--cycle is oriented
+// counterclockwise (clockwise) or zero if all three points are colinear.
+// Equivalently, return a positive (negative) value if c lies to the
+// left (right) of the line through a and b or zero if c lies on this line.
+// The value returned is the determinant
+// |a.x a.y 1|
+// |b.x b.y 1|
+// |c.x c.y 1|
+//
+real orient(pair a, pair b, pair c)
+{
+ return orient2d(a,b,c);
+}
+
+// Return a positive (negative) value if d lies inside (outside)
+// the circle passing through the counterclockwise-oriented points a,b,c
+// or zero if d lies on this circle.
+// The value returned is the determinant
+// |a.x a.y a.x^2+a.y^2 1|
+// |b.x b.y b.x^2+b.y^2 1|
+// |c.x c.y c.x^2+c.y^2 1|
+// |d.x d.y d.x^2+d.y^2 1|
+real incircle(pair a, pair b, pair c, pair d)
+{
+ return incircle(a.getx(),a.gety(),b.getx(),b.gety(),c.getx(),c.gety(),
+ d.getx(),d.gety());
+}