plot::Curve2d
-- graphical
primitive for a two-dimensional curveplot::Curve2d
([x, y], t = a..b)
represents
a plot of the curve defined by t -> (x(t); y(t)) with
t in [a,b].
plot::Curve2d([x, y], t = a..b <, option1,
option2...>)
x, y |
- | arithmetical expressions in t |
t |
- | identifier |
a, b |
- | arithmetical expressions |
option1, option2, ... |
- | plot option(s) of the form OptionName =
value |
plot::Curve3d
,
plot::Function2d
,
RGB
plot::Curve2d
represent graphical
primitives for two-dimensional curves that can be displayed via
plot(...)
, or used with other graphical primitives of the
plot
library.plot::Curve2d
has the type
"graphprim"
, i.e., if o
is such an object,
then the result of type(o)
is the string
"graphprim"
.option1
, option2
... are specified
by equations OptionName = value
. The following table gives
an overview of the available options:
OptionName |
admissible values | default value |
Color | [Flat] , [Flat, [r,g,b]] , [Height] , [Height, [r,g,b], [R,G,B]] , [Function, f] |
[Height] |
Discont | TRUE , FALSE |
TRUE |
Grid | [n] |
[100] |
LineStyle | SolidLines, DashedLines | SolidLines |
LineWidth | positive integers | 1 |
PointStyle | Circles, FilledCircles, FilledSquares, Squares | FilledSquares |
PointWidth | positive integers | 30 |
RealValuesOnly | TRUE , FALSE |
TRUE |
Smoothness | [n] |
[0] |
Style | [Points] , [Lines] , [LinesPoints] , [Impulses] |
[Lines] |
Title | strings | |
TitlePosition | [x, y] |
|
plot2d
for further
details on each option, except for Discont and RealValuesOnly, which are described in detail
below.Scene options for the parameters
option1
, option2
... are not allowed! One may
pass scene options to the call of plot
, or use plot::Scene
to create an object
representing a graphical scene. Cf. example 1.
::
.
Each attribute has the property ``read'', i.e., the value of an
attribute attr
of a graphical primitive o
can
be read with o::attr
. If the attribute also has the
``write'' property, then the value of the attribute can be changed with
o::attr := new_value
.
The following attributes are available for a curve primitive:
attribute | meaning | properties |
options |
A table of plot options of the curve primitive. Note
that if you change the value of this attribute, the entries of the
assigned table are not checked to be valid plot options for curve
primitives. Invalid entries lead to runtime errors.
The initial value of this attribute is the table stored under the
domain entry |
read/write |
plotdata |
List of the plot data of the curve primitive in a
plot2d conforming
syntax (see the method "getPlotdata" below). Note that the
value of this attribute should only be used if the attribute
refreshPlotdata has the value FALSE (see
below). |
read |
range |
The parameter of the curve and its range. The initial
value is the parameter t = a..b . |
read/write |
refreshPlotdata |
A boolean value which signals whether the plot data of
the curve primitive must be (re-)build with the method
"getPlotdata" (see below). If its value is
FALSE , then the plot data of the curve primitive is stored
in the attribute plotdata . The initial value is
TRUE . Cf. example 5. |
read/write |
term |
The term of the curve. Its initial value is the
parameter [x, y] . |
read/write |
value
[x(t),
y(t)]
of the curve is checked for discontinuities. Admissible
values are TRUE
and FALSE
; the default is Discont = TRUE
.
TRUE
enables symbolic
checking of discontinuities. If found, unwanted graphical effects such
as spurious lines at the discontinuities are eliminated.FALSE
disables the
check.value
[x(t), y(t)]
of the curve
produces a complex value during the evaluation of the plot, then an
error occurs. Specifying RealValuesOnly =
TRUE
, such errors are trapped. Only those parts of the
curve producing real values are plotted.
With RealValuesOnly = FALSE
no
internal check is performed. The renderer produces an error, when it
encounters a complex value. The default is RealValuesOnly = TRUE
.
See example 4.
An object of plot::Curve2d
consists of two operands.
The first operand is the term of the curve specified as the list
[x, y]
. The second one is the parameter of the curve and
its range in the form t = a..b
.
Operands of a curve primitive can be accessed either using the
system function op
, the
index operator [ ]
, or
using the attributes described above. For example, if
curve
is such an object, then the calls
op(curve,1)
, curve[1]
and
curve::term
return the list [x, y]
.
Via curve[1] := [new_x, new_y]
or curve::term :=
[new_x, new_y]
, the term of a curve primitive can be
changed.
See the methods "op"
, "_index"
,
"set_index"
and "slot"
below.
Use the slot operator ::
to get or set plot options of
such objects afterwards, i.e., when they have been created. For
example, if curve
is such an object, then
curve::Color := RGB::Red
changes the color of the curve
primitive curve
to red.
Evaluating an object of type plot::Curve2d
returns
itself.
Calling an object of plot::Curve2d
as a function yields
the object itself, regardless of the arguments. The arguments are
not evaluated.
is a table of plot options for curve primitives and their default
values. Each entry has the form OptionName =
default_value
.
When an object of the domain plot::Curve2d
is created,
then a copy of this table is stored under the attribute
options
(see the table of attributes above), where those
options are added and replaced, respectively, which are given by the
(optional) parameters option1
, option2
... of
the creating call (see ``Creating Elements'' above).
Plot options, which are not contained in the table stored under the
attribute options
will not be included in the plot data of
the object created by the method "getPlotdata"
(see
below).
For those options, the corresponding default value either is set by
a graphical scene, if the option also
exists as a scene option (such as the option PointWidth), or it is internally set by the function
plot2d
which is used to
plot the object. See the table of plot options above, which gives a
summary of the available plot options for curve primitives and their
default values. See example 2.
To change the default value of some plot options, the option name
and its default value may be added to the table
"defaultOptions"
, or replaced by a new value,
respectively.
is a set of the available option names for plots of two-dimensional curves.
_index(dom curve, positive integer i)
i
th operand of curve
. See
``Operands'' above for a description of the operands of
curve
. If i
is greater
than 2, then FAIL
is returned._index
, i.e., one may use it in the
form curve[i]
, or in functional notation
_index(curve, i)
.dimension(dom curve)
getPlotdata(dom curve)
curve
in a plot2d
conforming syntax, i.e., it
has the form [Mode = Curve, [...], ...]
.
For example, with s :=
plot::Curve2d::getPlotdata(curve)
the call
plot2d(s[1])
gives a plot of curve
.
options
(see the table of attributes above). For any other
plot option not contained in this table, the corresponding default
value set by the function plot2d
for curves is used when
plotting the object.plotdata
of curve
.refreshPlotdata
of curve
to
FALSE
.plot::Scene
to build the plot data of
the graphical scene.nops(dom curve)
nops
, i.e., one may use it in the form
nops(curve)
.op(dom curve, positive
integer i)
i
th operand of curve
. See
``Operands'' above for a description of the operands of
curve
. If i
is greater
than 2, then FAIL
is returned.op
, i.e., one may use it in the form
op(curve, i)
.set_index(dom curve, positive integer i, any val)
i
th operand of curve
by the
value val
. See ``Operands'' above for a description of the
operands of curve
.i
is greater than 2, or if
val
is not an admissible value for the i
th
operand, then a warning message is issued. In this case the call of
this method has no effect on the object curve
.refreshPlotdata
of curve
to
TRUE
.slot(dom curve, string slotname)
slotname
of
curve
. slotname
may either be the name of an
attribute or the name of a plot option. See the tables of available
plot options and attributes above.slotname
is the name of a plot option, but the
option is not contained in the table stored under the attribute
options
, then FAIL
is returned.
If slotname
is an invalid attribute or option, then an
error message is issued.
slot
, i.e., one may use it in the form
curve::slotname_id
(here, slotname_id
must be
the identifier corresponding to the string slotname
), or
in functional notation slot(curve, slotname)
.slot(dom curve, string slotname, any val)
slotname
to the value val
.slotname
, or if val
is not an admissible
value for slotname
, then a warning message is issued. In
this case, the value of slotname
remains unchanged.slot
, i.e., one may use it in the form
curve::slotname_id := val
(here, slotname_id
must be the identifier corresponding to the string
slotname
), or in functional notation slot(curve,
slotname, val)
.refreshPlotdata
of
curve
is set to TRUE
.checkOption(equation OptionName =
value)
OptionName
is an available
plot option for curve primitives (see the table of available plot
options above), and value
is an admissible value for this
option.[TRUE, OptionName,
newValue]
is returned. Note that the value of the option could
have been converted into an admissible format. Thus,
newValue
must be used as the value of the option
OptionName
instead of value
.[FALSE, error_msg]
is returned.
The string error_msg
is a description of the located
problem, which can be passed, for example, to the system function
error
to raise a
user-specified exception.copy(dom curve)
curve
.plot::copy
. See its help page for
details.modify(dom curve, equation(s) Name1 = value1...)
curve
and changes the
slots Name1
... of this copy to the new values
value1
...Name1
... must be names of attributes
or plot options of the domain plot::Curve2d
. Otherwise a
warning message is issued, and the slot remains unchanged. Also, if one
of the values value1
... is not an admissible value for the
corresponding attribute or plot option, respectively, the change of the
slot is ignored.
See the tables of available options and attributes above.
refreshPlotdata
of the copy of curve
to
TRUE
.plot::modify
.print(dom curve)
plot::Curve2d([x, y], t = a..b)
. It is used to print
objects of plot::Curve2d
to the screen.print
for details.The following call returns an object representing the graph of the unit circle:
>> c := plot::Curve2d([sin(t), cos(t)], t = 0..2*PI)
plot::Curve2d([sin(t), cos(t)], t = 0..2 PI)
To plot this curve in a graphical scene, call plot
:
>> plot(c)
Plot options of the curve can be given as additional parameters in the creating call, such as increasing the width of the lines of a graph and plotting the graph in red color:
>> c2 := plot::Curve2d([sin(t), cos(t)], t = 0..2*PI, Color = RGB::Red, LineWidth = 50 )
plot::Curve2d([sin(t), cos(t)], t = 0..2 PI)
>> plot(c2)
To change default values of some scene options, pass the
scene options to the function plot
as additional arguments. For
example, change the scaling of the plot and increase the number of
ticks on both axes:
>> plot(c2, Scaling = Constrained, Ticks = [10,10])
See the help page of plot::Scene
for available scene
options.
If a curve primitive is created, values of some plot options of the created object can be read, or replaced by new values.
To illustrate this, we create the following curve:
>> c1 := plot::Curve2d([t*cos(t), t*sin(t)], t = 0..4*PI)
plot::Curve2d([t cos(t), t sin(t)], t = 0..4 PI)
We create a copy of this curve, change some plot options of the copied object, and plot both objects in a graphical scene:
>> c2 := plot::copy(c1): c2::Style := [Points]: c2::Grid := [30]: plot(c1, c2)
Plot options, which are explicitely set for a curve
primitive, are stored under the attribute options
and can
be read with the slot operator ::
. The plot options for
the first created object are:
>> c1::options
table( RealValuesOnly = TRUE, Discont = TRUE, Grid = [100], Color = [Flat, [1.0, 0.0, 0.0]] )
These are the default values of some plot options for
two-dimensional curve primitives, defined by the entry
"defaultOptions"
of the domain
plot::Curve2d
:
>> plot::Curve2d::defaultOptions
table( RealValuesOnly = TRUE, Discont = TRUE, Grid = [100], Color = [Flat, [1.0, 0.0, 0.0]] )
When the plot data of a curve primitive is created
(calling the method "getPlotdata"
), only those plot
options are used that are contained in the table
c1::options
. Here these are:
>> plot::Curve2d::getPlotdata(c1)
[[Mode = Curve, [t cos(t), t sin(t)], t = [0.0, 12.56637061], Grid = [100], Color = [Flat, [1.0, 0.0, 0.0]]]]
This means that for any other available plot option not
contained in the table c1::options
, the default value is
either set by plot::Scene
,
if the option also exists as a scene option, or it is internally set by
the function plot2d
when plotting the object.
You might wonder why the options RealValuesOnly and Discont are not
contained in the plot structure returned by the method
"getPlotdata"
. The options are special options for objects
of the domain plot::Curve2d
. They are used to determine
the plot data of such an object. They are not accepted as valid options
for the mode Curve
of the plot2d
command.
The curve primitive c2
contains the following
options:
>> c2::options
table( Style = [Points], RealValuesOnly = TRUE, Discont = TRUE, Grid = [30], Color = [Flat, [1.0, 0.0, 0.0]] )
As you see, the option Style was
added to this table, and the default value of the option Grid was replaced by the new value [30]
. Use
delete
to remove plot
options:
>> delete c2::options[Style]: c2::options
table( RealValuesOnly = TRUE, Discont = TRUE, Grid = [30], Color = [Flat, [1.0, 0.0, 0.0]] )
In order to illustrate the effect of the option Discont, we create the following curve primitive:
>> c := plot::Curve2d([tan(t), t], t = 0..4*PI)
plot::Curve2d([tan(t), t], t = 0..4 PI)
The tangens has singularities at multiplicities of
PI/2, which is determined by plot::Curve2d
, if
the option Discont is set to TRUE
.
This is the default behaviour of plot::Curve2d
:
>> plot(c)
Setting this option to FALSE
causes
spurious lines at the singularities:
>> c::Discont := FALSE: plot(c)
If the option RealValuesOnly is disabled, complex arguments produced by the parametrization of the curve lead to runtime errors during the evaluation of the plot:
>> c := plot::Curve2d([sqrt(t), -sqrt(t)], t = -5..5, RealValuesOnly = FALSE ): plot(c)
Error: Non-real values detected (try option RealValuesOnly = \ TRUE) [plotlib::clip2d_Curve]
This example illustrates how to read and write attributes of curve primitives (see the table of available attributes in ``Details'' above).
In example 2, we already used the
attribute options
, which stores plot options defined
individually for a curve primitive and which overrides the
corresponding default values set by MuPAD.
The attribute term
holds the term of a curve primitive.
For example, if curve
is an object of
plot::Curve2d
such as:
>> c := plot::Curve2d([tan(t), t], t = 0..4*PI, Color = RGB::Blue)
plot::Curve2d([tan(t), t], t = 0..4 PI)
then c::term
returns the list:
>> c::term
[tan(t), t]
We plot this curve:
>> plot(c)
Because the attribute term
has the
``write'' property, you can change the value of this attribute as
follows:
>> c::term := [1/cos(t), t]: plot(c)
The value of term
must be a list of two
arithmetical expressions, otherwise an error message is issued.
An example of a ``read-only'' attribute is the attribute
plotdata
. It stores the plot data of a curve primitive in
a plot2d
conforming
syntax. However, the value of this attribute should only be used if the
attribute refreshPlotdata
has the value
FALSE
.
For example, if we create a new curve primitive, then the value of
plotdata
is the empty list:
>> c2 := plot::Curve2d([t^2, t^2], t = -5..5): c2::plotdata
[]
and refreshPlotdata
signals that the plot
data must be created:
>> c2::refreshPlotdata
TRUE
A call of the method "getPlotdata"
, which
is caused by plotting the curve, for example, creates the plot data of
a curve primitive:
>> plot::Curve2d::getPlotdata(c2)
2 2 [[Mode = Curve, [t , t ], t = [-5.0, 5.0], Grid = [100], Color = [Flat, [1.0, 0.0, 0.0]]]]
This plot data is the new value of the attribute
plotdata
, and refreshPlotdata
was set to
FALSE
. Thus, an unnecessary rebuilding of the plot data of
this object can be avoided by reading the value of
plotdata
:
>> c2::refreshPlotdata(c2), c2::plotdata
2 2 FALSE, [[Mode = Curve, [t , t ], t = [-5.0, 5.0], Grid = [100], Color = [Flat, [1.0, 0.0, 0.0]]]]
Any change of a plot option or an attribute of the curve
primitive sets the value of refreshPlotdata
to
TRUE
:
>> c2::Color:= RGB::Black: c2::refreshPlotdata(c2)
TRUE
This means that the value of plotdata
is
not longer valid, and the method "getPlotdata"
must be
called to rebuild the plot data of c2
.