Constants: $slop INCH IDENT

slop = get_slop();

Constants: LEFT RIGHT FRONT FWD FORWARD BACK BOTTOM BOT DOWN TOP UP CENTER CTR CENTRE

Constants: SEGMENT RAY LINE

move(v) CHILDREN;     pts = move(v, p);     pts = move(STRING, p);     mat = move(v);

left(x) CHILDREN;     pts = left(x, p);     mat = left(x);

right(x) CHILDREN;     pts = right(x, p);     mat = right(x);

fwd(y) CHILDREN;     pts = fwd(y, p);     mat = fwd(y);

back(y) CHILDREN;     pts = back(y, p);     mat = back(y);

down(z) CHILDREN;     pts = down(z, p);     mat = down(z);

up(z) CHILDREN;     pts = up(z, p);     mat = up(z);

rot(a, [cp=], [reverse=]) CHILDREN;
rot([X,Y,Z], [cp=], [reverse=]) CHILDREN;     rot(a, v, [cp=], [reverse=]) CHILDREN;
rot(from=, to=, [a=], [reverse=]) CHILDREN;     pts = rot(a, p=, [cp=], [reverse=]);
pts = rot([X,Y,Z], p=, [cp=], [reverse=]);
pts = rot(a, v, p=, [cp=], [reverse=]);
pts = rot([a], from=, to=, p=, [reverse=]);     M = rot(a, [cp=], [reverse=]);
M = rot([X,Y,Z], [cp=], [reverse=]);     M = rot(a, v, [cp=], [reverse=]);
M = rot(from=, to=, [a=], [reverse=]);

xrot(a, [cp=]) CHILDREN;     rotated = xrot(a, p, [cp=]);     mat = xrot(a, [cp=]);

yrot(a, [cp=]) CHILDREN;     rotated = yrot(a, p, [cp=]);     mat = yrot(a, [cp=]);

zrot(a, [cp=]) CHILDREN;     rotated = zrot(a, p, [cp=]);     mat = zrot(a, [cp=]);

tilt(to=, [reverse=], [cp=]) CHILDREN;     pts = tilt(to=, p=, [reverse=], [cp=]);
M = tilt(to=, [reverse=], [cp=]);

scale(SCALAR) CHILDREN;     scale([X,Y,Z]) CHILDREN;     pts = scale(v, p, [cp=]);
mat = scale(v, [cp=]);

xscale(x, [cp=]) CHILDREN;     scaled = xscale(x, p, [cp=]);     mat = xscale(x, [cp=]);

yscale(y, [cp=]) CHILDREN;     scaled = yscale(y, p, [cp=]);     mat = yscale(y, [cp=]);

zscale(z, [cp=]) CHILDREN;     scaled = zscale(z, p, [cp=]);     mat = zscale(z, [cp=]);

mirror(v) CHILDREN;     pt = mirror(v, p);     mat = mirror(v);

xflip([x=]) CHILDREN;     pt = xflip(p, [x]);     mat = xflip([x=]);

yflip([y=]) CHILDREN;     pt = yflip(p, [y]);     mat = yflip([y=]);

zflip([z=]) CHILDREN;     pt = zflip(p, [z]);     mat = zflip([z=]);

frame_map(v1, v2, v3, [reverse=]) CHILDREN;
transformed = frame_map(v1, v2, v3, p=points, [reverse=]);
map = frame_map(v1, v2, v3, [reverse=]);
map = frame_map(x=VECTOR1, y=VECTOR2, [reverse=]);
map = frame_map(x=VECTOR1, z=VECTOR2, [reverse=]);
map = frame_map(y=VECTOR1, z=VECTOR2, [reverse=]);

skew([sxy=]|[axy=], [sxz=]|[axz=], [syx=]|[ayx=], [syz=]|[ayz=], [szx=]|[azx=], [szy=]|[azy=]) CHILDREN;
pts = skew(p, [sxy=]|[axy=], [sxz=]|[axz=], [syx=]|[ayx=], [syz=]|[ayz=], [szx=]|[azx=], [szy=]|[azy=]);
mat = skew([sxy=]|[axy=], [sxz=]|[axz=], [syx=]|[ayx=], [syz=]|[ayz=], [szx=]|[azx=], [szy=]|[azy=]);

pts = apply(transform, points);

PARENT() position(at) CHILDREN;

PARENT() orient(anchor, [spin]) CHILDREN;

PARENT() align(anchor, [orient], [spin], [inside=]) CHILDREN;

PARENT() attach(from, [overlap=], [norot=]) CHILDREN;
PARENT() attach(from, to, [overlap=], [norot=]) CHILDREN;

PARENT() tag(tag) CHILDREN;

PARENT() force_tag([tag]) CHILDREN;

PARENT() default_tag(tag) CHILDREN;

tag_scope([scope]) CHILDREN;

diff([remove], [keep]) PARENT() CHILDREN;

tag_diff(tag, [remove], [keep]) PARENT() CHILDREN;

intersect([intersect], [keep]) PARENT() CHILDREN;

tag_intersect(tag, [intersect], [keep]) PARENT() CHILDREN;

conv_hull([keep]) CHILDREN;

tag_conv_hull(tag, [keep]) CHILDREN;

hide(tags) CHILDREN;

show_only(tags) CHILDREN;

show_int(tags) CHILDREN;

PARENT() face_mask(faces) CHILDREN;

PARENT() edge_mask([edges], [except]) CHILDREN;

PARENT() corner_mask([corners], [except]) CHILDREN;

PARENT() face_profile(faces, r|d=, [convexity=]) CHILDREN;

PARENT() edge_profile([edges], [except], [convexity]) CHILDREN;

PARENT() edge_profile([edges], [except=], [convexity=], [flip=], [corner_type=]) CHILDREN;

PARENT() corner_profile([corners], [except], [r=|d=], [convexity=]) CHILDREN;

attachable(anchor, spin, two_d=true, size=, [size2=], [shift=], [override=], ...) {OBJECT; children();}
attachable(anchor, spin, two_d=true, r=|d=, ...) {OBJECT; children();}
attachable(anchor, spin, two_d=true, path=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, two_d=true, region=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], size=, [size2=], [shift=], [override=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], r=|d=, l=, [axis=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], r1=|d1=, r2=|d2=, l=, [axis=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], r=|d=, ...) {OBJECT; children();}
attachable(anchor, spin, path=, l=|h=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, region=, l=|h=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], vnf=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], geom=) {OBJECT; children();}

mat = reorient(anchor, spin, [orient], two_d=true, size=, [size2=], [shift=], ...);
pts = reorient(anchor, spin, [orient], two_d=true, size=, [size2=], [shift=], p=, ...);
mat = reorient(anchor, spin, [orient], two_d=true, r=|d=, ...);
pts = reorient(anchor, spin, [orient], two_d=true, r=|d=, p=, ...);
mat = reorient(anchor, spin, [orient], two_d=true, path=, [extent=], ...);
pts = reorient(anchor, spin, [orient], two_d=true, path=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], two_d=true, region=, [extent=], ...);
pts = reorient(anchor, spin, [orient], two_d=true, region=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], size=, [size2=], [shift=], ...);
vnf = reorient(anchor, spin, [orient], size=, [size2=], [shift=], p=, ...);
mat = reorient(anchor, spin, [orient], r=|d=, l=, [axis=], ...);
vnf = reorient(anchor, spin, [orient], r=|d=, l=, [axis=], p=, ...);
mat = reorient(anchor, spin, [orient], r1=|d1=, r2=|d2=, l=, [axis=], ...);
vnf = reorient(anchor, spin, [orient], r1=|d1=, r2=|d2=, l=, [axis=], p=, ...);
mat = reorient(anchor, spin, [orient], r|d=, ...);
vnf = reorient(anchor, spin, [orient], r|d=, p=, ...);
mat = reorient(anchor, spin, [orient], path=, l=|h=, [extent=], ...);
vnf = reorient(anchor, spin, [orient], path=, l=|h=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], region=, l=|h=, [extent=], ...);
vnf = reorient(anchor, spin, [orient], region=, l=|h=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], vnf, [extent], ...);
vnf = reorient(anchor, spin, [orient], vnf, [extent], p=, ...);

a = named_anchor(name, pos, [orient], [spin]);
a = named_anchor(name, [pos], rot=, [flip=]);

geom = attach_geom(...);
geom = attach_geom(two_d=true, size=, [size2=], [shift=], ...);
geom = attach_geom(two_d=true, r=|d=, ...);
geom = attach_geom(two_d=true, region=, [extent=], ...);
geom = attach_geom(size=, [size2=], [shift=], ...);
geom = attach_geom(r=|d=, l=|h=, [axis=], ...);
geom = attach_geom(r1|d1=, r2=|d2=, l=, [axis=], ...);
geom = attach_geom(r=|d=, ...);
geom = attach_geom(region=, l=|h=, [extent=], [shift=], [scale=], [twist=], ...);
geom = attach_geom(vnf=, [extent=], ...);

PARENT() show_anchors([s], [std=], [custom=]);

anchor_arrow([s], [color], [flag], [anchor=], [orient=], [spin=]) [ATTACHMENTS];

anchor_arrow2d([s], [color]);

expose_anchors(opacity) {child1() show_anchors(); child2() show_anchors(); ...}

show_transform_list(tlist, [s]);     show_transform_list(tlist) {CHILDREN};

generic_airplane([s]);

frame_ref(s, opacity);

square(size, [center], ...);
square(size, [center], ...) [ATTACHMENTS];     path = square(size, [center], ...);

rect(size, [rounding], [chamfer], ...) [ATTACHMENTS];
path = rect(size, [rounding], [chamfer], ...);

circle(r|d=, ...) [ATTACHMENTS];     circle(points=) [ATTACHMENTS];
circle(r|d=, corner=) [ATTACHMENTS];     path = circle(r|d=, ...);
path = circle(points=);     path = circle(r|d=, corner=);

ellipse(r|d=, [realign=], [circum=], [uniform=], ...) [ATTACHMENTS];
path = ellipse(r|d=, [realign=], [circum=], [uniform=], ...);

regular_ngon(n, r|d=|or=|od=, [realign=]) [ATTACHMENTS];
regular_ngon(n, ir=|id=, [realign=]) [ATTACHMENTS];
regular_ngon(n, side=, [realign=]) [ATTACHMENTS];

pentagon(or|od=, [realign=], [align_tip=|align_side=]) [ATTACHMENTS];
pentagon(ir=|id=, [realign=], [align_tip=|align_side=]) [ATTACHMENTS];
pentagon(side=, [realign=], [align_tip=|align_side=]) [ATTACHMENTS];
path = pentagon(...);

hexagon(r/or, [realign=], <align_tip=|align_side=>, [rounding=], ...) [ATTACHMENTS];
hexagon(d=/od=, ...) [ATTACHMENTS];     hexagon(ir=/id=, ...) [ATTACHMENTS];
hexagon(side=, ...) [ATTACHMENTS];     path = hexagon(...);

octagon(r/or, [realign=], [align_tip=|align_side=], [rounding=], ...) [ATTACHMENTS];
octagon(d=/od=, ...) [ATTACHMENTS];     octagon(ir=/id=, ...) [ATTACHMENTS];
octagon(side=, ...) [ATTACHMENTS];     path = octagon(...);

