=== Abstract ===
Currently SymPy does not include a geometry module. This project
proposes to fill that gap by starting the foundation for a geometry
module. The base of the geometry package would be the Entity interface
for a geometrical entity. Extending from this interface would be
entities such as Points, Lines, Rays, Segments, Polygons, Circles,
and so on. After creating different objects a user could then query
different things about sets of objects such as 'Does X intersect with
Y?' or 'Does X contain Y?' CAS systems do not traditionally contain
geometry packages, but some take the analytic geometry approach to
solve geometrical queries using algebraic representations. For
example, a line can be expressed as an equation. Two lines can have
simultaneous equations solved to find the point of intersection.

Although not covered by this project, future development could include
extending the geometry to three dimensions and inquiring information
based on surfaces and volumes. Also, a more physics based approach
could be taken to determine intersection of moving objects.



=== Project Name ===
SymPy Geometry Module

=== Synopsis===
This project would consist of implementing a geometry module to SymPy.
This module would introduce the following concepts to the SymPy
library:
* Geometrical Entities
	- Points
	- Lines, Rays, Segments
	- Polygons (general, triangle, rectangle, square, etc)
	- Circles
* Geometrical Information
	- Does X intersect with Y? If so, at what points.
	- Does X contain Y?
	- How far is X from Y?
	- Is X found within Y?
	- What is the area of X?
	- What is the length/perimeter of X?
	- What is the convex hull of the set of points?

This will just be the basis for the SoC project, but much more can be
done such as extending the above to curves, surfaces, and volumes. The
framework of the module will be thought out so that future
developments will be as simple and as effortless as possible. For
Example, if a graphing module were ever added to SymPy then there
should be little work to get these geometrical entities to plot
themselves.


=== Benefits For The Python and Mathematics/Science Community ===
The SymPy package is a lightweight and simple CAS, built from scratch
in Python. This alone already proposes several advantages to other
CAS packages. The lightweight nature of SymPy makes it preferable
over heavier packages, such as SAGE, for doing simple calculations.
Python itself makes prototyping and experimentation of new algorithms
and ideas very simple. Educationally, students can readily access the
algorithms used by SymPy for personal study and research. The
simplicity of Python does not shroud student's concept of the
algorithm behind confusing syntax or technical details, such as
memory management in C/C++ or the reasoning for using a certain
collection in Java.

SymPy already has a fairly powerful base including, but not limited
to, integration and differentiation. Although traditionally, geometry
itself is not considered part of a CAS, more newer CAS packages
include geometry packages. Analytic geometry itself involves viewing
classical geometry problems in an algebraic representation and
manipulating these representations to get the results one needs.
Calculus and algebra by itself can only go so far to get the results
we are looking for, but everyday situations often involves, for
example, the intersection of two objects or the distance between two
objects. Such would be the result of my work on a geometry module for
SymPy.


=== Schedule ===
The following lists a rough estimate of the phases of development I
intend on achieving if accepted into the Google SoC:

-- Phase 1 (Present - Week 2)
This phase would be the initial research phase. I will research the
best abstract representations for the different entities to be
implemented, and then the best algorithms to use when gathering any
information, such as intersections.

-- Phase 2 (Week 2 - Week 4)
This phase would involve designing the interfaces for geometrical
entities and operations. For example, what operations should be
common to all entities. This phase would also include the first
simple implementation of the different entities with very little
functionality.

-- Phase 3 (Week 4 - Week 10)
This phase would involved all of the major implementation:
	- Intersections
	- Bisectors
	- Coincidence relations
	- Geometrical properties (area, length, perimeter, etc)
	- Convex Hulls
	- Distance
	- Containment

-- Phase 4 (Week 10 - End)
This phase would be debugging, testing, documentation, and cleaning
up all code.

=== Deliverables ===
The following lists the set of deliverables expected to be produced
by the end of the SoC:

- The Entity interface and several implementing classes including
	- Point
	- Line, Ray, Segment
	- Polygon
	- Circle
- The ability to query information about
	- Intersections
	- Bisectors
	- Coincidence relations
	- Geometrical properties (area, length, perimeter, etc)
	- Distance
	- Containment
- The ability to create a convex hull from a set of points
- Documentation
- Tests

=== Previous Work ===
1. In the Summer of 2005 I was selected to work on Wax, a very nice
   wrapper for wxPython. My responsibilities included implementing new
   high-level widgets, fixing old ones, fixing examples, creating a
   documentation tool, and creating an XML format that Wax would use
   to generate GUIs.

2. In the Summer of 2006 I worked on an AAA (authentication,
   authorization, accounting) system for Memorial University's modem
   pool. The existing system was becoming outdated, and so I created a
   set of Python scripts that interacted with a RADIUS server to do
   the required accounting and authentication. These scripts included
   unit tests using Python's unit testing suite.

3. In the Fall of 2007 I worked on the Phon Project, a large scale
   shared database for the study of phonological development
   (generally of children).

Less significant work would include school projects (virtual machine
and a large-scale, web based help request system) and the numerous
Python scripts I have written for double-checking assignment answers
and producing data for my Technical Writing course in Mathematics.


=== Personal Bio ===
My name is Jason Gedge and I am a 20 year old just finishing my third
year of a Pure Math and Computer Science joint honours degree at the
Memorial University of Newfoundland. I have a deep love for both areas
of my degree and am always enthused when given the opportunity to
merge the two into my work. I work hard and always try my best to
finish what I start. My hard work and dedication to school has allowed
me to maintain a perfect GPA. I hope to bring this dedication and work
ethic to the Google Summer of Code.


=== Why Should You Pick Me? ===
Besides for the hard work and dedication I put towards every project I
work on, I have a deep love for all things mathematical. I have an
extensive mathematics and CS background and I am also very capable
with Python, as it is my language of choice for just about everything!
I have taken courses in the following mathematical areas:
    - Number Theory
    - Complex analysis
    - Linear Algebra
    - Calculus
    - Combinatorics
    - Discrete Math
    - Intro Statistics
    - Geometry
    - Technical writing (required research into various areas)
I believe that my love for math, my mathematical background, and my
extensive knowledge of Python make me the perfect candidate to
contribute towards the SymPy project. I am also confident that I will
deliver rather than disappoint.