# Commands

cmdName: \AtoB
cmdSpec: (<xA,yA>)(<xB,yB>){<nodeName>}
cmdContent: <xA,yA> <xB,yB> <nodeName>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Defines 'nodeName' as vector difference of B and A---ie, B-A. OK to reuse node names. Eg, \AtoB(P)(Q){Q}.


cmdName: \ArrowNotch
cmdSpec: {<nodeName>}{<nodeIndex>}{<direction>}{<Notch>}
cmdContent: <nodeName> <nodeIndex> <direction> <Notch>
cmdDelim: 0000
cmdOpt: 0000
cmdDescription:
For a  node sequence, compute position of arrow with tip at index <nodeIndex> in specified direction (<,>), creating a node named <Notch>. The arrowhead may then be drawn with \psline{->}.


cmdName: \cnodeput
cmdSpec: {<angle><-0}(x,y){<name>}{<stuff>}
cmdContent: <angle><-0 x,y <name> <stuff>
cmdDelim: 0100
cmdOpt: 1000
cmdDescription:
Circular node, refpt at center, placed at (x,y). (x,y) may be omitted if an angle is specified. * fills background with fillcolor.


cmdName: \cput
cmdSpec: {<angle><-0}(<x,y>){<stuff>}
cmdContent: <angle><-0 <x,y> <stuff>
cmdDelim: 010
cmdOpt: 100
cmdDescription:
Circular frame around stuff (rotated through angle), refpt at center, placed at (x,y), around stuff. * fills background with fillcolor.


cmdName: \curvepnode
cmdSpec: (<tval>){<expr in t>}{<nodeName>}
cmdContent: <tval> <expr in t> <nodeName>
cmdDelim: 100
cmdOpt: 000
cmdDescription:
Defines 'nodeName' as point on parametric curve at t=tval. The expr may be either algebraic or PostScript.


cmdName: \curvepnodes
cmdSpec: {<tmin>}{<tmax>}{<expr in t>}{<nodeRoot>}
cmdContent: <tmin> <tmax> <expr in t> <nodeRoot>
cmdDelim: 0000
cmdOpt: 0000
cmdDescription:
Defines node sequence as points on parametric curve at equally spaced t values, using plotpoints setting. The expr may be either algebraic or PostScript.


cmdName: \dataplot
cmdSpec: {<command>}
cmdContent: <command>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
First store data to command using \savedata{<command>}[<data>] or \readdata{<command>}{<filename>}. Allows more options than \fileplot.


cmdName: \dataplotThreeD
cmdSpec: {<command>}
cmdContent: <command>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
First store data to command using \savedata{<command>}[<data>] or \readdata{<command>}{<filename>}. Allows more options than \fileplotThreeD.


cmdName: \everypsbox
cmdSpec: {<commands>}
cmdContent: <commands>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Sets a token register--applied to every subsequent PSTricks LR-box. Eg, \everypsbox{\scriptstyle}\pcline(1,2)(3,4)$\naput{s}$ applies \scriptstyle to s.


cmdName: \fileplot
cmdSpec: {<filename>}
cmdContent: <filename>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Data in filename should be x y pairs. Only other options for plotstyle are polygon, dots. Settings for arrows, linearc, showpoints ignored. If more options required, use \readdata and \dataplot.


cmdName: \fileplotThreeD
cmdSpec: {<filename>}
cmdContent: <filename>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Data in filename should be x y z triples. Only other options for plotstyle are polygon, dots. Settings for arrows, linearc, showpoints ignored. If more options required, use \readdata and \dataplotThreeD.


cmdName: \fnode
cmdSpec: (<x,y><-0,0){<name>}
cmdContent: <x,y><-0,0 <name>
cmdDelim: 10
cmdOpt: 10
cmdDescription:
To control size of f(rame)node, set keyword framesize=<dim dim>. Eg, \fnode[framesize=5pt 2,linecolor=blue](1,4){F}.


cmdName: \fnpnode
cmdSpec: {<xval>}{<expr in x>}{<nodeName>}
cmdContent: <xval> <expr in x> <nodeName>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Defines 'nodeName' as point on graph at x=xval. The expr may be either algebraic (if algebraic keyword specified) or PostScript. Eg, \def\myfn{Ex(-x)*sin(2*x)}\fnpnode[algebraic]{1.3}{\myfn}{P}.


cmdName: \fnpnodes
cmdSpec: {<xmin>}{<xmax>}{<expr in x>}{<nodeRoot>}
cmdContent: <xmin> <xmax> <expr in x> <nodeRoot>
cmdDelim: 0000
cmdOpt: 0000
cmdDescription:
Defines node sequence as points on graph at equally spaced x values, using plotpoints setting. The expr may be either algebraic (if algebraic keyword specified) or PostScript. 


cmdName: \getThreeDCoor
cmdSpec: (<3-vector>){<macro>}
cmdContent: <3-vector> <macro>
cmdDelim: 10
cmdOpt: 00
cmdDescription:
Stores a 3-vector specified as, eg, 4,2,-1 in the form 4 2 -1 allowing it to be output to PostScript without further processing. Eg, \getThreeDCoor(4,2,-1){\abc} stores '4 2 -1' in \abc.


cmdName: \listplot
cmdSpec: {<list>}
cmdContent: <list>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
List is space-delimited data pairs stored a macro using \savedata, or read from file with \readdata. May contain TeX macros and Postscript code.


cmdName: \listplotThreeD
cmdSpec: {<list>}
cmdContent: <list>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
List is space-delimited data triples stored in a macro using \savedata, or read from file with \readdata. May contain TeX macros and Postscript code.


cmdName: \mmultido
cmdSpec: {<variables>}{<repetitions>}{<stuff>}}
cmdContent: <variables> <repetitions> <stuff>}
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Eg, \mmultido{\ia=0+1,\ib=1+-2}{10}{\psdot(\ia,\ib)} places dots at (1,-1)...(10,-19). Like \multido, but increments all variables once before looping.


cmdName: \multips
cmdSpec: {<angle><-0}(<x0,y0><-0,0)(<dx,dy>){<int>}{<PureGraphics>}
cmdContent: <angle><-0 <x0,y0><-0,0 <dx,dy> <int> <PureGraphics>
cmdDelim: 01100
cmdOpt: 11000
cmdDescription:
For pure graphic objects only. Put down int copies of stuff starting at (x0,y0) and advancing each iteration by (dx,dy). See also \multirput.


cmdName: \multirput
cmdSpec: {<angle><-0}(<x0,y0><-0,0)(<dx,dy>){<int>}{<stuff>}
cmdContent: <angle><-0 <x0,y0><-0,0 <dx,dy> <int> <stuff>
cmdDelim: 01100
cmdOpt: 11000
cmdDescription:
Variant of \rput, putting down int copies of stuff starting at (x0,y0) and advancing each iteration by (dx,dy). (Cartesian coordinates only.) See also \multips.


