Syntax Summary

Syntax Summary

(abl:abh-edge-offset blank radius limit-list
[acis-opts])

(abl:abh-edge-project blank edge distance direction
left sequence [acis-opts])

(abl:abh-imprint int-graph edge-list [acis-opts])

(abl:abh-slice blank tool [acis-opts])

(abl:const-rad radius [acis-opts])

(abl:create-vradius-wire svradius min-param
max-param max-iteration)

(abl:create-vradius-wire-from-edge svradius in-edge
max-iteration)

(abl:edge-blend edge {vradius=null | vradius-pair
         round1=-1.0 round2=-1.0}
         [single=#f] [lofted-keyword loft-edge=null]
         [section-keyword left-thumbweight=-1.0
         right-thumbweight=-1.0]
         [side-edge1=null [tangent-flag1=#f]]
         [side-edge2=null [tangent-flag2=#f]]
         [start-setback=-1.0 end-setback=1.0])

(abl:ell-rad ref-face-left major1 min1 angle1 angle2
[major2=major1 min2=min1] [acis-opts])

(abl:ent-ent-blend {face1 | edge1 [tangent-keyword
         tangent-face1]} {face2 | edge2
         [tangent-keyword tangent-face2]}
         {vradius | vradius-pair round1 round2}
         position convexity
         [def-edge] [section-keyword left-thumbweight
         right-thumbweight] [acis-opts])

(abl:create-vradius-value svradius sreal min-param
max-param)

(abl:create-vradius-value-from-edge svradius
sreal in-edge)

(abl:fixed-width-rad width [acis-opts])

(abl:make-radius-param-rads param-list radii-list
[acis-opts])

(abl:make-radius-param-rads-tan param-list
radii-list [slope-keyword slope]
[slope-keyword slope] [acis-opts])

(abl:pos-rad position-list radii-list curve-edge
["start-tan"]["end-tan"] [transform] [acis-opts])

(abl:rnd-ch-rad left1 right1
[left2=left1 right2=right1] [acis-opts])

(abl:set-abh-blends edge-list {vradius=null | vradius-pair}
         [section-keyword value1 value2]
         [calibration-keyword
         {calibration-curve start-edge end-edge} |
         {(calibration-curve start-edge end-edge)}]
         [side-edge1=null [tangent-flag1=#f]]
         [side-edge2=null [tangent-flag2=#f]]
         [start-setback=0 end-setback=0]
         [lofted-keyword loft-edge] [acis-opts])

(abl:set-instruction entity action=2 [position]
[acis-opts])

(abl:spline-rad edge [acis-opts])

(abl:two-ends-rad radius1 radius2 [acis-opts])

(abl:var-round edge radius-1 radius-2
["fix" | "single"] [acis-opts])

(acis:test type | date | test-name)

(acisoptions:set [acis-opts] [["option-name" option] | ...])

(acis_journal:end acis-opts)

(acis_journal:pause acis-opts)

(acis_journal:resume acis-opts)

(acis_journal:set [journal | acis-opts]
["file "filename"])

(acis_journal:start acis-opts)

(adv-cover:cover-circuit edge adv-cover-opts)

(adv-cover:max-gap adv-cover-opts)

(adv-cover:options [name-of-option
value] [adv-cover-opts])

(adv-cover:recover-face face adv-cover-opts)

(afig:apply-transform fig tform)

(afig:create entity-lits)

(afig:get-transform fig)

(afig:set-transform fig tform)

(afig:show fig [off] [view=active])

(annotation:assert anno-save-name [history]
[member-name entity] ...)

(annotation:assert-not anno-save-name [history]
[member-name entity] ...)

(annotation:clear-all)

(annotation:hook-all)

(annotation:inputs entity [no-tags])

(annotation:member-name annotation entity)

(annotation:outputs annotation)

(annotation:unhook-all)

(arc:center arc)

(arc:end-angle arc)

(arc:major-axis arc)

(arc:radius arc)

(arc:set-center curve center)

(arc:set-direction curve vector)

(arc:set-end curve angle)

(arc:set-normal curve vector)

(arc:set-radius curve radius)

(arc:set-radius-ratio curve ratio)

(arc:set-start curve angle)

(arc:start-angle arc)

(attrib:add entity-list name [value])

(attrib:get entity [name [value]])

(attrib:remove entity-list [name [value]])

(attrib:replace entity-list name [value])

(background type)

(background:props background)

(background:set-prop background name value)

(background:type background)

(background:types)

(background? object)

(blend:chamfer edge left-range right-range
["fix" | "single"])

(blend:chamfer-on-edge entity-list offset-left
[offset-right=offset-left setback-start=0
setback-end=setback-start] [acis-opts])

(blend:complete wire sheet body [acis-opts])

(blend:const-rad-on-edge entity-list blend-radius
[setback-start=0 setback-end=setback-start] [acis-opts])

(blend:delete entity ["single"] [acis-opts])

(blend:edge-info edge)

(blend:enquire edge)

(blend:entities [entity-list] [option [data]]...)

(blend:fix edge [acis-opts])

(blend:get-network entity [acis-opts])

(blend:get-smooth-edges entity [acis-opts])

(blend:make-cross-curve edge real [acis-opts])

(blend:make-sheet entity-list [acis-opts])

(blend:make-ss-sheet entity-list)

(blend:make-wire sheet body [acis-opts])

(blend:network entity-list [acis-opts])

(blend:on-vertex entity-list [setback=-1 [bulge=1]] |
[flag [bulge]])

(blend:preview edge)

(blend:remove-from-edge edge)

(blend:remove-from-vertex vertex)

(blend:round edge blend-radius ["fix" | "single"])

(blend:set-prop edge {prop-name value})

(blend:sheet edge [acis-opts])

(blend:smooth-edges-to-curve edge-list [acis-opts])

(blend:ss-sheet edge [acis-opts])

(blend:test [type | date | test-name] [dojournal])

(blend:var-rad-on-edge entity-list radius-start
radius-end [setback-start=0
setback-end=setback-start] [acis-opts])

(blend:var-round edge start-radius end-radius
["fix" | "single"])

(blend:vertex vertex {prop-name value} [type] [acis-opts])

(blend:vertex-info vertex)

(blend:wire edge sheet [acis-opts])

(body:combine body-list)

(body:edge-regions edge-list [coin-tol] [min-length])

(body:find-face body direction)

(body:get-transform body)

(body:reverse body)

(body:separate entity)

(body? object)

(bool:chop body1 body2 [keep-leftovers=#t]
[keep-opt] [acis-opts])

(bool:clip [body-list] [view=active]
[hither=SPAresabs] [yon] [acis-opts])

(bool:glue-subtract body1 body2 faces1 faces2
[glue-opts | "name-of-option" {value} ...]
[keep-opt] [acis-opts])

(bool:glue-subtract-inter-graph body1 body2 faces1
faces2 [glue-opts | "name-of-option" {value} ...]
[acis-opts])

(bool:glue-unite body1 body2 faces1 faces2
[glue-opts | "name-of-option" {value} ...]
[keep-opt] [acis-opts])

(bool:glue-unite-inter-graph body1 body2 faces1
faces2 [glue-opts | "name-of-option" {value} ...]
[acis-opts])

(bool:intersect body1 ... bodyn [keep-opt] [acis-opts])

(bool:join-edges edgelist [join] [acis-opts])

(bool:merge entity [acis-opts])

(bool:merge-faces body [type=plane] [acis-opts])

(bool:nonreg-chop body1 body2 [keep-leftovers=#t]
[keep-opt] [acis-opts])

(bool:nonreg-intersect body1 ... bodyn [keep-opt] [acis-opts])

(bool:nonreg-subtract body1 ... bodyn [keep-opt]
[acis-opts])

(bool:nonreg-unite body1 ... bodyn [keep-opt]
[acis-opts])

(bool:regularise ent [acis-opts])

(bool:sel-imprint tool-body-or-faces blank-body-or-faces [split-check=#t] [acis-opts])

(bool:sel-unite blank-body tool-body
option1 option2)

(bool:select1 blank-body tool-body [acis-opts])

(bool:select2 in-body in-cells [acis-opts])

(bool:subtract body1 ... bodyn [keep-opt]
[acis-opts])

(bool:trim-faces faces [trim] [acis-opts])

(bool:tube blank tool start end opt [acis-opts])

(bool:unite body1 ... bodyn [keep-opt]
[acis-opts])

(bool:unite-wires tool blank [acis-opts])

(bool:wifa-imp edge face*)

(cell:2d? cell)

(cell:3d? cell)

(cell:area cell [accuracy=0.1])

(cell:attach entity-list)

(cell:classify-position cell position)

(cell:copy cell)

(cell:expand entity-list)

(cell:find face1 [face2])

(cell:flatten entity-list)

(cell:massprop cell [selector accuracy
proj-root proj-normal])

(cell:remove entity-list)

(cell? entity)

(check-interrupt)

(coedge:add-pcurve coedge)

(coedge:types)

(coedge? object)

(color:rgb red green blue)

(color:rgb? object)

(curve:bs3-eval-arc-3curve curve-list point-list
param-list normal)

(curve:bs3-eval-tan-pt curve point guess-param)

(curve:circular center radius [normal=z-axis])

(curve:circular? object)

(curve:domain edge)

(curve:elliptical center major-axis [normal=z-axis]
[ratio])

(curve:elliptical? object)

(curve:end-param edge-or-curve)

(curve:end-pos edge-or-curve)

(curve:end-tan edge-or-curve)

(curve:eval edge-or-curve parameter [integer-type])

(curve:eval-curvature edge parameter)

(curve:eval-pos edge-or-curve parameter)

(curve:eval-tan edge-or-curve parameter)

(curve:from-edge edge)

(curve:from-tcoedge tcoedge)

(curve:intersect curve1 curve2 [bounded=#t] [acis-opts])

(curve:length edge-or-curve [start] [end])

(curve:linear pos-start pos-gvec)

(curve:linear? object)

(curve:normal edge-or-curve)

(curve:param edge-or-curve param-pos)

(curve:param-at-dist edge-or-curve distance [parameter=0])

(curve:project-pos edge-or-curve in-pos [parameter=0])

(curve:ray-pos [curve pick-ray] | [entray])

(curve:start-param edge-or-curve)

(curve:start-pos edge-or-curve)

(curve:start-tan edge-or-curve)

(curve:transform edge-or-curve transform)

(curve? object)

(cvty:concave cvty)

(cvty:convex cvty)

(cvty:inflect cvty)

(cvty:knife cvty)

(cvty:mixed cvty)

(cvty:tangent cvty)

(cvty:unknown cvty)

(cvty:unset cvty)

(debug:all-modules level=0 [base-level])

(debug:file [filename | "stderr" | "stdout"])

(debug:list-modules [level=off])

(debug:module module-name [level=off])

(derived-tag:string tag)

(dl-item:color item)

(dl-item:display item)

(dl-item:erase item)

(dl-item:point position)

(dl-item:polyline position-list [fill=#f])

(dl-item:set-color item color)

(dl-item:text position string)

(dl-item? object)

(dl:dynamic-silhouette-display on-off)

(dl:interleaf [filename=plotfile.il] [color=#f]
[x-size y-size] [view=active])

(dl:metafile [filename] [view=active] [emf-wmf]
[header=#f])

(dl:postscript [filename=plotfile.ps] [color=#f]
[x-size y-size] [view=active])

(dl:print [x-resolution=300 y-resolution=300]
[view=active])

(ds:add-attractor owner target=1 [xyz-position] [power=2]
gain=100)

(ds:add-circ-cstrn owner target=1 behavior uv-center
uv-a uv-b [element-count=8 integral-degree=10])

(ds:add-circ-load owner target=1 uv-center uv-a uv-b
[gain=100 element-count=8 integral-degree=10])

(ds:add-cstrn owner target=1 {shape | tag} behavior
{uv-pts}+ [integral-degree=10])

(ds:add-dist-press owner target=1 gain=100 [pos-param1 pos-param2])

(ds:add-parab-cstrn owner target=1 behavior
start-ppt tang-xsect-ppt stop-ppt
[integral-degree=10])

(ds:add-parab-load owner target=1 start-ppt
tang-xsect-ppt stop-ppt
[gain=100 integral-degree=10])

(ds:add-patch owner target=1 shape point1 point2 point3
refinement)

(ds:add-pt-cstrn owner target=1 behavior
{uv-position | pick-event})

(ds:add-pt-press owner target=1 {uv-position | pick} gain=100)

(ds:add-spring owner target=1 {uv-position | pick} [xyz-position]
gain=100 [slide-state=0])

(ds:add-spring-curve owner target=1 pos-param1 pos-param2
{{position1 position2} | {positionc positiona positionb}}
[gain=100 integral-degree=10])

(ds:add-spring-set owner target=1 [domain-points] position gain)

(ds:add-str-cstrn owner target=1 behavior
start-point stop-point [integral-degree=10])

(ds:add-str-load owner target=1 start-point stop-point
[gain=100 integral-degree=10])

(ds:add-vector-load owner target=1 [image-vector]
gain=100)

(ds:adm-options "name-of-option"
{value(s)} {options})

(ds:commit owner)

(ds:crv-cstrn-from-load owner tag memory="remember")

(ds:crv-load-from-cstrn owner tag memory="remember")

(ds:debug owner [target=1])

(ds:elevate-degree owner [target=1] [continuity-flag=0])

(ds:end-sculpting owner)

(ds:extrapolate owner target=1)

(ds:gen-path [start-time=0 stop-time=3600 store-count=121
integration-count=3])

(ds:get-active-patch owner)

(ds:get-alpha owner [target=1])

(ds:get-beta owner [target=1])

(ds:get-child-tag owner [target=1])

(ds:get-comb-graphics owner [target=1])

(ds:get-cstrn owner tag)

(ds:get-default-state owner [target=1])

(ds:get-delta owner [target=1])

(ds:get-tags owner owner tag)

(ds:get-dmods owner)

(ds:get-dof-state owner [target=1])

(ds:get-draw-grid owner [target=1])

(ds:get-draw-state owner [target=1] flag)

(ds:get-dynamics owner [target=1])

(ds:get-entities owner)

(ds:get-entity owner tag)

(ds:set-epsilon owner target)

(ds:get-gamma owner [target=1])

(ds:get-icon-radius owner)

(ds:get-integral-degree owner [target=1])

(ds:get-interior-state owner [target=1])

(ds:get-load-gain owner tag)

(ds:get-minimal-corners owner tag)

(ds:get-parent-tag owner [target=1])

(ds:get-pt-uv owner tag)

(ds:get-pt-xyz owner tag [point-index=0])

(ds:get-shape-degree owner [target=1])

(ds:get-shape-dofs owner [target=1])

(ds:get-shape-knots owner [target=1])

(ds:get-sibling-tag owner [target=1])

(ds:get-spring-length owner target=1 gain=100 [inc])

(ds:get-tag-param-max owner tag)

(ds:get-tag-param-min owner tag)

(ds:get-tag-patch owner tag)

(ds:get-tag-summary owner [target=1 print=1])

(ds:get-tag-type owner tag)

(ds:get-tags owner)

(ds:get-tan-display-gain owner [target=1])

(ds:get-tight-state owner tag)

(ds:get-type-string type)

(ds:get-xyz owner target=1 uv-position)

(ds:journal-off)

(ds:journal-on filename [cascade=0])

(ds:link-face face1 face2 [adm-options]
[acis-opts])

(ds:make-tracking-curve owner tag target=1)

(ds:pick-dmod-tag owner pick-event)

(ds:pick-par-pos owner pick-event [tag-flag=2])

(ds:pick-position owner pick-event [tag-flag=2])

(ds:pick-tag-id owner pick-event)

(ds:remove-dm-attributes owner)

(ds:rm-multi-face owner target)

(ds:rm-patch owner [target=1])

(ds:rm-tag-object owner tag)

(ds:set-alpha owner target=1 resistance-u [resistance-v atheta])

(ds:set-attractor-power owner target=1 [power=2])

(ds:set-beta owner target=1 bend-resu [bend-resv btheta])

(ds:set-comb-graphics owner target=1 elem-point-count
gain=1)

(ds:set-cstrn-behavior owner tag behavior)

(ds:set-cstrn-domain-dir owner tag uv-dir point-index)

(ds:set-cstrn-state owner tag state)

(ds:set-default-shape owner target=1 shape-flag)

(ds:set-delta owner target=1 delta)

(ds:set-draw-grid owner target=1 gridpolygonu [gridpolygonv])

(ds:set-draw-state owner target=1 ctpoint-flag)

(ds:set-dynamics owner target=1 timestep-dt mass damp)

(ds:set-epsilon owner target epsilon)

(ds:set-gamma owner target=1 [gamma])

(ds:set-icon-radius owner radius)

(ds:set-interior-state owner target=1 interior-stateflag)

(ds:set-load-gain owner tag gain [increment])

(ds:set-pt-uv owner tag uv-position)

(ds:set-pt-xyz owner tag point-index
{xyz-position | direction pick-event})

(ds:set-tag-icon-grid owner tag density)

(ds:set-tag-icon-size owner tag size)

(ds:set-tan-display-gain owner target=1 [gain=1])

(ds:set-tight-state owner tag state)

(ds:set-tracking-curve-target owner tag
edge [rev=0])

(ds:solve owner [target=1 iteration-count=1])

(ds:split-domain owner target=1 uv-pos-list)

(ds:start-adm entity [adm-options] [acis-opts])

(ds:test-edge controlpt-count [size-x=36 [size-z=0.0
[curve-degree=3 [x0=0 [u-min=0 [u-max=1]]]]]])

(ds:test-face ucont-pt-count vcont-pt-count
         [size-x=36 [size-y=36 [size-z=0 [rational=0
         [degree-u=3 [degree-v=3 [x0=0 [y0=0
         [u-min=0 [v-min=0 [u-max=1 [v-max=1]]]]]]]]]]]])

(ds:test-scatter point-count x-size y-size z-size)

(ds:toggle-cstrn owner tag)

(ds:toggle-seam owner target=1)

(ds:use-link-cstrns)

(dummy-name:add entity string)

(ed-cvty-info:angles ed-cvty-info)

(ed-cvty-info:instantiate ed-cvty-info tolerance)

(ed-cvty-info:tangent-convexity ed-cvty-info)

(ed-cvty-info:unknown ed-cvty-info)

(ed-cvty-info:unset ed-cvty-info)

(edge:arclength-metric edge)

(edge:arclength-param edge [approx-ok])

(edge:bezier point1 point2 point3 point4)

(edge:bezier-ndeg (list-points))

(edge:bs in-edge [extra-info=#f])

(edge:chain start-edge-entity [stop-edge-entity])

(edge:circular center-position radius
[start-angle=0 [end-angle=360]])

(edge:circular-3curve entray1 entray2 entray3
[full=#t])

(edge:circular-3pt edge-pos1 edge-pos2
edge-pos3 [full=#f])

(edge:circular-center-rim center-pos
edge-pos1 [edge-pos2=360])

(edge:circular-diameter edge-pos1
edge-pos2 [full=#f])

(edge:circular? object)

(edge:combine edge1 edge2)

(edge:conic point1 point2 point3 rho)

(edge:convexity edge [param] [acis-opts])

(edge:curve? object)

(edge:domain edge)

(edge:ed-cvty-info edge [use-curvatures=#t]
[approx-ok=#f] [interval=entire common-range])

(edge:ellipse center normal major-axis
[radius-ratio=1 [start-angle=0 end-angle=360]])

(edge:elliptical center-pos start-pos ratio
[start-angle=0 [end-angle=360]])

(edge:elliptical? object)

(edge:end edge)

(edge:end-dir edge)

(edge:end-pt-cvty-info edge [use-curvatures=#t])

(edge:entity-rel edge entity)

(edge:extend in-entity in-start in-end)

(edge:fillet entray1 entray2 radius
[trim1=#t [trim2=#t]])

(edge:from-curve curve [start end])

(edge:get-tolerance edge [force-update])

(edge:helix axis-start axis-end start-dir radius
thread-distance [handedness=#t])

(edge:law law start end [perp-law])

(edge:length edge)

(edge:linear {position | point | entray}
{position | point | entray})

(edge:linear? object)

(edge:merge edge)

(edge:mid-point edge [approximation=#t])

(edge:mid-point-dir edge [approximation=#t])

(edge:mid-pt-cvty-info edge [use-curvatures=#t])

(edge:min-rad in-edge)

(edge:move edge dist [extend=#t])

(edge:plaw surface law start end)

(edge:project-to-face in-edge in-face)

(edge:project-to-plane edge plane-pos plane-normal)

(edge:pt-cvty-info edge param
[use-curvatures=#t])

(edge:reverse edge)

(edge:reversed? edge face)

(edge:scan-gaps edges)

(edge:set-free edges)

(edge:set-no-merge-attrib [edge-list] [acis-opts])

(edge:shortest edges)

(edge:spiral center normal [start-position |
start-direction] width angle [handedness
start-radius])

(edge:spline position-list
         [[start-angle | start-direction | spline-condition]
         [end-angle | end-direction]] ["periodic"]
         ["exact"])

(edge:spline position-list param-list
[start-direction | spline-condition]
[end-direction])

(edge:spline? object)

(edge:split edge1 {position | edge2})

(edge:split-at-disc edge [disc-order | acis-opts])

(edge:split-at-proportion edge proportion)

(edge:spring axis-point axis-vector
         start-position handedness thread-distance
         rotation-degrees {[trans-height trans-degrees
         thread-distance rotation-degrees]...})

(edge:spring-law axis-point axis-vector
         start-position radius-law handedness
         thread-distance rotation-degrees
         {[trans-height trans-degrees
         thread-distance rotation-degrees]...})

(edge:spring-tapte axis-point axis-vector start-position
         taper-angle handedness thread-distance
         rotation-degrees {[trans-height trans-degrees
         thread-distance rotation-degrees]...})

(edge:start edge)

(edge:start-dir edge)

(edge:start-pt-cvty-info edge [use-curvatures=#t])

(edge:tolerant edge)

(edge:trim entray {position | entray})

(edge:trim-chain entray-list close)

(edge:trim-intersect entray entray)

(edge:trim-middle entray {position | entray}
{position | entray})

(edge:type edge)

(edge:types)

(edge? object)

(eelist:add list entity)

(eelist:entities list)

(eelist:new)

(eelist:remove list entity)

(entity entity-id [part=active])

(entity:accurate-approx entity [fit=resfit])

(entity:annotation-names entity)

(entity:annotation entity)

(entity:attach-derived-tag entity string)

(entity:bend ent-list neutral-root bending-axis
         bending-direction bend-radius
         [bend-angle [bend-width
         [center-bend-flag [bend-position*]]]])

(entity:bend-to-curve body start end initial-rail
edge final-rail)

(entity:box entity-list [create-box])

(entity:cells body-list)

(entity:check entity-list [check-level]
[insanity-type] [acis-opts])

(entity:coedges entity-list [include-pat])

(entity:color entity)

(entity:copy entity-list [part])

(entity:copy-contents entity [transform])

(entity:count-facets [entity])

(entity:debug entity [level=0])

(entity:deep-copy entity-list [part] [deepcopy-skip=#f])

(entity:delete entity-list)

(entity:delete-facets entity-list)

(entity:dindex given-entity [containing-entity])

(entity:display entity-list)

(entity:display-facets entity-list [view] [hide])

(entity:displayed? entity)

(entity:dist part1 part2 [acis-opts])

(entity:dspindex entity type index)

(entity:edges entity-list)

(entity:erase entity-list)

(entity:extrema entity vector1 [vector2] [vector3] [acis-opts])

(entity:faces entity-list)

(entity:facet entity-list [view] [unfaceted-only]
[acis-opts])

(entity:facet-area entity-list [acis-opts])

(entity:faceted? entity)

(entity:fix-transform body)

(entity:get-id entity)

(entity:highlighted? entity)

(entity:how-connected entity1 entity2 [scan-type])

(entity:index entity [list])

(entity:loops entity-list [include-pat])

(entity:lose-attribs entity [save-name])

(entity:lumps entity-list)

(entity:material entity)

(entity:material-color entity)

(entity:material-reflection entity)

(entity:material-texture entity)

(entity:material-transparency entity)

(entity:move body-list xoffset yoffset
zoffset [fix-transform])

(entity:next entity)

(entity:owner entity)

(entity:part entity)

(entity:pattern entity pattern [copy-pat
[seed-index [no-cross-face-list] [check]]] [acis-opts])

(entity:point-distance entity position [acis-opts])

(entity:previous entity)

(entity:print-facets [entity-list]
[view] [scale] [hide] [acis-opts])

(entity:refinement entity [acis-opts])

(entity:refinements entity)

(entity:reflect body-list [xorigin=0 yorigin=0 zorigin=0]
xnormal ynormal znormal [fix-transform])

(entity:refresh-pattern entity refresh-list pattern
[copy-pattern] [seed-index] [no-cross-faces] [check])

(entity:remove-pcurves entity)

(entity:render-sides entity)

(entity:reset-boxes entity)

(entity:reset-pcurves entity [coedges])

(entity:rotate body-list [xorigin yorigin zorigin]
xaxis yaxis zaxis angle [fix-transform])

(entity:scale body-list xscale
[yscale=xscale zscale=xscale] [fix-transform])

(entity:select entity-list {on-off})

(entity-selected? entity)

(entity:sense in-entity)

(entity:set-color entity-list color)

(entity:set-facet-color entity vector)

(entity:set-highlight entity-list {on-off})

(entity:set-material entity-list material)

(entity:set-material-color entity rgb-color)

(entity:set-material-reflection entity
ambient-ref diffuse-ref specular-ref exponent)

(entity:set-material-texture entity filename)

(entity:set-material-transparency entity transparency-factor)

(entity:set-part entity [part=active])

(entity:set-refinement entity-list refine [acis-opts])

(entity:set-render entity-list on-off=#t)

(entity:set-render-sides [entity-list] sides)

(entity:set-texture-space entity-list texture-space)

(entity:shells entity-list [include-pat])

(entity:simplify ent-list [acis-opts])

(entity:spline-convert entity [acis-opts])

(entity:stitch list [acis-opts])

(entity:stretch body position1 position2 distance continuity)

(entity:tcoedges entity-list [include-pat])

(entity:tedges entity-list [include-pat])

(entity:texture-space entity)

(entity:tolerize entity)

(entity:touch {entity1 | entity-list1}
{entity2 | entity-list1 | entity-list2} [acis-opts])

(entity:transform entity-list transform)

(entity:tvertices entity-list [include-pat])

(entity:twist body position1 position2 theta1 theta2
continuity)

(entity:vertices entity-list)

(entity:wires entity-list [include-pat])

(entity:write-facets entity-list filename)

(entity:write-raw-facets entity-list filename)

(entity? object)

(entray entity ray)

(entray:entity entray)

(entray:position entray)

(entray:ray entray)

(entray:vertex entray)

(entray? object)

(env:active-part)

(env:active-view)

(env:active-wcs-color)

(env:auto-display)

(env:count-parts)

(env:default-color)

(env:highlight-color)

(env:load-state filename)

(env:parts)

(env:point-size)

(env:point-style)

(env:restore-product-id)

(env:restored-units-scale)

(env:save-product-id)

(env:save-state filename)

(env:save-units-scale)

(env:set-active-part part)

(env:set-active-view view)

(env:set-active-wcs-color color=0 1 0)

(env:set-auto-display on-off=#t)

(env:set-default-color color=0 1 0)

(env:set-highlight-color color=1 1 1)

(env:set-point-size size=10)

(env:set-point-style style-string=x)

(env:set-save-units-scale scale)

(env:set-tolerance resabs=1^e-6 resnor=1^e-10
resfit=1^e-3 resmch=1^e-11)

(env:tolerance)

(env:views)

(environment-map:data colors widths heights filename)

(environment-map:lwi img+x img-x
img+y img-y img+z img-z)

(environment-map:render entities=all
resolution position)

(environment-map:stripe stripe-width widths heights)

(environment-map? object)

(event x y button view [state])

(event:alt? event)

(event:button event)

(event:control? event)

(event:left? event)

(event:middle? event)

(event:ray event)

(event:right? event)

(event:shift? event)

(event:view event)

(event:x event)

(event:y event)

(event? object)

(face:area face)

(face:bs in-face [extra-info=#f])

(face:check face)

(face:cone position1 position2 radius1 radius2
[start-angle=0 end-angle=360 ratio position3])

(face:conic radius conic-constant extent [length])

(face:conical? object)

(face:cylinder position1 position2 radius
[start-angle=0 end-angle=360 ratio position3])

(face:cylinder-axis entity)

(face:cylinder-radius entity)

(face:cylindrical? object)

(face:derivtest face [num-u] [num-v] [start-u]
[end-u] [start-u] [start-v] [end-v] [file])

(face:extend entity start-u end-u start-v end-v)

(face:get-loft-laws entity)

(face:get-silhouette face [from-pos to-pos] [proj-type] [transf] [ao])

(face:intersect face1 face2 [acis-opts])

(face:law law start-u end-u start-v end-v)

(face:offset face distance [apply-transform=#f])

(face:offset-loops input-ent offset
[gap-type [use-transform] [acis-opts]])

(face:par-box face)

(face:planar-disk center normal radius)

(face:planar? object)

(face:plane position width height [normal])

(face:plane-normal entity)

(face:plane-ray entity)

(face:point-relationship face-entity test-position
         [transf] ["par-pos-guess" u-guess v-guess]
         [prev-pos [prev-pos-containment]]
         [use-cache = 0 [cache-size = 10]] [acis-opts])

(face:point-relationship-list face-entity position-list
[transf] ["par-pos-guess" u-guess v-guess]
[use-cache = 0 [cache-size = 10]] [acis-opts])

(face:prop face [tolerance=0.01])

(face:ray-at-position face-entity test-position)

(face:remove face)

(face:reverse face)

(face:scar? face | body)

(face:sphere position radius
[latitude-start=-90 [latitude-end=90
[longitude-start=0 [longitude-end=360 [poledir]]]]])

(face:sphere-center face)

(face:sphere-radius face)

(face:spherical? object)

(face:spline-ctrlpts surface-data)

(face:spline-grid grid-data interpolate)

(face:spline? object)

(face:split face split-along-u use-percent
param-value [acis-opts])

(face:split-at-disc face [disc-order = 1] [acis-opts])

(face:toroidal? object)

(face:torus position spine-radius tube-radius
[tube-start=0 tube-end=360 spine-start=0
spine-end=360 vector])

(face:type face1)

(face:types)

(face:uncover face [acis-opts])

(face:unhook face [acis-opts])

(face? object)

(filter:and filt1 ... filtn)

(filter:apply filter entity-or-list)

(filter:color color)

(filter:display)

(filter:not filter)

(filter:or filt1 ... filtn)

(filter:type type-name)

(filter:types)

(find:angle input1 [input2] [logical])

(find:bump seed [return-type [no-cross-list
[show-loop=#f]]])

(find:pattern-index entity)

(foreground type)

(foreground:props foreground)

(foreground:set-prop foreground name value)

(foreground:type foreground)

(foreground:types)

(foreground? object)

(generic:add ent-list attrib-name
[option [opt-value*]])

(generic:get ent [attrib-name])

(generic:remove ent-list attrib)

(gl:cull-mode)

(gl:fill-style)

(gl:get-pixel-format [view])

(gl:metafile [filename] [view] [emf-wmf=#t]
[header=#f])

(gl:print [view])

(gl:rebuild)

(gl:set-cull-mode mode)

(gl:set-fill-style style)

(gl:view [x-window y-window width height] [part])

(glue:options "name-of-option" {value} [glue-opts])

(graph {graph-string | face-ent-list | cell-list}
[acis-opts])

(graph:add-edge output-graph vertex1 vertex2)

(graph:add-vertex in-graph in-name)

(graph:adjacent in-graph vertex1 vertex2)

(graph:branch in-graph in-trunk
which-branch [keep-trunk=#f])

(graph:component in-graph in-which)

(graph:components in-graph)

(graph:connected? in-graph)

(graph:copy in-graph)

(graph:cut-edge? in-graph in-edge)

(graph:cut-edges in-graph)

(graph:cut-vertex? in-graph test-vertex)

(graph:cut-vertices in-graph)

(graph:cycle-vertex? in-graph in-vertex)

(graph:cycle? in-graph)

(graph:degree? in-graph in-vertex)

(graph:edge-entities in-graph)

(graph:edge-weight in-graph {edge-name weight} |
{vertex-name1 vertex-name2 weight})

(graph:entities in-graph [use-ordering=#f])

(graph:get-order in-graph in-vertex)

(graph:intersect in-graph1 in-graph2)

(graph:is-subset small-graph large-graph)

(graph:kind in-graph kind on-off)

(graph:kind? in-graph kind item1 [item2])

(graph:kinds? in-graph item1 [item2])

(graph:lightest-path in-graph in-vertex1 in-vertex2)

(graph:linear? in-graph)

(graph:negate in-graph)

(graph:order-cyclic in-graph in-first in-last)

(graph:order-from in-graph in-vertex)

(graph:order-with in-graph1 in-graph2)

(graph:set-kind in-graph kind on-off item1 [item2])

(graph:shortest-cycle in-graph in-vertex)

(graph:shortest-path in-graph in-vertex1 in-vertex2)

(graph:show-order in-graph)

(graph:split-branches in-graph)

(graph:subgraph-2dcell whole-graph [acis-opts])

(graph:subgraph-3dcell whole-graph [acis-opts])

(graph:subset in-graph {subset-law |
low-bounds up-bounds})

(graph:subset-with-plane whole-graph plane-origin
plane-normal [acis-opts])

(graph:subtract in-graph1 in-graph2 in-keep)

(graph:subtract-edges in-graph1 in-graph2)

(graph:total-weight in-graph)

(graph:tree? in-graph)

(graph:unite in-graph1 in-graph2)

(graph:vertex-entities in-graph [use-ordering=#f])

(graph:which-component in-graph in-object)

(grid:display-color)

(grid:display-interval)

(grid:display-method)

(grid:displayed?)

(grid:interval)

(grid:set-display on-off)

(grid:set-display-color color)

(grid:set-display-interval nx=10 ny=10)

(grid:set-display-method method=dots)

(grid:set-interval dx dy [dz])

(grid:set-snapping on-off)

(grid:snapping-on?)

(gvector x y z [space=model])

(gvector:+ gvector1 gvector2)

(gvector:- gvector1 gvector2)

(gvector:copy gvector)

(gvector:cross gvector1 gvector2)

(gvector:dot gvector1 gvector2)

(gvector:from-to position1 position2)

(gvector:length gvector)

(gvector:parallel? gvector1 gvector2)

(gvector:perpendicular? gvector1 gvector2)

(gvector:reverse gvector)

(gvector:scale gvector scale)

(gvector:set! gvector {x y z})

(gvector:set-x! gvector x)

(gvector:set-y! gvector y)

(gvector:set-z! gvector z)

(gvector:transform gvector transform)

(gvector:unitize gvector)

(gvector:view x y z [view=active])

(gvector:x gvector)

(gvector:y gvector)

(gvector:z gvector)

(gvector? object)

(hh:analyze-body body [acis-opts])

(hh:analyze-coedge body [acis-opts])

(hh:analyze-edge body [acis-opts])

(hh:analyze-face body [acis-opts])

(hh:analyze-geom body [acis-opts])

(hh:analyze-loop body [acis-opts])

(hh:analyze-lump body [acis-opts])

(hh:analyze-shell body [acis-opts])

(hh:analyze-simplify body [acis-opts])

(hh:analyze-stitch body [acis-opts])

(hh:analyze-vertex entity [acis-opts])

(hh:autoheal body [filename] [acis-opts])

(hh:combine body-list [acis-opts])

(hh:geombuild body [acis-opts])

(hh:geombuild-analyze body [acis-opts])

(hh:get-analytic-tol body)

(hh:get-geombuild-tol body)

(hh:get-isospline-tol body)

(hh:get-simplify-tol body)

(hh:get-stitch-max-tol body)

(hh:get-stitch-min-tol body)

(hh:init-body-for-healing body)

(hh:make-tolerant body [acis-opts])

(hh:postprocess body [acis-opts])

(hh:preprocess body [acis-opts])

(hh:reset-tols)

(hh:set-analytic-tol tolerance)

(hh:set-geombuild-tol tolerance)

(hh:set-isospline-tol tolerance)

(hh:set-simplify-tol tolerance)

(hh:set-stitch-max-tol tolerance)

(hh:set-stitch-min-tol tolerance)

(hh:show-bad-coedges body)

(hh:show-bad-edges body)

(hh:show-bad-faces body)

(hh:show-bad-vertices body)

(hh:show-body body)

(hh:show-closed-curves body)

(hh:show-closed-surfaces body)

(hh:show-coedges-no-partner body)

(hh:show-coedges-not-on-faces body)

(hh:show-concave-edges body)

(hh:show-convex-edges body)

(hh:show-degenerate-curves body)

(hh:show-degenerate-surfaces body)

(hh:show-discontinuous-curves body)

(hh:show-discontinuous-surfaces body)

(hh:show-loops-disoriented body)

(hh:show-loops-gaps body)

(hh:show-loops-not-on-faces body)

(hh:show-loops-open body)

(hh:show-lumps body)

(hh:show-periodic-curves body)

(hh:show-periodic-surfaces body)

(hh:show-self-intersecting-curves body)

(hh:show-self-intersecting-surfaces body)

(hh:show-shells body)

(hh:show-short-edges body)

(hh:show-simplified body)

(hh:show-spline body)

(hh:show-tangent-edges body)

(hh:show-tolerant-edges body)

(hh:show-unstitched body)

(hh:show-vertices-edges-dont-meet body)

(hh:show-vertices-not-on-edges body)

(hh:show-vertices-not-on-faces body)

(hh:simplify body [acis-opts])

(hh:solve-analytic body [acis-opts])

(hh:solve-gen-spline body [acis-opts])

(hh:solve-isospline body [acis-opts])

(hh:solve-sharp-edge body [acis-opts])

(hh:stitch body [acis-opts])

(hh:terminate-body-for-healing body [acis-opts])

(hh:wrapup body [acis-opts])

(history part | entity | history-id
[part-id] | "default")

(history:ensure-empty-root-state [history])

(history:get-active-state-id [history])

(history:get-default)

(history:get-entity-from-id id [history])

(history:get-modified-faces mod-type-string
[delta-state-name-string=null] [history])

(history:load filename [textmode=#t] [part=active])

(history:save filename [text-mode=#t]
[save-type="entire"] [history])

(history:size hist)

(history:validate-streams)

(ihl:clean [token=0] body-list)

(ihl:compute [token=0] body-list [view=active]
[unfaceted=#f])

(ihl:display body-list [unfaceted=#f])

(ihl:draw ihl-data [view=active] [clear])

(ihl:postscript ihl-data [filename=plotfile.ps]
[color=#f] [x-size=195.9 y-size=259.4]
[view=active])

(ihl:retrieve body-list [token=0])

(is:helix in-entity)

(journal:abort)

(journal:append [filename])

(journal:load filename)

(journal:off)

(journal:on [filename])

(journal:pause)

(journal:resume)

(journal:save filename)

(journal:step value)

(journal:test [type | date | test-name])

(law {"law-functions" | type} [law-data]*)

(law:boundary-field entity-list options [acis-opts])

(law:bounds law1 [low high])

(law:check law)

(law:count)

(law:cubic a b f-a f-b df-a df-b)

(law:derivative law [with-respect-to])

(law:end in-law [term])

(law:eval law input)

(law:eval-par-pos in-law input)

(law:eval-position law input)

(law:eval-vector law input)

(law:hedgehog
         {path vector-list [number-hair [size]]} |
         {hair-law base-law start-x end-x
         {[number-hair] | [start-y end-y [number-hair]] |
         [start-y end-y start-z end-z [number-hair]]}})

(law:inverse in-law)

(law:line-line-interset point1 gvector1 point2 gvector2)

(law:linear a b f-a f-b)

(law:make-entity {some-law-functions | type}
[law-data]*)

(law:make-rails path [twist [axis [faces
[user-rails [version]]]]])

(law:min-dist entity1 entity2)

(law:nderivative law value [with-respect-to
[number-of [type=0]]])

(law:nintegrate law low-lim up-lim [tol])

(law:nmax law low-lim up-lim)

(law:nmin law low-lim up-lim)

(law:nroot law low-lim up-lim)

(law:nsolve law1 law2 low-lim up-lim)

(law:quintic a b f-a f-b df-a df-b ddf-a ddf-b)

(law:reset-deriv a-law i)

(law:set-deriv a-law i deriv-law)

(law:simplify law)

(law:start in-law [term])

(law:warp ent-list law)

(law? object)

(light light-type)

(light:create-shadows light entity-list)

(light:delete-shadows light)

(light:list)

(light:on? entity)

(light:props light-type)

(light:set on-off light-list)

(light:set-prop light name value)

(light:type light)

(light:types)

(light? object)

(line:set-direction curve direction)

(line:set-end curve position)

(line:set-start curve position)

(load-dll filename)

(loop:external? loop)

(loop:find entity1 entity2)

(loop:type loop)

(loop? object)

(lop:convert-pipes body-or-face-list [acis-opts])

(lop:edge-taper-faces face-list edge-list direction
angle [box-h box-l] [acis-opts])

(lop:move-faces face-list vector-or-transform
[box-h box-l] [acis-opts])

(lop:offset-body body offset [box-h box-l] [acis-opts])

(lop:offset-faces face-list offset [box-h box-l]
[acis-opts])

(lop:offset-specific def-face-list def-offset
spec-face-list spec-offset-list [box-h box-l]
[acis-opts])

(lop:remove-attributes entity [acis-opts])

(lop:rotate-faces face-list point axis angle
[box-h box-l] [acis-opts])

(lop:shadow-taper-faces face-list direction
angle [box-h box-l] [acis-opts])

(lop:sweep-more face-list distance [box-l box-h]
[acis-opts])

(lop:taper-faces face-list point normal angle
[box-h box-l] [acis-opts])

(lop:test name [do_journal])

(lop:tweak-faces face-list tool-list sense-list
[box-h box-l] [acis-opts])

(lop:tweak-faces-extend face-list tool-list
sense-list [box-h box-l] [acis-opts])

(lop:tweak-faces-init face-list tool-list sense-list
[box-h box-l] [acis-opts])

(lop:tweak-pick-edge-solution edge solution)

(lop:tweak-query-edge-solutions edge)

(lump? object)

(material)

(material:color-props material)

(material:color-type material)

(material:color-types)

(material:displacement-props material)

(material:displacement-status material)

(material:displacement-type material)

(material:displacement-types)

(material:reflection-props material)

(material:reflection-status material)

(material:reflection-type material)

(material:reflection-types)

(material:set-color-prop material name value)

(material:set-color-type material color-type)

(material:set-displacement-prop material name value)

(material:set-displacement-status material status)

(material:set-displacement-type material displacement-type)

(material:set-reflection-prop material name value)

(material:set-reflection-status material status=#t)

(material:set-reflection-type material reflection-type)

(material:set-transparency-prop material name value)

(material:set-transparency-status material status=#t)

(material:set-transparency-type material transparency-type)

(material:transparency-props material)

(material:transparency-status material)

(material:transparency-type material)

(material:transparency-types)

(material? object)

(mixed-body? object)

(monitor:file filename)

(option:get option-string)

(option:list)

(option:reset)

(option:set option-string value)

(par-pos u v)

(par-pos:copy par-pos)

(par-pos:distance par-pos1 par-pos2)

(par-pos:set! par-pos {u v})

(par-pos:set-u! par-pos u)

(par-pos:set-v! par-pos v)

(par-pos:u par-pos)

(par-pos:v par-pos)

(par-pos? object)

(part id)

(part:clear [part=active])

(part:clear-selection [part=active])

(part:close [part=active])

(part:debug [part=active])

(part:delete-rendering-context [part=active] name)

(part:entities [part=active] [filter=NULL])

(part:get-distribution-mode)

(part:load filename [textmode=#t] [part=active]
[with-history=#f])

(part:modified? [part=active])

(part:name [part=active])

(part:new [size=1009])

(part:save [filename=partname.sat] [textmode=#t]
[part=active] [with-history=#f]
[mainline-only=#f])

(part:save-selection ent-list filename [textmode=#f]
[with-history=#f])

(part:selection [part=active])

(part:set-distribution-mode on-off)

(part:set-name [name=id name] [part=active])

(part:views [part=active])

(part? object)

(pattern {trans-vec [x-vec [y-vec [scale [z-vec
[keep [root-transf]]]]]]} | in-pat |
{positions [root]})

(pattern:alternating-keep pat keep1 keep2
which-dim [merge=#t])

(pattern:alternating-scale pat scale1 scale2
which-dim root [merge=#t])

(pattern:check entity [type-list] [color])

(pattern:circular? pat {face | {center axis}})

(pattern:compose pat1 pat2)

(pattern:concatenate pat1 pat2 [transform])

(pattern:coords-to-index pat coords)

(pattern:copy pat)

(pattern:cylindrical {center normal | face}
num-angular [num-axial=0] [distance=0]
[alternating=#f])

(pattern:cylindrical? pat {face | {center axis}})

(pattern:edge entity-list number root
[on-endpoints=#f] [normal-dir tangent-dir])

(pattern:elliptical center normal num
[not-rotate=#f root [angle=360
[ratio=1 major-axis]]])

(pattern:from-list {position-list [root]} |
{transf-list [root-transf]})

(pattern:get-transform pat [index1 [index2]])

(pattern:hex normal xvec xnum ynum)

(pattern:hex-cylindrical center normal num-angular
[num-axial=0] [radius=0])

(pattern:index-to-coords pat index)

(pattern:keep pat keep [merge=#t])

(pattern:linear xvec xnum [yvec ynum [zvec znum]])

(pattern:linear-scale pat begin-scale end-scale
which-dim root [merge=#t])

(pattern:make-entity pat)

(pattern:mirror pat root normal)

(pattern:move-element pat coords transf)

(pattern:periodic-keep pat keep which-dim [merge=#t])

(pattern:periodic-scale pat scales which-dim root
[merge=#t])

(pattern:planar? pat {face | {root-point normal}})

(pattern:polar-grid center normal num dist
[start] [not-rotate=#f] [hex-symmetry=#f]
[start-angle=0] [end-angle=360] [ratio=1])

(pattern:print-transform [index1 [index2]])

(pattern:radial center normal num-radial
num-angular dist [start] [not-rotate=#f]
[start-angle=0] [end-angle=360] [ratio=1])

(pattern:random extents number [dimension=3]
[ellipsoidal=#f] [x-vec=(1 0 0)] [y-vec=(0 1 0)])

(pattern:random-keep pat fraction [merge=#t])

(pattern:random-offset pat amplitude)

(pattern:random-orient pat [min-axial max-axial
axial-dir min-tilt max-tilt tilt-dir])

(pattern:random-scale pat min_scale max_scale
root [merge=#t])

(pattern:reflect pat root normal)

(pattern:remove entity)

(pattern:remove-element pat coords)

(pattern:restore-element pat coords)

(pattern:scale pat scale root [merge=#t])

(pattern:scale-element pat coords scale root)

(pattern:set-root-transf pat root-transf)

(pattern:size pat)

(pattern:spherical center num-latitudes
root [spacing])

(pattern:spherical? pat {face | center})

(pattern:surface entity num-u num-v root
[on-boundary=#f] [dir-u dir-v])

(pattern:test [type | date | test-name] [index=-1])

(pattern:transform pat transf)

(pattern:undo-move-element pat coords)

(pattern? object)

(phl:clean [token=0] body-list)

(phl:compute [token=0] body-list [view=active])

(phl:display body-list)

(phl:draw phl-data [view=active] [clear=#f])

(phl:draw-cv phl-data [view=active] [clear=#f])

(phl:interleaf phl-data [filename=plotfile.ps]
[color=#f] [x-size=195.9mm y-size=259.4mm]
[view=active])

(phl:options)

(phl:postscript phl-data [filename=plotfile.ps]
[color=#f] [x-size=195.9mm y-size=259.4mm]
[view=active])

(phl:postscript-cv phl-data [filename=plotfile.ps]
[color=#f] [x-size=195.9mm y-size=259.4mm]
[view=active])

(phl:retrieve [token=0] body-list)

(phlv5:clean [token=0] body-list [acis-opts])

(phlv5:compute [body-list] [token=0] [view=active]
[phlv5-options=0] [acis-opts])

(phlv5:draw phlv5-data)

(phlv5:options "name-of-option" {value})

(phlv5:retrieve [token=0] body-list)

(pick:aperture)

(pick:edge {event | pick-ray} [filter])

(pick:entity event [filter] [depth])

(pick:face {event | pick-ray} [face-index] [filter])

(pick:in-region event1 event2 [filter])

(pick:position event [plane-position
[plane-direction=xy-plane]])

(pick:ray event [plane-position
[plane-direction=xy-plane]])

(pick:set-aperture dx=15 dy=15)

(pick:vertex {event | pick-ray} [filter])

(point position)

(point:position point)

(point? object)

(position x y z [space="models"])

(position:closest position position-list)

(position:copy position)

(position:distance position1 {position2 | ray})

(position:interpolate position1 position2 weight)

(position:offset position gvector)

(position:project-to-line position line-pos line-dir)

(position:project-to-plane position
plane-pos plane-normal)

(position:set! pos1 {{x y z} | {pos2}})

(position:set-x! position x)

(position:set-y! position y)

(position:set-z! position z)

(position:transform position transform)

(position:view x y z [view=active])

(position:x position)

(position:y position)

(position:z position)

(position? object)

(project:wire wire body vector distance [acis-opts])

(pt-cvty-info:angle pt-cvty-info)

(pt-cvty-info:instantiate pt-cvty-info tol)

(pt-cvty-info:tangent-convexity pt-cvty-info)

(pt-cvty-info:unknown pt-cvty-info)

(pt-cvty-info:unset pt-cvty-info)

(ray position gvector)

(ray:gvector ray)

(ray:position ray)

(ray:queue posx posy posz vecx vecy vecz radius)

(ray:valid? ray)

(ray? object)

(rbd:add driver)

(rbd:clear [flag-all=#t])

(rbd:drag activate entity-list [base=position 0 0 0])

(rbd:drag? object)

(rbd:drivers [depth])

(rbd:generic activate base=position 0 0 0)

(rbd:generic? object)

(rbd:line activate [base=position 0 0 0])

(rbd:line? object)

(rbd:pop)

(rbd:push [driver])

(rbd:rectangle activate [base=position 0 0 0])

(rbd:rectangle? object)

(rbd:remove driver)

(rbd:remove-type type-predicate)

(rbd:scheme activate hooks [locals])

(rbd:scheme-get-local driver index)

(rbd:scheme-get-position driver event)

(rbd:scheme-set-local driver index object)

(rbd:scheme? object)

(rbd:start event)

(rbd:stop)

(rbd:update event)

(rbd:view activate pe type [reverse=#t])

(rbd:window activate base)

(rbd:window? object)

(rbi:rep-self-int body changed-face-list)

(read-event)

(read-ray)

(refinement)

(refinement:default)

(refinement:props refinement)

(refinement:set-default refinement [acis-opts])

(refinement:set-prop refinement [name value |
name-value-list])

(refinement? object)

(refresh-all)

(rem:remove-faces face-list [box-h box-l] [acis-opts])

(render [entity-list=all] [view=active])

(render:background)

(render:control-variable name)

(render:control-variables)

(render:edge-width [view=active])

(render:environment-map)

(render:foreground)

(render:interleaf [entity-list=all]
[filename=plotfile.il] [x-size=215.9mm
y-size=279.4mm] [view=active])

(render:metafile [filename=plotfile.il]
[entity-list=all] [view=active])

(render:mode)

(render:modes)

(render:pnm [entity-list=all]
[filename=plotfile.pnm]
[binary=#t [color=#t]] [view=active])

(render:postscript [entity-list=all]
[filename=plotfile.ps] [color=#f]
[x-size=195.9mm y-size=259.4mm] [view=active])

(render:print [entity-list=all] [x-resolution
y-resolution] [view=active])

(render:rebuild [part])

(render:set-background background)

(render:set-control-variable name value)

(render:set-default-color-type color-type)

(render:set-default-displacement-type displacement-type)

(render:set-default-reflection-type reflection-type)

(render:set-default-transparency-type transparency-type)

(render:set-edge-width [width] [view=active])

(render:set-environment-map environment-map)

(render:set-foreground foreground)

(render:set-mode mode)

(render:targa [entity-list=all] [filename]
[x-size y-size]
[compress [color]] [view=active])

(ro:color item)

(ro:delete rendering-object)

(ro:display rendering-object)

(ro:erase rendering-object)

(ro:line pos1 pos2)

(ro:new view-opt)

(ro:point position)

(ro:polyline pos-list [fill=#f])

(ro:text position text)

(roll [number-of-states=-1] [name-string=NULL]
[end] [start] [history])

(roll:back? [history])

(roll:debug history [level] [ent-name])

(roll:delete-all-states [history])

(roll:delete-following-states [history])

(roll:delete-inactive-states [history])

(roll:delete-previous-states [history])

(roll:forward? [history])

(roll:get-logging)

(roll:mark-end)

(roll:mark-start)

(roll:merge-delta-state name [stream])

(roll:merge-delta-states [id1 | name1] [id2 | name2]
[stream] [prune-partners=#f])

(roll:name-state name-string [history])

(roll:named-states name-pattern [history])

(roll:set-logging on-off)

(roll:set-max-states num [history])

(roll:to-state-id state-id [history])

(section coedges [laws] in-flag take-off-factor
[no-loop-flag=#f] [acis-opts])

(set-timer [on-off])

(sheet:1d body)

(sheet:2d body)

(sheet:cover body ["multiple"])

(sheet:cover-wire-loops (list w1 w2 ...))

(sheet:cover-wires body [surf] [acis-opts])

(sheet:edge-regions edge-list [coin-tol]
[min-length] [wire])

(sheet:enclose face side [lumps=#f])

(sheet:face face)

(sheet:loft-wires section-list [[skin-options] |
         [arc-length=#f [no-twist=#t [align=#t
         [perpendicular=#f [simplify=#t [closed=#f
         [solid=#t [periodic=#f [acis-opts]]]]]]]]]])

(sheet:loft-wires-guides section-list guide-list [skin-options] [acis-opts])

(sheet:net-sections section-list-v section-list-u
[align-directions=#f [simplify=#f [tolerance]]])

(sheet:net-wires body-list-v body-list-u
[[skin-options] | [align=#f [simplify=#f
[tolerance [acis-opts]]]]])

(sheet:planar-edges edge-list option)

(sheet:planar-wire body)

(sheet:planar-wires wire-bodies
["nest" union])

(sheet:skin-wires body-list [path] [[skin-options] |
         [arc-length=#f
         [no-twist=#t [align=#t
         [simplify=#t [closed=#f
         [solid=#t [periodic=#f]]]]]]]])

(sheet:skin-wires-branch trunk-list branch-list
         [skin-options] [normal-type] [arc-length=#f
         [no-twist=#t [align=#t
         [simplify=#t [solid=#t [acis-opts]]]]]])

(sheet:skin-wires-draft body-list angle1 angle2
         [[guides] | [magnitude1] [magnitude2]]
         [[skin-options] |
         [arc-length=#f [no-twist=#t
         [align-directions=#t [simplify=#t
         [solid=#t [acis-opts]]]]]]])

(sheet:skin-wires-guides body-list guides
         [[skin-options] | [arc-length=#f [no-twist=#t
         [align=#t [simplify=#f
         [closed=#f [solid=#t [virtualGuides=#f
         [acis-opts]]]]]]]]])

(sheet:skin-wires-normal body-list normal-type
         [[skin-options] | [arc-length=#f [no-twist=#t
         [align=#t [simplify=#t [closed=#f
         [solid=#t [acis-opts]]]]]]]])

(sheet:skin-wires-vectors body-list vector-list
         [magnitude-list] | [guide-list] [[options] |
         [arc-length=#f [no-twist=#t [align=#t
         [simplify=#t [closed=#f [solid=#t [acis-opts]]]]]]]])

(shell:hollow-body body-or-face-list thickness
[box-height box-length] [acis-opts])

(shell:hollow-body-specific body
         def-inside-off def-outside-off openface-list
         spec-inside-face-list spec-inside-off-list
         spec-outside-face-list spec-outside-off-list
         [box-height box-length] [acis-opts])

(shell:offset-make-sheet def-face-list def-offset
spec-face-list spec-offset-list [box-height box-length]
[acis-opts])

(shell:sheet-thicken body thickness [both=#f]
[box-height box-length] [acis-opts])

(shell? object)

(skin:options "name-of-option" {value}
[skin-options])

(skin:test [type | date | test-name])

(slinterface:remove-vertex interface body position
[acis-opts])

(slinterface:align-wires interface [acis-opts])

(slinterface:breakup-wires interface [acis-opts])

(slinterface:build-body interface [acis-opts])

(slinterface:build-edges interface [acis-opts])

(slinterface:build-faces interface [acis-opts])

(slinterface:clear-guide-curves interface [acis-opts])

(slinterface:clear-mapping-curves interface [acis-opts])

(slinterface:collapse-wires interface [acis-opts])

(slinterface:debug interface)

(slinterface:delete-interface interface [acis-opts])

(slinterface:face-lofting face0
         [take-off-factor0=3.0] face1
         [take-off-factor1=3.0] [[skin-options] |
         [arc-length=#f
         [no-twist=#t [align=#t
         [perpendicular=#f [simplify=#t
         [acis-opts]]]]]]])

(slinterface:get-tanfac-scale interface
need-optimal [acis-opts])

(slinterface:get-tanfac-scale interface [acis-opts])

(slinterface:get-valid-vertices interface
wire [acis-opts])

(slinterface:lofting section-list [[skin-options] |
         [arc-length=#t [no-twist=#f
         [align=#f [perpendicular=#f
         [simplify=#f [closed=#f [solid=#t
         [periodic=#f [acis-opts]]]]]]]]]])

(slinterface:lofting-options interface
         [[skin-options] |
         [arc-length=#f [no-twist=#t
         [align=#t [perpendicular=#f
         [simplify=#t [closed=#f [solid=#t
         [periodic=#f [acis-opts]]]]]]]]]])

(slinterface:lose-surface interface [acis-opts])

(slinterface:mapping-curve interface position-list
[acis-opts])

(slinterface:min-rad interface [acis-opts])

(slinterface:minimizetwist-wires interface
[skin-options])

(slinterface:modify-vertex interface [acis-opts])

(slinterface:reenter-coedges interface sections [acis-opts])

(slinterface:remove-mapping-curve interface index
[acis-opts])

(slinterface:remove-vertex interface body position
[acis-opts])

(slinterface:set-start-vertex interface wire-number
vertex-number [acis-opts])

(slinterface:set-tan-facs interface tangent-factor [acis-opts])

(slinterface:show-guide-curves interface [acis-opts])

(slinterface:show-mapping-curves interface [acis-opts])

(slinterface:simplify-wires interface [acis-opts])

(slinterface:skin-guide interface edge [acis-opts])

(slinterface:skinning body-list [[options] |
         [arc-length=#t [no-twist=#f
         [align-directions=#f [simplify=#f
         [closed=#f [solid=#t [periodic=#f
         [acis-opts]]]]]]]]])

(slinterface:skinning-draft body-list angle1 angle2
         magnitude1 magnitude2 [options] [arc-length=#f
         [no-twist=#t [align=#t
         [simplify=#t [solid=#t [acis-opts]]]]]])

(slinterface:skinning-normal body-list [[normals]
         [[options | [arc-length=#f [no-twist=#t [align=#t
         [simplify=#t [closed=#f [solid=#t
         [acis-opts]]]]]]]]]])

(slinterface:skinning-options interface [[options] |
         [arc-length=#t [no-twist=#f
         [align-directions=#f [simplify=#f
         [closed=#f [solid=#t [periodic=#f
         [virtualGuides=#f [merge-wirecoedges=#f
         [estimate-loft-tanfacs=#f [match-vertices=#f
         [guidePreference [acis-opts]]]]]]]]]]]]]])

(slinterface:skinning-ruled body-list options [acis-opts])

(slinterface:skinning-vectors body-list vector-list
         [magnitude-list] [[options] | [arc-length=#f
         [no-twist=#t [align=#t [simplify=#t [closed=#f
         [solid=#t [acis-opts]]]]]]]])

(slinterface:wires interface [acis-opts])

(solid:area solid-body [tolerance=0.01])

(solid:blend-edges entity-list radius [acis-opts])

(solid:blend-edges-pos-rads edge-list
position-list radii-list [start-slope [end-slope]]
[acis-opts])

(solid:block {{diagonal1 diagonal2 | (diagonal-x1
diagonal-y1 diagonal-z1 diagonal-x2 diagonal-y2
diagonal-z2)}})

(solid:chamfer-edges entity-list
left-offset-distance [right-offset-distance]
[acis-opts])

(solid:chamfer-vertex vertex offset1
         {[[edge1] [{offsets edges}]*
         [distancestraight=#t]] | [chamfernormal]}
         [acis-opts])

(solid:chamfer-vertices entity-list offset
[distancestraight=#t] [acis-opts])

(solid:check-ff-intersections entity [file-name]
[acis-opts])

(solid:classify-position entity test-position
[use-boxes] [acis-opts])

(solid:closed? object)

(solid:cone {{start-axis end-axis} | {start-axis-x
         start-axis-y start-axis-z end-axis-x end-axis-y
         end-axis-z}} base-radius top-radius
         [ratio=1 [position3 | {x3 y3 z3}]])

(solid:cylinder {{start-pos end-pos} | {x-start
y-start z-start x-end y-end z-end}} radius
[ratio=1 {position3 | {x3 y3 z3}}])

(solid:flat-on-face point offset
{face-list | body | normal
[{face-list | body}]} [acis-opts])

(solid:imprint body1 body2 [acis-opts])

(solid:imprint-stitch body1 body2 [acis-opts])

(solid:inter-graph blank tool [acis-opts])

(solid:intersect bodies [acis-opts])

(solid:loft-faces
         face0 [take-off-factor0=3.0]
         face1 [take-off-factor1=3.0]
         [skin-options] | [acis-opts])

(solid:loft-faces-guides
     face0 [take-off-factor0=3.0]
     face1 [take-off-factor1=3.0]
     guides [options] | [ao])

(solid:manifold? object)

(solid:massprop entity [integer-type=0 [thickness] tolerance=0.01
{{position=center} | {x=center-x y=center-y
z=center-z}} direction=z-axis])

(solid:planar-slice body plane-position
plane-normal [acis-opts])

(solid:prism height major-radius minor-radius nsides)

(solid:pyramid height major-radius minor-radius nsides
[top])

(solid:ray-test entity ray [acis-opts])

(solid:skin-faces face0 face1 [[options] |
[arc-length=#f] [no-twist=#t]
[align-directions=#t] [simplify=#t [acis-opts]]])

(solid:slice blank tool [acis-opts])

(solid:sphere {center-position | {center-x center-y
center-z}} radius)

(solid:split body [acis-opts])

(solid:stitch body1 body2 [split] [acis-opts])

(solid:subtract body-1 body-2 [...body-n] [acis-opts])

(solid:torus {center-position | {center-x center-y
center-z}} major-radius minor-radius)

(solid:unhook-wire-edge edge [acis-opts])

(solid:unite body-1 body-2 [...body-n] [acis-opts])

(solid:unstitch-nm body1 [acis-opts])

(solid:var-chamfer-edges entity-list
         left-beginning-range [right-beginning-range]
         [left-end-range] [right-end-range]
         [left-round-chamfer-radius]
         [right-round-chamfer-radius] [acis-opts])

(solid:wiggle width depth height
{wiggle-type | shape1 shape2 shape3 shape4})

(solid? object)

(splgrid)

(splgrid:copy grid)

(splgrid:point-item grid row column)

(splgrid:print grid)

(splgrid:set-point-item grid row column value)

(splgrid:set-point-list grid list rows columns)

(splgrid:set-tolerance grid value)

(splgrid:set-u-tanvec-item grid index value
start-or-end)

(splgrid:set-u-tanvec-list grid list start-or-end)

(splgrid:set-v-tanvec-item grid index value
start-or-end)

(splgrid:set-v-tanvec-list grid list start-or-end)

(splgrid:tolerance grid)

(splgrid:u-points grid)

(splgrid:u-tanvec-item grid index start-or-end)

(splgrid:v-points grid)

(splgrid:v-tanvec-item grid index start-or-end)

(splgrid? object)

(splsurf)

(splsurf:copy surface)

(splsurf:ctrlpt-count surface)

(splsurf:ctrlpt-item surface row column)

(splsurf:param surface param-str)

(splsurf:print surface)

(splsurf:set-ctrlpt-item surface row column value)

(splsurf:set-ctrlpt-list surface list row column)

(splsurf:set-u-knot-item surface index value)

(splsurf:set-u-knot-list surface list count)

(splsurf:set-u-param surface degree rational form pole)

(splsurf:set-v-knot-item surface index value)

(splsurf:set-v-knot-list surface list count)

(splsurf:set-v-param surface degree rational form pole)

(splsurf:set-weight-item surface row column value)

(splsurf:set-weight-list surface list)

(splsurf:u-knot-count surface)

(splsurf:u-knot-item surface index)

(splsurf:v-knot-count surface)

(splsurf:v-knot-item surface index)

(splsurf:weight-item surface row column)

(splsurf? object)

(stitch:edges list [stitch-max-tol] [acis-opts])

(surface:domain face)

(surface:eval srf su sv [level])

(surface:eval-curvatures srf su sv )

(surface:eval-normal surf u v)

(surface:eval-pos surf u v)

(surface:from-face face)

(surface:point-perp srf pos)

(surface:range srf [box-pos-1 box-pos-2])

(surface? object)

(sweep:get-path in-obj)

(sweep:get-profile in-obj)

(sweep:law profile {path | distance | vector | axis}
[sweep-options])

(sweep:options "name-of-option"
{value | location direction})

(sweep:test [type | date | test-name])

(system:bell [duration=hardware-settings]
[frequency=hardware-settings])

(system:command cmd)

(system:getenv name-string)

(system:name)

(system:play-sound filename [async=1])

(system:set-timer-off)

(system:set-timer-on num-sec)

(system:sleep duration)

(system:time-string)

(tcoedge-bad-crv:csl tm-check)

(tcoedge-bad-crv? tm-check)

(tcoedge-bs2-non-g1? t)

(tcoedge-bs2-outside-sf? tm-check)

(tcoedge-crv-non-g1? tm-check)

(tedge-bad-crv:csl tm-check)

(tedge-bad-crv? tm-check)

(tedge-crv-non-g1? tm-check)

(tedge-local-self-int? tm-check)

(tedge-remote-self-int:other-edge-param tm-check)

(tedge-remote-self-int? tm-check)

(tedge-tcoedge-bad-geom? tm-check)

(tedge-tcoedge-bad-tol tm-check)

(tedge-tcoedge-ranges:start tm-check)

(tedge-tcoedge-ranges? tm-check)

(test:deep-copy entity-list [tolerance] [report-all]
[file1 [file2]])

(test:equal arg1 arg2 [tolerance] [msg])

(test:greater-than variable fixed [tolerance] [msg])

(test:less-than variable fixed [tolerance] [msg])

(test:performance string)

(text position text-string [font] [size])

(text:font text-entity)

(text:location text-entity)

(text:set-font text-entity font)

(text:set-location text-entity location)

(text:set-size text-entity size)

(text:set-string text-entity string)

(text:size text-entity)

(text:string text-entity)

(text? object)

(texture-space type)

(texture-space:props texture-space)

(texture-space:set-prop texture-space name value)

(texture-space:type texture-space)

(texture-space:types)

(texture-space? object)

(timer:end)

(timer:get-time)

(timer:show-time)

(timer:start)

(tm-bad-topology? tm-check)

(tm-check:all edge)

(tm-check:tcoedge coedge)

(tm-check:tcoedge-bad-crv coedge)

(tm-check:tcoedge-bs2-non-g1 coedge)

(tm-check:tcoedge-bs2-outside-sf coedge)

(tm-check:tcoedge-crv-non-g1 edge)

(tm-check:tedge edge)

(tm-check:tedge-bad-crv edge)

(tm-check:tedge-crv-non-g1 edge)

(tm-check:tedge-local-self-int edge)

(tm-check:tedge-remote-self-int edge)

(tm-check:tedge-self-int edge)

(tm-check:tedge-tcoedge coedge)

(tm-check:tedge-tcoedge-bad-geom coedge)

(tm-check:tedge-tcoedge-bad-tol coedge)

(tm-check:tedge-tcoedge-ranges coedge)

(tm-check:tedge-tol edge)

(tm-check:tm-bad-topology edge)

(tm-chk-info:coedge tm-check)

(tm-chk-info:coedge-param tm-check)

(tm-chk-info:edge tm-check)

(tm-chk-info:edge-param tm-check)

(tm-chk-info:print tm-check [port])

(tm-chk-info:print1 tm-check [port])

(tm-chk-info? object)

(tolerance:detect-short-edges entity [tolerance]
[replace])

(tolerant:detect-sliver-faces entity
[tolerance] [replace=false])

(tolerant:fix entity)

(tolerant:move edge vector)

(tolerant:none entity)

(tolerant:optimize entity)

(tolerant:optimized? check-entity)

(tolerant:replace-edge-with-tvertex edge-list)

(tolerant:replace-face-with-tedge face)

(tolerant:report entity)

(tolerant:update entity)

(tolerant? check-entity)

(transform:axes origin-position x-axis y-axis)

(transform:compose transform1 transform2)

(transform:copy transform)

(transform:identity)

(transform:inverse transform)

(transform:print transform)

(transform:reflection plane-position
plane-direction)

(transform:rotation origin-position
axis-direction angle)

(transform:scaling x-scale [y-scale z-scale])

(transform:translation gvector)

(transform? object)

(tube:options [keep-law-string keep-law]
         [keep-branches-string branch-bool]
         [bool-type-string bool-type]
         ["connected" logical]
         ["merge" logical]
         ["only_from" integer])

(ui:error-dialog msg-string [x y
width=string-dependent height=107])

(ui:info-dialog msg-string [x y
width=string-dependent height=111])

(ui:prompt msg-string)

(ui:warning-dialog msg-string [x y
width=string-dependent height=109])

(ui:yesno-dialog msg-string [title-string=ACIS]
[x y width=string-dependent height=109])

(versionid)

(versiontag [major minor release])

(vertex-template:set-default)

(vertex:fillet vertex radius [edge1 edge2])

(vertex:from-position pos)

(vertex:get-tolerance vertex [force-update])

(vertex:position vertex)

(vertex:tolerant vertex)

(vertex? object)

(view:axes [view=active] [length=10])

(view:axes? [view=active])

(view:bg-color [view=active])

(view:clear [view=active])

(view:coedge-direction coedge | coedge-list | loop |
face coedges-on-off=#t [view=active])

(view:coedge-direction-clear [view=active])

(view:coedges [view=active] [edges])

(view:coedges? [view=active])

(view:compute-extrema [view=active])

(view:context [view=active])

(view:copy-to-clipboard event1 event2)

(view:debug [level] [view=active])

(view:delete [view=active])

(view:display-facets disp)

(view:display-param-lines disp)

(view:display-surface-polys disp)

(view:dl [x-window y-window width height]
[backup] [part])

(view:draw-point position [view=active])

(view:draw-polyline position-list [fill]
[view=active])

(view:draw-text position string [view=active])

(view:edge-hedgehog edge ["u" u-min u-max ]
["der" der-type = 1] ["nu" nu = 20 ]
["scale" factor = 1])

(view:edges [edges] [view=active])

(view:edges? [view=active])

(view:eye [view=active])

(view:face-hedgehog face
     ["uv" u-min u-max v-min v-max]
     ["vec" vec-type = 0] ["nuv" nu = 20 nu = 20 ]
     ["scale" factor = 1]
     )

(view:fg-color [view=active])

(view:flush [view=active])

(view:gl [x-window y-window width height] [part])

(view:handle [view=active])

(view:hedgehog-clear [view=active])

(view:height [view=active])

(view:hiddenline [on-off] [view=active])

(view:hiddenline? [view=active])

(view:hither [view=active])

(view:interleaf [filename=plotfile.il] [color]
[x-size=190 y-size=254] [view=active])

(view:link-to-window window [parent] [part])

(view:out [view=active])

(view:part [view=active])

(view:permanent-point position [size=36]
[view=active])

(view:permanent-point-clear [view=active])

(view:perspective? [view=active])

(view:polygonoffset [on-off] [view=active])

(view:polygonoffset? [view=active])

(view:postscript [filename=plotfile.ps] [color=#f]
[x-size=190 y-size=254] [view=active])

(view:refresh [view=active] [clear])

(view:resize [view=active])

(view:right [view=active])

(view:set eye-position target-position
up-direction [view=active])

(view:set-bg-color color [view=active])

(view:set-clipping hither=0.025 yon [view=active])

(view:set-context [view=active]
[context=dl_context])

(view:set-draw-mode mode [view=active])

(view:set-eye eye-position=(0,0,0) [view=active])

(view:set-fg-color color [view=active])

(view:set-font font-string [view=active])

(view:set-font-size size [view=active])

(view:set-hither hither=0.025 [view=active])

(view:set-line-style style-string [view=active])

(view:set-line-width size=1 [view=active])

(view:set-part [view=active] [part])

(view:set-perspective persp-orth [view=active])

(view:set-point-size size=10 [view=active])

(view:set-point-style style-string [view=active])

(view:set-rb-mode on-off [view=active])

(view:set-size width height [view=active])

(view:set-target target-position=(0,0,0)
[view=active])

(view:set-title name-string [view=active])

(view:set-up up-direction=(0,0,1) [view=active])

(view:set-viewport [orgx orgy width height]
[view=active])

(view:set-yon yon [view=active])

(view:shaded [on-off] [view=active])

(view:shaded? [view=active])

(view:sil [view=active] [sil])

(view:sil? [view=active])

(view:target [view=active])

(view:tcoedges [view=active] [edge-on-off])

(view:tcoedges? [view=active])

(view:up [view=active])

(view:vertices [view=active] [vertices])

(view:vertices? [view=active])

(view:viewport [view=active])

(view:width [view=active])

(view:with-handle handle)

(view:yon [view=active])

(view:zoom-window event1 event2 [view=active])

(view? object)

(void? object)

(warp:test name)

(wcs origin-pos {x-pos | x-vec} {y-pos | y-vec})

(wcs:active)

(wcs:from-transform transform)

(wcs:origin [wcs])

(wcs:set-active wcs)

(wcs:to-model-transform [wcs])

(wcs:to-wcs-transform [wcs])

(wcs:x-axis [wcs])

(wcs:y-axis [wcs])

(wcs:z-axis [wcs])

(wcs? object)

(wire-body entity-list)

(wire-body:area wire)

(wire-body:kwire [vector] position {bulge position}*)

(wire-body:length wire)

(wire-body:offset wire offset-distance-law
[twist-law] [gap-type] [trim] [direction])

(wire-body:planar? object)

(wire-body:points plist)

(wire-body:polygon center start normal
side-length sides on-center output-string)

(wire-body:self-intersect? wire-body [acis-opts])

(wire-body:unbranch entity-list)

(wire-body? object)

(wire:clean wire [acis-opts])

(wire:closed? object)

(wire:end wire)

(wire:get-net-curves-u face)

(wire:get-net-curves-v face)

(wire:get-skin-curves face)

(wire:planar? object)

(wire:reverse wire)

(wire:start wire)

(wire:unite-edges edges)

(wire? object)