[Edu-sig] Working with Vpython

[kirby urner]

For just starting to explore with VPython window, getting one's feet
wet, I'm looking at such as stickworks.py as a simple place to begin
(excerpts below).

The stickworks namespace wants us to think of Vector objects as
radiating from (0,0,0), i.e. they're always tail anchored to the
origin.

class Vector (object):

    """
    A wrapper for visual.vector that expresses a cylinder via draw(),
    always pegged to the origin
    """

    radius = 0.03

    def __init__(self, xyz, color=(0,0,1)):
        self.v = vector(*xyz)
        self.xyz = xyz
        self.color = color
        self.cyl = None

    def draw(self):
        """define and render the cylinder"""
        self.cyl = cylinder(pos = (0,0,0), axis = self.v, radius =
self.radius, color = self.color)

    def erase(self):
        """toss the cylinder"""
        if self.cyl:
            self.cyl.visible = 0
        self.cyl = None

    def __repr__(self):
        return 'Vector @ (%s,%s,%s)' % self.xyz

    # some vector ops, including scalar multiplication

    def cross(self, other):
        temp = cross(self.v, other.v)
        return Vector((temp.x, temp.y, temp.z))

etc.

Edges, on the other hand, otherwise known as line segments, may
connect any two points in space, and as such are defined by the arrow
*tips* of two Vectors of the type defined above.

class Edge (object):

    """
    Edges are defined by two Vectors (above) and express as cylinder via draw().
    """

    radius = 0.03

    def __init__(self, v0, v1, color=(1,0,0)):
        self.v0 = v0
        self.v1 = v1
        self.color = color
        self.cyl = None

    def draw(self):
        """define and render the cylinder"""
        temp = (self.v1 - self.v0).xyz
        self.cyl = cylinder(pos = self.v0.xyz, axis = vector(*temp),
                              radius = self.radius, color = self.color)

    def erase(self):
        """toss the cylinder"""
        if self.cyl:
            self.cyl.visible = 0
        self.cyl = None

    def __repr__(self):
        return 'Edge from %s to %s' % (self.v0, self.v1)

You'll find this dichotomy in some published linear algebra books e.g.
this one by Wayne Bishop and Stewart Venit ISBN: 087150300X (Wayne
being a Cal State prof and one of my sparring partners on math-teach).

I'm not using VPython's cylinder and vector objects directly because
I'm wanting an even  simpler namespace.  Vectors are my primary
constituent, followed by edges as pairs of vectors, and faces as
tuples of vectors defining three or more edges.

Of course in the Fuller School we quickly move to a small subset of
polyhedra organized in a particular way (or core mandala, source of
many dharmas).  We harp on Euler's V + F = E + 2.  We talk in an alien
manner about our 4D Simplex with energy added (4D++).

But that doesn't mean every gnu math teachers needs to follow our lead
and/or sequence.  The curriculum is a network, and the many trailheads
go to many places (partially overlapping) in different orders.

Plus Arthur of Pygeo has a whole other toolset you could explore.
Save the Bucky stuff for later, if ever.  Tell 'em I said it was OK.

The sequence I'm developing here is:

intro to namespaces --> import stickworks as a namespace --> explore in VPython

Given stickworks is provided, student creativity will be more in what
they can *do* with it.
I'll be thinking of some projects.

Dissecting and tweaking source code will also be a focus, as fluency
gradually develops, plus writing new modules that assume the above as
all given.

Kirby