cmdName: \ncangle
cmdSpec: {<arrows><--}{<nodeA>}{<nodeB>}
cmdContent: <arrows><-- <nodeA> <nodeB>
cmdDelim: 000
cmdOpt: 100
cmdDescription:
Node connection with two arms and diagonal perp. to armA, allowing offset. Best effect with angleA and angleB multiples of 90.


cmdName: \ncangles
cmdSpec: {<arrows><--}{<nodeA>}{<nodeB>}
cmdContent: <arrows><-- <nodeA> <nodeB>
cmdDelim: 000
cmdOpt: 100
cmdDescription:
Node connection with two arms and two perp. diagonals, allowing offset. Best effect with angleA and angleB multiples of 90.


cmdName: \ncbarr
cmdSpec: {<arrows><--}{<nodeA>}{<nodeB>}
cmdContent: <arrows><-- <nodeA> <nodeB>
cmdDelim: 000
cmdOpt: 100
cmdDescription:
Node connection like \ncbar, but with 5 segments, all horizontal or vertical. Must set angleA to 0 or 180.


cmdName: \ncdiag
cmdSpec: {<arrows><--}{<nodeA>}{<nodeB>}
cmdContent: <arrows><-- <nodeA> <nodeB>
cmdDelim: 000
cmdOpt: 100
cmdDescription:
Node connection with two arms and a diagonal, allowing offset. Best effect with angleA and angleB multiples of 90.


cmdName: \ncdiagg
cmdSpec: {<arrows><--}{<nodeA>}{<nodeB>}
cmdContent: <arrows><-- <nodeA> <nodeB>
cmdDelim: 000
cmdOpt: 100
cmdDescription:
Node connection with one arm and a diagonal, allowing offset. Best effect with angleA a multiple of 90---angleB is computed.


cmdName: \newpsfontdot
cmdSpec: {<name>}[<xW xS yS yW xO yO>]{<fontname>}{<glyphNumber>}
cmdContent: <name> <xW xS yS yW xO yO> <fontname> <glyphNumber>
cmdDelim: 0200
cmdOpt: 0000
cmdDescription:
Make new dot object, [...]=Postscript transformation matrix. GlyphNumber must be hex value enclosed in angle brackets.


cmdName: \newpsstyle
cmdSpec: {<name>}{<par1=value1,...>}
cmdContent: <name> <par1=value1,...>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
Save a group of settings as name, using with, eg, \newpsstyle{mystyle}{linecolor=red}\psline[style=mystyle](4,5).


cmdName: \nodexn
cmdSpec: {<node expr>}{<nodeName>}
cmdContent: <node expr> <nodeName>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
Defines a node by a node expression. Eg, \nodexn{.25(1,3)+.333(2;90)-1.2([nodesep=.5cm]Q)}{P} defines P as a linear combination. Each parenthesized term in the expression must be understood to \SpecialCoor.


cmdName: \nput
cmdSpec: {<refangle>}{<name>}{<stuff>}
cmdContent: <refangle> <name> <stuff>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Node version of \uput. Place stuff by node <name> at distance labelsep, angle refangle---may use \SpecialCoor angle forms. Rotation can be set using keyword rot, distance by keyword labelsep.


cmdName: \parabola
cmdSpec: {<arrows><--}(<x0,y0>)(<x1,y1>)
cmdContent: <arrows><-- <x0,y0> <x1,y1>
cmdDelim: 011
cmdOpt: 100
cmdDescription:
If pType=0 (default case) Symmetric parabola, extremum at (x1,y1), starting at (x0,y0). If pType=1, half-parabola from (x0,y0) to extremal point (x1,y1).


cmdName: \parametricPlotThreeD
cmdSpec: (<tmin,tmax>){<functions>}
cmdContent: <tmin,tmax> <functions>
cmdDelim: 10
cmdOpt: 00
cmdDescription:
Functions x(t) y(t) z(t) specified by PS code in variable t. If algebraic option specified, use infix notation, separate with |.


cmdName: \parametricPlotThreeD
cmdSpec: (<tmin,tmax>)(<umin,umax>){<functions>}
cmdContent: <tmin,tmax> <umin,umax> <functions>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Functions x(t,u) y(t,u) z(t,u) specified by PS code in variables t,u. If algebraic option specified, use infix notation, separate with |.


cmdName: \pcbarr
cmdSpec: {<arrows><--}{<nodeA>}{<nodeB>}
cmdContent: <arrows><-- <nodeA> <nodeB>
cmdDelim: 000
cmdOpt: 100
cmdDescription:
Point connection like \pcbar, but with 5 segments, all horizontal or vertical. Must set angleA to 0 or 180.


cmdName: \pnodes
cmdSpec: {<root node name>}
cmdContent: <root node name>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Declare a sequence of nodes. Eg, \pnodes{P}(0,1)(2,-1)(3,4) has the same effect as \pnode(0,1){P0}\pnode(2,-1){P1}\pnode(3,4){P2}.


cmdName: \polyIntersections
cmdSpec: {<nodeName1>}{<nodeName2>}(<xA,yA>)(<xB,yB>)
cmdContent: <nodeName1> <nodeName2> <xA,yA> <xB,yB>
cmdDelim: 0011
cmdOpt: 0000
cmdDescription:
Defines polyline as (x0,y0)... and computes first points of intersection of polyline with AB, in each direction. The results are named 'nodeName1' and 'nodeName2'.


cmdName: \polyIntersections
cmdSpec: {<nodeName1>}{<nodeName2>}(<xA,yA>)(<xB,yB>){<nodeRoot>}{<int>}
cmdContent: <nodeName1> <nodeName2> <xA,yA> <xB,yB> <nodeRoot> <int>
cmdDelim: 001100
cmdOpt: 000000
cmdDescription:
Defines polyline as nodeRoot0..nodeRoot<int> and computes first points of intersection of polyline with AB, in each direction. The results are named 'nodeName1' and 'nodeName2'.


cmdName: \psarc
cmdSpec: {<arrows><--}(<x,y><-0,0){<radius>}{<angleA>}{<angleB>}
cmdContent: <arrows><-- <x,y><-0,0 <radius> <angleA> <angleB>
cmdDelim: 01000
cmdOpt: 11000
cmdDescription:
Anticlockwise circular arc, center (x,y), starting at angleA, ending at angleB. At least one of arrows, center must be specified.


cmdName: \psarcn
cmdSpec: {<arrows><--}(<x,y><-0,0){<radius>}{<angleA>}{<angleB>}
cmdContent: <arrows><-- <x,y><-0,0 <radius> <angleA> <angleB>
cmdDelim: 01000
cmdOpt: 11000
cmdDescription:
Clockwise circular arc, center (x,y), starting at angleB, ending at angleA. At least one of arrows, center must be specified.