right_triangle(size, [center], ...) [ATTACHMENTS];
path = right_triangle(size, [center], ...);

trapezoid(h, w1, w2, [shift=], [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
trapezoid(h, w1, ang=, [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
trapezoid(h, w2=, ang=, [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
trapezoid(w1=, w2=, ang=, [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
path = trapezoid(...);

star(n, r/or, ir, [realign=], [align_tip=], [align_pit=], ...) [ATTACHMENTS];
star(n, r/or, step=, ...) [ATTACHMENTS];
path = star(n, r/or, ir, [realign=], [align_tip=], [align_pit=], ...);
path = star(n, r/or, step=, ...);

jittered_poly(path, [dist]);

teardrop2d(r/d=, [ang], [cap_h]) [ATTACHMENTS];
path = teardrop2d(r|d=, [ang], [cap_h]);

egg(length, r1|d1=, r2|d2=, R|D=) [ATTACHMENTS];
path = egg(length, r1|d1=, r2|d2=, R|D=);

region=ring(n, r1=|d1=, r2=|d2=, [full=], [angle=], [start=]);
region=ring(n, ring_width, r=|d=, [full=], [angle=], [start=]);
region=ring(n, [ring_width], [r=,d=], points=[P0,P1,P2], [full=]);
region=ring(n, [ring_width], corner=[P0,P1,P2], [r=,d=], [r1|d1=], [r2=|d2=], [full=]);
region=ring(n, [ring_width], [r=|d=], width=, thickness=, [full=]);
ring(...) [ATTACHMENTS];

glued_circles(r/d=, [spread], [tangent], ...) [ATTACHMENTS];
path = glued_circles(r/d=, [spread], [tangent], ...);

keyhole(l/length=, r1/d1=, r2/d2=, [shoulder_r=], ...) [ATTACHMENTS];
path = keyhole(l/length=, r1/d1=, r2/d2=, [shoulder_r=], ...);

supershape([step],[n=], [m1=], [m2=], [n1=], [n2=], [n3=], [a=], [b=], [r=/d=]) [ATTACHMENTS];
path = supershape([step], [n=], [m1=], [m2=], [n1=], [n2=], [n3=], [a=], [b=], [r=/d=]);

reuleaux_polygon(n, r|d=, ...) [ATTACHMENTS];
path = reuleaux_polygon(n, r|d=, ...);

text(text, [size], [font], ...);

round2d(r) [ATTACHMENTS];     round2d(or=) [ATTACHMENTS];     round2d(ir=) [ATTACHMENTS];
round2d(or=, ir=) [ATTACHMENTS];

shell2d(thickness, [or], [ir])

cube(size, [center]);
cube(size, [center], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
vnf = cube(size, ...);

cuboid(size, [anchor=], [spin=], [orient=]);     cuboid(size, p1=, ...);
cuboid(p1=, p2=, ...);
cuboid(size, [chamfer=], [edges=], [except=], [trimcorners=], ...);
cuboid(size, [rounding=], [teardrop=], [edges=], [except=], [trimcorners=], ...);
cuboid(...) ATTACHMENTS;

prismoid(size1, size2, [h|l|height|length], [shift], [xang=], [yang=], ...) [ATTACHMENTS];
prismoid(size1, size2, h|l|height|length, [chamfer=], [rounding=]...) [ATTACHMENTS];
prismoid(size1, size2, h|l|height|length, [chamfer1=], [chamfer2=], [rounding1=], [rounding2=], ...) [ATTACHMENTS];
vnf = prismoid(...);

octahedron(size, ...) [ATTACHMENTS];     vnf = octahedron(size, ...);

rect_tube(h, size, isize, [center], [shift]);
rect_tube(h, size, wall=, [center=]);     rect_tube(h, isize=, wall=, [center=]);
rect_tube(h, size1=, size2=, wall=, ...);
rect_tube(h, isize1=, isize2=, wall=, ...);
rect_tube(h, size1=, size2=, isize1=, isize2=, ...);
rect_tube(h, size, isize, chamfer=, ...);
rect_tube(h, size, isize, chamfer1=, chamfer2= ...);
rect_tube(h, size, isize, ichamfer=, ...);
rect_tube(h, size, isize, ichamfer1=, ichamfer2= ...);
rect_tube(h, size, isize, chamfer=, ichamfer=, ...);
rect_tube(h, size, isize, rounding=, ...);
rect_tube(h, size, isize, rounding1=, rounding2= ...);
rect_tube(h, size, isize, irounding=, ...);
rect_tube(h, size, isize, irounding1=, irounding2= ...);
rect_tube(h, size, isize, rounding=, irounding=, ...);
rect_tube(...) ATTACHMENTS;

wedge(size, [center], ...) [ATTACHMENTS];     vnf = wedge(size, [center], ...);

cylinder(h, r=/d=, [center=]);     cylinder(h, r1/d1=, r2/d2=, [center=]);
cylinder(h, r=/d=, [center=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
cylinder(h, r1/d1=, r2/d2=, [center=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
vnf = cylinder(h, r=/d=, ...);     vnf = cylinder(h, r1/d1=, r2/d2=, ...);

cyl(l|h|length|height, r, [center], [circum=], [realign=]) [ATTACHMENTS];
cyl(l|h|length|height, d=, ...) [ATTACHMENTS];
cyl(l|h|length|height, r1=, r2=, ...) [ATTACHMENTS];
cyl(l|h|length|height, d1=, d2=, ...) [ATTACHMENTS];
cyl(l|h|length|height, r|d, chamfer=, [chamfang=], [from_end=], ...);
cyl(l|h|length|height, r|d, chamfer1=, [chamfang1=], [from_end=], ...);
cyl(l|h|length|height, r|d, chamfer2=, [chamfang2=], [from_end=], ...);
cyl(l|h|length|height, r|d, chamfer1=, chamfer2=, [chamfang1=], [chamfang2=], [from_end=], ...);
cyl(l|h|length|height, r|d, rounding=, ...);
cyl(l|h|length|height, r|d, rounding1=, ...);
cyl(l|h|length|height, r|d, rounding2=, ...);
cyl(l|h|length|height, r|d, rounding1=, rounding2=, ...);
cyl(l|h|length|height, r|d, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_taper=], [tex_inset=], ...);
cyl(l|h|length|height, r1=, r2=, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_taper=], [tex_inset=], ...);
cyl(l|h|length|height, d1=, d2=, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_taper=], [tex_inset=], ...);
vnf = cyl(...);

xcyl(l|h|length|height, r|d=, [anchor=], ...) [ATTACHMENTS];
xcyl(l|h|length|height, r1=|d1=, r2=|d2=, [anchor=], ...) [ATTACHMENTS];

ycyl(l|h|length|height, r|d=, [anchor=], ...) [ATTACHMENTS];
ycyl(l|h|length|height, r1=|d1=, r2=|d2=, [anchor=], ...) [ATTACHMENTS];

zcyl(l|h|length|height, r|d=, [anchor=],...) [ATTACHMENTS];
zcyl(l|h|length|height, r1=|d1=, r2=|d2=, [anchor=],...);

tube(h|l, or, ir, [center], [realign=], [anchor=], [spin=],[orient=]) [ATTACHMENTS];
tube(h|l, od=, id=, ...) [ATTACHMENTS];
tube(h|l, or|od=|ir=|id=, wall=, ...) [ATTACHMENTS];
tube(h|l, ir1=|id1=, ir2=|id2=, or1=|od1=, or2=|od2=, ...) [ATTACHMENTS];
tube(h|l, or1=|od1=, or2=|od2=, wall=, ...) [ATTACHMENTS];

pie_slice(l|h=|height=|length=, r, ang, [center]);
pie_slice(l|h=|height=|length=, d=, ang=, ...);
pie_slice(l|h=|height=|length=, r1=|d1=, r2=|d2=, ang=, ...);
vnf = pie_slice(l|h=|height=|length=, r, ang, [center]);
vnf = pie_slice(l|h=|height=|length=, d=, ang=, ...);
vnf = pie_slice(l|h=|height=|length=, r1=|d1=, r2=|d2=, ang=, ...);
pie_slice(l|h, r, ang, ...) ATTACHMENTS;

sphere(r|d=);
sphere(r|d=, [anchor=], [spin=], [orient=]) [ATTACHMENTS];
vnf = sphere(r|d=, [anchor=], [spin=], [orient=]) [ATTACHMENTS];

spheroid(r|d, [circum], [style]) [ATTACHMENTS];
vnf = spheroid(r|d, [circum], [style]);

torus(r_maj|d_maj, r_min|d_min, [center], ...) [ATTACHMENTS];
torus(or|od, ir|id, ...) [ATTACHMENTS];
torus(r_maj|d_maj, or|od, ...) [ATTACHMENTS];
torus(r_maj|d_maj, ir|id, ...) [ATTACHMENTS];
torus(r_min|d_min, or|od, ...) [ATTACHMENTS];
torus(r_min|d_min, ir|id, ...) [ATTACHMENTS];
vnf = torus(r_maj|d_maj, r_min|d_min, [center], ...);
vnf = torus(or|od, ir|id, ...);     vnf = torus(r_maj|d_maj, or|od, ...);
vnf = torus(r_maj|d_maj, ir|id, ...);     vnf = torus(r_min|d_min, or|od, ...);
vnf = torus(r_min|d_min, ir|id, ...);

teardrop(h|l=|length=|height=, r, [ang], [cap_h], [chamfer=], ...) [ATTACHMENTS];
teardrop(h|l=|length=|height=, d=, [ang=], [cap_h=], [chamfer=], ...) [ATTACHMENTS];
teardrop(h|l=|height=|length=, r1=, r2=, [ang=], [cap_h1=], [cap_h2=], ...) [ATTACHMENTS];
teardrop(h|l=|height=|length=, d1=, d2=, [ang=], [cap_h1=], [cap_h2=], ...) [ATTACHMENTS];
vnf = teardrop(h|l=|height=|length=, r|d=, [ang=], [cap_h=], ...);
vnf = teardrop(h|l=|height=|length=, r1=|d1=, r2=|d2=, [ang=], [cap_h=], ...);
vnf = teardrop(h|l=|height=|length=, r1=|d1=, r2=|d2=, [ang=], [cap_h1=], [cap_h2=], ...);

onion(r|d=, [ang=], [cap_h=], [circum=], [realign=], ...) [ATTACHMENTS];
vnf = onion(r|d=, [ang=], [cap_h=], [circum=], [realign=], ...);

text3d(text, [h], [size], [font], [language=], [script=], [direction=], [atype=], [anchor=], [spin=], [orient=]);

path_text(path, text, [size], [thickness], [font], [lettersize=], [offset=], [reverse=], [normal=], [top=], [textmetrics=], [kern=])

fillet(l, r, [ang], [overlap], ...) [ATTACHMENTS];
fillet(l|length=|h=|height=, d=, [ang=], [overlap=], ...) [ATTACHMENTS];

heightfield(data, [size], [bottom], [maxz], [xrange], [yrange], [style], [convexity], ...) [ATTACHMENTS];
vnf = heightfield(data, [size], [bottom], [maxz], [xrange], [yrange], [style], ...);

vnf = cylindrical_heightfield(data, l|length=|h=|height=, r|d=, [base=], [transpose=], [aspect=]);
cylindrical_heightfield(data, l|length=|h=|height=, r|d=, [base=], [transpose=], [aspect=]) [ATTACHMENTS];

ruler(length, width, [thickness=], [depth=], [labels=], [pipscale=], [maxscale=], [colors=], [alpha=], [unit=], [inch=]) [ATTACHMENTS];

stroke(path, [width], [closed], [endcaps], [endcap_width], [endcap_length], [endcap_extent], [trim]);
stroke(path, [width], [closed], [endcap1], [endcap2], [endcap_width1], [endcap_width2], [endcap_length1], [endcap_length2], [endcap_extent1], [endcap_extent2], [trim1], [trim2]);

dashed_stroke(path, dashpat, [width=], [closed=]);
dashes = dashed_stroke(path, dashpat, [closed=]);

path=arc(n, r|d=, angle);     path=arc(n, r|d=, angle=[START,END]);
path=arc(n, r|d=, start=, angle=);     path=arc(n, width=, thickness=);
path=arc(n, cp=, points=[P0,P1], [long=], [cw=], [ccw=]);
path=arc(n, points=[P0,P1,P2]);     path=arc(n, corner=[P0,P1,P2], r=);
path=arc(wedge=true,...)     arc(...) [ATTACHMENTS];

path = catenary(width, droop=|angle=, n=);

path = helix(l|h, [turns=], [angle=], r=|r1=|r2=, d=|d1=|d2=);

path = turtle(commands, [state], [full_state=], [repeat=])

debug_polygon(points, paths, [vertices=], [edges=], [convexity=], [size=]);

mask2d_roundover(r|d=|h=|height=|cut=|joint=, [inset], [mask_angle], [excess], [flat_top=], [quarter_round=]) [ATTACHMENTS];
path = mask2d_roundover(r|d=|h=|height=|cut=|joint=, [inset], [mask_angle], [excess], [flat_top=], [quarter_round=]);

mask2d_teardrop(r|d=, [angle], [inset] [mask_angle], [excess], [cut=], [joint=], [h=|height=]) [ATTACHMENTS];
path = mask2d_teardrop(r|d=, [angle], [inset], [mask_angle], [excess], [cut=], [joint=], [h=|height=]);

mask2d_cove(r|d=|h=|height=, [inset], [mask_angle], [excess], [bulge=], [flat_top=], [quarter_round=]) [ATTACHMENTS];
path = mask2d_cove(r|d=|h=, [inset], [mask_angle], [excess], [bulge=], [flat_top=]);

mask2d_chamfer(edge, [angle], [inset], [excess]) [ATTACHMENTS];
mask2d_chamfer(y=, [angle=], [inset=], [excess=]) [ATTACHMENTS];
mask2d_chamfer(x=, [angle=], [inset=], [excess=]) [ATTACHMENTS];
path = mask2d_chamfer(edge, [angle], [inset], [excess]);
path = mask2d_chamfer(y=, [angle=], [inset=], [excess=]);
path = mask2d_chamfer(x=, [angle=], [inset=], [excess=]);

mask2d_rabbet(size, [mask_angle], [excess]) [ATTACHMENTS];
path = mask2d_rabbet(size, [mask_angle], [excess]);

mask2d_dovetail(edge, angle, [inset], [shelf], [excess], ...) [ATTACHMENTS];
mask2d_dovetail(width=, angle=, [inset=], [shelf=], [excess=], ...) [ATTACHMENTS];
mask2d_dovetail(height=, angle=, [inset=], [shelf=], [excess=], ...) [ATTACHMENTS];
mask2d_dovetail(width=, height=, [inset=], [shelf=], [excess=], ...) [ATTACHMENTS];
path = mask2d_dovetail(edge, [angle], [inset], [shelf], [excess]);

mask2d_ogee(pattern, [excess], ...) [ATTAHCMENTS];
path = mask2d_ogee(pattern, [excess], ...);

chamfer_edge_mask(l|h=|length=|height=, chamfer, [excess]) [ATTACHMENTS];

chamfer_corner_mask(chamfer) [ATTACHMENTS];

chamfer_cylinder_mask(r|d=, chamfer, [ang], [from_end]) [ATTACHMENTS];

rounding_edge_mask(l|h=|length=|height=, r|d=, [excess=]) [ATTACHMENTS];
rounding_edge_mask(l|h=|length=|height=, r1=|d1=, r2=|d2=, [excess=]) [ATTACHMENTS];

rounding_corner_mask(r|d, [excess=], [style=]) [ATTACHMENTS];

rounding_angled_edge_mask(h|l=|length=|height=, r|d=, [ang=]) [ATTACHMENTS];
rounding_angled_edge_mask(h|l=|length=|height=, r1=|d1=, r2=|d2=, [ang=]) [ATTACHMENTS];

rounding_angled_corner_mask(r|d=, [ang]) [ATTACHMENTS];

rounding_cylinder_mask(r|d=, rounding);

rounding_hole_mask(r|d, rounding, [excess]) [ATTACHMENTS];

teardrop_edge_mask(l|h=|length=|height=, r|d=, [angle], [excess], [anchor], [spin], [orient]) [ATTACHMENTS];

teardrop_corner_mask(r|d=, [angle], [excess], [anchor], [spin], [orient]) [ATTACHMENTS];

move_copies(a) CHILDREN;     copies = move_copies(a, p=);     mats = move_copies(a);

xcopies(spacing, [n], [sp=]) CHILDREN;     xcopies(l=, [n=], [sp=]) CHILDREN;
xcopies(LIST) CHILDREN;
copies = xcopies(spacing, [n], [sp=], p=);     copies = xcopies(l=, [n=], [sp=], p=);
copies = xcopies(LIST, p=);     mats = xcopies(spacing, [n], [sp=]);
mats = xcopies(l=, [n=], [sp=]);     mats = xcopies(LIST);

ycopies(spacing, [n], [sp=]) CHILDREN;     ycopies(l=, [n=], [sp=]) CHILDREN;
ycopies(LIST) CHILDREN;
copies = ycopies(spacing, [n], [sp=], p=);     copies = ycopies(l=, [n=], [sp=], p=);
copies = ycopies(LIST, p=);     mats = ycopies(spacing, [n], [sp=]);
mats = ycopies(l=, [n=], [sp=]);     mats = ycopies(LIST);

zcopies(spacing, [n], [sp=]) CHILDREN;     zcopies(l=, [n=], [sp=]) CHILDREN;
zcopies(LIST) CHILDREN;
copies = zcopies(spacing, [n], [sp=], p=);     copies = zcopies(l=, [n=], [sp=], p=);
copies = zcopies(LIST, p=);     mats = zcopies(spacing, [n], [sp=]);
mats = zcopies(l=, [n=], [sp=]);     mats = zcopies(LIST);

line_copies(spacing, [n], [p1=]) CHILDREN;
line_copies(spacing, [l=], [p1=]) CHILDREN;
line_copies([n=], [l=], [p1=]) CHILDREN;
line_copies([n=], [p1=], [p2=]) CHILDREN;
line_copies([spacing], [p1=], [p2=]) CHILDREN;
copies = line_copies([spacing], [n], [p1=], p=);
copies = line_copies([spacing], [l=], [p1=], p=);
copies = line_copies([n=], [l=], [p1=], p=);
copies = line_copies([n=], [p1=], [p2=], p=);
copies = line_copies([spacing], [p1=], [p2=], p=);
mats = line_copies([spacing], [n], [p1=]);
mats = line_copies([spacing], [l=], [p1=]);
mats = line_copies([n=], [l=], [p1=]);     mats = line_copies([n=], [p1=], [p2=]);
mats = line_copies([spacing], [p1=], [p2=]);

grid_copies(spacing, size=, [stagger=], [scale=], [inside=]) CHILDREN;
grid_copies(n=, size=, [stagger=], [scale=], [inside=]) CHILDREN;
grid_copies(spacing, [n], [stagger=], [scale=], [inside=]) CHILDREN;
grid_copies(n=, inside=, [stagger], [scale]) CHILDREN;
copies = grid_copies(spacing, size=, [stagger=], [scale=], [inside=], p=);
copies = grid_copies(n=, size=, [stagger=], [scale=], [inside=], p=);
copies = grid_copies(spacing, [n], [stagger=], [scale=], [inside=], p=);
copies = grid_copies(n=, inside=, [stagger], [scale], p=);
mats = grid_copies(spacing, size=, [stagger=], [scale=], [inside=]);
mats = grid_copies(n=, size=, [stagger=], [scale=], [inside=]);
mats = grid_copies(spacing, [n], [stagger=], [scale=], [inside=]);
mats = grid_copies(n=, inside=, [stagger], [scale]);

rot_copies(rots, [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
copies = rot_copies(rots, [cp=], [sa=], [delta=], [subrot=], p=);
copies = rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=], p=);
copies = rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=], p=);
mats = rot_copies(rots, [cp=], [sa=], [delta=], [subrot=]);
mats = rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=]);
mats = rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=]);

xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;
copies = xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
copies = xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);
mats = xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
mats = xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);

yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;
copies = yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
copies = yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);
mats = yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
mats = yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);

zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;
copies = zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
copies = zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);
mats = zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
mats = zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);

arc_copies(n, r|d=, [sa=], [ea=], [rot=]) CHILDREN;
arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=]) CHILDREN;
copies = arc_copies(n, r|d=, [sa=], [ea=], [rot=], p=);
copies = arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=], p=);
mats = arc_copies(n, r|d=, [sa=], [ea=], [rot=]);
mats = arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=]);

sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=]) CHILDREN;
copies = sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=], p=);
mats = sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=]);

path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=]) CHILDREN;
path_copies(path, dist=, [rotate_children=], [closed=]) CHILDREN;
copies = path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=], p=);
copies = path_copies(path, dist=, [rotate_children=], [closed=], p=);
mats = path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=]);
mats = path_copies(path, dist=, [rotate_children=], [closed=]);

xflip_copy([offset], [x]) CHILDREN;     copies = xflip_copy([offset], [x], p=);
mats = xflip_copy([offset], [x]);

yflip_copy([offset], [y]) CHILDREN;     copies = yflip_copy([offset], [y], p=);
mats = yflip_copy([offset], [y]);

zflip_copy([offset], [z]) CHILDREN;     copies = zflip_copy([offset], [z], p=);
mats = zflip_copy([offset], [z]);

mirror_copy(v, [cp], [offset]) CHILDREN;
copies = mirror_copy(v, [cp], [offset], p=);
mats = mirror_copy(v, [cp], [offset]);

xdistribute(spacing, [sizes]) CHILDREN;     xdistribute(l=, [sizes=]) CHILDREN;

ydistribute(spacing, [sizes]) CHILDREN;     ydistribute(l=, [sizes=]) CHILDREN;

zdistribute(spacing, [sizes]) CHILDREN;     zdistribute(l=, [sizes=]) CHILDREN;

