***Introduction***:
> introduction -- who are you, your involvement in SAGE
[maybe quick description of experience
and how you involved with SAGE.]
> motivation -- Q: why write own code when matplotlib already
has a good user interface.
A: matplotlib is data oriented,
[give example like plotting sin curve]
where as mathematica is more
[function / functionally / mathematical]
[deals with expressions as opposed to data]
***Overall purpose***
... what functionality does it provide?
> similarities to Mathematica [give examples]
> differences with Mathematica [pythonic ... give examples]
> I want to reproduce the intuitive visualizing of mathematical
objects that Mathematica provides and the same time do it
in a Pythonic way that is general/easy to extend.
***No GUI***
--- instead when have the browser interface
which in many ways is like a mathematica notebook.
> Mention that when you use "show" the image is
rendered into a png by default
***Comparison***
> you could show the difference of SAGE plotting
code compared to Mathematica code for the same expressions
***Classes - What - Where - How***
> class Graphics(SageObject)
1) all plots are of type Graphics
> p = plot(sin,-2,2)
> p
sage: p
Graphics object consisting of 1 graphics primitive
sage: pp = p[0]
sage: pp
Line defined by 201 points
2) this class has (hidden methods ? ) that use
use the functions of other Primitive classes
*give one example of this*
>
3) this class has also the *show* and *save* methods
that deal with the actually generation of the images
*when one of these methods is called, only then
is most of the /grunt/ work done ... i.e. compute axis
and actually write the image file (eps, png, ...)
this process takes almost all the time involved
> class GraphicsPrimitive(SageObject)
1) this class is inherited by all the
specific primitive objects (e.g. GraphicsPrimitive_Line(GraphicsPrimitive) )
2) the methods, that are useful for any GraphicsPrimitive_* type,
are dealing with the /options/
> class GraphicsPrimitive_*(GraphicsPrimitive)
1) these all have an __init__ method that
inherit from GraphicsPrimitive.__init__(self, options) **explain**
2) these all use builtin constructors (is this right name ???)
to do things like len, getitem, setitem, etc.
3) *Important* these all have a
_render_on_subplot(self, subplot) method that takes as
input the current *matplotlib* subplot instance and adds
the corresponding graphics primitive to the current subplot
*important* -> options that pertain to the current primitive
are also set with this method
--------------------------------------------------------------------
What is Mathematica-like and what is Pythonic?
Pythonic:
> all names of functions adhere to lower-case
name with underscrores seperating different words
> make a table giving actual comparisons
> arithemtic of Graphics types (addition of plots, etc)
> describe builtin methods, give examples of usage
------------------------------------------------------------
TODO:
> Add "density_plot" and "contour_plot"
> make graphics_array scale correctly when
there is only one row of graphics, etc.
> Add option to plot to add a frame
(without normal axis and tick marks on frame)
*Show this give an error?:
show(plot(lambda x: sin(x),-30,-100,rgbcolor=hue(0.5)),axes_label=["AX","BY"])
> remove uneccesary functions in plotting documentation
(e.g. sin, cos, modf)
> are the "Factory" functions public or private ...
should they be hidden in the documentation ??
> change disk range from *degrees* to *radians*