cmdName: \psaxes
cmdSpec: {<arrows><--}(<x0,y0><-x1,y1)(<x1,y1><-0,0)(<x2,y2>)[<x>,<angle><-,][<y>,<angle><-,]
cmdContent: <arrows><-- <x0,y0><-x1,y1 <x1,y1><-0,0 <x2,y2> <x>,<angle><-, <y>,<angle><-,
cmdDelim: 011122
cmdOpt: 111011
cmdDescription:
Make axes enclosed by rectangle with opposing corners (x1,y1) and (x2,y2), axes crossing at (x0,y0). Last, optional, arguments position x,y labels relative to tips of axes, under pstricks-add.


cmdName: \psBox
cmdSpec: (<x0,y0,z0>){<width>}{<depth>}{<height>}
cmdContent: <x0,y0,z0> <width> <depth> <height>
cmdDelim: 1000
cmdOpt: 0000
cmdDescription:
Draw projection of rectangular rooted at (x0,y0,z0) with specified width, depth height. Accepts showInside keyword. Set RotX, etc to rotate. Face colors depend on xyzLight setting.


cmdName: \psbrace
cmdSpec: (<x0,y0>)(<x1,y1>){<label text>}
cmdContent: <x0,y0> <x1,y1> <label text>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Draw brace connecting two points (may be nodes) with specified label. Uses keywords braceWidth, braceWidthInner, braceWidthOuter, bracePos. Label position governed by nodesepA, nodesepB.


cmdName: \psBspline
cmdSpec: {<root name><-''}
cmdContent: <root name><-''
cmdDelim: 0
cmdOpt: 1
cmdDescription:
The points are the control points of a uniform cubic B-spline curve. If 'root name' is provided, say ='B', the intermediate points are named BL0, BR0, and the interpolated points are named BS0, etc.


cmdName: \psbspline
cmdDescription:
The points are to be interpolated by an open uniform cubic B-spline curve without naming intermediate points of the construction.


cmdName: \psBsplineC
cmdSpec: {<root name><-''}
cmdContent: <root name><-''
cmdDelim: 0
cmdOpt: 1
cmdDescription:
The points are the control points of a uniform cubic B-spline curve. Same as \psBspline except that control points are extended periodically, resulting in a closed curve.


cmdName: \psBsplineE
cmdSpec: {<root name><-''}
cmdContent: <root name><-''
cmdDelim: 0
cmdOpt: 1
cmdDescription:
The points are the control points of a uniform cubic B-spline curve. Same as \psBspline except that first and last segments are omitted.


cmdName: \psBsplineNodesE
cmdSpec: {<root name>}{<int>}
cmdContent: <root name> <int>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
The node sequence specifies the control points of a uniform cubic B-spline curve whose first and last segments are omitted.


cmdName: \psBsplineInterp
cmdSpec: {<root name>}{<int>}
cmdContent: <root name> <int>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
The node sequence specifies points to be interpolated by a uniform cubic B-spline curve. If root name=S, the result is a node sequence SB0... of control points to which \psBslineNodes may be applied to produce an interpolating curve.


cmdName: \psBsplineInterpC
cmdSpec: {<root name>}{<int>}
cmdContent: <root name> <int>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
The node sequence specifies points to be interpolated by a closed uniform cubic B-spline curve. If root name=S, the result is a node sequence SB0... of control points to which \psBslineNodesC may be applied to produce an interpolating curve.


cmdName: \psChart
cmdSpec: {<comma separated value list>}{<comma separated value list>}{<radius>}
cmdContent: <comma separated value list> <comma separated value list> <radius>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
The first list gives the sizes of the wedges. The second lists only the wedges that are exploded. Keywords chartSep (default 10pt), chartColor and userColor may be specified. The chart center is (0,0), and may need to be \rput. Defines node sequences psChart?, psChartO?, psChartI?


cmdName: \psCircleTangents
cmdSpec: (<x0,y0>)(<x1,y1>){<rad1>}
cmdContent: <x0,y0> <x1,y1> <rad1>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Creates nodes CircleT1, CircleT2 at tangency points on circle from exterior point x0,y0. Points may be specified in any \SpecialCoor form.


cmdName: \psComment
cmdSpec: ''[par<-'']{<arrows>}(A)(B){<text>}[<line macro><-'']
cmdContent: par<-'' <arrows> A B <text> <line macro><-''
cmdDelim: 3201102
cmdOpt: 0100001
cmdDescription:
Place label 'text' so that its reference point is at A and a line is drawn from A to B using \pcline. If 'line macro' is set to \rput, effect is to add \rput(A){text}.


cmdName: \psCoordinates
cmdSpec: (<coords>)
cmdContent: <coords>
cmdDelim: 1
cmdOpt: 0
cmdDescription:
Place a dot (parameters dotstyle, dotscale etc) at <coords> and drop lines (parameters linecolor, linestyle etc) to axes.


cmdName: \pscustom
cmdSpec: {<commands>}
cmdContent: <commands>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Principal use is to concatenate open curves to form a closed curve, such as region enclosed by two graphs.


cmdName: \psDefPSPNodes
cmdDescription:
Creates nodes and corners and midpoints of picture using default names PSPtl, PSPtc, PSPtr, PSPcl, PSPcc, etc.


cmdName: \psEllipseTangents
cmdSpec: (<x0,y0>)(<x1,y1>){<rad1,rad2>}
cmdContent: <x0,y0> <x1,y1> <rad1,rad2>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Creates nodes EllipseT1, EllipseT2 at tangency points on ellipse from exterior point x0,y0. Arguments may be specified in any \SpecialCoor form.


cmdName: \psEllipseTangentsN
cmdSpec: (<x0,y0>)(<x1,y1>){<rad1,rad2>}{<base name>}
cmdContent: <x0,y0> <x1,y1> <rad1,rad2> <base name>
cmdDelim: 1100
cmdOpt: 0000
cmdDescription:
Creates nodes <base name>1, <base name>2 at tangency points on ellipse from exterior point x0,y0. Arguments may be specified in any \SpecialCoor form.


cmdName: \psForeach
cmdSpec: {<variable>}{<value list>}{<action>}
cmdContent: <variable> <value list> <action>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Perform 'action' for each value in 'value list'. The 'action' is not grouped, unlike \psforeach. Uses \psLoopIndex as internal counter.


cmdName: \psforeach
cmdSpec: {<variable>}{<value list>}{<action>}
cmdContent: <variable> <value list> <action>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Perform 'action' for each value in 'value list'. The 'action' is grouped, unlike \psForeach. Uses \psLoopIndex as internal counter.


cmdName: \psFormatInt
cmdSpec: {<macro|number>}
cmdContent: <macro|number>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Formats the expanded macro or number using the value of the keyword intSeparator (defaults to a space).