distribute(spacing, sizes, dir) CHILDREN;
distribute(l=, [sizes=], [dir=]) CHILDREN;

recolor([c]) CHILDREN;

color_this([c]) CHILDREN;

rainbow(list,[stride],[maxhues],[shuffle],[seed]) CHILDREN;

color_overlaps([color]) CHILDREN;

hsl(h,[s],[l],[a]) CHILDREN;     rgb = hsl(h,[s],[l],[a]);

hsv(h,[s],[v],[a]) CHILDREN;     rgb = hsv(h,[s],[v],[a]);

half_of(v, [cp], [s], [planar]) CHILDREN;     result = half_of(p,v,[cp]);

left_half([s], [x]) CHILDREN;
left_half(planar=true, [s], [x]) CHILDREN;     result = left_half(p, [x]);

right_half([s=], [x=]) CHILDREN;
right_half(planar=true, [s=], [x=]) CHILDREN;     result = right_half(p, [x=]);

front_half([s], [y]) CHILDREN;
front_half(planar=true, [s], [y]) CHILDREN;     result = front_half(p, [y]);

back_half([s], [y]) CHILDREN;
back_half(planar=true, [s], [y]) CHILDREN;     result = back_half(p, [y]);

bottom_half([s], [z]) CHILDREN;     result = bottom_half(p, [z]);

top_half([s], [z]) CHILDREN;     result = top_half(p, [z]);