cmdName: \psframe
cmdSpec: (<x0,y0><-0,0)(<x1,y1>)
cmdContent: <x0,y0><-0,0 <x1,y1>
cmdDelim: 11
cmdOpt: 10
cmdDescription:
Rectangular frame with opposing corners at (x0,y0) and (x1,y1). * form fills with linecolor. Unstarred form uses fillcolor with edge of linecolor.


cmdName: \psframebox
cmdSpec: {<stuff>}
cmdContent: <stuff>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Simple frame around stuff. * fills background with fillcolor. For rounded corners, set positive value for framearc or linearc, depending on whether cornersize is relative or absolute.


cmdName: \psGetNodeCenter
cmdSpec: {<node name>}
cmdContent: <node name>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Used within PostScript code to obtain the x,y coordinates of the center of a node, usually for purposes of defining another node in relation to it.


cmdName: \psgraph
cmdSpec: (<x0,y0><-x1,y1)(<x1,y1><-0,0)(<x2,y2>){<width>}{<height>}
cmdContent: <x0,y0><-x1,y1 <x1,y1><-0,0 <x2,y2> <width> <height>
cmdDelim: 11100
cmdOpt: 11000
cmdDescription:
Creates both a pspicture and axes in canvas of specified width, height, adjusting xunit, yunit as necessary. Parameters are for axes only. See also llx, lly, urx, ury.


cmdName: \psgrapha
cmdSpec: (<x1,y1><-0,0)(<x2,y2>){<width>}{<height>}
cmdContent: <x1,y1><-0,0 <x2,y2> <width> <height>
cmdDelim: 1100
cmdOpt: 1000
cmdDescription:
Creates both a pspicture and broken axes in canvas of specified width, height, adjusting xunit, yunit as necessary. Parameters are for axes only. See also llx, lly, urx, ury.


cmdName: \psgrid
cmdSpec: (<x0,y0><-x1,y1)(<x1,y1><-0,0)(<x2,y2><-10,10)
cmdContent: <x0,y0><-x1,y1 <x1,y1><-0,0 <x2,y2><-10,10
cmdDelim: 111
cmdOpt: 111
cmdDescription:
Grid with opposing corners (x1,y1), (x2,y2), numbers on axes through (x0,y0). In pspicture, takes coords from psicture bounds.


cmdName: \psIntersectionPoint
cmdSpec: (<x0,y0>)(<x1,y1>)(<x2,y2>)(<x3,y3>){<node name>}
cmdContent: <x0,y0> <x1,y1> <x2,y2> <x3,y3> <node name>
cmdDelim: 11110
cmdOpt: 00000
cmdDescription:
Define node as intersection of line segments A(x0,y0)-B(x1,y1) and C(x2,y2)-D(x3,y3). (Part of pstricks-add.)


cmdName: \psLCNode
cmdSpec: (<x0,y0>){<value0>}(<x1,y1>){<value1>}{<new node name>}
cmdContent: <x0,y0> <value0> <x1,y1> <value1> <new node name>
cmdDelim: 10100
cmdOpt: 00000
cmdDescription:
Assigns <new node name> (must differ from P0 and P1) to the linear combination <value0>P_0+<value1>P_1. Useful in conjunction with \psParallelLine.


cmdName: \psLCNodeVar
cmdSpec: (<x0,y0>)(<x1,y1>){<value1,value2>}{<new node name>}
cmdContent: <x0,y0> <x1,y1> <value1,value2> <new node name>
cmdDelim: 1100
cmdOpt: 0000
cmdDescription:
Assigns <new node name> to the linear combination <value0>P_0+<value1>P_1. Useful in conjunction with \psParallelLine.


cmdName: \psline
cmdSpec: {<arrows><--}
cmdContent: <arrows><--
cmdDelim: 0
cmdOpt: 1
cmdDescription:
Draws line through sequence of points using linewidth, linecolor, linearc. * form closes and fills with linecolor.


cmdName: \psmatrix
cmdDescription:
LaTeX uses \begin{psmatrix}...\end{psmatrix}. Matrix-like environment for making arrays of nodes with names of form {1,1}...


cmdName: \psnline
cmdSpec: {<arrows><--}(<num1,num2>){<nodeRoot>}
cmdContent: <arrows><-- <num1,num2> <nodeRoot>
cmdDelim: 010
cmdOpt: 100
cmdDescription:
Draws line through points of a node sequence, with same options as for \psline. Num1 is initial index, num2 the number of segments. Eg, \psnline(3,5){P} draws line through P3, P4,..., P8.


cmdName: \psParallelLine
cmdSpec: (<x0,y0>)(<x1,y1>)(<x2,y2>){<scale factor>}{<new node name>}
cmdContent: <x0,y0> <x1,y1> <x2,y2> <scale factor> <new node name>
cmdDelim: 11100
cmdOpt: 00000
cmdDescription:
Define new node as end of parallel translation of line segment P_0P_1 to start at P_2, with length multiplied by <scale factor>.


cmdName: \pspicture
cmdSpec: (<x0,y0><-0,0)(<x1,y1>)
cmdContent: <x0,y0><-0,0 <x1,y1>
cmdDelim: 11
cmdOpt: 10
cmdDescription:
Rectangular canvas with opposing corners at (x0,y0) and (x1,y1). LaTeX uses \begin{pspicture}...\end{pspicture}. * clips picture to boundary.


cmdName: \psplot
cmdSpec: {<xmin>}{<xmax>}[<PS Commands>='']{<function>}
cmdContent: <xmin> <xmax> <PS Commands>='' <function>
cmdDelim: 0020
cmdOpt: 0000
cmdDescription:
Function is specified by PS code in variable x. If algebraic option specified, use infix notation. [<PS commands>] entry requires pstricks-add.


cmdName: \psplotThreeD
cmdSpec: (<xmin,xmax>)(<ymin,ymax>){<function>}
cmdContent: <xmin,xmax> <ymin,ymax> <function>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Function is specified by PS code in variables x,y. If algebraic option specified, use infix notation.


cmdName: \pspolygon
cmdDescription:
Draws closed polygon through sequence of points using linewidth, linecolor, linearc, framearc, cornersize. * form fills with linecolor.


cmdName: \psRelLine
cmdSpec: {<arrows><--}(<x0,y0>)(<x1,y1>){<scale factor>}{<end node name>}
cmdContent: <arrows><-- <x0,y0> <x1,y1> <scale factor> <end node name>
cmdDelim: 01100
cmdOpt: 10000
cmdDescription:
Draw line from (x0,y0) with length=<scale factor>*|P_0P_1|, at <angle> relative to to P_0P_1. End of segment is named <end node name>.


cmdName: \psRelLineVar
cmdSpec: {<arrows><--}(<x0,y0>)(<x1,y1>)(<u,v>){<end node name>}
cmdContent: <arrows><-- <x0,y0> <x1,y1> <u,v> <end node name>
cmdDelim: 01110
cmdOpt: 10000
cmdDescription:
Draw line from (x0,y0) with length=|(u,v)|*|P_0P_1|, at arg(u,v) relative to to P_0P_1. End of segment is named <end node name>. The vector (u,v) may take any form acceptable to \SpecialCoor.


cmdName: \psRelNode
cmdSpec: (<x0,y0>)(<x1,y1>){<scale factor>}{<end node name>}
cmdContent: <x0,y0> <x1,y1> <scale factor> <end node name>
cmdDelim: 1100
cmdOpt: 0000
cmdDescription:
Define new node <end node name> as end of line segment from (x0,y0) with length=<scale factor>*|P_0P_1|, at <angle> relative to to P_0P_1.


cmdName: \psRelNodeVar
cmdSpec: (<x0,y0>)(<x1,y1>)(<u,v>){<end node name>}
cmdContent: <x0,y0> <x1,y1> <u,v> <end node name>
cmdDelim: 1110
cmdOpt: 0000
cmdDescription:
Define new node <end node name> as end of line segment from (x0,y0) with length=|(u,v)|*|P_0P_1|, at arg(u,v) relative to to P_0P_1. The vector (u,v) may take any form acceptable to \SpecialCoor.


cmdName: \psrline
cmdSpec: {<arrows><--}(<x0,y0>)
cmdContent: <arrows><-- <x0,y0>
cmdDelim: 01
cmdOpt: 10
cmdDescription:
Draws line starting at x0,y0, with increments x1,y1 etc. Same options as for \psline. Eg, \psrline(3,5)(P)(Q) draws line through (3,5), (3,5)+P, (3,5)+P+Q.


cmdName: \psStartPoint
cmdSpec: (<x,y>)
cmdContent: <x,y>
cmdDelim: 1
cmdOpt: 0
cmdDescription:
Set start for drawing a sequence of vectors. Optional parameter specifies a basename for the node sequence.


cmdName: \psStepa
cmdSpec: {<nodeRoot>}{<int>}
cmdContent: <nodeRoot> <int>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
Plots step function determined by specified node sequence.  Eg, \psStepa{P}{10} uses points P0,...P10 as corners.


cmdName: \pstScalePoints
cmdSpec: (<xScale,yScale>){xPS}{yPS}
cmdContent: <xScale,yScale> xPS yPS
cmdDelim: 100
cmdOpt: 000
cmdDescription:
For use only with \listplot. Applies PostScript code xPS to x values, yPS to y values, then scales with factors xScale, yScale.


cmdName: \pst@absdim
cmdSpec: {<dim>}{result as dimension register}
cmdContent: <dim> result as dimension register
cmdDelim: 00
cmdOpt: 00
cmdDescription:
Returns absolute value of a length as a dimension register. Eg, \pst@absdim{-2cm}{\abc} sets \abc=2cm.


cmdName: \pst@maxdim
cmdSpec: {<dim>}{<dim>}{result as dimension register}
cmdContent: <dim> <dim> result as dimension register
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Returns max of two lengths as dimension register value. Eg, \pst@maxdim{3cm}{2pt}{\abc} defines \abc as 3cm.


cmdName: \pst@mindim
cmdSpec: {<dim>}{<dim>}{result as dimension register}
cmdContent: <dim> <dim> result as dimension register
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Returns min of two lengths as dimension register value. Eg, \pst@mindim{3cm}{2pt}{\abc} defines \abc as 2pt.


cmdName: \pstaddThreeDVec
cmdSpec: (<vectorA>)(<vectorB>){<macro>}
cmdContent: <vectorA> <vectorB> <macro>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Stores the sum of vectorA and vectorB in the macro, space delimited. Eg, \pstaddThreeDVec(1,2,3)(2,0,1){\result} stores '3 2 4' in \result.


cmdName: \psTextFrame
cmdSpec: (<x1,y1>)(<x2,y2>){<Text>}
cmdContent: <x1,y1> <x2,y2> <Text>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Place framed text in box with corners (x1,y1), (x2,y2). Text can be minipage or parbox. Parameter ref specifies refpt.


cmdName: \pstFPDiv
cmdSpec: {result as macro (integer)}{<num>}{<num>}
cmdContent: result as macro (integer) <num> <num>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Returns integer part of ratio of first num to second. Eg, \pstFPDiv{\abc}{3.1}{2} defines \abc as 1.


cmdName: \pstGetSlope
cmdSpec: (<coords>)(<coords>){result as macro}
cmdContent: <coords> <coords> result as macro
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Returns slope of line joing two points as macro value. Eg, \pstGetSlope(1,1)(2,2){\abc} defines \abc as 1.


cmdName: \pstParaboloid
cmdSpec: {<radius>}{<height>}
cmdContent: <radius> <height>
cmdDelim: 00
cmdOpt: 00
cmdDescription:
Draw paraboloid with center of base at 0,0,0, with specified height and top radius. Set elsewhere using \pstThreeDPut.


cmdName: \pstRotPointIIID
cmdSpec: [RotX=<anglex>,RotY=<angley>,RotZ=<anglez>](<x,y,z>){\xVal}{\yVal}{\zVal}
cmdContent: RotX=<anglex>,RotY=<angley>,RotZ=<anglez> <x,y,z> \xVal \yVal \zVal
cmdDelim: 21000
cmdOpt: 00000
cmdDescription:
Stores the image of (x,y,z) under the specified rotation. The coordinates of the image are placed in the specified macros, which must have been defined in advance, and can be named arbitrarily.


cmdName: \pstriangle
cmdSpec: (<x0,y0><-0,0)(<x1,y1>)
cmdContent: <x0,y0><-0,0 <x1,y1>
cmdDelim: 11
cmdOpt: 10
cmdDescription:
Isosceles triangle, base centered at (x0,y0), (base,height)=(x1,y1). Parameter gangle controls rotation.


cmdName: \pstScalePoints
cmdSpec: (<xscale,yscale>){<xPScode>}{<yPScode>}
cmdContent: <xscale,yscale> <xPScode> <yPScode>
cmdDelim: 100
cmdOpt: 000
cmdDescription:
Applies to all following \listplot. Applies xPScode (eg, 1000 add) to all x values, then multiplies resulting x values by xScale. Similarly for y.


cmdName: \pstsubThreeDVec
cmdSpec: (<vectorA>)(<vectorB>){<macro>}
cmdContent: <vectorA> <vectorB> <macro>
cmdDelim: 110
cmdOpt: 000
cmdDescription:
Stores the vectorA-vectorB in the macro, space delimited. Eg, \pstsubThreeDVec(1,2,3)(2,0,1){\result} stores '-1 2 2' in \result.