partition_mask(l, w, h, [cutsize], [cutpath], [gap], [inverse], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

partition_cut_mask(l, w, h, [cutsize], [cutpath], [gap], [inverse], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

partition(size, [spread], [cutsize], [cutpath], [gap], [spin], [$slop=]) CHILDREN;

bounding_box([excess],[planar]) CHILDREN;

chain_hull() CHILDREN;

path_extrude2d(path, [caps=], [closed=], [s=], [convexity=]) 2D-CHILDREN;

cylindrical_extrude(ir|id=, or|od=, [size=], [convexity=], [spin=], [orient=]) 2D-CHILDREN;

extrude_from_to(pt1, pt2, [convexity=], [twist=], [scale=], [slices=]) 2D-CHILDREN;

path_extrude(path, [convexity], [clipsize]) 2D-CHILDREN;

minkowski_difference() { BASE; DIFF1; DIFF2; ... }

offset3d(r, [size], [convexity]) CHILDREN;

round3d(r) CHILDREN;     round3d(or) CHILDREN;     round3d(ir) CHILDREN;
round3d(or, ir) CHILDREN;

is_path(list, [dim], [fast])

bool = is_1region(path, [name])

outpath = force_path(path, [name])

path_merge_collinear(path, [eps])

path_length(path,[closed])

path_segment_lengths(path,[closed])

fracs = path_length_fractions(path, [closed]);

newpath = subdivide_path(path, n|refine=|maxlen=, [method=], [closed=], [exact=]);

newpath = resample_path(path, n|spacing=, [closed=]);

bool = is_path_simple(path, [closed], [eps]);

index_pt = path_closest_point(path, pt);

tangs = path_tangents(path, [closed], [uniform]);

norms = path_normals(path, [tangents], [closed]);

curvs = path_curvature(path, [closed]);

torsions = path_torsion(path, [closed]);

path_list = path_cut(path, cutdist, [closed]);

cuts = path_cut_points(path, cutdist, [closed=], [direction=]);

paths = split_path_at_self_crossings(path, [closed], [eps]);

splitpolys = polygon_parts(poly, [nonzero], [eps]);

bool = is_region(x);

bool = is_valid_region(region, [eps]);

bool = is_region_simple(region, [eps]);

region = make_region(polys, [nonzero], [eps]);

region = force_region(poly)

region(r, [anchor], [spin=], [cp=], [atype=]) [ATTACHMENTS];

debug_region(region, [vertices=], [edges=], [convexity=], [size=]);

check = point_in_region(point, region, [eps]);

area = region_area(region);

b = are_regions_equal(region1, region2, [either_winding])

split_region = split_region_at_region_crossings(region1, region2, [closed1], [closed2], [eps])

rgns = region_parts(region);

offsetpath = offset(path, [r=|delta=], [chamfer=], [closed=], [check_valid=], [quality=], [same_length=])
path_faces = offset(path, return_faces=true, [r=|delta=], [chamfer=], [closed=], [check_valid=], [quality=], [firstface_index=], [flip_faces=])

union() CHILDREN;     region = union(regions);     region = union(REGION1,REGION2);
region = union(REGION1,REGION2,REGION3);

difference() CHILDREN;     region = difference(regions);
region = difference(REGION1,REGION2);
region = difference(REGION1,REGION2,REGION3);

intersection() CHILDREN;     region = intersection(regions);
region = intersection(REGION1,REGION2);
region = intersection(REGION1,REGION2,REGION3);

exclusive_or() CHILDREN;     region = exclusive_or(regions);
region = exclusive_or(REGION1,REGION2);
region = exclusive_or(REGION1,REGION2,REGION3);

path = hull_region(region);     hull_region(region);

skin(profiles, slices, [z=], [refine=], [method=], [sampling=], [caps=], [closed=], [style=], [convexity=], [anchor=],[cp=],[spin=],[orient=],[atype=]) [ATTACHMENTS];
vnf = skin(profiles, slices, [z=], [refine=], [method=], [sampling=], [caps=], [closed=], [style=], [anchor=],[cp=],[spin=],[orient=],[atype=]);

linear_sweep(region, [height], [center=], [slices=], [twist=], [scale=], [style=], [caps=], [convexity=]) [ATTACHMENTS];
linear_sweep(region, [height], [center=], texture=, [tex_size=]|[tex_reps=], [tex_depth=], [style=], [tex_samples=], ...) [ATTACHMENTS];
vnf = linear_sweep(region, [height], [center=], [slices=], [twist=], [scale=], [style=], [caps=]);
vnf = linear_sweep(region, [height], [center=], texture=, [tex_size=]|[tex_reps=], [tex_depth=], [style=], [tex_samples=], ...);

vnf = rotate_sweep(shape, [angle], ...);
rotate_sweep(shape, [angle], ...) [ATTACHMENTS];
rotate_sweep(shape, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_samples=], [tex_rot=], [tex_inset=], ...) [ATTACHMENTS];

spiral_sweep(poly, h, r|d=, turns, [taper=], [center=], [taper1=], [taper2=], [internal=], ...)[ATTACHMENTS];
spiral_sweep(poly, h, r1=|d1=, r2=|d2=, turns, [taper=], [center=], [taper1=], [taper2=], [internal=], ...)[ATTACHMENTS];
vnf = spiral_sweep(poly, h, r|d=, turns, ...);
vnf = spiral_sweep(poly, h, r1=|d1=, r1=|d2=, turns, ...);

path_sweep(shape, path, [method], [normal=], [closed=], [twist=], [twist_by_length=], [symmetry=], [scale=], [scale_by_length=], [last_normal=], [tangent=], [uniform=], [relaxed=], [caps=], [style=], [convexity=], [anchor=], [cp=], [spin=], [orient=], [atype=]) [ATTACHMENTS];
vnf = path_sweep(shape, path, [method], [normal=], [closed=], [twist=], [twist_by_length=], [symmetry=], [scale=], [scale_by_length=], [last_normal=], [tangent=], [uniform=], [relaxed=], [caps=], [style=], [transforms=], [anchor=], [cp=], [spin=], [orient=], [atype=]);

path_sweep2d(shape, path, [closed], [caps], [quality], [style], [convexity=], [anchor=], [spin=], [orient=], [atype=], [cp=]) [ATTACHMENTS];
vnf = path_sweep2d(shape, path, [closed], [caps], [quality], [style], [anchor=], [spin=], [orient=], [atype=], [cp=]);

sweep(shape, transforms, [closed], [caps], [style], [convexity=], [anchor=], [spin=], [orient=], [atype=]) [ATTACHMENTS];
vnf = sweep(shape, transforms, [closed], [caps], [style], [anchor=], [spin=], [orient=], [atype=]);

newprof = subdivide_and_slice(profiles, slices, [numpoints], [method], [closed]);

profs = slice_profiles(profiles, slices, [closed]);

rlist = rot_resample(rotlist, n, [method=], [twist=], [scale=], [smoothlen=], [long=], [turns=], [closed=])

newpoly = associate_vertices(polygons, split);

tx = texture(tex, [n=], [inset=], [gap=], [roughness=]);

vnf = vnf_vertex_array(points, [caps=], [cap1=], [cap2=], [style=], [reverse=], [col_wrap=], [row_wrap=], [triangulate=]);

vnf = vnf_tri_array(points, [row_wrap], [reverse])

vnf = vnf_join([VNF, VNF, VNF, ...]);

vnf = vnf_from_polygons(polygons, [eps]);

vnf = vnf_from_region(region, [transform], [reverse]);

bool = is_vnf(x);

rvnf = vnf_reverse_faces(vnf);

vnf2 = vnf_quantize(vnf,[q]);

new_vnf = vnf_merge_points(vnf, [eps]);

clean_vnf = vnf_drop_unused_points(vnf);

vnf2 = vnf_triangulate(vnf);

newvnf = vnf_unify_faces(vnf);

sliced = vnf_slice(vnf, dir, cuts);

vnf_polyhedron(vnf) [ATTACHMENTS];
vnf_polyhedron([VNF, VNF, VNF, ...]) [ATTACHMENTS];

vnf_wireframe(vnf, [width]);

vol = vnf_volume(vnf);

area = vnf_area(vnf);

newvnf = vnf_halfspace(plane, vnf, [closed], [boundary]);

bentvnf = vnf_bend(vnf,r|d=,[axis=]);

vnf_hull = hull_vnf(vnf);     hull_vnf(vnf,[fast]);

debug_vnf(vnfs, [faces=], [vertices=], [opacity=], [size=], [convexity=], [filter=]);

vnf_validate(vnf, [size], [show_warns=], [check_isects=], [opacity=], [adjacent=], [label_verts=], [label_faces=], [wireframe=]);

pt = bezier_points(bezier, u);     ptlist = bezier_points(bezier, RANGE);
ptlist = bezier_points(bezier, LIST);

path = bezier_curve(bezier, [splinesteps], [endpoint]);

deriv = bezier_derivative(bezier, u, [order]);
derivs = bezier_derivative(bezier, LIST, [order]);
derivs = bezier_derivative(bezier, RANGE, [order]);

tanvec = bezier_tangent(bezier, u);     tanvecs = bezier_tangent(bezier, LIST);
tanvecs = bezier_tangent(bezier, RANGE);

crv = bezier_curvature(curve, u);     crvlist = bezier_curvature(curve, LIST);
crvlist = bezier_curvature(curve, RANGE);

u = bezier_closest_point(bezier, pt, [max_err]);

pathlen = bezier_length(bezier, [start_u], [end_u], [max_deflect]);

u = bezier_line_intersection(bezier, line);

pt = bezpath_points(bezpath, curveind, u, [N]);
ptlist = bezpath_points(bezpath, curveind, LIST, [N]);
path = bezpath_points(bezpath, curveind, RANGE, [N]);

path = bezpath_curve(bezpath, [splinesteps], [N], [endpoint])

res = bezpath_closest_point(bezpath, pt, [N], [max_err]);

plen = bezpath_length(path, [N], [max_deflect]);

bezpath = path_to_bezpath(path, [closed], [tangents], [uniform], [size=]|[relsize=]);

bezpath = bezpath_close_to_axis(bezpath, [axis], [N]);

bezpath = bezpath_offset(offset, bezier, [N]);

pts = bez_begin(pt, a, r, [p=]);     pts = bez_begin(pt, VECTOR, [r], [p=]);

pts = bez_tang(pt, a, r1, r2, [p=]);
pts = bez_tang(pt, VECTOR, [r1], [r2], [p=]);

pts = bez_joint(pt, a1, a2, r1, r2, [p1=], [p2=]);
pts = bez_joint(pt, VEC1, VEC2, [r1=], [r2=], [p1=], [p2=]);

pts = bez_end(pt, a, r, [p=]);     pts = bez_end(pt, VECTOR, [r], [p=]);

bool = is_bezier_patch(x);

patch = bezier_patch_flat(size, [N=], [spin=], [orient=], [trans=]);

rpatch = bezier_patch_reverse(patch);

pt = bezier_patch_points(patch, u, v);
ptgrid = bezier_patch_points(patch, LIST, LIST);
ptgrid = bezier_patch_points(patch, RANGE, RANGE);

vnf = bezier_vnf(patches, [splinesteps], [style]);

vnf = bezier_vnf_degenerate_patch(patch, [splinesteps], [reverse]);
vnf_edges = bezier_vnf_degenerate_patch(patch, [splinesteps], [reverse], return_edges=true);

n = bezier_patch_normals(patch, u, v);
ngrid = bezier_patch_normals(patch, LIST, LIST);
ngrid = bezier_patch_normals(patch, RANGE, RANGE);

debug_bezier(bez, [size], [N=]);

debug_bezier_patches(patches, [size=], [splinesteps=], [showcps=], [showdots=], [showpatch=], [convexity=], [style=]);

rounded_path = round_corners(path, [method], [radius=], [cut=], [joint=], [closed=], [verbose=]);

smoothed = smooth_path(path, [tangents], [size=|relsize=], [splinesteps=], [closed=], [uniform=]);

joined_path = path_join(paths, [joint], [k=], [relocate=], [closed=]);

offset_stroke(path, [width], [rounded=], [chamfer=], [start=], [end=], [check_valid=], [quality=], [closed=],...) [ATTACHMENTS];
path = offset_stroke(path, [width], closed=false, [rounded=], [chamfer=], [start=], [end=], [check_valid=], [quality=],...);
region = offset_stroke(path, [width], closed=true, [rounded=], [chamfer=], [start=], [end=], [check_valid=], [quality=],...);

offset_sweep(path, [height|length=|h=|l=], [bottom], [top], [offset=], [convexity=],...) [ATTACHMENTS];
vnf = offset_sweep(path, [height|length=|h=|l=], [bottom], [top], [offset=], ...);

convex_offset_extrude(height, [bottom], [top], ...) 2D-CHILDREN;

rounded_prism(bottom, [top], [height=|h=|length=|l=], [joint_top=], [joint_bot=], [joint_sides=], [k=], [k_top=], [k_bot=], [k_sides=], [splinesteps=], [debug=], [convexity=],...) [ATTACHMENTS];
vnf = rounded_prism(bottom, [top], [height=|h=|length=|l=], [joint_top=], [joint_bot=], [joint_sides=], [k=], [k_top=], [k_bot=], [k_sides=], [splinesteps=], [debug=]);

bent_cutout_mask(r|radius, thickness, path);

join_prism(polygon, base, length=|height=|l=|h=, fillet=, [base_T=], [scale=], [prism_end_T=], [short=], ...) [ATTACHMENTS];
join_prism(polygon, base, aux=, fillet=, [base_T=], [aux_T=], [scale=], [prism_end_T=], [short=], ...) [ATTACHMENTS];
vnf = join_prism( ... );

path = turtle3d(commands, [state=], [repeat=]);
mats = turtle3d(commands, transforms=true, [state=], [repeat=]);
state = turtle3d(commands, full_state=true, [state=], [repeat=]);

Constants: PHI EPSILON INF NAN

list = count(n, [s], [step], [reverse]);

x = lerp(a, b, u);     l = lerp(a, b, LIST);

x = lerpn(a, b, n);     x = lerpn(a, b, n, [endpoint]);

x2 = sqr(x);

val = log2(x);

l = hypot(x, y, [z]);

x = factorial(n, [d]);

x = binomial(n);

x = binomial_coefficient(n, k);

x = gcd(a,b)

div = lcm(a, b);     divs = lcm(list);

a = sinh(x);

a = cosh(x);

a = tanh(x);

a = asinh(x);

a = acosh(x);

a = atanh(x);

num = quant(x, y);

num = quantdn(x, y);

num = quantup(x, y);

val = constrain(v, minval, maxval);

mod = posmod(x, m)

ang = modang(x);

x = sum(v, [dflt]);

x = mean(v);

middle = median(v)

delts = deltas(v,[wrap]);

sums = cumsum(v);

x = product(v);

prod_list = cumprod(list, [right]);

x = convolve(p,q);

sum_of_sines(a,sines)

rand_int(minval, maxval, n, [seed]);

points = random_points(n, dim, [scale], [seed]);

arr = gaussian_rands([n],[mean], [cov], [seed]);

arr = exponential_rands([n], [lambda], [seed])

points = spherical_random_points([n], [radius], [seed]);

points = random_polygon([n], [size], [seed]);

x = deriv(data, [h], [closed])

x = deriv2(data, [h], [closed])

x = deriv3(data, [h], [closed])

z = complex(list)

c = c_mul(z1,z2)

x = c_div(z1,z2)

w = c_conj(z)

x = c_real(z)

x = c_imag(z)

I = c_ident(n)

n = c_norm(z)

roots = quadratic_roots(a, b, c, [real])

x = polynomial(p, z)

x = polymult(p,q)     x = polymult([p1,p2,p3,...])

[quotient,remainder] = poly_div(n,d)

sum = poly_add(p,q)

roots = poly_roots(p, [tol]);

roots = real_roots(p, [eps], [tol])

x = root_find(f, x0, x1, [tol])

test = is_matrix(A, [m], [n], [square])

b = is_matrix_symmetric(A, [eps])

b = is_rotation(A, [dim], [centered])

echo_matrix(M, [description], [sig], [sep], [eps]);
dummy = echo_matrix(M, [description], [sig], [sep], [eps]),

list = column(M, i);

mat = submatrix(M, idx1, idx2);

mat = ident(n);

mat = diagonal_matrix(diag, [offdiag]);

M = transpose(M, [reverse]);

x = outer_product(u,v);     M = outer_product(u,v);

mat = submatrix_set(M, A, [m], [n]);

A = hstack(M1, M2)     A = hstack(M1, M2, M3)     A = hstack([M1, M2, M3, ...])

bmat = block_matrix([[M11, M12,...],[M21, M22,...], ... ]);

solv = linear_solve(A,b,[pivot])

x = linear_solve3(A,b)

mat = matrix_inverse(A)

B = rot_inverse(A)

x = null_space(A)

qr = qr_factor(A,[pivot]);

x = back_substitute(R, b, [transpose]);

L = cholesky(A);

d = det2(M);

d = det3(M);

d = det4(M);

d = determinant(M);

norm_fro(A)

matrix_trace(M)

bool = is_vector(v, [length], [zero=], [all_nonzero=], [eps=]);

v_new = add_scalar(v, s);

v3 = v_mul(v1, v2);

v3 = v_div(v1, v2);

v2 = v_abs(v);

v2 = v_floor(v);

v2 = v_ceil(v);

v2 = v_lookup(x, v);

v = unit(v, [error]);

theta = v_theta([X,Y]);

ang = vector_angle(v1,v2);     ang = vector_angle([v1,v2]);
ang = vector_angle(PT1,PT2,PT3);     ang = vector_angle([PT1,PT2,PT3]);

axis = vector_axis(v1,v2);     axis = vector_axis([v1,v2]);
axis = vector_axis(PT1,PT2,PT3);     axis = vector_axis([PT1,PT2,PT3]);

newv = vector_bisect(v1,v2);

pt_pair = pointlist_bounds(pts);

index = closest_point(pt, points);

index = furthest_point(pt, points);

indices = vector_search(query, r, target);

tree = vector_search_tree(points,leafsize);

indices = vector_nearest(query, k, target);

pt = point2d(p, [fill]);

pts = path2d(points);

pt = point3d(p, [fill]);

pts = path3d(points, [fill]);

pt = point4d(p, [fill]);

pt = path4d(points, [fill]);

pt = polar_to_xy(r, theta);     pt = polar_to_xy([R, THETA]);
pts = polar_to_xy([[R,THETA], [R,THETA], ...]);

r_theta = xy_to_polar(x,y);     r_theta = xy_to_polar([X,Y]);
r_thetas = xy_to_polar([[X,Y], [X,Y], ...]);

xy = project_plane(plane, p);     M = project_plane(plane)

xyz = lift_plane(plane, p);     M = lift_plane(plane);

pt = cylindrical_to_xyz(r, theta, z);
pt = cylindrical_to_xyz([RADIUS,THETA,Z]);
pts = cylindrical_to_xyz([[RADIUS,THETA,Z], [RADIUS,THETA,Z], ...]);

rtz = xyz_to_cylindrical(x,y,z);     rtz = xyz_to_cylindrical([X,Y,Z]);
rtzs = xyz_to_cylindrical([[X,Y,Z], [X,Y,Z], ...]);

pt = spherical_to_xyz(r, theta, phi);
pt = spherical_to_xyz([RADIUS,THETA,PHI]);
pts = spherical_to_xyz([[RADIUS,THETA,PHI], [RADIUS,THETA,PHI], ...]);

r_theta_phi = xyz_to_spherical(x,y,z)     r_theta_phi = xyz_to_spherical([X,Y,Z])
r_theta_phis = xyz_to_spherical([[X,Y,Z], [X,Y,Z], ...])

pt = altaz_to_xyz(alt, az, r);     pt = altaz_to_xyz([ALT,AZ,R]);
pts = altaz_to_xyz([[ALT,AZ,R], [ALT,AZ,R], ...]);

alt_az_r = xyz_to_altaz(x,y,z);     alt_az_r = xyz_to_altaz([X,Y,Z]);
alt_az_rs = xyz_to_altaz([[X,Y,Z], [X,Y,Z], ...]);

pt = is_point_on_line(point, line, [bounded], [eps]);

bool = is_collinear(a, [b, c], [eps]);

dist = point_line_distance(pt, line, [bounded]);

dist = segment_distance(seg1, seg2, [eps]);

vec = line_normal([P1,P2])     vec = line_normal(p1,p2)

pt = line_intersection(line1, line2, [bounded1], [bounded2], [bounded=], [eps=]);

pt = line_closest_point(line, pt, [bounded]);

line = line_from_points(points, [fast], [eps]);

bool = is_coplanar(points,[eps]);

plane = plane3pt(p1, p2, p3);     plane = plane3pt([p1, p2, p3]);

plane = plane3pt_indexed(points, i1, i2, i3);

plane = plane_from_normal(normal, [pt])

plane = plane_from_points(points, [fast], [eps]);

plane = plane_from_polygon(points, [fast], [eps]);

vec = plane_normal(plane);

d = plane_offset(plane);

pt = plane_line_intersection(plane, line, [bounded], [eps]);

line = plane_intersection(plane1, plane2)
pt = plane_intersection(plane1, plane2, plane3)

angle = plane_line_angle(plane,line);

pts = plane_closest_point(plane, points);

dist = point_plane_distance(plane, point)

bool = are_points_on_plane(points, plane, [eps]);

pts = circle_line_intersection(r|d=, cp, line, [bounded], [eps=]);

pts = circle_circle_intersection(r1|d1=, cp1, r2|d2=, cp2, [eps]);

circ = circle_2tangents(r|d=, pt1, pt2, pt3, [tangents=]);
circ = circle_2tangents(r|d=, [PT1, PT2, PT3], [tangents=]);

circ = circle_3points(pt1, pt2, pt3);     circ = circle_3points([PT1, PT2, PT3]);

tangents = circle_point_tangents(r|d=, cp, pt);

segs = circle_circle_tangents(r1|d1=, cp1, r2|d2=, cp2);

isect = sphere_line_intersection(r|d=, cp, line, [bounded], [eps=]);

area = polygon_area(poly, [signed]);

c = centroid(object, [eps]);

vec = polygon_normal(poly);

bool = point_in_polygon(point, poly, [nonzero], [eps])

pt = polygon_line_intersection(poly, line, [bounded], [nonzero], [eps]);

triangles = polygon_triangulate(poly, [ind], [error], [eps])

bool = is_polygon_clockwise(poly);

newpoly = clockwise_polygon(poly);

newpoly = ccw_polygon(poly);

newpoly = reverse_polygon(poly)

newpoly = reindex_polygon(reference, poly);

newpoly = align_polygon(reference, poly, [angles], [cp], [tran], [return_ind]);

bool = are_polygons_equal(poly1, poly2, [eps])

face_list_or_index_list = hull(points);

hull_points(points, [fast]);

index_list = hull2d_path(points,all)

faces = hull3d_faces(points)

bool = is_polygon_convex(poly, [eps]);

dist = convex_distance(points1, points2,eps);

bool = convex_collision(points1, points2, [eps]);

info = rot_decode(rotation,[long]); // Returns: [angle,axis,cp,translation]

C = law_of_cosines(a, b, c);     c = law_of_cosines(a, b, C=);

B = law_of_sines(a, A, b);     b = law_of_sines(a, A, B=);

adj = hyp_opp_to_adj(hyp,opp);     adj = opp_hyp_to_adj(opp,hyp);

adj = hyp_ang_to_adj(hyp,ang);     adj = ang_hyp_to_adj(ang,hyp);

adj = opp_ang_to_adj(opp,ang);     adj = ang_opp_to_adj(ang,opp);

opp = hyp_adj_to_opp(hyp,adj);     opp = adj_hyp_to_opp(adj,hyp);

opp = hyp_ang_to_opp(hyp,ang);     opp = ang_hyp_to_opp(ang,hyp);

opp = adj_ang_to_opp(adj,ang);     opp = ang_adj_to_opp(ang,adj);

hyp = adj_opp_to_hyp(adj,opp);     hyp = opp_adj_to_hyp(opp,adj);

hyp = adj_ang_to_hyp(adj,ang);     hyp = ang_adj_to_hyp(ang,adj);

hyp = opp_ang_to_hyp(opp,ang);     hyp = ang_opp_to_hyp(ang,opp);

ang = hyp_adj_to_ang(hyp,adj);     ang = adj_hyp_to_ang(adj,hyp);

ang = hyp_opp_to_ang(hyp,opp);     ang = opp_hyp_to_ang(opp,hyp);

ang = adj_opp_to_ang(adj,opp);     ang = opp_adj_to_ang(opp,adj);

ver = bosl_version();

ver = bosl_version_num();

ver = bosl_version_str();

bosl_required(version);

ver = version_to_list(x);

str = version_to_str(version);

str = version_to_num(version);

cmp = version_cmp(a,b);

test = approx(a, b, [eps])

x = all_zero(x, [eps]);

test = all_nonzero(x, [eps]);

test = all_positive(x,[eps]);

test = all_negative(x, [eps]);

all_nonpositive(x, [eps]);

all_nonnegative(x, [eps]);

b = all_equal(vec, [eps]);

are_ends_equal(list, [eps]);

bool = is_increasing(list, [strict]);

bool = is_decreasing(list, [strict]);

test = compare_vals(a, b);

test = compare_lists(a, b)

idx = min_index(vals);     idxlist = min_index(vals, all=true);

idx = max_index(vals);     idxlist = max_index(vals, all=true);

idx = find_approx(val, list, [start=], [eps=]);
indices = find_approx(val, list, all=true, [start=], [eps=]);

list = deduplicate(list, [closed], [eps]);

new_idxs = deduplicate_indexed(list, indices, [closed], [eps]);

list_wrap(path, [eps]);

list_unwrap(list, [eps]);

ulist = unique(list);

sorted_counts = unique_count(list);

slist = sort(list, [idx]);

idxlist = sortidx(list, [idx]);

ulist = group_sort(list,[idx]);

groupings = group_data(groups, values);

small = list_smallest(list, k)

bool = is_homogeneous(list, [depth]);

llen = min_length(list);

llen = max_length(list);

dims = list_shape(v, [depth]);

bool = in_list(val, list, [idx]);

item = select(list, start);     item = select(list, [s:d:e]);
item = select(list, [i0,i1...,ik]);     list = select(list, start, end);

list = slice(list, s, e);

item = last(list);

list = list_head(list, [to]);

list = list_tail(list, [from]);

sublist = bselect(list, index);

list = repeat(val, n);

arr = list_bset(indexset, valuelist, [dflt]);

list = list(l)

list = force_list(value, [n], [fill]);

rlist = reverse(list);

rlist = list_rotate(list, [n]);

shuffled = shuffle(list, [seed]);

newlist = repeat_entries(list, N, [exact]);

newlist = list_pad(list, minlen, [fill]);

list = list_set(list, indices, values, [dflt], [minlen]);

list = list_insert(list, indices, values);

list = list_remove(list, ind);

list = list_remove_values(list, values, [all]);

range = idx(list, [s=], [e=], [step=]);
for(i=idx(list, [s=], [e=], [step=])) ...

p = pair(list, [wrap]);
for (p = pair(list, [wrap])) ... // On each iteration, p contains a list of two adjacent items.

list = triplet(list, [wrap]);     for (t = triplet(list, [wrap])) ...

list = combinations(l, [n]);

list = permutations(l, [n]);

groups = list_to_matrix(v, cnt, [dflt]);

list = flatten(l);

list = full_flatten(l);

s = set_union(a, b, [get_indices]);

s = set_difference(a, b);

s = set_intersection(a, b);

typ = typeof(x);

bool = is_type(x, types);

bool = is_def(x);

bool = is_str(x);

bool = is_int(n);     bool = is_integer(n);

bool = all_integer(x);

bool = is_nan(x);

bool = is_finite(x);

bool = is_range(x);

bool = valid_range(x);

bool = is_func(x);

bool = is_consistent(list, [pattern]);

bool = same_shape(a,b);

check = is_bool_list(list,[length])

bool = any(l);
bool = any(l, func); // Requires OpenSCAD 2021.01 or later.

bool = all(l);
bool = all(l, func); // Requires OpenSCAD 2021.01 or later.

seq = num_true(l);
seq = num_true(l, func); // Requires OpenSCAD 2021.01 or later.

val = default(val, dflt);

val = first_defined(v, [recursive]);

val = one_defined(vals, names, [dflt])

cnt = num_defined(v);

bool = any_defined(v, [recursive]);

bool = all_defined(v, [recursive]);

x = u_add(a, b);

x = u_sub(a, b);

x = u_mul(a, b);

x = u_div(a, b);

anchr = get_anchor(anchor,center,[uncentered],[dflt]);

r = get_radius([r1=], [r2=], [r=], [d1=], [d2=], [d=], [dflt=]);

vec = scalar_vec3(v, [dflt]);

sides = segs(r);

no_children($children);

req_children($children);

dummy = no_function(name)

no_module();

deprecate(new_name);

assert_approx(got, expected, [info]);

assert_equal(got, expected, [info]);

shape_compare([eps]) {TEST_SHAPE; EXPECTED_SHAPE;}

bool = looping(state);

state = loop_while(state, continue);

bool = loop_done(state);

newstr = substr(str, [pos], [len]);

newstr = suffix(str,len);

ind = str_find(str,pattern,[last=],[all=],[start=]);

bool = starts_with(str,pattern);

bool = ends_with(str,pattern);

string_list = str_split(str, sep, [keep_nulls]);

str = str_join(list, [sep]);

str = str_strip(s,c,[start],[end]);

padded = str_pad(str, length, char, [left]);

newstr = str_replace_char(str, char, replace);

newstr = downcase(str);

newstr = upcase(str);

str = rand_str(n, [charset], [seed]);

num = parse_int(str, [base])

num = parse_float(str);

num = parse_frac(str,[mixed=],[improper=],[signed=]);

num = parse_num(str);

str = format_int(i, [mindigits]);

s = format_fixed(f, [digits]);

str = format_float(f,[sig]);

s = format(fmt, vals);

x = is_lower(s);

x = is_upper(s);

x = is_digit(s);

x = is_hexdigit(s);

x = is_letter(s);

struct2 = struct_set(struct, key, value, [grow=]);
struct2 = struct_set(struct, [key1, value1, key2, value2, ...], [grow=]);

struct2 = struct_remove(struct, key);

val = struct_val(struct, key, default);

keys = struct_keys(struct);

echo_struct(struct, [name]);     foo = echo_struct(struct, [name]);

bool = is_struct(struct);

lst = map(func, list);     lst = map(function (x) x+1, list);

lst = filter(func, list);     lst = filter(function (x) x>1, list);

res = reduce(func, list, [init]);
res = reduce(function (a,b) a+b, list, <init=);

res = accumulate(func, list, [init]);
res = accumulate(function (a,b) a+b, list, [init=]);

x = while(init, cond, func);

x = for_n(n, init, func);

indices = find_all(func, list);
indices = find_all(function (x) x>1, list);

idx = find_first(func, list, [start=]);

idx = binsearch(key,list, [cmp]);

hx = simple_hash(x);

hm = hashmap([hashsize=]);
hm = hashmap(items=KEYVAL_LIST, [hashsize=]);     hm2 = hm(key, val);
hm2 = hm(additems=KEYVAL_LIST);     hm2 = hm(del=KEY);     x = hm(key);
for (kv=hm()) let(k=kv[0], v=kv[1]) ...

fn = f_1arg(func);

fn = f_2arg(target_func);

fn = f_2arg_simple(target_func);

fn = f_3arg(target_func);

newfunc = ival(func);

newfunc = xval(func);

fn = f_cmp();     fn = f_cmp(b);     fn = f_cmp(a,b);

fn = f_gt();     fn = f_gt(b);     fn = f_gt(a,b);

fn = f_lt();     fn = f_lt(b);     fn = f_lt(a,b);

fn = f_gte();     fn = f_gte(b);     fn = f_gte(a,b);

fn = f_lte();     fn = f_lte(b);     fn = f_lte(a,b);

fn = f_eq();     fn = f_eq(b);     fn = f_eq(a,b);

fn = f_neq();     fn = f_neq(b);     fn = f_neq(a,b);

fn = f_approx();     fn = f_approx(b);     fn = f_approx(a,b);

fn = f_napprox();     fn = f_napprox(b);     fn = f_napprox(a,b);

fn = f_or();     fn = f_or(a=);     fn = f_or(b=);     fn = f_or(a=,b=);

fn = f_and();     fn = f_and(a=);     fn = f_and(b=);     fn = f_and(a=,b=);

fn = f_nor();     fn = f_nor(a=);     fn = f_nor(b=);     fn = f_nor(a=,b=);

fn = f_nand();     fn = f_nand(a=);     fn = f_nand(b=);     fn = f_nand(a=,b=);

fn = f_xor();     fn = f_xor(a=);     fn = f_xor(b);     fn = f_xor(a=,b=);

fn = f_not();     fn = f_not(a);

fn = f_even();     fn = f_even(a);

fn = f_odd();     fn = f_odd(a);

fn = f_add();     fn = f_add(a=);     fn = f_add(b);     fn = f_add(a=,b=);

fn = f_sub();     fn = f_sub(a=);     fn = f_sub(b);     fn = f_sub(a=,b=);

fn = f_mul();     fn = f_mul(a=);     fn = f_mul(b);     fn = f_mul(a=,b=);

fn = f_div();     fn = f_div(a=);     fn = f_div(b);     fn = f_div(a=,b=);

fn = f_mod();     fn = f_mod(a=);     fn = f_mod(b);     fn = f_mod(a=,b=);

fn = f_pow();     fn = f_pow(a=);     fn = f_pow(b);     fn = f_pow(a=,b=);

fn = f_neg();     fn = f_neg(a);

fn = f_min();     fn = f_min(a);

fn = f_max();     fn = f_max(a);

fn = f_min2();     fn = f_min2(a=);     fn = f_min2(b);     fn = f_min2(a=,b=);

fn = f_max2();     fn = f_max2(a=);     fn = f_max2(b);     fn = f_max2(a=,b=);

fn = f_min3();     fn = f_min3(a=);     fn = f_min3(b=);     fn = f_min3(c=);
fn = f_min3(a=,b=);     fn = f_min3(b=,c=);     fn = f_min3(a=,c=);     fn = f_min3(a=,b=,c=);

fn = f_max3();     fn = f_max3(a=);     fn = f_max3(b=);     fn = f_max3(c=);
fn = f_max3(a=,b=);     fn = f_max3(b=,c=);     fn = f_max3(a=,c=);     fn = f_max3(a=,b=,c=);

fn = f_sin();     fn = f_sin(a);

fn = f_cos();     fn = f_cos(a);

fn = f_tan();     fn = f_tan(a);

fn = f_asin();     fn = f_asin(a);

fn = f_acos();     fn = f_acos(a);

fn = f_atan();     fn = f_atan(a);

fn = f_atan2();     fn = f_atan2(a=);     fn = f_atan2(b);     fn = f_atan2(a=,b=);

fn = f_len();     fn = f_len(a);

fn = f_chr();     fn = f_chr(a);

fn = f_ord();     fn = f_ord(a);

fn = f_str();     fn = f_str(a);

fn = f_str2();     fn = f_str2(a=);     fn = f_str2(b);     fn = f_str2(a=,b=);

fn = f_str3();     fn = f_str3(a=);     fn = f_str3(b=);     fn = f_str3(c=);
fn = f_str3(a=,b=);     fn = f_str3(b=,c=);     fn = f_str3(a=,c=);     fn = f_str3(a=,b=,c=);

fn = f_floor();     fn = f_floor(a);

fn = f_round();     fn = f_round(a);

fn = f_ceil();     fn = f_ceil(a);

fn = f_abs();     fn = f_abs(a);

fn = f_sign();     fn = f_sign(a);

fn = f_ln();     fn = f_ln(a);

fn = f_log();     fn = f_log(a);

fn = f_exp();     fn = f_exp(a);

fn = f_sqr();     fn = f_sqr(a);

fn = f_sqrt();     fn = f_sqrt(a);

fn = f_norm();     fn = f_norm(a);

fn = f_cross();     fn = f_cross(a=);     fn = f_cross(b);     fn = f_cross(a=,b=);

fn = f_is_def();

fn = f_is_undef();

fn = f_is_bool();

fn = f_is_num();

fn = f_is_int();

fn = f_is_nan();

fn = f_is_finite();

fn = f_is_string();

fn = f_is_list();

fn = f_is_range();

fn = f_is_function();

fn = f_is_vector();

fn = f_is_path();

fn = f_is_region();

fn = f_is_vnf();

fn = f_is_patch();

threaded_rod(d, l|length, pitch, [internal=], ...) [ATTACHMENTS];

threaded_nut(nutwidth, id, h|height|thickness, pitch,...) [ATTACHMENTS];

trapezoidal_threaded_rod(d, l|length, pitch, [thread_angle=|flank_angle=], [thread_depth=], [internal=], ...) [ATTACHMENTS];

trapezoidal_threaded_nut(nutwidth, id, h|height|thickness, pitch, [thread_angle=|flank_angle=], [thread_depth], ...) [ATTACHMENTS];

acme_threaded_rod(d, l|length, tpi|pitch=, [internal=], ...) [ATTACHMENTS];

acme_threaded_nut(nutwidth, id, h|height|thickness, tpi|pitch=, [shape=], ...) [ATTACHMENTS];

npt_threaded_rod(size, [internal=], ...) [ATTACHMENTS];

buttress_threaded_rod(d, l|length, pitch, [internal=], ...) [ATTACHMENTS];

buttress_threaded_nut(nutwidth, id, h|height|thickness, pitch, ...) [ATTACHMENTS];

square_threaded_rod(d, l|length, pitch, [internal=], ...) [ATTACHMENTS];

square_threaded_nut(nutwidth, id, h|height|thickness, pitch, ...) [ATTACHMENTS];

ball_screw_rod(d, l|length, pitch, [ball_diam], [ball_arc], [internal=], ...) [ATTACHMENTS];

generic_threaded_rod(d, l|length, pitch, profile, [internal=], ...) [ATTACHMENTS];

generic_threaded_nut(nutwidth, id, h|height|thickness, pitch, profile, [$slop], ...) [ATTACHMENTS];

thread_helix(d, pitch, turns=, [thread_depth=], [thread_angle=|flank_angle=], [profile=], [starts=], [internal=], ...) {ATTACHMENTS};
thread_helix(d1=,d2=, pitch=, turns=, [thread_depth=], [thread_angle=|flank_angle=], [profile=], [starts=], [internal=], ...) {ATTACHMENTS};

screw([spec], [head], [drive], [thread=], [drive_size=], [length=|l=], [thread_len=], [undersize=], [shaft_undersize=], [head_undersize=], [tolerance=], [blunt_start=], [details=], [anchor=], [atype=], [orient=], [spin=]) [ATTACHMENTS];

screw_hole([spec], [head], [thread=], [length=|l=], [oversize=], [hole_oversize=], [teardrop=], [head_oversize], [tolerance=], [$slop=], [blunt_start=], [anchor=], [atype=], [orient=], [spin=]) [ATTACHMENTS];

shoulder_screw(s, d, length, [head=], [thread_len=], [tolerance=], [head_size=], [drive=], [drive_size=], [thread=], [undersize=], [shaft_undersize=], [head_undersize=], [shoulder_undersize=],[atype=],[anchor=],[orient=],[spin=]) [ATTACHMENTS];

screw_head(screw_info, [details],[counterbore],[flat_height],[teardrop],[internal])

nut([spec], [shape], [thickness], [nutwidth], [thread=], [tolerance=], [hole_oversize=], [bevel=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

nut_trap_side(trap_width, [spec], [shape], [thickness], [nutwidth=], [poke_len=], [poke_diam=], [$slop=], [anchor=], [orient=], [spin=]) [ATTACHMENTS];

nut_trap_inline(length|l|heigth|h, [spec], [shape], [$slop=], [anchor=], [orient=], [spin=]) [ATTACHMENTS];

info = screw_info(name, [head], [drive], [thread=], [drive_size=], [oversize=], [head_oversize=])

nut_spec = nut_info(name, [shape], [thickness=], [thread=], [width=], [hole_oversize=]);

thread_specification(screw_spec, [tolerance], [internal])

phillips_mask(size) [ATTACHMENTS];

depth = phillips_depth(size, d);

diam = phillips_diam(size, depth);

hex_drive_mask(size, length, [anchor], [spin], [orient], [$slop]) [ATTACHMENTS];

torx_mask(size, l, [center]) [ATTACHMENTS];

torx_mask2d(size);

info = torx_info(size);

diam = torx_diam(size);

depth = torx_depth(size);

robertson_mask(size, [extra], [ang], [$slop=]);

pco1810_neck([wall]) [ATTACHMENTS];

pco1810_cap([h], [r|d], [wall], [texture]) [ATTACHMENTS];

pco1881_neck([wall]) [ATTACHMENTS];

pco1881_cap(wall, [texture]) [ATTACHMENTS];

generic_bottle_neck([wall], ...) [ATTACHMENTS];

generic_bottle_cap(wall, [texture], ...) [ATTACHMENTS];

bottle_adapter_neck_to_cap(wall, [texture], ...) [ATTACHMENTS];

bottle_adapter_cap_to_cap(wall, [texture]) [ATTACHMENTS];

bottle_adapter_neck_to_neck(...) [ATTACHMENTS];

sp_neck(diam, type, wall|id=, [style=], [bead=]) [ATTACHMENTS];

sp_cap(diam, type, wall, [style=], [top_adj=], [bot_adj=], [texture=], [$slop]) [ATTACHMENTS];

true_diam = sp_diameter(diam,type)

cubetruss(extents, [clips=], [bracing=], [size=], [strut=], [clipthick=], ...) [ATTACHMENTS];

cubetruss_corner(h, extents, [bracing=], [size=], [strut=], [clipthick=]);

cubetruss_support([size=], [strut=], [extents=]) [ATTACHMENTS];

cubetruss_foot(w, [size=], [strut=], [clipthick=]) [ATTACHMENTS];

cubetruss_joiner([w=], [vert=], [size=], [strut=], [clipthick=]) [ATTACHMENTS];

cubetruss_uclip(dual, [size=], [strut=], [clipthick=]) [ATTACHMENTS];

cubetruss_segment([size=], [strut=], [bracing=]);

cubetruss_clip(extents, [size=], [strut=], [clipthick=]) [ATTACHMENTS];

length = cubetruss_dist(cubes, [gaps], [size=], [strut=]);

spur_gear(circ_pitch, teeth, [thickness], [helical=], [pressure_angle=], [profile_shift=], [backlash=], [shaft_diam=], [hide=], [clearance=], [slices=], [internal=], [herringbone=]) [ATTACHMENTS];
spur_gear(mod=|diam_pitch=, teeth=, [thickness=], ...) [ATTACHMENTS];
vnf = spur_gear(circ_pitch, teeth, [thickness], ...);
vnf = spur_gear(mod=|diam_pitch=, teeth=, [thickness=], ...);

spur_gear2d(circ_pitch, teeth, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]) [ATTACHMENTS];
spur_gear2d(mod=|diam_pitch=, teeth=, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]) [ATTACHMENTS];
rgn = spur_gear2d(circ_pitch, teeth, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]);
rgn = spur_gear2d(mod=, teeth=, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]);