cmdName: \pstThreeDBox
cmdSpec: (<x0,y0,z0>)(<x1,y1,z1>)(<x2,y2,z2>)(<x3,y3,z3>)
cmdContent: <x0,y0,z0> <x1,y1,z1> <x2,y2,z2> <x3,y3,z3>
cmdDelim: 1111
cmdOpt: 0000
cmdDescription:
Draw projection of parallepiped rooted at (x0,y0,z0). Other coordinates define edge vectors. Accepts hiddenLine keyword.


cmdName: \pstThreeDCircle
cmdSpec: (<cx,cy,cz>)(<ux,uy,uz>)(<vx,vy,vz>)
cmdContent: <cx,cy,cz> <ux,uy,uz> <vx,vy,vz>
cmdDelim: 111
cmdOpt: 000
cmdDescription:
Draw projection of circle, center (cx,cy,cz), semiaxis vectors (ux,uy,uz) and (vx,vy,vz). Use startAngle, endAngle for arc.


cmdName: \pstThreeDDot
cmdSpec: (<x,y,z>)
cmdContent: <x,y,z>
cmdDelim: 1
cmdOpt: 0
cmdDescription:
Draw dot, using two dimensional dot parameters. If drawCoor=true, drop dashed lines to coordinate planes.


cmdName: \pstThreeDEllipse
cmdSpec: (<cx,cy,cz>)(<ux,uy,uz>)(vx,vy,vz)
cmdContent: <cx,cy,cz> <ux,uy,uz> vx,vy,vz
cmdDelim: 111
cmdOpt: 000
cmdDescription:
Draw projection of ellipse, center (cx,cy,cz), semiaxis vectors (ux,uy,uz) and (vx,vy,vz). Use startAngle, endAngle for arc.


cmdName: \pstThreeDPlaneGrid
cmdSpec: (<xmin,ymin>)(<xmax,ymax>)
cmdContent: <xmin,ymin> <xmax,ymax>
cmdDelim: 11
cmdOpt: 00
cmdDescription:
Make grid in plane specified by planeGrid---one of xy,xz,yz. Also uses subticks (default 10), planeGridOffset (default 0).


cmdName: \psunit
cmdDescription:
Dimension register storing psunit. Set with, eg, \psset{unit=<dim>}, which also sets xunit, yunit and runit.


cmdName: \psVector
cmdSpec: (<x,y>)
cmdContent: <x,y>
cmdDelim: 1
cmdOpt: 0
cmdDescription:
Next increment in a sequence of vectors. Initial point and node sequence basename may be set using \psStartPoint, otherwise nodes are labelled Vector0, Vector1,....


cmdName: \psxline
cmdSpec: {<arrows><--}(<x0,y0>){<nodeExpr1>}{<nodeExpr2>}
cmdContent: <arrows><-- <x0,y0> <nodeExpr1> <nodeExpr2>
cmdDelim: 0100
cmdOpt: 1000
cmdDescription:
Draws line from (x0,y0)+nodeExpr1 to (x0,y0)+nodeExpr2. Same options as for \psline. Eg, \psxline(R){P}{Q} draws line from R+P to R+Q.


cmdName: \Put
cmdSpec: {<ref>}{<position>}{<stuff>}
cmdContent: <ref> <position> <stuff>
cmdDelim: 000
cmdOpt: 000
cmdDescription:
Place 'stuff' with its reference point 'ref' translated to 'position'. Rotation of 'stuff' is controlled by kwd 'rot', which can take any form acceptable to \SpecialCoor. The refpt 'ref' can be a named refpt, like Bl, or any form of polar. Accepts all arguments in any form acceptable to \SpecialCoor. Eg, \Put{;30}(0,0){x}, \Put{B}(0,0){x}, \Put{10pt;(P)}(Q){x}, \Put[rot=(P)]{B}(0,0){x}.


cmdName: \rhombus
cmdSpec: {<edge length>}(<xA,yA>)(<xB,yB>){<nodeC>}{<nodeD>}
cmdContent: <edge length> <xA,yA> <xB,yB> <nodeC> <nodeD>
cmdDelim: 01100
cmdOpt: 00000
cmdDescription:
Given opposing vertices and edge length of a rhombus, computes remaining vertices C, D as nodes. (Does not draw the rhombus.)


cmdName: \rmultiput
cmdSpec: {<stuff>}(<coords>)...
cmdContent: <stuff> <coords>)..
cmdDelim: 01
cmdOpt: 00
cmdDescription:
Eg, \rmultiput{\psdot(0,0)}(0,0)(3,2)(1,4) places dots at (0,0),(3,2), and (1,4). Same options as \multirput.


cmdName: \rnode
cmdSpec: [refpt<-c]{<name>}{<stuff>}
cmdContent: refpt<-c <name> <stuff>
cmdDelim: 200
cmdOpt: 100
cmdDescription:
Place stuff in box (no frame) with specified refpoint, which defaults to center (c). Other values are combinations of t,b,B with l,r.


cmdName: \rput
cmdSpec: [<refpt><-c]{<rotation><-0}(<x,y><-0,0){<stuff>}
cmdContent: <refpt><-c <rotation><-0 <x,y><-0,0 <stuff>
cmdDelim: 2010
cmdOpt: 1110
cmdDescription:
Translate refpt of stuff to (x,y), and rotation (may be one of U, L, D, R, N, W, S, E---* preceding angle undoes containing rotations) about refpt. Initial * blanks background. If (x,y) is not specified, <rotation> must be.


cmdName: \shownode
cmdSpec: {<nodeName>}
cmdContent: <nodeName>
cmdDelim: 0
cmdOpt: 0
cmdDescription:
Enters the coordinates of nodeName in the the console log. A PostScript error will result if the node does not exist.


cmdName: \SpecialCoor
cmdDescription:
Turns on recognition of special coordinate and angle forms. (Turn off with \NormalCoor.) Additional coordinate forms understood: (r;theta), (! <postscript code>), (*x {f(x)}), (P), ([nodesep=10pt,offset=2]P), ([params]{B}A), (P1 | P2) with x coord from P1, y coord from P2. Angle forms may be numeric, ! <postscript>, or (P) for any of the above forms of P.


cmdName: \Tfan
cmdDescription:
Triangular node with base fansize, opposite corner the predecessor node, adjusted by nodesepA and offsetA.


cmdName: \thickBspline
cmdSpec: {<nodeRootName>}{<segments>}{<thickness>}{<items to clip>}
cmdContent: <nodeRootName> <segments> <thickness> <items to clip>
cmdDelim: 0000
cmdOpt: 0000
cmdDescription:
Create a clipping path of specified thickness around the interpolating curve and place graphics to be clipped.


cmdName: \uput
cmdSpec: {<distance><-labelsep}[<refangle>]{<rotation><-0}(<x,y><-0,0){<stuff>}
cmdContent: <distance><-labelsep <refangle> <rotation><-0 <x,y><-0,0 <stuff>
cmdDelim: 02010
cmdOpt: 10110
cmdDescription:
Place stuff by (x,y) at distance, angle refangle, rotated by rotation, which may be one of r, u, l, d ur, ul, dr, dl. * form blanks background. SPECIAL CASE: if refangle is specified as a node, eg, (P), the angle is not OP but (x,y)P unless you specify (x,y) as >(x,y).


# Parameters

parName: algebraic
parPat: <true|false>
parDefault: false
parcseq: \ifPst@algebraic
parDescription:
If true, use algebraic expressions, not Postscript code---angles in radians, Ex=exponential fn, ch=cosh, sh=sinh. Eg, Ex(-x/2)*sin(2*x)+sh(x)*ln(x+1)


parName: Alpha
parPat: <angle>
parDefault: 45
parDescription:
Viewangle specification (with Beta). Alpha determines horizontal angle from viewangle to y axis. (Eg, set Alpha=90 to view from x axis.) Set with \psset.


parName: arcangle
parPat: <angle>
parDefault: 8
parDescription:
In arc type node connections, gives angle from connecting line to arc---arcangleA and arcangleB may be set separately.


parName: arrowlength
parPat: <num>
parDefault: 1.4
parDescription:
Length of arrowhead, as fraction of length. In \psBoxplot, factor by which barwidth/2 is multiplied to produce whisker lengths.


parName: arrows
parPat: <string>
parDefault: -
parcseq: \psk@arrowA,\psk@arrowB
parDescription:
Style of arrow to place on ends of an open curve. Eg, arrows=-> places an arrowhead at end of curve. <D-D> makes larger, curved arrowheads at start and end.


parName: barstyle
parPat: <list>
parcseq: \@barstylelist
parDescription:
Apply a list of named styles to psbarchart elements. Predefined styles are black, darkgray, gray, lightgray, white, red, green, blue.


parName: blendmode
parPat: <0|1|2|3|4>
parDefault: 0
parcseq: \psk@blendmode
parDescription:
Only for fillstyle=shape, with transparency. Values signify Normal|Compatible|Screen|Multiply|HardLight


parName: colorType
parPat: <0|1|2|3|4|5>
parDefault: 0
parcseq: \psk@colorType
parDescription:
0: two color mode. 1: wavelength mode (400,,700). 2: wavelength mode, inverted. 3: grayscale mode. 4: grayscale mode, inverted. 5: Custom, as specified by 'colorTypeDef'.


parName: cornersize
parPat: <relative|absolute>
parDefault: relative
parDescription:
If relative, framearc determines radius of rounded corners. If absolute, linearc determines the radius.


parName: dash
parPat: <dim dim>
parDefault: 5pt 2pt
parDescription:
Black-white dash pattern for linestyle=dashed only. With pstricks-add, you can have arbitrary length patterns like 5pt 1pt 3pt ...


parName: Derive
parDescription:
Though defined as a keyword, Derive(n,f(x)) is in fact mapped to a PostScript function EvalDerive---the nth derivative of f(x), which must be expressed algebraically.


parName: dotstyle
parDefault: *
parcseq: \psk@dotstyle
parDescription: Except for diamond, hollow centers are colored fillcolor.
parPat:
<*|o|Bo|x|+|B+|asterisk|Basterisk|oplus|otimes|B||square|Bsquare|square*|diamond|diamond*|triangle|Btriangle|triangle*|pentagon|Bpentagon|pentagon*>


parName: drawCoor
parPat: <true|false>
parDefault: false
parDescription:
In 3dPlot, specify if item placed with \pstThreeDDot or \pstThreeDBox should be accompanied by dashed lines to coordinate planes.


parName: equalunits
parPat: <true|false>
parDefault: false
parDescription:
If true, xunit is forced to be equal to yunit, possibly resulting in additional white space above or to right of picture.


parName: eulerRotation
parPat: <true|false>
parDefault: false
parDescription:
In 3dPlot, true starts eulerRotation option, making new rotation relative to current coordinate system.


parName: fullcanvas
parPat: <true|false>
parDefault: false
parDescription:
If true, an invisible border is drawn around the psgrapha canvas so that clipping never reduces the speciﬁed size.


parName: graphPaper
parPat: <true|false>
parDefault: false
parDescription:
If true, draw graph-paper-like grid based on values in \xGridMin, \xGridMax, etc. Similar to showGrid.


parName: Hue
parPat: <angle>
parDefault: 180
parcseq: \pst@HueAngle
parDescription:
Only for plotstyle=colordots---must be in range 0..360. Saturaation and Brightness are determined by y value.


parName: liftpen
parPat: <0|1|2>
parDefault: 0
parDescription:
Controls transition from end of one curve to beginning of next curve. 0 joins with line, 1 joins with line to origin, 2 makes no joins.


parName: lineAngle
parPat: <angle>
parDefault: 0
parDescription:
If set to a non-zero value, forces linking segment to have angle=lineAngle, recomputing armA and angleB if necessary.


parName: linearc
parPat: <dim>
parDefault: 0pt
parDescription:
Determines corner radius for lines, polygons and zigzags. Does same for \psframe and boxing macros if cornersize=absolute.


parName: linestyle
parPat: <none|solid|dashed|dotted|symbol>
parDefault: solid
parcseq: \pslinestyle
parDescription:
Curve commands should render in this style. The symbol style uses symbolFont, symbolStep, rotateSymbol, startAngle, rot.


parName: llx
parPat: <dim>
parDefault: 0
parDescription:
Space to leave on left edge of \psgraph (adds) and \psgrapha (subtracts). Must be \psset prior to \begin{psgraph[a]}.


parName: lly
parPat: <dim>
parDefault: 0
parDescription:
Space to leave on lower edge of \psgraph (adds) and \psgrapha (subtracts). Must be \psset prior to \begin{psgraph[a]}.


parName: mathLabel
parPat: <true|false>
parDefault: true
parDescription:
If true, font size must be set by a math style, eg \textstyle, \displaystyle, \scriptstyle, \scriptscriptstyle. Also see labelFontSize setting.


parName: method
parPat: <rk4|varrkiv|adams|{}>
parDefault: {}
parcseq: \psk@method
parDescription:
DE solution method. Defaults to adams. May also choose Runge-Kutta 4 (rk4) or rk4 with adaaptive step(varrkiv).


parName: metricFunction
parPat: <true|false>
parDefault: false
parcseq: \ifPST@metricFunction
parDescription:
If true, the metric function specified must be a function of x and y only, otherwise it may involve dx, dy and ds.