ring_gear(circ_pitch, teeth, thickness, [backing|od=|or=|width=], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear(mod=, teeth=, thickness=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear(diam_pitch=, teeth=, thickness=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];

ring_gear2d(circ_pitch, teeth, [backing|od=|or=|width=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear2d(mod=, teeth=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear2d(diam_pitch=, teeth=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];

rack(pitch, teeth, thickness, [base|bottom=|width=], [helical=], [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
rack(mod=, teeth=, thickness=, [base=|bottom=|width=], [helical=], [pressure_angle=], [backlash]=, [clearance=]) [ATTACHMENTS];
vnf = rack(pitch, teeth, thickness, [base|bottom=|width=], [helical=], [pressure_angle=], [backlash=], [clearance=]);
vnf = rack(mod=, teeth=, thickness=, [base=|bottom=|width=], [helical=], [pressure_angle=], [backlash=], [clearance=]);

rack2d(pitch, teeth, [base|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
rack2d(mod=, teeth=, [base=|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
path = rack2d(pitch, teeth, [base|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]);
path = rack2d(mod=, teeth=, [base=|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]);

crown_gear(circ_pitch, teeth, backing, face_width, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
crown_gear(diam_pitch=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
crown_gear(mod=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
vnf = crown_gear(circ_pitch, teeth, backing, face_width, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
vnf = crown_gear(diam_pitch=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
vnf = crown_gear(mod=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);

gear_dist(mod=|diam_pitch=|circ_pitch=, teeth, mate_teeth, [shaft_angle], [shaft_diam], [face_width=], [hide=], [spiral=], [cutter_radius=], [right_handed=], [pressure_angle=], [backing=|thickness=|bottom=], [cone_backing=], [backlash=], [slices=], [internal=], [gear_spin=], ...) [ATTACHMENTS];
vnf = gear_dist(mod=|diam_pitch=|circ_pitch=, teeth, mate_teeth, [shaft_angle], [face_width=], [hide=], [spiral=], [cutter_radius=], [right_handed=], [pressure_angle=], , [backing=|thickness=|bottom=], [cone_backing=], [backlash=], [slices=], [internal=], [gear_spin=], ...);

worm(circ_pitch, d, l, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
worm(mod=, d=, l=, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
vnf = worm(circ_pitch, d, l, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
vnf = worm(mod=, d=, l=, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);

enveloping_worm(circ_pitch, mate_teeth, d, [left_handed=], [starts=], [arc=], [pressure_angle=]);
enveloping_worm(mod=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
enveloping_worm(diam_pitch=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
vnf = enveloping_worm(circ_pitch, mate_teeth, d, [left_handed=], [starts=], [arc=], [pressure_angle=]);
vnf = enveloping_worm(mod=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
vnf = enveloping_worm(diam_pitch=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);

worm_gear(circ_pitch, teeth, worm_diam, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=], [shaft_diam=]) [ATTACHMENTS];
worm_gear(mod=, teeth=, worm_diam=, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=], [shaft_diam=]) [ATTACHMENTS];
vnf = worm_gear(circ_pitch, teeth, worm_diam, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=]);
vnf = worm_gear(mod=, teeth=, worm_diam=, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=]);

gear_data = planetary_gears(mod=|circ_pitch=|diam_pitch=, n, max_teeth, ring_carrier=|carrier_ring=|sun_carrier=|carrier_sun=|sun_ring=|ring_sun=, [helical=], [gear_spin=]);

circ_pitch = circular_pitch(circ_pitch);     circ_pitch = circular_pitch(mod=);
circ_pitch = circular_pitch(diam_pitch=);

dp = diametral_pitch(circ_pitch);     dp = diametral_pitch(mod=);
dp = diametral_pitch(diam_pitch=);

mod = module_value(circ_pitch);     mod = module_value(mod=);
mod = module_value(diam_pitch=);

pr = pitch_radius(pitch, teeth, [helical]);
pr = pitch_radius(mod=, teeth=, [helical=]);

or = outer_radius(circ_pitch, teeth, [helical=], [clearance=], [internal=], [profile_shift=], [shorten=]);
or = outer_radius(mod=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=], [shorten=]);
or = outer_radius(diam_pitch=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=], [shorten=]);

ang = bevel_pitch_angle(teeth, mate_teeth, [drive_angle=]);

thick = worm_gear_thickness(pitch, teeth, worm_diam, [worm_arc=], [crowning=], [clearance=]);
thick = worm_gear_thickness(mod=, teeth=, worm_diam=, [worm_arc=], [crowning=], [clearance=]);

dist = worm_dist(mod=|diam_pitch=|circ_pitch=, d, starts, teeth, [profile_shift], [pressure_angle=]);

dist = gear_dist(mod=|diam_pitch=|circ_pitch=, teeth1, teeth2, [helical], [profile_shift1], [profile_shift2], [pressure_angle=], [backlash=]);

dist = gear_dist_skew(mod=|diam_pitch=|circ_pitch=, teeth1, teeth2, helical1, helical2, [profile_shift1], [profile_shift2], [pressure_angle=]

ang = gear_skew_angle(teeth1, teeth2, helical1, helical2, [profile_shift1], [profile_shift2], [pressure_angle=]

total_shift = get_profile_shift(mod=|diam_pitch=|circ_pitch=, desired, teeth1, teeth2, [helical], [pressure_angle=],

x = auto_profile_shift(teeth, [pressure_angle], [helical], [profile_shift=]);
x = auto_profile_shift(teeth, [pressure_angle], [helical], get_min=);
x = auto_profile_shift(teeth, min_teeth=);

shorten = gear_shorten(teeth1, teeth2, [helical], [profile_shift1], [profile_shift2], [pressure_angle=]);

shorten = gear_shorten_skew(teeth1, teeth2, helical1, helical2, [profile_shift1], [profile_shift2], [pressure_angle=]);

knuckle_hinge(length, offset, segs, [inner], [arm_height=], [arm_angle=], [fill=], [clear_top=], [gap=], [round_top=], [round_bot=], [knuckle_diam=], [pin_diam=], [pin_fn=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

living_hinge_mask(l, thick, [layerheight=], [foldangle=], [hingegap=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

apply_folding_hinges_and_snaps(thick, [foldangle=], [hinges=], [snaps=], [sockets=], [snaplen=], [snapdiam=], [hingegap=], [layerheight=], [$slop=]) CHILDREN;

snap_lock(thick, [snaplen=], [snapdiam=], [layerheight=], [foldangle=], [hingegap=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

snap_socket(thick, [snaplen=], [snapdiam=], [layerheight=], [foldangle=], [hingegap=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];

half_joiner_clear(l, w, [ang=], [clearance=], [overlap=]) [ATTACHMENTS];
vnf = half_joiner_clear(l, w, [ang=], [clearance=], [overlap=]);

half_joiner(l, w, [base=], [ang=], [screwsize=], [$slop=]) [ATTACHMENTS];
vnf = half_joiner(l, w, [base=], [ang=], [screwsize=], [$slop=]);

half_joiner2(l, w, [base=], [ang=], [screwsize=])
vnf = half_joiner2(l, w, [base=], [ang=], [screwsize=])

joiner_clear(l, w, [ang=], [clearance=], [overlap=]) [ATTACHMENTS];

joiner(l, w, base, [ang=], [screwsize=], [$slop=]) [ATTACHMENTS];

dovetail(gender, w=|width, h=|height, slide|thickness=, [slope=|angle=], [taper=|back_width=], [chamfer=], [r=|radius=], [round=], [extra=], [$slop=])

snap_pin(size, [pointed=], [anchor=], [spin=], [orient]=) [ATTACHMENTS];
snap_pin(r=|radius=|d=|diameter=, l=|length=, nub_depth=, snap=, thickness=, [clearance=], [preload=], [pointed=]) [ATTACHMENTS];

snap_pin_socket(size, [fixed=], [fins=], [pointed=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
snap_pin_socket(r=|radius=|d=|diameter=, l=|length=, nub_depth=, snap=, [fixed=], [pointed=], [fins=]) [ATTACHMENTS];

rabbit_clip(type, length, width, snap, thickness, depth, [compression=], [clearance=], [lock=], [lock_clearance=], [splineteps=], [anchor=], [orient=], [spin=]) [ATTACHMENTS];

linear_bearing_housing(d, l, tab, gap, wall, tabwall, screwsize) [ATTACHMENTS];

linear_bearing(l, od, id, length) [ATTACHMENTS];

lmXuu_housing(size, tab, gap, wall, tabwall, screwsize) [ATTACHMENTS];

lmXuu_bearing(size) [ATTACHMENTS];

diam_len = lmXuu_info(size);

modular_hose(size, type, [clearance], [waist_len], [anchor], [spin], [orient]) [ATTACHMENTS];

r = modular_hose_radius(size, [outer]);

nema_stepper_motor(size, h, shaft_len, [$slop=], ...) [ATTACHMENTS];

nema_mount_mask(size, depth, l, [$slop], ...);

info = nema_motor_info(size);

regular_polyhedron([name],[index=],[type=],[faces=],[facetype=],[hasfaces=],...) [CHILDREN];
regular_polyhedron(..., [or=|r=|d=],[ir=],[mr=],[side=],[facedown=],[anchor=], ...) [CHILDREN];]
regular_polyhedron(..., [draw=], [rounding=], [stellate=], [repeat=], [rotate_children=]) [CHILDREN];
regular_polyhedron("trapezohedron", [longside=],[h=], ...) [CHILDREN];

info = regular_polyhedron_info(info, ...);

slider(l, w, h, [base=], [wall=], [ang=], [$slop=]) [ATTACHMENTS];

rail(l, w, h, [chamfer=], [ang=]) [ATTACHMENTS];

manfrotto_rc2_plate([chamfer],[anchor],[orient],[spin]) [ATTACHMENTS];

sparse_wall(h, l, thick, [maxang=], [strut=], [max_bridge=]) [ATTACHMENTS];

corrugated_wall(h, l, thick, [strut=], [wall=]) [ATTACHMENTS];

thinning_wall(h, l, thick, [ang=], [braces=], [strut=], [wall=]) [ATTACHMENTS];

thinning_triangle(h, l, thick, [ang=], [strut=], [wall=], [diagonly=], [center=]) [ATTACHMENTS];

narrowing_strut(w, l, wall, [ang=]) [ATTACHMENTS];

wire_bundle(path, wires, [wirediam], [rounding], [wirenum=], [corner_steps=]);