parName: pcRef
parPat: <true|false>
parDefault: true
parDescription:
For \ncangles. With pcRef=true the arm length is computed from the node center, but the connection is still drawn from the border of the node.


parName: plane
parPat: xy|xz|yz
parDefault: xy
parDescription:
In 3dPlot, plane written to by \pstPlanePut commands. First letter indicates width direction, second height direction.


parName: planeGridOffset
parPat: <value>
parDefault: 0
parDescription:
In 3dPlot \pstThreeDPlaneGrid, value by which grid should be shifted, eg, to make a frame around an object.


parName: plotNo
parPat: <int>
parDefault: 1
parDescription:
Allows selection of y column from data macro when data was read from a source with more than 2 columns. Must also set plotNoMax.


parName: plotNoMax
parPat: <int>
parDefault: 1
parDescription:
Specifies number of y columns in original data file. Use in conjunction with plotNo to specify column to use in plot.


parName: plotstyle
parPat: <dots|line|polygon|curve|ecurve|ccurve|LineToXAxis|LineToYAxis|bar|LSM|values|colordots>
parDefault: line
parDescription:
How to join points in plots. To get arrows, use arrows parameter. The bar style draws a barplot. LSM does least squares fit in \listplot.


parName: pOrigin
parPat: <lt|lB|lb|t|c|B|b|rt|rB|rb>
parDescription:
In 3dPlot, positioning key, similar to usage of refpt in \rput. Default setting depends on setting for \rput.


parName: pType
parPat: <0|1>
parDefault: 0
parcseq: \psk@pType
parDescription:
Set pType=0 for symmetric parabola given 1 point and min/max, 1 for half-parabola from point to extremal.


parName: RotAngle
parPat: <angle>
parDefault: 0
parDescription:
In 3dplot, degrees to rotate about vector xRotVec,yRotVec,zRotVec using 'quaternion' option for RotSequence.


parName: rotateSymbol
parPat: <true|false>
parDefault: false
parcseq: \ifPst@rotateSymbol
parDescription:
With linestyle=symbol, permits rotation. Initial value is startAngle---others are controlled by rot.


parName: showfullcanvas
parPat: <true|false>
parDefault: false
parDescription:
If true, an invisible border is drawn around the pslayout canvas so that clipping never reduces the speciﬁed size.


parName: tickdim
parPat: <dim>
parDefault: 4pt
parDescription:
Length (measured from the axis to the tip of the tick) of major ticks used on both axes. Always non-negative. Use in conjunction with tickpref.


parName: tickpref
parPat: <A|B|C>
parDescription:
Used with tickdim. Choice A makes ticks of length tickdim pointing into main quadrant. Choice C means the opposite. Choice B means both sides.


parName: tickstyle
parPat: <full|top|bottom>
parDefault: full
parDescription:
Deprecated. Use ticksize instead. If top, ticks are placed on side of axes opposite labels. Bottom gives same side, full extends both sides.


parName: tnyref
parPat: <dim>
parDefault: \dp\strutbox
parDescription:
When positioned left or right of node, label edge is tnsep from node and vertical point aligns with tnref (default value: vref).


parName: trigLabelBase
parPat: <num>
parDefault: 0
parDescription:
If trigLabels=true, use trig labels on x axis, with trigLabelBase governing denominators. Eg, trigLabelBase=3 makes \pi/3 the first label. Use trigx with \psgraph.


parName: trigx
parPat: <true|false>
parDescription:
If true, labels on x axis are multiplied by \pi, though the underlying coordinates are not modiﬁed. Arguments must therefore replace x with x/\pi.


parName: urx
parPat: <dim>
parDefault: 0
parDescription:
Space to leave on right edge of \psgraph (adds) and \psgrapha (subtracts). Must be \psset prior to \begin{psgraph[a]}.


parName: ury
parPat: <dim>
parDefault: 0
parDescription:
Space to leave on upper edge of \psgraph (adds) and \psgrapha (subtracts). Must be \psset prior to \begin{psgraph[a]}.


parName: userColor
parPat: <color list>
parDefault: {}
parDescription:
Comma separated list of user defined colors for the wedges. Eg, userColor={red!30,green!30,blue!40,yellow}.


parName: xAxis
parPat: <true|false>
parDefault: true
parDescription:
If false, draw no x axis and no ticks on x axis. (If xyAxes=false, xAxis and yAxis are set to false.)


parName: xAxisLabelPos
parPat: <text>
parDescription:
If void, draw xAxisLabel at tip of x axis. If {c,-5pt}, draw label centered and 5pt below x axis. If {4pt,-5pt}, draw label {4pt,-5pt} relative to axes crossing point.


parName: xDecimals
parPat: <num>
parDefault: {}
parDescription:
If unspecified, decimal values on x axis are handled as usual. Eg, xDecimals=2 forces 2 decimal places in x labels. (xyDecimals specifies xDecimals and yDecimals.)


parName: Xnodesep
parPat: <dim>
parDefault: 0pt
parDescription:
Sets XnodesepA, XnodesepB. In \SpecialCoor, specifies true horizontal displacement from center of node.


parName: XnodesepA
parPat: <dim>
parDefault: 0pt
parDescription:
Modifies x-start position for node connection by dim from center of node A. Negative values cause longer connections.


parName: XnodesepB
parPat: <dim>
parDefault: 0pt
parDescription:
Modifies x-end position for node connection by dim from center of node B. Negative values cause longer connections.


parName: xPlotpoints
parPat: <value>
parDefault: 25
parDescription:
In 3dPlot, number of subdivision points in x value. Also used for t subdivision count by \parametricPlotThreeD.


parName: yAxis
parPat: <true|false>
parDefault: true
parDescription:
If false, draw no y axis and no ticks on y axis. (If xyAxes=false, xAxis and yAxis are set to false.)


parName: yAxisLabelPos
parPat: <text>
parDescription:
If void, draw yAxisLabel at tip of y axis. If {-5pt,c}, draw label centered and 5pt to left of y axis. If {4pt,-5pt}, draw label {4pt,-5pt} relative to axes crossing point.


parName: yDecimals
parPat: <number>
parDefault: {}
parDescription:
If unspecified, decimal values on y axis are handled as usual. Eg, xDecimals=2 forces 2 decimal places in x labels. (xyDecimals specifies xDecimals and yDecimals.)


parName: Ynodesep
parPat: <dim>
parDefault: 0pt
parDescription:
Sets YnodesepA, YnodesepB. In \SpecialCoor, specifies true vertical displacement from center of node.


parName: YnodesepA
parPat: <dim>
parDefault: 0pt
parDescription:
Modifies y-start position for node connection by dim from center of node A. Negative values cause longer connections.


parName: YnodesepB
parPat: <dim>
parDefault: 0pt
parDescription:
Modifies y-end position for node connection by dim from center of node B. Negative values cause longer connections.


