Mathutils update

- also included is some fixes for preprocessor inclues and some clean up of the previous commit

-rewrite and bugfixes
  ----------------------------------
  Here's my changelog:
  -fixed Rand() so that it doesn't seed everytime and should generate better random numbers
  - changed a few error return types to something more appropriate
  - clean up of uninitialized variables & removal of unneccessary objects
  - NMesh returns wrapped vectors now
  - World returns wrapped matrices now
  - Object.getEuler() and Object.getBoundingBox() return Wrapped data when data is present
  - Object.getMatrix() returns wrapped data if it's worldspace, 'localspace' returns a new matrix
  - Vector, Euler, Mat, Quat, call all now internally wrap object without destroying internal datablocks
  - Removed memory allocation (unneeded) from all methods
  - Vector's resize methods are only applicable to new vectors not wrapped data.
  - Matrix(), Quat(), Euler(), Vector() now accepts ANY sequence list, including tuples, list, or a self object to copy - matrices accept multiple sequences
  - Fixed Slerp() so that it now works correctly values are clamped between 0 and 1
  - Euler.rotate does internal rotation now
  - Slice assignment now works better for all types
  - Vector * Vector and Quat * Quat are defined and return the DOT product
  - Mat * Vec and Vec * Mat are defined now
  - Moved #includes to .c file from headers. Also fixed prototypes in mathutils
  - Added new helper functions for incref'ing to genutils
  - Major cleanup of header files includes - include Mathutils.h for access to math types
  - matrix.toQuat() and .toEuler() now fixed take appropriate matrix sizes
  - Matrix() with no parameters now returns an identity matrix by default not a zero matrix
  - printf() now prints with 6 digits instead of 4
  - printf() now prints output with object descriptor
  - Matrices now support [x][y] assignment (e.g. matrix[x][y] = 5.4)
  - Matrix[index] = value now expectes a sequence not an integer. This will now set a ROW of the matrix through a sequence.  index cannot go above the row size of the matrix.
  - slice operations on matrices work with sequences now (rows of the matrix) example:  mymatrix[0:2] returns a list of 2 wrapped vectors with access to the matrix data.
  - slice assignment will no longer modify the data if the assignment operation fails
  - fixed error in matrix * scalar multiplication
  - euler.toMatrix(), toQuat() no longer causes "creep" from repeated use
  - Wrapped data will generate wrapped objects when toEuler(), toQuat(), toMatrix() is used
  - Quats can be created with angle/axis, axis/angle
  - 4x4 matrices can be multiplied by 3D vectors (by popular demand :))
  - vec *quat / quat * vec is now defined
  - vec.magnitude alias for vec.length
  - all self, internal methods return a pointer to self now so you can do print vector.internalmethod() or vector.internalmethod().nextmethod() (no more print matrix.inverse() returning 'none')
  - these methods have been deprecated (still functioning but suggested to use the corrected functionality):
    * CopyVec() - replaced by Vector() functionality
    * CopyMat() - replaced by Matrix() functionality
    * CopyQuat() - replace by Quaternion() functionality
    * CopyEuler() - replaced by Euler() functionality
    * RotateEuler() - replaced by Euler.rotate() funtionality
    * MatMultVec() - replaced by matrix * vector
    * VecMultMat() - replaced by vector * matrix
  -  New struct containers references to python object data or internally allocated blender data for wrapping
  * Explaination here:  math structs now function as a 'simple wrapper' or a 'py_object' - data that is created on the fly will now be a 'py_object' with its memory managed by python
  *    otherwise if the data is returned by blender's G.main then the math object is a 'simple wrapper' and data can be accessed directly from the struct just like other python objects.

18 files changed, 3145 insertions, 3727 deletions

diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c
index 75e84f9d140..d0a0bea3ae6 100644
--- a/source/blender/python/api2_2x/Blender.c
+++ b/source/blender/python/api2_2x/Blender.c
@@ -41,30 +41,27 @@
 #include <io.h>
 #endif
 
-#ifndef O_BINARY
-# define O_BINARY 0
-#endif
-
-#include <BDR_editobject.h>	/* exit_editmode() */
-#include <BIF_usiblender.h>
-#include <BLI_blenlib.h>
-#include <BLO_writefile.h>
-#include <BKE_exotic.h>
-#include <BKE_global.h>
-#include <BKE_packedFile.h>
-#include <BKE_object.h>
-#include <BKE_text.h>
-#include <BPI_script.h>
-#include <BSE_headerbuttons.h>
-#include <DNA_ID.h>
-#include <DNA_object_types.h>
-#include <DNA_scene_types.h>
-#include <DNA_screen_types.h>	/* for SPACE_VIEW3D */
-#include <DNA_space_types.h>	/* for SPACE_VIEW3D */
-#include <DNA_scriptlink_types.h>
-#include <DNA_userdef_types.h>
-#include <BKE_ipo.h>
-#include <blendef.h>
+#include "BKE_utildefines.h"
+#include "BDR_editobject.h"	/* exit_editmode() */
+#include "BIF_usiblender.h"
+#include "BLI_blenlib.h"
+#include "BLO_writefile.h"
+#include "BKE_exotic.h"
+#include "BKE_global.h"
+#include "BKE_packedFile.h"
+#include "BKE_object.h"
+#include "BKE_text.h"
+#include "BPI_script.h"
+#include "BSE_headerbuttons.h"
+#include "DNA_ID.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"	/* for SPACE_VIEW3D */
+#include "DNA_space_types.h"	/* for SPACE_VIEW3D */
+#include "DNA_scriptlink_types.h"
+#include "DNA_userdef_types.h"
+#include "BKE_ipo.h"
+#include "blendef.h"
 
 #include "EXPP_interface.h" /* for bpy_gethome() */
 #include "gen_utils.h"
diff --git a/source/blender/python/api2_2x/Bone.c b/source/blender/python/api2_2x/Bone.c
index 7c96a02d595..87ae85db99f 100644
--- a/source/blender/python/api2_2x/Bone.c
+++ b/source/blender/python/api2_2x/Bone.c
@@ -32,26 +32,30 @@
 
 #include "Bone.h"
 
-#include <BKE_main.h>
-#include <BKE_global.h>
-#include <BKE_object.h>
-#include <BKE_armature.h>
-#include <BKE_library.h>
-#include <BLI_blenlib.h>
-#include <DNA_action_types.h>
-#include <DNA_armature_types.h>
-#include <DNA_ipo_types.h>
-#include <BIF_poseobject.h>
-#include <BKE_action.h>
-#include <BSE_editaction.h>
-#include <BKE_constraint.h>
-#include <MEM_guardedalloc.h>
+#include "BKE_main.h"
+#include "BKE_global.h"
+#include "BKE_object.h"
+#include "BKE_armature.h"
+#include "BKE_library.h"
+#include "BLI_blenlib.h"
+#include "DNA_action_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_ipo_types.h"
+#include "BIF_poseobject.h"
+#include "BKE_action.h"
+#include "BSE_editaction.h"
+#include "BKE_constraint.h"
+#include "MEM_guardedalloc.h"
+#include "BKE_utildefines.h"
+#include "BLI_arithb.h"
 #include "constant.h"
 #include "gen_utils.h"
 #include "NLA.h"
 #include "quat.h"
 #include "matrix.h"
 #include "vector.h"
+#include "Types.h"
+
 
 //--------------------Python API function prototypes for the Bone module----
 static PyObject *M_Bone_New( PyObject * self, PyObject * args );
@@ -237,7 +241,6 @@ PyObject *Bone_Init( void )
 //--------------- updatePyBone------------------------------------
 static int updatePyBone( BPy_Bone * self )
 {
-	int x, y;
 	char *parent_str = "";
 
 	if( !self->bone ) {
@@ -540,45 +543,19 @@ PyObject *Bone_CreatePyObject( struct Bone * bone )
 	//allocate space for python vars
 	blen_bone->name = PyMem_Malloc( 32 + 1 );
 	blen_bone->parent = PyMem_Malloc( 32 + 1 );
-	blen_bone->head =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	blen_bone->tail =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	blen_bone->loc =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	blen_bone->dloc =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	blen_bone->size =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	blen_bone->dsize =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	blen_bone->quat =
-		( QuaternionObject * )
-		newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
-	blen_bone->dquat =
-		( QuaternionObject * )
-		newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
-	blen_bone->obmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	blen_bone->parmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	blen_bone->defmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	blen_bone->irestmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	blen_bone->posemat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
+	blen_bone->head = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	blen_bone->tail = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	blen_bone->loc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	blen_bone->dloc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	blen_bone->size = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	blen_bone->dsize = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	blen_bone->quat = blen_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
+	blen_bone->dquat = blen_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
+	blen_bone->obmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	blen_bone->parmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	blen_bone->defmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	blen_bone->irestmat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	blen_bone->posemat = blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
 
 	if( !updatePyBone( blen_bone ) )
 		return EXPP_ReturnPyObjError( PyExc_AttributeError,
@@ -627,45 +604,19 @@ static PyObject *M_Bone_New( PyObject * self, PyObject * args )
 	//allocate space for python vars
 	py_bone->name = PyMem_Malloc( 32 + 1 );
 	py_bone->parent = PyMem_Malloc( 32 + 1 );
-	py_bone->head =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	py_bone->tail =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	py_bone->loc =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	py_bone->dloc =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	py_bone->size =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	py_bone->dsize =
-		( VectorObject * )
-		newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
-	py_bone->quat =
-		( QuaternionObject * )
-		newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
-	py_bone->dquat =
-		( QuaternionObject * )
-		newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
-	py_bone->obmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	py_bone->parmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	py_bone->defmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	py_bone->irestmat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
-	py_bone->posemat =
-		( MatrixObject * )
-		newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
+	py_bone->head = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	py_bone->tail = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	py_bone->loc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	py_bone->dloc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	py_bone->size = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	py_bone->dsize = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
+	py_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
+	py_bone->dquat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
+	py_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	py_bone->parmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	py_bone->defmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	py_bone->irestmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
+	py_bone->posemat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
 
 	//default py values
 	BLI_strncpy( py_bone->name, name_str, strlen( name_str ) + 1 );
@@ -762,19 +713,17 @@ static PyObject *Bone_getWeight( BPy_Bone * self )
 static PyObject *Bone_getHead( BPy_Bone * self )
 {
 	PyObject *attr = NULL;
-	float *vec;
+	float vec[3];
 	int x;
 
 	if( !self->bone ) {	//test to see if linked to armature
 		//use python vars
-		vec = PyMem_Malloc( 3 * sizeof( float ) );
 		for( x = 0; x < 3; x++ )
 			vec[x] = self->head->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3 );
+		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
 	} else {
 		//use bone datastruct
-		attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
-					3 );
+		attr = newVectorObject( NULL, 3, Py_NEW );
 		( ( VectorObject * ) attr )->vec[0] = self->bone->head[0];
 		( ( VectorObject * ) attr )->vec[1] = self->bone->head[1];
 		( ( VectorObject * ) attr )->vec[2] = self->bone->head[2];
@@ -790,19 +739,17 @@ static PyObject *Bone_getHead( BPy_Bone * self )
 static PyObject *Bone_getTail( BPy_Bone * self )
 {
 	PyObject *attr = NULL;
-	float *vec;
+	float vec[3];
 	int x;
 
 	if( !self->bone ) {	//test to see if linked to armature
 		//use python vars
-		vec = PyMem_Malloc( 3 * sizeof( float ) );
 		for( x = 0; x < 3; x++ )
 			vec[x] = self->tail->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3 );
+		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
 	} else {
 		//use bone datastruct
-		attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
-					3 );
+		attr = newVectorObject( NULL, 3, Py_NEW );
 		( ( VectorObject * ) attr )->vec[0] = self->bone->tail[0];
 		( ( VectorObject * ) attr )->vec[1] = self->bone->tail[1];
 		( ( VectorObject * ) attr )->vec[2] = self->bone->tail[2];
@@ -818,19 +765,17 @@ static PyObject *Bone_getTail( BPy_Bone * self )
 static PyObject *Bone_getLoc( BPy_Bone * self )
 {
 	PyObject *attr = NULL;
-	float *vec;
+	float vec[3];
 	int x;
 
 	if( !self->bone ) {	//test to see if linked to armature
 		//use python vars
-		vec = PyMem_Malloc( 3 * sizeof( float ) );
 		for( x = 0; x < 3; x++ )
 			vec[x] = self->loc->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3 );
+		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
 	} else {
 		//use bone datastruct
-		attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
-					3 );
+		attr = newVectorObject( NULL, 3, Py_NEW );
 		
 //		( ( VectorObject * ) attr )->vec[0] = self->bone->loc[0];
 //		( ( VectorObject * ) attr )->vec[1] = self->bone->loc[1];
@@ -847,19 +792,17 @@ static PyObject *Bone_getLoc( BPy_Bone * self )
 static PyObject *Bone_getSize( BPy_Bone * self )
 {
 	PyObject *attr = NULL;
-	float *vec;
+	float vec[3];
 	int x;
 
 	if( !self->bone ) {	//test to see if linked to armature
 		//use python vars
-		vec = PyMem_Malloc( 3 * sizeof( float ) );
 		for( x = 0; x < 3; x++ )
 			vec[x] = self->size->vec[x];
-		attr = ( PyObject * ) newVectorObject( vec, 3 );
+		attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
 	} else {
 		//use bone datastruct
-		attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
-					3 );
+		attr = newVectorObject( NULL, 3, Py_NEW );
 //		( ( VectorObject * ) attr )->vec[0] = self->bone->size[0];
 //		( ( VectorObject * ) attr )->vec[1] = self->bone->size[1];
 //		( ( VectorObject * ) attr )->vec[2] = self->bone->size[2];
@@ -875,20 +818,18 @@ static PyObject *Bone_getSize( BPy_Bone * self )
 static PyObject *Bone_getQuat( BPy_Bone * self )
 {
 	PyObject *attr = NULL;
-	float *quat;
+	float quat[4];
 	int x;
 
 	if( !self->bone ) {	//test to see if linked to armature
 		//use python vars - p.s. - you must return a copy or else
 		//python will trash the internal var
-		quat = PyMem_Malloc( 4 * sizeof( float ) );
 		for( x = 0; x < 4; x++ )
 			quat[x] = self->quat->quat[x];
-		attr = ( PyObject * ) newQuaternionObject( quat );
+		attr = ( PyObject * ) newQuaternionObject( quat, Py_NEW );
 	} else {
 		//use bone datastruct
-		attr = newQuaternionObject( PyMem_Malloc
-					    ( 4 * sizeof( float ) ) );
+		attr = newQuaternionObject( NULL, Py_NEW );
 //		( ( QuaternionObject * ) attr )->quat[0] = self->bone->quat[0];
 //		( ( QuaternionObject * ) attr )->quat[1] = self->bone->quat[1];
 //		( ( QuaternionObject * ) attr )->quat[2] = self->bone->quat[2];
@@ -1697,7 +1638,7 @@ static PyObject *Bone_getRestMatrix( BPy_Bone * self, PyObject * args )
 		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 						"expected 'bonespace' or 'worldspace'" ) );
 
-	matrix = newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
+	matrix = newMatrixObject( NULL, 4, 4 , Py_NEW);
 
 	if( !self->bone ) {	//test to see if linked to armature
 		//use python vars
diff --git a/source/blender/python/api2_2x/Mathutils.c b/source/blender/python/api2_2x/Mathutils.c
index 8c8a69f7a1d..9d0d22641a1 100644
--- a/source/blender/python/api2_2x/Mathutils.c
+++ b/source/blender/python/api2_2x/Mathutils.c
@@ -30,799 +30,570 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
-#include <Python.h>
-#include <BKE_main.h>
-#include <BKE_global.h>
-#include <BKE_library.h>
-#include <BKE_utildefines.h>
-#include <BLI_blenlib.h>
-#include <BLI_arithb.h>
-#include <PIL_time.h>
-#include <BLI_rand.h>
 #include <math.h>
-#include "vector.h"
-#include "euler.h"
-#include "quat.h"
-#include "matrix.h"
+#include "BKE_main.h"
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_utildefines.h"
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "PIL_time.h"
+#include "BLI_rand.h"
 #include "blendef.h"
 #include "mydevice.h"
 #include "constant.h"
 #include "gen_utils.h"
 #include "Mathutils.h"
-
-
-/*****************************************************************************/
-// Python API function prototypes for the Mathutils module.  
-/*****************************************************************************/
-static PyObject *M_Mathutils_Rand( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_Vector( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_CrossVecs( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_DotVecs( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_AngleBetweenVecs( PyObject * self,
-					       PyObject * args );
-static PyObject *M_Mathutils_MidpointVecs( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_VecMultMat( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_ProjectVecs( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_CopyVec( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_Matrix( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_RotationMatrix( PyObject * self,
-					     PyObject * args );
-static PyObject *M_Mathutils_ScaleMatrix( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_OrthoProjectionMatrix( PyObject * self,
-						    PyObject * args );
-static PyObject *M_Mathutils_ShearMatrix( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_TranslationMatrix( PyObject * self,
-						PyObject * args );
-static PyObject *M_Mathutils_MatMultVec( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_CopyMat( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_Quaternion( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_CrossQuats( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_DotQuats( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_CopyQuat( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_DifferenceQuats( PyObject * self,
-					      PyObject * args );
-static PyObject *M_Mathutils_Slerp( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_Euler( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_CopyEuler( PyObject * self, PyObject * args );
-static PyObject *M_Mathutils_RotateEuler( PyObject * self, PyObject * args );
-
-/*****************************************************************************/
-// The following string definitions are used for documentation strings.      
-// In Python these will be written to the console when doing a                 
-// Blender.Mathutils.__doc__           
-/*  Mathutils Module strings                   */
-/****************************************************************************/
+//-------------------------DOC STRINGS ---------------------------
 static char M_Mathutils_doc[] = "The Blender Mathutils module\n\n";
-static char M_Mathutils_Vector_doc[] =
-	"() - create a new vector object from a list of floats";
-static char M_Mathutils_Matrix_doc[] =
-	"() - create a new matrix object from a list of floats";
-static char M_Mathutils_Quaternion_doc[] =
-	"() - create a quaternion from a list or an axis of rotation and an angle";
-static char M_Mathutils_Euler_doc[] =
-	"() - create and return a new euler object";
+static char M_Mathutils_Vector_doc[] = "() - create a new vector object from a list of floats";
+static char M_Mathutils_Matrix_doc[] = "() - create a new matrix object from a list of floats";
+static char M_Mathutils_Quaternion_doc[] = "() - create a quaternion from a list or an axis of rotation and an angle";
+static char M_Mathutils_Euler_doc[] = "() - create and return a new euler object";
 static char M_Mathutils_Rand_doc[] = "() - return a random number";
-static char M_Mathutils_CrossVecs_doc[] =
-	"() - returns a vector perpedicular to the 2 vectors crossed";
+static char M_Mathutils_CrossVecs_doc[] = "() - returns a vector perpedicular to the 2 vectors crossed";
 static char M_Mathutils_CopyVec_doc[] = "() - create a copy of vector";
-static char M_Mathutils_DotVecs_doc[] =
-	"() - return the dot product of two vectors";
-static char M_Mathutils_AngleBetweenVecs_doc[] =
-	"() - returns the angle between two vectors in degrees";
-static char M_Mathutils_MidpointVecs_doc[] =
-	"() - return the vector to the midpoint between two vectors";
-static char M_Mathutils_MatMultVec_doc[] =
-	"() - multiplies a matrix by a column vector";
-static char M_Mathutils_VecMultMat_doc[] =
-	"() - multiplies a row vector by a matrix";
-static char M_Mathutils_ProjectVecs_doc[] =
-	"() - returns the projection vector from the projection of vecA onto vecB";
-static char M_Mathutils_RotationMatrix_doc[] =
-	"() - construct a rotation matrix from an angle and axis of rotation";
-static char M_Mathutils_ScaleMatrix_doc[] =
-	"() - construct a scaling matrix from a scaling factor";
-static char M_Mathutils_OrthoProjectionMatrix_doc[] =
-	"() - construct a orthographic projection matrix from a selected plane";
-static char M_Mathutils_ShearMatrix_doc[] =
-	"() - construct a shearing matrix from a plane of shear and a shear factor";
+static char M_Mathutils_DotVecs_doc[] = "() - return the dot product of two vectors";
+static char M_Mathutils_AngleBetweenVecs_doc[] = "() - returns the angle between two vectors in degrees";
+static char M_Mathutils_MidpointVecs_doc[] = "() - return the vector to the midpoint between two vectors";
+static char M_Mathutils_MatMultVec_doc[] = "() - multiplies a matrix by a column vector";
+static char M_Mathutils_VecMultMat_doc[] = "() - multiplies a row vector by a matrix";
+static char M_Mathutils_ProjectVecs_doc[] =	"() - returns the projection vector from the projection of vecA onto vecB";
+static char M_Mathutils_RotationMatrix_doc[] = "() - construct a rotation matrix from an angle and axis of rotation";
+static char M_Mathutils_ScaleMatrix_doc[] =	"() - construct a scaling matrix from a scaling factor";
+static char M_Mathutils_OrthoProjectionMatrix_doc[] = "() - construct a orthographic projection matrix from a selected plane";
+static char M_Mathutils_ShearMatrix_doc[] = "() - construct a shearing matrix from a plane of shear and a shear factor";
 static char M_Mathutils_CopyMat_doc[] = "() - create a copy of a matrix";
-static char M_Mathutils_TranslationMatrix_doc[] =
-	"() - create a translation matrix from a vector";
+static char M_Mathutils_TranslationMatrix_doc[] = "() - create a translation matrix from a vector";
 static char M_Mathutils_CopyQuat_doc[] = "() - copy quatB to quatA";
 static char M_Mathutils_CopyEuler_doc[] = "() - copy eulB to eultA";
-static char M_Mathutils_CrossQuats_doc[] =
-	"() - return the mutliplication of two quaternions";
-static char M_Mathutils_DotQuats_doc[] =
-	"() - return the dot product of two quaternions";
-static char M_Mathutils_Slerp_doc[] =
-	"() - returns the interpolation between two quaternions";
-static char M_Mathutils_DifferenceQuats_doc[] =
-	"() - return the angular displacment difference between two quats";
-static char M_Mathutils_RotateEuler_doc[] =
-	"() - rotate euler by an axis and angle";
-
-
-/****************************************************************************/
-// Python method structure definition for Blender.Mathutils module:     
-/****************************************************************************/
+static char M_Mathutils_CrossQuats_doc[] = "() - return the mutliplication of two quaternions";
+static char M_Mathutils_DotQuats_doc[] = "() - return the dot product of two quaternions";
+static char M_Mathutils_Slerp_doc[] = "() - returns the interpolation between two quaternions";
+static char M_Mathutils_DifferenceQuats_doc[] = "() - return the angular displacment difference between two quats";
+static char M_Mathutils_RotateEuler_doc[] = "() - rotate euler by an axis and angle";
+//-----------------------METHOD DEFINITIONS ----------------------
 struct PyMethodDef M_Mathutils_methods[] = {
-	{"Rand", ( PyCFunction ) M_Mathutils_Rand, METH_VARARGS,
-	 M_Mathutils_Rand_doc},
-	{"Vector", ( PyCFunction ) M_Mathutils_Vector, METH_VARARGS,
-	 M_Mathutils_Vector_doc},
-	{"CrossVecs", ( PyCFunction ) M_Mathutils_CrossVecs, METH_VARARGS,
-	 M_Mathutils_CrossVecs_doc},
-	{"DotVecs", ( PyCFunction ) M_Mathutils_DotVecs, METH_VARARGS,
-	 M_Mathutils_DotVecs_doc},
-	{"AngleBetweenVecs", ( PyCFunction ) M_Mathutils_AngleBetweenVecs,
-	 METH_VARARGS,
-	 M_Mathutils_AngleBetweenVecs_doc},
-	{"MidpointVecs", ( PyCFunction ) M_Mathutils_MidpointVecs,
-	 METH_VARARGS,
-	 M_Mathutils_MidpointVecs_doc},
-	{"VecMultMat", ( PyCFunction ) M_Mathutils_VecMultMat, METH_VARARGS,
-	 M_Mathutils_VecMultMat_doc},
-	{"ProjectVecs", ( PyCFunction ) M_Mathutils_ProjectVecs, METH_VARARGS,
-	 M_Mathutils_ProjectVecs_doc},
-	{"CopyVec", ( PyCFunction ) M_Mathutils_CopyVec, METH_VARARGS,
-	 M_Mathutils_CopyVec_doc},
-	{"Matrix", ( PyCFunction ) M_Mathutils_Matrix, METH_VARARGS,
-	 M_Mathutils_Matrix_doc},
-	{"RotationMatrix", ( PyCFunction ) M_Mathutils_RotationMatrix,
-	 METH_VARARGS,
-	 M_Mathutils_RotationMatrix_doc},
-	{"ScaleMatrix", ( PyCFunction ) M_Mathutils_ScaleMatrix, METH_VARARGS,
-	 M_Mathutils_ScaleMatrix_doc},
-	{"ShearMatrix", ( PyCFunction ) M_Mathutils_ShearMatrix, METH_VARARGS,
-	 M_Mathutils_ShearMatrix_doc},
-	{"TranslationMatrix", ( PyCFunction ) M_Mathutils_TranslationMatrix,
-	 METH_VARARGS,
-	 M_Mathutils_TranslationMatrix_doc},
-	{"CopyMat", ( PyCFunction ) M_Mathutils_CopyMat, METH_VARARGS,
-	 M_Mathutils_CopyMat_doc},
-	{"OrthoProjectionMatrix",
-	 ( PyCFunction ) M_Mathutils_OrthoProjectionMatrix, METH_VARARGS,
-	 M_Mathutils_OrthoProjectionMatrix_doc},
-	{"MatMultVec", ( PyCFunction ) M_Mathutils_MatMultVec, METH_VARARGS,
-	 M_Mathutils_MatMultVec_doc},
-	{"Quaternion", ( PyCFunction ) M_Mathutils_Quaternion, METH_VARARGS,
-	 M_Mathutils_Quaternion_doc},
-	{"CopyQuat", ( PyCFunction ) M_Mathutils_CopyQuat, METH_VARARGS,
-	 M_Mathutils_CopyQuat_doc},
-	{"CrossQuats", ( PyCFunction ) M_Mathutils_CrossQuats, METH_VARARGS,
-	 M_Mathutils_CrossQuats_doc},
-	{"DotQuats", ( PyCFunction ) M_Mathutils_DotQuats, METH_VARARGS,
-	 M_Mathutils_DotQuats_doc},
-	{"DifferenceQuats", ( PyCFunction ) M_Mathutils_DifferenceQuats,
-	 METH_VARARGS,
-	 M_Mathutils_DifferenceQuats_doc},
-	{"Slerp", ( PyCFunction ) M_Mathutils_Slerp, METH_VARARGS,
-	 M_Mathutils_Slerp_doc},
-	{"Euler", ( PyCFunction ) M_Mathutils_Euler, METH_VARARGS,
-	 M_Mathutils_Euler_doc},
-	{"CopyEuler", ( PyCFunction ) M_Mathutils_CopyEuler, METH_VARARGS,
-	 M_Mathutils_CopyEuler_doc},
-	{"RotateEuler", ( PyCFunction ) M_Mathutils_RotateEuler, METH_VARARGS,
-	 M_Mathutils_RotateEuler_doc},
+	{"Rand", (PyCFunction) M_Mathutils_Rand, METH_VARARGS, M_Mathutils_Rand_doc},
+	{"Vector", (PyCFunction) M_Mathutils_Vector, METH_VARARGS, M_Mathutils_Vector_doc},
+	{"CrossVecs", (PyCFunction) M_Mathutils_CrossVecs, METH_VARARGS, M_Mathutils_CrossVecs_doc},
+	{"DotVecs", (PyCFunction) M_Mathutils_DotVecs, METH_VARARGS, M_Mathutils_DotVecs_doc},
+	{"AngleBetweenVecs", (PyCFunction) M_Mathutils_AngleBetweenVecs, METH_VARARGS, M_Mathutils_AngleBetweenVecs_doc},
+	{"MidpointVecs", (PyCFunction) M_Mathutils_MidpointVecs, METH_VARARGS, M_Mathutils_MidpointVecs_doc},
+	{"VecMultMat", (PyCFunction) M_Mathutils_VecMultMat, METH_VARARGS, M_Mathutils_VecMultMat_doc},
+	{"ProjectVecs", (PyCFunction) M_Mathutils_ProjectVecs, METH_VARARGS, M_Mathutils_ProjectVecs_doc},
+	{"CopyVec", (PyCFunction) M_Mathutils_CopyVec, METH_VARARGS, M_Mathutils_CopyVec_doc},
+	{"Matrix", (PyCFunction) M_Mathutils_Matrix, METH_VARARGS, M_Mathutils_Matrix_doc},
+	{"RotationMatrix", (PyCFunction) M_Mathutils_RotationMatrix, METH_VARARGS, M_Mathutils_RotationMatrix_doc},
+	{"ScaleMatrix", (PyCFunction) M_Mathutils_ScaleMatrix, METH_VARARGS, M_Mathutils_ScaleMatrix_doc},
+	{"ShearMatrix", (PyCFunction) M_Mathutils_ShearMatrix, METH_VARARGS, M_Mathutils_ShearMatrix_doc},
+	{"TranslationMatrix", (PyCFunction) M_Mathutils_TranslationMatrix, METH_VARARGS, M_Mathutils_TranslationMatrix_doc},
+	{"CopyMat", (PyCFunction) M_Mathutils_CopyMat, METH_VARARGS, M_Mathutils_CopyMat_doc},
+	{"OrthoProjectionMatrix", (PyCFunction) M_Mathutils_OrthoProjectionMatrix,  METH_VARARGS, M_Mathutils_OrthoProjectionMatrix_doc},
+	{"MatMultVec", (PyCFunction) M_Mathutils_MatMultVec, METH_VARARGS, M_Mathutils_MatMultVec_doc},
+	{"Quaternion", (PyCFunction) M_Mathutils_Quaternion, METH_VARARGS, M_Mathutils_Quaternion_doc},
+	{"CopyQuat", (PyCFunction) M_Mathutils_CopyQuat, METH_VARARGS, M_Mathutils_CopyQuat_doc},
+	{"CrossQuats", (PyCFunction) M_Mathutils_CrossQuats, METH_VARARGS, M_Mathutils_CrossQuats_doc},
+	{"DotQuats", (PyCFunction) M_Mathutils_DotQuats, METH_VARARGS, M_Mathutils_DotQuats_doc},
+	{"DifferenceQuats", (PyCFunction) M_Mathutils_DifferenceQuats, METH_VARARGS,M_Mathutils_DifferenceQuats_doc},
+	{"Slerp", (PyCFunction) M_Mathutils_Slerp, METH_VARARGS, M_Mathutils_Slerp_doc},
+	{"Euler", (PyCFunction) M_Mathutils_Euler, METH_VARARGS, M_Mathutils_Euler_doc},
+	{"CopyEuler", (PyCFunction) M_Mathutils_CopyEuler, METH_VARARGS, M_Mathutils_CopyEuler_doc},
+	{"RotateEuler", (PyCFunction) M_Mathutils_RotateEuler, METH_VARARGS, M_Mathutils_RotateEuler_doc},
 	{NULL, NULL, 0, NULL}
 };
+//----------------------------MODULE INIT-------------------------
+PyObject *Mathutils_Init(void)
+{
+	PyObject *submodule;
+
+	//seed the generator for the rand function
+	BLI_srand((unsigned int) (PIL_check_seconds_timer() *
+				      0x7FFFFFFF));
+
+	submodule = Py_InitModule3("Blender.Mathutils",
+				    M_Mathutils_methods, M_Mathutils_doc);
+	return (submodule);
+}
+//-----------------------------METHODS----------------------------
+//----------------column_vector_multiplication (internal)---------
+//COLUMN VECTOR Multiplication (Matrix X Vector)
+// [1][2][3]   [a]
+// [4][5][6] * [b]
+// [7][8][9]   [c]
+//vector/matrix multiplication IS NOT COMMUTATIVE!!!!
+PyObject *column_vector_multiplication(MatrixObject * mat, VectorObject* vec)
+{
+	float vecNew[4], vecCopy[4];
+	double dot = 0.0f;
+	int x, y, z = 0;
+
+	if(mat->rowSize != vec->size){
+		if(mat->rowSize == 4 && vec->size != 3){
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"matrix * vector: matrix row size and vector size must be the same\n");
+		}else{
+			vecCopy[3] = 0.0f;
+		}
+	}
 
+	for(x = 0; x < vec->size; x++){
+		vecCopy[x] = vec->vec[x];
+		}
 
-//***************************************************************************
-// Function:             M_Mathutils_Rand            
-//***************************************************************************
-static PyObject *M_Mathutils_Rand( PyObject * self, PyObject * args )
+	for(x = 0; x < mat->rowSize; x++) {
+		for(y = 0; y < mat->colSize; y++) {
+			dot += mat->matrix[x][y] * vecCopy[y];
+		}
+		vecNew[z++] = dot;
+		dot = 0.0f;
+	}
+	return (PyObject *) newVectorObject(vecNew, vec->size, Py_NEW);
+}
+//-----------------row_vector_multiplication (internal)-----------
+//ROW VECTOR Multiplication - Vector X Matrix
+//[x][y][z] *  [1][2][3]
+//             [4][5][6]
+//             [7][8][9]
+//vector/matrix multiplication IS NOT COMMUTATIVE!!!!
+PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat)
 {
+	float vecNew[4], vecCopy[4];
+	double dot = 0.0f;
+	int x, y, z = 0, size;
+
+	if(mat->colSize != vec->size){
+		if(mat->rowSize == 4 && vec->size != 3){
+			return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+				"vector * matrix: matrix column size and the vector size must be the same\n");
+		}else{
+			vecCopy[3] = 0.0f;
+		}
+	}
+	size = vec->size;
+	for(x = 0; x < vec->size; x++){
+		vecCopy[x] = vec->vec[x];
+	}
 
+	//muliplication
+	for(x = 0; x < mat->colSize; x++) {
+		for(y = 0; y < mat->rowSize; y++) {
+			dot += mat->matrix[y][x] * vecCopy[y];
+		}
+		vecNew[z++] = dot;
+		dot = 0.0f;
+	}
+	return (PyObject *) newVectorObject(vecNew, size, Py_NEW);
+}
+//----------------------------------Mathutils.Rand() --------------------
+//returns a random number between a high and low value
+PyObject *M_Mathutils_Rand(PyObject * self, PyObject * args)
+{
 	float high, low, range;
 	double rand;
+	//initializers
 	high = 1.0;
 	low = 0.0;
 
-	if( !PyArg_ParseTuple( args, "|ff", &low, &high ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected optional float & float\n" ) );
+	if(!PyArg_ParseTuple(args, "|ff", &low, &high))
+		return (EXPP_ReturnPyObjError(PyExc_TypeError,
+			"Mathutils.Rand(): expected nothing or optional (float, float)\n"));
 
-	if( ( high < low ) || ( high < 0 && low > 0 ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"high value should be larger than low value\n" ) );
-
-	//seed the generator
-	BLI_srand( ( unsigned int ) ( PIL_check_seconds_timer(  ) *
-				      0x7FFFFFFF ) );
+	if((high < low) || (high < 0 && low > 0))
+		return (EXPP_ReturnPyObjError(PyExc_ValueError,
+			"Mathutils.Rand(): high value should be larger than low value\n"));
 
 	//get the random number 0 - 1
-	rand = BLI_drand(  );
+	rand = BLI_drand();
 
 	//set it to range
 	range = high - low;
 	rand = rand * range;
 	rand = rand + low;
 
-	return PyFloat_FromDouble( ( double ) rand );
+	return PyFloat_FromDouble(rand);
 }
-
-//***************************************************************************
-// Function:             M_Mathutils_Vector               
-// Python equivalent:     Blender.Mathutils.Vector        
+//----------------------------------VECTOR FUNCTIONS---------------------
+//----------------------------------Mathutils.Vector() ------------------
 // Supports 2D, 3D, and 4D vector objects both int and float values
-// accepted. Mixed float and int values accepted. Ints are parsed to float  
-//***************************************************************************
-static PyObject *M_Mathutils_Vector( PyObject * self, PyObject * args )
+// accepted. Mixed float and int values accepted. Ints are parsed to float 
+PyObject *M_Mathutils_Vector(PyObject * self, PyObject * args)
 {
 	PyObject *listObject = NULL;
 	int size, i;
 	float vec[4];
 
 	size = PySequence_Length(args);
-	if ( size == 1 ) {
+	if (size == 1) {
 		listObject = PySequence_GetItem(args, 0);
-		if ( PySequence_Check(listObject) ) {
+		if (PySequence_Check(listObject)) {
 			size = PySequence_Length(listObject);
-		} else {
-			goto bad_args;	// Single argument was not a sequence
+		} else { // Single argument was not a sequence
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_TypeError, 
+				"Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n");
 		}
-	} else if ( size == 0 ) {
-		return ( PyObject * ) newVectorObject( NULL, 3 );
+	} else if (size == 0) {
+		//returns a new empty 3d vector
+		return (PyObject *) newVectorObject(NULL, 3, Py_NEW); 
 	} else {
-		Py_INCREF(args);
-		listObject = args;
+		listObject = EXPP_incr_ret(args);
 	}
-	if (size<2 || size>4) {
-		goto bad_args;		// Invalid vector size
+	if (size<2 || size>4) { // Invalid vector size
+		Py_XDECREF(listObject);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n");
 	}
 	for (i=0; i<size; i++) {
 		PyObject *v, *f;
 
 		v=PySequence_GetItem(listObject, i);
-		if (v==NULL) {
-			Py_DECREF(listObject);
-			return NULL;	// Failed to read sequence
+		if (v==NULL) { // Failed to read sequence
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_RuntimeError, 
+				"Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n");
 		}
 		f=PyNumber_Float(v);
-		if(f==NULL) {
+		if(f==NULL) { // parsed item not a number
 			Py_DECREF(v);
-			goto bad_args;
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_TypeError, 
+				"Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n");
 		}
 		vec[i]=PyFloat_AS_DOUBLE(f);
-		Py_DECREF(f);
-		Py_DECREF(v);
+		EXPP_decr2(f,v);
 	}
 	Py_DECREF(listObject);
-	return ( PyObject * ) newVectorObject( vec, size );
-
-bad_args:
-	Py_XDECREF(listObject);
-	PyErr_SetString( PyExc_TypeError, "2-4 floats expected (optionally in a sequence)");
-	return NULL;
+	return (PyObject *) newVectorObject(vec, size, Py_NEW);
 }
-
-//***************************************************************************
-//Begin Vector Utils
-
-static PyObject *M_Mathutils_CopyVec( PyObject * self, PyObject * args )
-{
-	VectorObject *vector;
-	float *vec;
-	int x;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple( args, "O!", &vector_Type, &vector ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected vector type\n" ) );
-
-	vec = PyMem_Malloc( vector->size * sizeof( float ) );
-	for( x = 0; x < vector->size; x++ ) {
-		vec[x] = vector->vec[x];
-	}
-
-	retval =  ( PyObject * ) newVectorObject( vec, vector->size );
-	
-	PyMem_Free( vec );
-	return retval;
-}
-
+//----------------------------------Mathutils.CrossVecs() ---------------
 //finds perpendicular vector - only 3D is supported
-static PyObject *M_Mathutils_CrossVecs( PyObject * self, PyObject * args )
+PyObject *M_Mathutils_CrossVecs(PyObject * self, PyObject * args)
 {
-	PyObject *vecCross;
-	VectorObject *vec1;
-	VectorObject *vec2;
-
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError, "expected 2 vector types\n" ) );
-	if( vec1->size != 3 || vec2->size != 3 )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"only 3D vectors are supported\n" ) );
-
-	vecCross = newVectorObject( NULL, 3 );
-	Crossf( ( ( VectorObject * ) vecCross )->vec, vec1->vec, vec2->vec );
-
+	PyObject *vecCross = NULL;
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+
+	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.CrossVecs(): expects (2) 3D vector objects\n");
+	if(vec1->size != 3 || vec2->size != 3)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.CrossVecs(): expects (2) 3D vector objects\n");
+
+	vecCross = newVectorObject(NULL, 3, Py_NEW);
+	Crossf(((VectorObject*)vecCross)->vec, vec1->vec, vec2->vec);
 	return vecCross;
 }
-
-static PyObject *M_Mathutils_DotVecs( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.DotVec() -------------------
+//calculates the dot product of two vectors
+PyObject *M_Mathutils_DotVecs(PyObject * self, PyObject * args)
 {
-	VectorObject *vec1;
-	VectorObject *vec2;
-	float dot;
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+	double dot = 0.0f;
 	int x;
 
-	dot = 0;
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError, "expected vector types\n" ) );
-	if( vec1->size != vec2->size )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"vectors must be of the same size\n" ) );
+	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.DotVec(): expects (2) vector objects of the same size\n");
+	if(vec1->size != vec2->size)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.DotVec(): expects (2) vector objects of the same size\n");
 
-	for( x = 0; x < vec1->size; x++ ) {
+	for(x = 0; x < vec1->size; x++) {
 		dot += vec1->vec[x] * vec2->vec[x];
 	}
-
-	return PyFloat_FromDouble( ( double ) dot );
+	return PyFloat_FromDouble(dot);
 }
-
-static PyObject *M_Mathutils_AngleBetweenVecs( PyObject * self,
-					       PyObject * args )
+//----------------------------------Mathutils.AngleBetweenVecs() ---------
+//calculates the angle between 2 vectors
+PyObject *M_Mathutils_AngleBetweenVecs(PyObject * self, PyObject * args)
 {
-	// original vectors, makea copy of these
-	VectorObject *vec1;
-	VectorObject *vec2;
-	
-	/* copy of the 2 input vectors, these can be normalized
-	without input vectors being normalized. bugfix 
-	no need to use vector objects, just use floats
-	No Chance of 4D vectors getting in.
-	
-	Use doubles, since floats will return nan when input vecs are large.*/
-	double vec1copy[3];
-	double vec2copy[3];
-	
-	float norm;
-	double dot, angleRads;
-	int x;
-
-	dot = 0.0f;
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError, "expected 2 vector types\n" ) );
-	if( vec1->size != vec2->size )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"vectors must be of the same size\n" ) );
-	if( vec1->size > 3 || vec2->size > 3 )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"only 2D,3D vectors are supported\n" ) );
-	
-	/* Check for 2 vectors being the same */
-	if (vec1->size == 3 &&
-		vec1->vec[0] == vec2->vec[0] &&
-		vec1->vec[1] == vec2->vec[1] &&
-		vec1->vec[2] == vec2->vec[2])
-			return PyFloat_FromDouble( dot ); /* 2 points are the same, return zero */
-	else if (vec1->size == 2 &&
-		vec1->vec[0] == vec2->vec[0] &&
-		vec1->vec[1] == vec2->vec[1])
-			return PyFloat_FromDouble( dot ); /* 2 points are the same, return zero */
-	
-	//normalize vec1copy
-	norm = 0.0f;
-	for( x = 0; x < vec1->size; x++ ) {
-		vec1copy[x] = vec1->vec[x]; /* Assign new vector in the loop */
-		norm += vec1copy[x] * vec1copy[x];
-	}
-	norm = ( float ) sqrt( norm );
-	for( x = 0; x < vec1->size; x++ ) {
-		vec1copy[x] /= norm;
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+	double dot = 0.0f, angleRads;
+	double norm_a = 0.0f, norm_b = 0.0f;
+	double vec_a[4], vec_b[4];
+	int x, size;
+
+	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.AngleBetweenVecs(): expects (2) vector objects of the same size\n");
+	if(vec1->size != vec2->size)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.AngleBetweenVecs(): expects (2) vector objects of the same size\n");
+
+	//since size is the same....
+	size = vec1->size;
+
+	//copy vector info
+	for (x = 0; x < vec1->size; x++){
+		vec_a[x] = vec1->vec[x];
+		vec_b[x] = vec2->vec[x];
 	}
 
-	//normalize vec2copy
-	norm = 0.0f;
-	for( x = 0; x < vec2->size; x++ ) {
-		vec2copy[x] = vec2->vec[x]; /* Assign new vector in the loop */
-		norm += vec2copy[x] * vec2copy[x];
+	//normalize vectors
+	for(x = 0; x < size; x++) {
+		norm_a += vec_a[x] * vec_a[x];
+		norm_b += vec_b[x] * vec_b[x];
 	}
-	norm = ( float ) sqrt( norm );
-	for( x = 0; x < vec2->size; x++ ) {
-		vec2copy[x] /= norm;
+	norm_a = (double)sqrt(norm_a);
+	norm_b = (double)sqrt(norm_b);
+	for(x = 0; x < size; x++) {
+		vec_a[x] /= norm_a;
+		vec_b[x] /= norm_b;
 	}
-
 	//dot product
-	for( x = 0; x < vec1->size; x++ ) {
-		dot += vec1copy[x] * vec2copy[x];
+	for(x = 0; x < size; x++) {
+		dot += vec_a[x] * vec_b[x];
 	}
-
 	//I believe saacos checks to see if the vectors are normalized
-	angleRads = (double)acos( dot );
+	angleRads = (double)acos(dot);
 
-	return PyFloat_FromDouble( angleRads * ( 180 / Py_PI ) );
+	return PyFloat_FromDouble(angleRads * (180 / Py_PI));
 }
-
-static PyObject *M_Mathutils_MidpointVecs( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.MidpointVecs() -------------
+//calculates the midpoint between 2 vectors
+PyObject *M_Mathutils_MidpointVecs(PyObject * self, PyObject * args)
 {
-
-	VectorObject *vec1;
-	VectorObject *vec2;
-	float *vec;
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+	float vec[4];
 	int x;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError, "expected vector types\n" ) );
-	if( vec1->size != vec2->size )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"vectors must be of the same size\n" ) );
-
-	vec = PyMem_Malloc( vec1->size * sizeof( float ) );
-
-	for( x = 0; x < vec1->size; x++ ) {
-		vec[x] = 0.5f * ( vec1->vec[x] + vec2->vec[x] );
-	}
-	retval = ( PyObject * ) newVectorObject( vec, vec1->size );
 	
-	PyMem_Free( vec );
-	return retval;
-}
-
-//row vector multiplication
-static PyObject *M_Mathutils_VecMultMat( PyObject * self, PyObject * args )
-{
-	PyObject *ob1 = NULL;
-	PyObject *ob2 = NULL;
-	MatrixObject *mat;
-	VectorObject *vec;
-	PyObject *retval;
-	float *vecNew;
-	int x, y;
-	int z = 0;
-	float dot = 0.0f;
-
-	//get pyObjects
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &vector_Type, &ob1, &matrix_Type, &ob2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "vector and matrix object expected - in that order\n" ) );
-
-	mat = ( MatrixObject * ) ob2;
-	vec = ( VectorObject * ) ob1;
-	if( mat->colSize != vec->size )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"matrix col size and vector size must be the same\n" ) );
-
-	vecNew = PyMem_Malloc( vec->size * sizeof( float ) );
-
-	for( x = 0; x < mat->colSize; x++ ) {
-		for( y = 0; y < mat->rowSize; y++ ) {
-			dot += mat->matrix[y][x] * vec->vec[y];
-		}
-		vecNew[z] = dot;
-		z++;
-		dot = 0;
+	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.MidpointVecs(): expects (2) vector objects of the same size\n");
+	if(vec1->size != vec2->size)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.MidpointVecs(): expects (2) vector objects of the same size\n");
+
+	for(x = 0; x < vec1->size; x++) {
+		vec[x] = 0.5f * (vec1->vec[x] + vec2->vec[x]);
 	}
-
-	retval =  ( PyObject * ) newVectorObject( vecNew, vec->size );
-
-	PyMem_Free( vecNew );
-	return retval;
+	return (PyObject *) newVectorObject(vec, vec1->size, Py_NEW);
 }
-
-static PyObject *M_Mathutils_ProjectVecs( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.ProjectVecs() -------------
+//projects vector 1 onto vector 2
+PyObject *M_Mathutils_ProjectVecs(PyObject * self, PyObject * args)
 {
-	VectorObject *vec1;
-	VectorObject *vec2;
-	PyObject *retval;
-	float *vec;
-	float dot = 0.0f;
-	float dot2 = 0.0f;
-	int x;
-
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError, "expected vector types\n" ) );
-	if( vec1->size != vec2->size )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"vectors must be of the same size\n" ) );
-
-	vec = PyMem_Malloc( vec1->size * sizeof( float ) );
-
-	//dot of vec1 & vec2
-	for( x = 0; x < vec1->size; x++ ) {
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+	float vec[4]; 
+	double dot = 0.0f, dot2 = 0.0f;
+	int x, size;
+
+	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.ProjectVecs(): expects (2) vector objects of the same size\n");
+	if(vec1->size != vec2->size)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.ProjectVecs(): expects (2) vector objects of the same size\n");
+
+	//since they are the same size...
+	size = vec1->size;
+
+	//get dot products
+	for(x = 0; x < size; x++) {
 		dot += vec1->vec[x] * vec2->vec[x];
-	}
-	//dot of vec2 & vec2
-	for( x = 0; x < vec2->size; x++ ) {
 		dot2 += vec2->vec[x] * vec2->vec[x];
 	}
+	//projection
 	dot /= dot2;
-	for( x = 0; x < vec1->size; x++ ) {
-		vec[x] = dot * vec2->vec[x];
+	for(x = 0; x < size; x++) {
+		vec[x] = (float)(dot * vec2->vec[x]);
 	}
-
-	retval = ( PyObject * ) newVectorObject( vec, vec1->size );
-	PyMem_Free( vec );
-	return retval;
+	return (PyObject *) newVectorObject(vec, size, Py_NEW);
 }
-
-//End Vector Utils
-
-//***************************************************************************
-// Function:      M_Mathutils_Matrix                                           // Python equivalent:      Blender.Mathutils.Matrix                          
-//***************************************************************************
+//----------------------------------MATRIX FUNCTIONS--------------------
+//----------------------------------Mathutils.Matrix() -----------------
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_Matrix( PyObject * self, PyObject * args )
+//create a new matrix type
+PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args)
 {
-
-	PyObject *rowA = NULL;
-	PyObject *rowB = NULL;
-	PyObject *rowC = NULL;
-	PyObject *rowD = NULL;
-	PyObject *checkOb = NULL;
-	PyObject *retval = NULL;
-	int x, rowSize, colSize;
-	float *mat;
-	int OK;
-
-	if( !PyArg_ParseTuple( args, "|O!O!O!O!", &PyList_Type, &rowA,
-			       &PyList_Type, &rowB,
-			       &PyList_Type, &rowC, &PyList_Type, &rowD ) ) {
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected 0, 2,3 or 4 lists\n" ) );
-	}
-
-	if( !rowA )
-		return newMatrixObject( NULL, 4, 4 );
-
-	if( !rowB )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected 0, 2,3 or 4 lists\n" ) );
-
-	//get rowSize
-	if( rowC ) {
-		if( rowD ) {
-			rowSize = 4;
-		} else {
-			rowSize = 3;
+	PyObject *listObject = NULL;
+	int argSize, seqSize = 0, i, j;
+	float matrix[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+
+	argSize = PySequence_Length(args);
+	if(argSize > 4){	//bad arg nums
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
+	} else if (argSize == 0) { //return empty 4D matrix
+		return (PyObject *) newMatrixObject(NULL, 4, 4, Py_NEW);
+	}else if (argSize == 1){
+		//copy constructor for matrix objects
+		PyObject *argObject;
+		argObject = PySequence_GetItem(args, 0);
+		Py_INCREF(argObject);
+		if(MatrixObject_Check(argObject)){
+			MatrixObject *mat;
+			mat = (MatrixObject*)argObject;
+			argSize = mat->rowSize; //rows
+			seqSize = mat->colSize; //cols
+			for(i = 0; i < (seqSize * argSize); i++){
+				matrix[i] = mat->contigPtr[i];
+			}
 		}
-	} else {
-		rowSize = 2;
-	}
-
-	//check size and get colSize
-	OK = 0;
-	if( ( PyList_Size( rowA ) == PyList_Size( rowB ) ) ) {
-		if( rowC ) {
-			if( ( PyList_Size( rowA ) == PyList_Size( rowC ) ) ) {
-				if( rowD ) {
-					if( ( PyList_Size( rowA ) ==
-					      PyList_Size( rowD ) ) ) {
-						OK = 1;
+		Py_DECREF(argObject);
+	}else{ //2-4 arguments (all seqs? all same size?)
+		for(i =0; i < argSize; i++){
+			PyObject *argObject;
+			argObject = PySequence_GetItem(args, i);
+			if (PySequence_Check(argObject)) { //seq?
+				if(seqSize){ //0 at first
+					if(PySequence_Length(argObject) != seqSize){ //seq size not same
+						return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+						"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
 					}
 				}
-				OK = 1;
+				seqSize = PySequence_Length(argObject);
+			}else{ //arg not a sequence
+				return EXPP_ReturnPyObjError(PyExc_TypeError, 
+					"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
 			}
-		} else
-			OK = 1;
-	}
-
-	if( !OK )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "each row of vector must contain the same number of parameters\n" );
-	colSize = PyList_Size( rowA );
-
-	//check for numeric types
-	/* PyList_GetItem() returns borrowed ref */
-	for( x = 0; x < colSize; x++ ) {
-		checkOb = PyList_GetItem( rowA, x );  
-		if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
-			return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-							"1st list - expected list of numbers\n" ) );
-		checkOb = PyList_GetItem( rowB, x );
-		if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
-			return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-							"2nd list - expected list of numbers\n" ) );
-		if( rowC ) {
-			checkOb = PyList_GetItem( rowC, x );
-			if( !PyInt_Check( checkOb )
-			    && !PyFloat_Check( checkOb ) )
-				return ( EXPP_ReturnPyObjError
-					 ( PyExc_TypeError,
-					   "3rd list - expected list of numbers\n" ) );
-		}
-		if( rowD ) {
-			checkOb = PyList_GetItem( rowD, x );
-			if( !PyInt_Check( checkOb )
-			    && !PyFloat_Check( checkOb ) )
-				return ( EXPP_ReturnPyObjError
-					 ( PyExc_TypeError,
-					   "4th list - expected list of numbers\n" ) );
+			Py_XDECREF(argObject);
 		}
-	}
-
-	//allocate space for 1D array
-	mat = PyMem_Malloc( rowSize * colSize * sizeof( float ) );
-
-	//parse rows
-	for( x = 0; x < colSize; x++ ) {
-		if( !PyArg_Parse( PyList_GetItem( rowA, x ), "f", &mat[x] ) )
-			return EXPP_ReturnPyObjError( PyExc_TypeError,
-						      "rowA - python list not parseable\n" );
-	}
-	for( x = 0; x < colSize; x++ ) {
-		if( !PyArg_Parse
-		    ( PyList_GetItem( rowB, x ), "f", &mat[( colSize + x )] ) )
-			return EXPP_ReturnPyObjError( PyExc_TypeError,
-						      "rowB - python list not parseable\n" );
-	}
-	if( rowC ) {
-		for( x = 0; x < colSize; x++ ) {
-			if( !PyArg_Parse
-			    ( PyList_GetItem( rowC, x ), "f",
-			      &mat[( ( 2 * colSize ) + x )] ) )
-				return EXPP_ReturnPyObjError( PyExc_TypeError,
-							      "rowC - python list not parseable\n" );
-		}
-	}
-	if( rowD ) {
-		for( x = 0; x < colSize; x++ ) {
-			if( !PyArg_Parse
-			    ( PyList_GetItem( rowD, x ), "f",
-			      &mat[( ( 3 * colSize ) + x )] ) )
-				return EXPP_ReturnPyObjError( PyExc_TypeError,
-							      "rowD - python list not parseable\n" );
+		//all is well... let's continue parsing
+		listObject = EXPP_incr_ret(args);
+		for (i = 0; i < argSize; i++){
+			PyObject *m;
+
+			m = PySequence_GetItem(listObject, i);
+			if (m == NULL) { // Failed to read sequence
+				Py_XDECREF(listObject);
+				return EXPP_ReturnPyObjError(PyExc_RuntimeError, 
+					"Mathutils.Matrix(): failed to parse arguments...\n");
+			}
+			for (j = 0; j < seqSize; j++) {
+				PyObject *s, *f;
+
+				s = PySequence_GetItem(m, j);
+					if (s == NULL) { // Failed to read sequence
+					Py_DECREF(m);
+					Py_XDECREF(listObject);
+					return EXPP_ReturnPyObjError(PyExc_RuntimeError, 
+						"Mathutils.Matrix(): failed to parse arguments...\n");
+				}
+				f = PyNumber_Float(s);
+				if(f == NULL) { // parsed item is not a number
+					EXPP_decr2(m,s);
+					Py_XDECREF(listObject);
+					return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+						"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
+				}
+				matrix[(seqSize*i)+j]=PyFloat_AS_DOUBLE(f);
+				EXPP_decr2(f,s);
+			}
+			Py_DECREF(m);
 		}
+		Py_DECREF(listObject);
 	}
-	//pass to matrix creation
-	retval =  newMatrixObject( mat, rowSize, colSize );
-
-	PyMem_Free( mat);
-	return retval;
+	return (PyObject *)newMatrixObject(matrix, argSize, seqSize, Py_NEW);
 }
-
-//***************************************************************************
-// Function:      M_Mathutils_RotationMatrix                                  
-// Python equivalent:    Blender.Mathutils.RotationMatrix  
-//***************************************************************************
+//----------------------------------Mathutils.RotationMatrix() ----------
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_RotationMatrix( PyObject * self, PyObject * args )
+//creates a rotation matrix
+PyObject *M_Mathutils_RotationMatrix(PyObject * self, PyObject * args)
 {
-	PyObject *retval;
-	float *mat;
-	float angle = 0.0f;
-	char *axis = NULL;
 	VectorObject *vec = NULL;
+	char *axis = NULL;
 	int matSize;
-	float norm = 0.0f;
-	float cosAngle = 0.0f;
-	float sinAngle = 0.0f;
-
-	if( !PyArg_ParseTuple
-	    ( args, "fi|sO!", &angle, &matSize, &axis, &vector_Type, &vec ) ) {
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected float int and optional string and vector\n" ) );
+	float angle = 0.0f, norm = 0.0f, cosAngle = 0.0f, sinAngle = 0.0f;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+
+	if(!PyArg_ParseTuple
+	    (args, "fi|sO!", &angle, &matSize, &axis, &vector_Type, &vec)) {
+		return EXPP_ReturnPyObjError (PyExc_TypeError, 
+			"Mathutils.RotationMatrix(): expected float int and optional string and vector\n");
 	}
-	if( angle < -360.0f || angle > 360.0f )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "angle size not appropriate\n" );
-	if( matSize != 2 && matSize != 3 && matSize != 4 )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
-	if( matSize == 2 && ( axis != NULL || vec != NULL ) )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "cannot create a 2x2 rotation matrix around arbitrary axis\n" );
-	if( ( matSize == 3 || matSize == 4 ) && axis == NULL )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "please choose an axis of rotation\n" );
-	if( axis ) {
-		if( ( ( strcmp( axis, "r" ) == 0 ) ||
-		      ( strcmp( axis, "R" ) == 0 ) ) && vec == NULL )
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "please define the arbitrary axis of rotation\n" );
+	if(angle < -360.0f || angle > 360.0f)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.RotationMatrix(): angle size not appropriate\n");
+	if(matSize != 2 && matSize != 3 && matSize != 4)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.RotationMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+	if(matSize == 2 && (axis != NULL || vec != NULL))
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.RotationMatrix(): cannot create a 2x2 rotation matrix around arbitrary axis\n");
+	if((matSize == 3 || matSize == 4) && axis == NULL)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.RotationMatrix(): please choose an axis of rotation for 3d and 4d matrices\n");
+	if(axis) {
+		if(((strcmp(axis, "r") == 0) ||
+		      (strcmp(axis, "R") == 0)) && vec == NULL)
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"Mathutils.RotationMatrix(): please define the arbitrary axis of rotation\n");
 	}
-	if( vec ) {
-		if( vec->size != 3 )
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "the arbitrary axis must be a 3D vector\n" );
+	if(vec) {
+		if(vec->size != 3)
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+						      "Mathutils.RotationMatrix(): the arbitrary axis must be a 3D vector\n");
 	}
-
-	mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
-
 	//convert to radians
-	angle = angle * ( float ) ( Py_PI / 180 );
-
-	if( axis == NULL && matSize == 2 ) {
+	angle = angle * (float) (Py_PI / 180);
+	if(axis == NULL && matSize == 2) {
 		//2D rotation matrix
-		mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
-		mat[1] = ( ( float ) sin( ( double ) ( angle ) ) );
-		mat[2] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
-		mat[3] = ( ( float ) cos( ( double ) ( angle ) ) );
-	} else if( ( strcmp( axis, "x" ) == 0 ) ||
-		   ( strcmp( axis, "X" ) == 0 ) ) {
+		mat[0] = (float) cosf (angle);
+		mat[1] = (float) sin (angle);
+		mat[2] = -((float) sin(angle));
+		mat[3] = (float) cos(angle);
+	} else if((strcmp(axis, "x") == 0) || (strcmp(axis, "X") == 0)) {
 		//rotation around X
 		mat[0] = 1.0f;
-		mat[1] = 0.0f;
-		mat[2] = 0.0f;
-		mat[3] = 0.0f;
-		mat[4] = ( ( float ) cos( ( double ) ( angle ) ) );
-		mat[5] = ( ( float ) sin( ( double ) ( angle ) ) );
-		mat[6] = 0.0f;
-		mat[7] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
-		mat[8] = ( ( float ) cos( ( double ) ( angle ) ) );
-	} else if( ( strcmp( axis, "y" ) == 0 ) ||
-		   ( strcmp( axis, "Y" ) == 0 ) ) {
+		mat[4] = (float) cos(angle);
+		mat[5] = (float) sin(angle);
+		mat[7] = -((float) sin(angle));
+		mat[8] = (float) cos(angle);
+	} else if((strcmp(axis, "y") == 0) || (strcmp(axis, "Y") == 0)) {
 		//rotation around Y
-		mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
-		mat[1] = 0.0f;
-		mat[2] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
-		mat[3] = 0.0f;
+		mat[0] = (float) cos(angle);
+		mat[2] = -((float) sin(angle));
 		mat[4] = 1.0f;
-		mat[5] = 0.0f;
-		mat[6] = ( ( float ) sin( ( double ) ( angle ) ) );
-		mat[7] = 0.0f;
-		mat[8] = ( ( float ) cos( ( double ) ( angle ) ) );
-	} else if( ( strcmp( axis, "z" ) == 0 ) ||
-		   ( strcmp( axis, "Z" ) == 0 ) ) {
+		mat[6] = (float) sin(angle);
+		mat[8] = (float) cos(angle);
+	} else if((strcmp(axis, "z") == 0) || (strcmp(axis, "Z") == 0)) {
 		//rotation around Z
-		mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
-		mat[1] = ( ( float ) sin( ( double ) ( angle ) ) );
-		mat[2] = 0.0f;
-		mat[3] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
-		mat[4] = ( ( float ) cos( ( double ) ( angle ) ) );
-		mat[5] = 0.0f;
-		mat[6] = 0.0f;
-		mat[7] = 0.0f;
+		mat[0] = (float) cos(angle);
+		mat[1] = (float) sin(angle);
+		mat[3] = -((float) sin(angle));
+		mat[4] = (float) cos(angle);
 		mat[8] = 1.0f;
-	} else if( ( strcmp( axis, "r" ) == 0 ) ||
-		   ( strcmp( axis, "R" ) == 0 ) ) {
+	} else if((strcmp(axis, "r") == 0) || (strcmp(axis, "R") == 0)) {
 		//arbitrary rotation
 		//normalize arbitrary axis
-		norm = ( float ) sqrt( vec->vec[0] * vec->vec[0] +
+		norm = (float) sqrt(vec->vec[0] * vec->vec[0] +
 				       vec->vec[1] * vec->vec[1] +
-				       vec->vec[2] * vec->vec[2] );
+				       vec->vec[2] * vec->vec[2]);
 		vec->vec[0] /= norm;
 		vec->vec[1] /= norm;
 		vec->vec[2] /= norm;
 
 		//create matrix
-		cosAngle = ( ( float ) cos( ( double ) ( angle ) ) );
-		sinAngle = ( ( float ) sin( ( double ) ( angle ) ) );
-		mat[0] = ( ( vec->vec[0] * vec->vec[0] ) * ( 1 - cosAngle ) ) +
+		cosAngle = (float) cos(angle);
+		sinAngle = (float) sin(angle);
+		mat[0] = ((vec->vec[0] * vec->vec[0]) * (1 - cosAngle)) +
 			cosAngle;
-		mat[1] = ( ( vec->vec[0] * vec->vec[1] ) * ( 1 - cosAngle ) ) +
-			( vec->vec[2] * sinAngle );
-		mat[2] = ( ( vec->vec[0] * vec->vec[2] ) * ( 1 - cosAngle ) ) -
-			( vec->vec[1] * sinAngle );
-		mat[3] = ( ( vec->vec[0] * vec->vec[1] ) * ( 1 - cosAngle ) ) -
-			( vec->vec[2] * sinAngle );
-		mat[4] = ( ( vec->vec[1] * vec->vec[1] ) * ( 1 - cosAngle ) ) +
+		mat[1] = ((vec->vec[0] * vec->vec[1]) * (1 - cosAngle)) +
+			(vec->vec[2] * sinAngle);
+		mat[2] = ((vec->vec[0] * vec->vec[2]) * (1 - cosAngle)) -
+			(vec->vec[1] * sinAngle);
+		mat[3] = ((vec->vec[0] * vec->vec[1]) * (1 - cosAngle)) -
+			(vec->vec[2] * sinAngle);
+		mat[4] = ((vec->vec[1] * vec->vec[1]) * (1 - cosAngle)) +
 			cosAngle;
-		mat[5] = ( ( vec->vec[1] * vec->vec[2] ) * ( 1 - cosAngle ) ) +
-			( vec->vec[0] * sinAngle );
-		mat[6] = ( ( vec->vec[0] * vec->vec[2] ) * ( 1 - cosAngle ) ) +
-			( vec->vec[1] * sinAngle );
-		mat[7] = ( ( vec->vec[1] * vec->vec[2] ) * ( 1 - cosAngle ) ) -
-			( vec->vec[0] * sinAngle );
-		mat[8] = ( ( vec->vec[2] * vec->vec[2] ) * ( 1 - cosAngle ) ) +
+		mat[5] = ((vec->vec[1] * vec->vec[2]) * (1 - cosAngle)) +
+			(vec->vec[0] * sinAngle);
+		mat[6] = ((vec->vec[0] * vec->vec[2]) * (1 - cosAngle)) +
+			(vec->vec[1] * sinAngle);
+		mat[7] = ((vec->vec[1] * vec->vec[2]) * (1 - cosAngle)) -
+			(vec->vec[0] * sinAngle);
+		mat[8] = ((vec->vec[2] * vec->vec[2]) * (1 - cosAngle)) +
 			cosAngle;
 	} else {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "unrecognizable axis of rotation type - expected x,y,z or r\n" );
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.RotationMatrix(): unrecognizable axis of rotation type - expected x,y,z or r\n");
 	}
-	if( matSize == 4 ) {
+	if(matSize == 4) {
 		//resize matrix
-		mat[15] = 1.0f;
-		mat[14] = 0.0f;
-		mat[13] = 0.0f;
-		mat[12] = 0.0f;
-		mat[11] = 0.0f;
 		mat[10] = mat[8];
 		mat[9] = mat[7];
 		mat[8] = mat[6];
@@ -833,146 +604,93 @@ static PyObject *M_Mathutils_RotationMatrix( PyObject * self, PyObject * args )
 		mat[3] = 0.0f;
 	}
 	//pass to matrix creation
-	retval = newMatrixObject( mat, matSize, matSize );
-
-	PyMem_Free( mat );
-	return retval;
+	return newMatrixObject(mat, matSize, matSize, Py_NEW);
 }
-
-//***************************************************************************
-// Function:      M_Mathutils_TranslationMatrix 
-// Python equivalent:       Blender.Mathutils.TranslationMatrix 
-//***************************************************************************
-static PyObject *M_Mathutils_TranslationMatrix( PyObject * self,
-						PyObject * args )
+//----------------------------------Mathutils.TranslationMatrix() -------
+//creates a translation matrix
+PyObject *M_Mathutils_TranslationMatrix(PyObject * self, PyObject * args)
 {
-	VectorObject *vec;
-	PyObject *retval;
-	float *mat;
+	VectorObject *vec = NULL;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
 
-	if( !PyArg_ParseTuple( args, "O!", &vector_Type, &vec ) ) {
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected vector\n" ) );
+	if(!PyArg_ParseTuple(args, "O!", &vector_Type, &vec)) {
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+						"Mathutils.TranslationMatrix(): expected vector\n");
 	}
-	if( vec->size != 3 && vec->size != 4 ) {
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "vector must be 3D or 4D\n" );
+	if(vec->size != 3 && vec->size != 4) {
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+					      "Mathutils.TranslationMatrix(): vector must be 3D or 4D\n");
 	}
-
-	mat = PyMem_Malloc( 4 * 4 * sizeof( float ) );
-	Mat4One( ( float ( * )[4] ) mat );
-
+	//create a identity matrix and add translation
+	Mat4One((float(*)[4]) mat);
 	mat[12] = vec->vec[0];
 	mat[13] = vec->vec[1];
 	mat[14] = vec->vec[2];
 
-	retval = newMatrixObject( mat, 4, 4 );
-
-	PyMem_Free( mat );
-	return retval;
+	return newMatrixObject(mat, 4, 4, Py_NEW);
 }
-
-
-//***************************************************************************
-// Function:   M_Mathutils_ScaleMatrix  
-// Python equivalent:       Blender.Mathutils.ScaleMatrix 
-//***************************************************************************
+//----------------------------------Mathutils.ScaleMatrix() -------------
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_ScaleMatrix( PyObject * self, PyObject * args )
+//creates a scaling matrix
+PyObject *M_Mathutils_ScaleMatrix(PyObject * self, PyObject * args)
 {
-	float factor;
-	int matSize;
 	VectorObject *vec = NULL;
-	float *mat;
-	float norm = 0.0f;
-	int x;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple
-	    ( args, "fi|O!", &factor, &matSize, &vector_Type, &vec ) ) {
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected float int and optional vector\n" ) );
+	float norm = 0.0f, factor;
+	int matSize, x;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+
+	if(!PyArg_ParseTuple
+	    (args, "fi|O!", &factor, &matSize, &vector_Type, &vec)) {
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"Mathutils.ScaleMatrix(): expected float int and optional vector\n");
 	}
-	if( matSize != 2 && matSize != 3 && matSize != 4 )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
-	if( vec ) {
-		if( vec->size > 2 && matSize == 2 )
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "please use 2D vectors when scaling in 2D\n" );
+	if(matSize != 2 && matSize != 3 && matSize != 4)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.ScaleMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+	if(vec) {
+		if(vec->size > 2 && matSize == 2)
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"Mathutils.ScaleMatrix(): please use 2D vectors when scaling in 2D\n");
 	}
-	mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
-
-	if( vec == NULL ) {	//scaling along axis
-		if( matSize == 2 ) {
+	if(vec == NULL) {	//scaling along axis
+		if(matSize == 2) {
 			mat[0] = factor;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
 			mat[3] = factor;
 		} else {
 			mat[0] = factor;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
-			mat[3] = 0.0f;
 			mat[4] = factor;
-			mat[5] = 0.0f;
-			mat[6] = 0.0f;
-			mat[7] = 0.0f;
 			mat[8] = factor;
 		}
-	} else {		//scaling in arbitrary direction
-
+	} else { //scaling in arbitrary direction
 		//normalize arbitrary axis
-		for( x = 0; x < vec->size; x++ ) {
+		for(x = 0; x < vec->size; x++) {
 			norm += vec->vec[x] * vec->vec[x];
 		}
-		norm = ( float ) sqrt( norm );
-		for( x = 0; x < vec->size; x++ ) {
+		norm = (float) sqrt(norm);
+		for(x = 0; x < vec->size; x++) {
 			vec->vec[x] /= norm;
 		}
-		if( matSize == 2 ) {
-			mat[0] = 1 +
-				( ( factor -
-				    1 ) * ( vec->vec[0] * vec->vec[0] ) );
-			mat[1] = ( ( factor -
-				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
-			mat[2] = ( ( factor -
-				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
-			mat[3] = 1 +
-				( ( factor -
-				    1 ) * ( vec->vec[1] * vec->vec[1] ) );
+		if(matSize == 2) {
+			mat[0] = 1 +((factor - 1) *(vec->vec[0] * vec->vec[0]));
+			mat[1] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+			mat[2] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+			mat[3] = 1 + ((factor - 1) *(vec->vec[1] * vec->vec[1]));
 		} else {
-			mat[0] = 1 +
-				( ( factor -
-				    1 ) * ( vec->vec[0] * vec->vec[0] ) );
-			mat[1] = ( ( factor -
-				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
-			mat[2] = ( ( factor -
-				     1 ) * ( vec->vec[0] * vec->vec[2] ) );
-			mat[3] = ( ( factor -
-				     1 ) * ( vec->vec[0] * vec->vec[1] ) );
-			mat[4] = 1 +
-				( ( factor -
-				    1 ) * ( vec->vec[1] * vec->vec[1] ) );
-			mat[5] = ( ( factor -
-				     1 ) * ( vec->vec[1] * vec->vec[2] ) );
-			mat[6] = ( ( factor -
-				     1 ) * ( vec->vec[0] * vec->vec[2] ) );
-			mat[7] = ( ( factor -
-				     1 ) * ( vec->vec[1] * vec->vec[2] ) );
-			mat[8] = 1 +
-				( ( factor -
-				    1 ) * ( vec->vec[2] * vec->vec[2] ) );
+			mat[0] = 1 + ((factor - 1) *(vec->vec[0] * vec->vec[0]));
+			mat[1] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+			mat[2] =((factor - 1) *(vec->vec[0] * vec->vec[2]));
+			mat[3] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+			mat[4] = 1 + ((factor - 1) *(vec->vec[1] * vec->vec[1]));
+			mat[5] =((factor - 1) *(vec->vec[1] * vec->vec[2]));
+			mat[6] =((factor - 1) *(vec->vec[0] * vec->vec[2]));
+			mat[7] =((factor - 1) *(vec->vec[1] * vec->vec[2]));
+			mat[8] = 1 + ((factor - 1) *(vec->vec[2] * vec->vec[2]));
 		}
 	}
-	if( matSize == 4 ) {
+	if(matSize == 4) {
 		//resize matrix
-		mat[15] = 1.0f;
-		mat[14] = 0.0f;
-		mat[13] = 0.0f;
-		mat[12] = 0.0f;
-		mat[11] = 0.0f;
 		mat[10] = mat[8];
 		mat[9] = mat[7];
 		mat[8] = mat[6];
@@ -983,152 +701,94 @@ static PyObject *M_Mathutils_ScaleMatrix( PyObject * self, PyObject * args )
 		mat[3] = 0.0f;
 	}
 	//pass to matrix creation
-	retval = newMatrixObject( mat, matSize, matSize );
-
-	PyMem_Free( mat );
-	return retval;
+	return newMatrixObject(mat, matSize, matSize, Py_NEW);
 }
-
-//***************************************************************************
-// Function:     M_Mathutils_OrthoProjectionMatrix  
-// Python equivalent:        Blender.Mathutils.OrthoProjectionMatrix 
-//***************************************************************************
+//----------------------------------Mathutils.OrthoProjectionMatrix() ---
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
-static PyObject *M_Mathutils_OrthoProjectionMatrix( PyObject * self,
-						    PyObject * args )
+//creates an ortho projection matrix
+PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject * self, PyObject * args)
 {
-	char *plane;
-	int matSize;
-	float *mat;
 	VectorObject *vec = NULL;
+	char *plane;
+	int matSize, x;
 	float norm = 0.0f;
-	int x;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple
-	    ( args, "si|O!", &plane, &matSize, &vector_Type, &vec ) ) {
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected string and int and optional vector\n" ) );
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+	
+	if(!PyArg_ParseTuple
+	    (args, "si|O!", &plane, &matSize, &vector_Type, &vec)) {
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"Mathutils.OrthoProjectionMatrix(): expected string and int and optional vector\n");
 	}
-	if( matSize != 2 && matSize != 3 && matSize != 4 )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
-	if( vec ) {
-		if( vec->size > 2 && matSize == 2 )
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "please use 2D vectors when scaling in 2D\n" );
+	if(matSize != 2 && matSize != 3 && matSize != 4)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.OrthoProjectionMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+	if(vec) {
+		if(vec->size > 2 && matSize == 2)
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"Mathutils.OrthoProjectionMatrix(): please use 2D vectors when scaling in 2D\n");
 	}
-	if( vec == NULL ) {	//ortho projection onto cardinal plane
-		if( ( ( strcmp( plane, "x" ) == 0 )
-		      || ( strcmp( plane, "X" ) == 0 ) ) && matSize == 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
+	if(vec == NULL) {	//ortho projection onto cardinal plane
+		if(((strcmp(plane, "x") == 0)
+		      || (strcmp(plane, "X") == 0)) && matSize == 2) {
 			mat[0] = 1.0f;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
-			mat[3] = 0.0f;
-		} else if( ( ( strcmp( plane, "y" ) == 0 )
-			     || ( strcmp( plane, "Y" ) == 0 ) )
-			   && matSize == 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
-			mat[0] = 0.0f;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
+		} else if(((strcmp(plane, "y") == 0) 
+			|| (strcmp(plane, "Y") == 0))
+			   && matSize == 2) {
 			mat[3] = 1.0f;
-		} else if( ( ( strcmp( plane, "xy" ) == 0 )
-			     || ( strcmp( plane, "XY" ) == 0 ) )
-			   && matSize > 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
+		} else if(((strcmp(plane, "xy") == 0)
+			     || (strcmp(plane, "XY") == 0))
+			   && matSize > 2) {
 			mat[0] = 1.0f;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
-			mat[3] = 0.0f;
 			mat[4] = 1.0f;
-			mat[5] = 0.0f;
-			mat[6] = 0.0f;
-			mat[7] = 0.0f;
-			mat[8] = 0.0f;
-		} else if( ( ( strcmp( plane, "xz" ) == 0 )
-			     || ( strcmp( plane, "XZ" ) == 0 ) )
-			   && matSize > 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
+		} else if(((strcmp(plane, "xz") == 0)
+			     || (strcmp(plane, "XZ") == 0))
+			   && matSize > 2) {
 			mat[0] = 1.0f;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
-			mat[3] = 0.0f;
-			mat[4] = 0.0f;
-			mat[5] = 0.0f;
-			mat[6] = 0.0f;
-			mat[7] = 0.0f;
 			mat[8] = 1.0f;
-		} else if( ( ( strcmp( plane, "yz" ) == 0 )
-			     || ( strcmp( plane, "YZ" ) == 0 ) )
-			   && matSize > 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
-			mat[0] = 0.0f;
-			mat[1] = 0.0f;
-			mat[2] = 0.0f;
-			mat[3] = 0.0f;
+		} else if(((strcmp(plane, "yz") == 0)
+			     || (strcmp(plane, "YZ") == 0))
+			   && matSize > 2) {
 			mat[4] = 1.0f;
-			mat[5] = 0.0f;
-			mat[6] = 0.0f;
-			mat[7] = 0.0f;
 			mat[8] = 1.0f;
 		} else {
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "unknown plane - expected: x, y, xy, xz, yz\n" );
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"Mathutils.OrthoProjectionMatrix(): unknown plane - expected: x, y, xy, xz, yz\n");
 		}
-	} else {		//arbitrary plane
+	} else { //arbitrary plane
 		//normalize arbitrary axis
-		for( x = 0; x < vec->size; x++ ) {
+		for(x = 0; x < vec->size; x++) {
 			norm += vec->vec[x] * vec->vec[x];
 		}
-		norm = ( float ) sqrt( norm );
-
-		for( x = 0; x < vec->size; x++ ) {
+		norm = (float) sqrt(norm);
+		for(x = 0; x < vec->size; x++) {
 			vec->vec[x] /= norm;
 		}
-
-		if( ( ( strcmp( plane, "r" ) == 0 )
-		      || ( strcmp( plane, "R" ) == 0 ) ) && matSize == 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
-			mat[0] = 1 - ( vec->vec[0] * vec->vec[0] );
-			mat[1] = -( vec->vec[0] * vec->vec[1] );
-			mat[2] = -( vec->vec[0] * vec->vec[1] );
-			mat[3] = 1 - ( vec->vec[1] * vec->vec[1] );
-		} else if( ( ( strcmp( plane, "r" ) == 0 )
-			     || ( strcmp( plane, "R" ) == 0 ) )
-			   && matSize > 2 ) {
-			mat = PyMem_Malloc( matSize * matSize *
-					    sizeof( float ) );
-			mat[0] = 1 - ( vec->vec[0] * vec->vec[0] );
-			mat[1] = -( vec->vec[0] * vec->vec[1] );
-			mat[2] = -( vec->vec[0] * vec->vec[2] );
-			mat[3] = -( vec->vec[0] * vec->vec[1] );
-			mat[4] = 1 - ( vec->vec[1] * vec->vec[1] );
-			mat[5] = -( vec->vec[1] * vec->vec[2] );
-			mat[6] = -( vec->vec[0] * vec->vec[2] );
-			mat[7] = -( vec->vec[1] * vec->vec[2] );
-			mat[8] = 1 - ( vec->vec[2] * vec->vec[2] );
+		if(((strcmp(plane, "r") == 0)
+		      || (strcmp(plane, "R") == 0)) && matSize == 2) {
+			mat[0] = 1 - (vec->vec[0] * vec->vec[0]);
+			mat[1] = -(vec->vec[0] * vec->vec[1]);
+			mat[2] = -(vec->vec[0] * vec->vec[1]);
+			mat[3] = 1 - (vec->vec[1] * vec->vec[1]);
+		} else if(((strcmp(plane, "r") == 0)
+			     || (strcmp(plane, "R") == 0))
+			   && matSize > 2) {
+			mat[0] = 1 - (vec->vec[0] * vec->vec[0]);
+			mat[1] = -(vec->vec[0] * vec->vec[1]);
+			mat[2] = -(vec->vec[0] * vec->vec[2]);
+			mat[3] = -(vec->vec[0] * vec->vec[1]);
+			mat[4] = 1 - (vec->vec[1] * vec->vec[1]);
+			mat[5] = -(vec->vec[1] * vec->vec[2]);
+			mat[6] = -(vec->vec[0] * vec->vec[2]);
+			mat[7] = -(vec->vec[1] * vec->vec[2]);
+			mat[8] = 1 - (vec->vec[2] * vec->vec[2]);
 		} else {
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "unknown plane - expected: 'r' expected for axis designation\n" );
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"Mathutils.OrthoProjectionMatrix(): unknown plane - expected: 'r' expected for axis designation\n");
 		}
 	}
-
-	if( matSize == 4 ) {
+	if(matSize == 4) {
 		//resize matrix
-		mat[15] = 1.0f;
-		mat[14] = 0.0f;
-		mat[13] = 0.0f;
-		mat[12] = 0.0f;
-		mat[11] = 0.0f;
 		mat[10] = mat[8];
 		mat[9] = mat[7];
 		mat[8] = mat[6];
@@ -1139,95 +799,62 @@ static PyObject *M_Mathutils_OrthoProjectionMatrix( PyObject * self,
 		mat[3] = 0.0f;
 	}
 	//pass to matrix creation
-	retval =  newMatrixObject( mat, matSize, matSize );
-	
-	PyMem_Free( mat );
-	return retval;
+	return newMatrixObject(mat, matSize, matSize, Py_NEW);
 }
-
-//***************************************************************************
-// Function:      M_Mathutils_ShearMatrix  
-// Python equivalent:       Blender.Mathutils.ShearMatrix 
-//***************************************************************************
-static PyObject *M_Mathutils_ShearMatrix( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.ShearMatrix() -------------
+//creates a shear matrix
+PyObject *M_Mathutils_ShearMatrix(PyObject * self, PyObject * args)
 {
-	float factor;
 	int matSize;
 	char *plane;
-	float *mat;
-	PyObject *retval;
+	float factor;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
 
-	if( !PyArg_ParseTuple( args, "sfi", &plane, &factor, &matSize ) ) {
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected string float and int\n" ) );
+	if(!PyArg_ParseTuple(args, "sfi", &plane, &factor, &matSize)) {
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"Mathutils.ShearMatrix(): expected string float and int\n");
 	}
+	if(matSize != 2 && matSize != 3 && matSize != 4)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.ShearMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
 
-	if( matSize != 2 && matSize != 3 && matSize != 4 )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "can only return a 2x2 3x3 or 4x4 matrix\n" );
-
-	if( ( ( strcmp( plane, "x" ) == 0 ) || ( strcmp( plane, "X" ) == 0 ) )
-	    && matSize == 2 ) {
-		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+	if(((strcmp(plane, "x") == 0) || (strcmp(plane, "X") == 0))
+	    && matSize == 2) {
 		mat[0] = 1.0f;
-		mat[1] = 0.0f;
 		mat[2] = factor;
 		mat[3] = 1.0f;
-	} else if( ( ( strcmp( plane, "y" ) == 0 )
-		     || ( strcmp( plane, "Y" ) == 0 ) ) && matSize == 2 ) {
-		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+	} else if(((strcmp(plane, "y") == 0)
+		     || (strcmp(plane, "Y") == 0)) && matSize == 2) {
 		mat[0] = 1.0f;
 		mat[1] = factor;
-		mat[2] = 0.0f;
 		mat[3] = 1.0f;
-	} else if( ( ( strcmp( plane, "xy" ) == 0 )
-		     || ( strcmp( plane, "XY" ) == 0 ) ) && matSize > 2 ) {
-		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+	} else if(((strcmp(plane, "xy") == 0)
+		     || (strcmp(plane, "XY") == 0)) && matSize > 2) {
 		mat[0] = 1.0f;
-		mat[1] = 0.0f;
-		mat[2] = 0.0f;
-		mat[3] = 0.0f;
 		mat[4] = 1.0f;
-		mat[5] = 0.0f;
 		mat[6] = factor;
 		mat[7] = factor;
-		mat[8] = 0.0f;
-	} else if( ( ( strcmp( plane, "xz" ) == 0 )
-		     || ( strcmp( plane, "XZ" ) == 0 ) ) && matSize > 2 ) {
-		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+	} else if(((strcmp(plane, "xz") == 0)
+		     || (strcmp(plane, "XZ") == 0)) && matSize > 2) {
 		mat[0] = 1.0f;
-		mat[1] = 0.0f;
-		mat[2] = 0.0f;
 		mat[3] = factor;
 		mat[4] = 1.0f;
 		mat[5] = factor;
-		mat[6] = 0.0f;
-		mat[7] = 0.0f;
 		mat[8] = 1.0f;
-	} else if( ( ( strcmp( plane, "yz" ) == 0 )
-		     || ( strcmp( plane, "YZ" ) == 0 ) ) && matSize > 2 ) {
-		mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
+	} else if(((strcmp(plane, "yz") == 0)
+		     || (strcmp(plane, "YZ") == 0)) && matSize > 2) {
 		mat[0] = 1.0f;
 		mat[1] = factor;
 		mat[2] = factor;
-		mat[3] = 0.0f;
 		mat[4] = 1.0f;
-		mat[5] = 0.0f;
-		mat[6] = 0.0f;
-		mat[7] = 0.0f;
 		mat[8] = 1.0f;
 	} else {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n" );
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Mathutils.ShearMatrix(): expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n");
 	}
-
-	if( matSize == 4 ) {
+	if(matSize == 4) {
 		//resize matrix
-		mat[15] = 1.0f;
-		mat[14] = 0.0f;
-		mat[13] = 0.0f;
-		mat[12] = 0.0f;
-		mat[11] = 0.0f;
 		mat[10] = mat[8];
 		mat[9] = mat[7];
 		mat[8] = mat[6];
@@ -1238,388 +865,398 @@ static PyObject *M_Mathutils_ShearMatrix( PyObject * self, PyObject * args )
 		mat[3] = 0.0f;
 	}
 	//pass to matrix creation
-	retval = newMatrixObject( mat, matSize, matSize );
-
-	PyMem_Free( mat );
-	return retval;
+	return newMatrixObject(mat, matSize, matSize, Py_NEW);
 }
-
-//***************************************************************************
-//Begin Matrix Utils
-
-static PyObject *M_Mathutils_CopyMat( PyObject * self, PyObject * args )
+//----------------------------------QUATERNION FUNCTIONS-----------------
+//----------------------------------Mathutils.Quaternion() --------------
+PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args)
 {
-	MatrixObject *matrix;
-	float *mat;
-	int x, y, z;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple( args, "O!", &matrix_Type, &matrix ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected matrix\n" ) );
-
-	mat = PyMem_Malloc( matrix->rowSize * matrix->colSize *
-			    sizeof( float ) );
-
-	z = 0;
-	for( x = 0; x < matrix->rowSize; x++ ) {
-		for( y = 0; y < matrix->colSize; y++ ) {
-			mat[z] = matrix->matrix[x][y];
-			z++;
+	PyObject *listObject = NULL, *n, *q, *f;
+	int size, i;
+	float quat[4];
+	double norm = 0.0f, angle = 0.0f;
+
+	size = PySequence_Length(args);
+	if (size == 1 || size == 2) { //seq?
+		listObject = PySequence_GetItem(args, 0);
+		if (PySequence_Check(listObject)) {
+			size = PySequence_Length(listObject);
+			if ((size == 4 && PySequence_Length(args) !=1) || 
+				(size == 3 && PySequence_Length(args) !=2) || (size >4 || size < 3)) { 
+				// invalid args/size
+				Py_XDECREF(listObject);
+				return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+					"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+			}
+	   		if(size == 3){ //get angle in axis/angle
+				n = PyNumber_Float(PySequence_GetItem(args, 1));
+				if(n == NULL) { // parsed item not a number or getItem fail
+					Py_XDECREF(listObject);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+				}
+				angle = PyFloat_AS_DOUBLE(n);
+				Py_DECREF(n);
+			}
+		}else{
+			listObject = PySequence_GetItem(args, 1);
+			if (PySequence_Check(listObject)) {
+				size = PySequence_Length(listObject);
+				if (size != 3) { 
+					// invalid args/size
+					Py_XDECREF(listObject);
+					return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+						"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+				}
+				n = PyNumber_Float(PySequence_GetItem(args, 0));
+				if(n == NULL) { // parsed item not a number or getItem fail
+					Py_XDECREF(listObject);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+				}
+				angle = PyFloat_AS_DOUBLE(n);
+				Py_DECREF(n);
+			} else { // argument was not a sequence
+				Py_XDECREF(listObject);
+				return EXPP_ReturnPyObjError(PyExc_TypeError, 
+					"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+			}
 		}
+	} else if (size == 0) { //returns a new empty quat
+		return (PyObject *) newQuaternionObject(NULL, Py_NEW); 
+	} else {
+		listObject = EXPP_incr_ret(args);
 	}
 
-	retval =  ( PyObject * ) newMatrixObject( mat, matrix->rowSize,
-						  matrix->colSize );
-	PyMem_Free( mat );
-	return retval;
-}
-
-static PyObject *M_Mathutils_MatMultVec( PyObject * self, PyObject * args )
-{
-
-	PyObject *ob1 = NULL;
-	PyObject *ob2 = NULL;
-	MatrixObject *mat;
-	VectorObject *vec;
-	PyObject *retval;
-	float *vecNew;
-	int x, y;
-	int z = 0;
-	float dot = 0.0f;
-
-	//get pyObjects
-	if( !PyArg_ParseTuple
-	    ( args, "O!O!", &matrix_Type, &ob1, &vector_Type, &ob2 ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "matrix and vector object expected - in that order\n" ) );
-
-	mat = ( MatrixObject * ) ob1;
-	vec = ( VectorObject * ) ob2;
-
-	if( mat->rowSize != vec->size )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"matrix row size and vector size must be the same\n" ) );
-
-	vecNew = PyMem_Malloc( vec->size * sizeof( float ) );
-
-	for( x = 0; x < mat->rowSize; x++ ) {
-		for( y = 0; y < mat->colSize; y++ ) {
-			dot += mat->matrix[x][y] * vec->vec[y];
+	if (size == 3) { // invalid quat size
+		if(PySequence_Length(args) != 2){
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+				"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+		}
+	}else{
+		if(size != 4){
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+				"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
 		}
-		vecNew[z] = dot;
-		z++;
-		dot = 0;
 	}
-
-	retval =  ( PyObject * ) newVectorObject( vecNew, vec->size );
-
-	PyMem_Free( vecNew );
-	return retval;
-}
-
-//***************************************************************************
-// Function:     M_Mathutils_Quaternion   
-// Python equivalent:       Blender.Mathutils.Quaternion   
-//***************************************************************************
-static PyObject *M_Mathutils_Quaternion( PyObject * self, PyObject * args )
-{
-	PyObject *listObject;
-	float *vec = NULL;
-	float *quat = NULL;
-	float angle = 0.0f;
-	int x;
-	float norm;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple
-	    ( args, "O!|f", &PyList_Type, &listObject, &angle ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected list and optional float\n" ) );
-
-	if( PyList_Size( listObject ) != 4 && PyList_Size( listObject ) != 3 )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"3 or 4 expected floats for the quaternion\n" ) );
-
-	vec = PyMem_Malloc( PyList_Size( listObject ) * sizeof( float ) );
-	for( x = 0; x < PyList_Size( listObject ); x++ ) {
-		if( !PyArg_Parse
-		    ( PyList_GetItem( listObject, x ), "f", &vec[x] ) )
-			return EXPP_ReturnPyObjError( PyExc_TypeError,
-						      "python list not parseable\n" );
+	for (i=0; i<size; i++) { //parse
+		q = PySequence_GetItem(listObject, i);
+		if (q == NULL) { // Failed to read sequence
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_RuntimeError, 
+				"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+		}
+		f = PyNumber_Float(q);
+		if(f == NULL) { // parsed item not a number
+			Py_DECREF(q);
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_TypeError, 
+				"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
+		}
+		quat[i] = PyFloat_AS_DOUBLE(f);
+		EXPP_decr2(f, q);
 	}
-
-	if( PyList_Size( listObject ) == 3 ) {	//an axis of rotation
-		norm = ( float ) sqrt( vec[0] * vec[0] + vec[1] * vec[1] +
-				       vec[2] * vec[2] );
-
-		vec[0] /= norm;
-		vec[1] /= norm;
-		vec[2] /= norm;
-
-		angle = angle * ( float ) ( Py_PI / 180 );
-		quat = PyMem_Malloc( 4 * sizeof( float ) );
-		quat[0] = ( float ) ( cos( ( double ) ( angle ) / 2 ) );
-		quat[1] =
-			( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[0];
-		quat[2] =
-			( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[1];
-		quat[3] =
-			( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[2];
-
-		retval = newQuaternionObject( quat );
-	} else
-		retval = newQuaternionObject( vec );
-
-	/* freeing a NULL ptr is ok */
-	PyMem_Free( vec );
-	PyMem_Free( quat );
-	
-	return retval;
+	if(size == 3){ //calculate the quat based on axis/angle
+		norm = sqrt(quat[0] * quat[0] + quat[1] * quat[1] + quat[2] * quat[2]);
+		quat[0] /= norm;
+		quat[1] /= norm;
+		quat[2] /= norm;
+
+		angle = angle * (Py_PI / 180);
+		quat[3] =(float) (sin(angle/ 2.0f)) * quat[2];
+		quat[2] =(float) (sin(angle/ 2.0f)) * quat[1];
+		quat[1] =(float) (sin(angle/ 2.0f)) * quat[0];
+		quat[0] =(float) (cos(angle/ 2.0f));
+	}
+	Py_DECREF(listObject);
+	return (PyObject *) newQuaternionObject(quat, Py_NEW);
 }
-
-//***************************************************************************
-//Begin Quaternion Utils
-
-static PyObject *M_Mathutils_CopyQuat( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.CrossQuats() ----------------
+//quaternion multiplication - associate not commutative
+PyObject *M_Mathutils_CrossQuats(PyObject * self, PyObject * args)
 {
-	QuaternionObject *quatU;
-	float *quat = NULL;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple( args, "O!", &quaternion_Type, &quatU ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected Quaternion type" ) );
-
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	quat[0] = quatU->quat[0];
-	quat[1] = quatU->quat[1];
-	quat[2] = quatU->quat[2];
-	quat[3] = quatU->quat[3];
-
-	retval = ( PyObject * ) newQuaternionObject( quat );
-	PyMem_Free( quat );
-	return retval;
-}
+	QuaternionObject *quatU = NULL, *quatV = NULL;
+	float quat[4];
 
-static PyObject *M_Mathutils_CrossQuats( PyObject * self, PyObject * args )
-{
-	QuaternionObject *quatU;
-	QuaternionObject *quatV;
-	float *quat = NULL;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type, &quatU,
-			       &quaternion_Type, &quatV ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected Quaternion types" ) );
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	QuatMul( quat, quatU->quat, quatV->quat );
-
-	retval = ( PyObject * ) newQuaternionObject( quat );
-	PyMem_Free( quat );
-	return retval;
-}
+	if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU, 
+		&quaternion_Type, &quatV))
+		return EXPP_ReturnPyObjError(PyExc_TypeError,"Mathutils.CrossQuats(): expected Quaternion types");
+	QuatMul(quat, quatU->quat, quatV->quat);
 
-static PyObject *M_Mathutils_DotQuats( PyObject * self, PyObject * args )
+	return (PyObject*) newQuaternionObject(quat, Py_NEW);
+}
+//----------------------------------Mathutils.DotQuats() ----------------
+//returns the dot product of 2 quaternions
+PyObject *M_Mathutils_DotQuats(PyObject * self, PyObject * args)
 {
-	QuaternionObject *quatU;
-	QuaternionObject *quatV;
+	QuaternionObject *quatU = NULL, *quatV = NULL;
+	double dot = 0.0f;
 	int x;
-	float dot = 0.0f;
 
-	if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type, &quatU,
-			       &quaternion_Type, &quatV ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected Quaternion types" ) );
+	if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU, 
+		&quaternion_Type, &quatV))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.DotQuats(): expected Quaternion types");
 
-	for( x = 0; x < 4; x++ ) {
+	for(x = 0; x < 4; x++) {
 		dot += quatU->quat[x] * quatV->quat[x];
 	}
-
-	return PyFloat_FromDouble( ( double ) ( dot ) );
+	return PyFloat_FromDouble(dot);
 }
-
-static PyObject *M_Mathutils_DifferenceQuats( PyObject * self,
-					      PyObject * args )
+//----------------------------------Mathutils.DifferenceQuats() ---------
+//returns the difference between 2 quaternions
+PyObject *M_Mathutils_DifferenceQuats(PyObject * self, PyObject * args)
 {
-	QuaternionObject *quatU;
-	QuaternionObject *quatV;
-	float *quat = NULL;
-	float *tempQuat = NULL;
-	PyObject *retval;
+	QuaternionObject *quatU = NULL, *quatV = NULL;
+	float quat[4], tempQuat[4];
+	double dot = 0.0f;
 	int x;
-	float dot = 0.0f;
 
-	if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type,
-			       &quatU, &quaternion_Type, &quatV ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected Quaternion types" ) );
-
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	tempQuat = PyMem_Malloc( 4 * sizeof( float ) );
+	if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, 
+		&quatU, &quaternion_Type, &quatV))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.DifferenceQuats(): expected Quaternion types");
 
 	tempQuat[0] = quatU->quat[0];
 	tempQuat[1] = -quatU->quat[1];
 	tempQuat[2] = -quatU->quat[2];
 	tempQuat[3] = -quatU->quat[3];
 
-	dot = ( float ) sqrt( ( double ) tempQuat[0] * ( double ) tempQuat[0] +
-			      ( double ) tempQuat[1] * ( double ) tempQuat[1] +
-			      ( double ) tempQuat[2] * ( double ) tempQuat[2] +
-			      ( double ) tempQuat[3] *
-			      ( double ) tempQuat[3] );
+	dot = sqrt(tempQuat[0] * tempQuat[0] + tempQuat[1] *  tempQuat[1] +
+			       tempQuat[2] * tempQuat[2] + tempQuat[3] * tempQuat[3]);
 
-	for( x = 0; x < 4; x++ ) {
-		tempQuat[x] /= ( dot * dot );
+	for(x = 0; x < 4; x++) {
+		tempQuat[x] /= (dot * dot);
 	}
-	QuatMul( quat, tempQuat, quatV->quat );
-
-	retval = ( PyObject * ) newQuaternionObject( quat );
-
-	PyMem_Free( quat );
-	PyMem_Free( tempQuat );
-	return retval;
+	QuatMul(quat, tempQuat, quatV->quat);
+	return (PyObject *) newQuaternionObject(quat, Py_NEW);
 }
-
-static PyObject *M_Mathutils_Slerp( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.Slerp() ------------------
+//attemps to interpolate 2 quaternions and return the result
+PyObject *M_Mathutils_Slerp(PyObject * self, PyObject * args)
 {
-	QuaternionObject *quatU;
-	QuaternionObject *quatV;
-	float *quat = NULL;
-	PyObject *retval;
-	float param, x, y, cosD, sinD, deltaD, IsinD, val;
-	int flag, z;
-
-	if( !PyArg_ParseTuple( args, "O!O!f", &quaternion_Type,
-			       &quatU, &quaternion_Type, &quatV, &param ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected Quaternion types and float" ) );
-
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-
-	cosD = quatU->quat[0] * quatV->quat[0] +
-		quatU->quat[1] * quatV->quat[1] +
-		quatU->quat[2] * quatV->quat[2] +
-		quatU->quat[3] * quatV->quat[3];
-
-	flag = 0;
-	if( cosD < 0.0f ) {
-		flag = 1;
-		cosD = -cosD;
+	QuaternionObject *quatU = NULL, *quatV = NULL;
+	float quat[4], quat_u[4], quat_v[4], param;
+	double x, y, dot, sinT, angle, IsinT;
+	int z;
+
+	if(!PyArg_ParseTuple(args, "O!O!f", &quaternion_Type, 
+		&quatU, &quaternion_Type, &quatV, &param))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.Slerp(): expected Quaternion types and float");
+
+	if(param > 1.0f || param < 0.0f)
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+					"Mathutils.Slerp(): interpolation factor must be between 0.0 and 1.0");
+
+	//copy quats
+	for(z = 0; z < 4; z++){
+		quat_u[z] = quatU->quat[z];
+		quat_v[z] = quatV->quat[z];
 	}
-	if( cosD > .99999f ) {
+
+	//dot product
+	dot = quat_u[0] * quat_v[0] + quat_u[1] * quat_v[1] +
+		quat_u[2] * quat_v[2] + quat_u[3] * quat_v[3];
+
+	//if negative negate a quat (shortest arc)
+	if(dot < 0.0f) {
+		quat_v[0] = -quat_v[0];
+		quat_v[1] = -quat_v[1];
+		quat_v[2] = -quat_v[2];
+		quat_v[3] = -quat_v[3];
+		dot = -dot;
+	}
+	if(dot > .99999f) { //very close
 		x = 1.0f - param;
 		y = param;
 	} else {
-		sinD = ( float ) sqrt( 1.0f - cosD * cosD );
-		deltaD = ( float ) atan2( sinD, cosD );
-		IsinD = 1.0f / sinD;
-		x = ( float ) sin( ( 1.0f - param ) * deltaD ) * IsinD;
-		y = ( float ) sin( param * deltaD ) * IsinD;
-	}
-	for( z = 0; z < 4; z++ ) {
-		val = quatV->quat[z];
-		if( val )
-			val = -val;
-		quat[z] = ( quatU->quat[z] * x ) + ( val * y );
+		//calculate sin of angle
+		sinT = sqrt(1.0f - (dot * dot));
+		//calculate angle
+		angle = atan2(sinT, dot);
+		//caluculate inverse of sin(theta)
+		IsinT = 1.0f / sinT;
+		x = sin((1.0f - param) * angle) * IsinT;
+		y = sin(param * angle) * IsinT;
 	}
-	retval = ( PyObject * ) newQuaternionObject( quat );
-	PyMem_Free( quat );
-	return retval;
-}
+	//interpolate
+	quat[0] = quat_u[0] * x + quat_v[0] * y;
+	quat[1] = quat_u[1] * x + quat_v[1] * y;
+	quat[2] = quat_u[2] * x + quat_v[2] * y;
+	quat[3] = quat_u[3] * x + quat_v[3] * y;
 
-//***************************************************************************
-// Function:     M_Mathutils_Euler        
-// Python equivalent:      Blender.Mathutils.Euler    
-//***************************************************************************
-static PyObject *M_Mathutils_Euler( PyObject * self, PyObject * args )
+	return (PyObject *) newQuaternionObject(quat, Py_NEW);
+}
+//----------------------------------EULER FUNCTIONS----------------------
+//----------------------------------Mathutils.Euler() -------------------
+//makes a new euler for you to play with
+PyObject *M_Mathutils_Euler(PyObject * self, PyObject * args)
 {
-	PyObject *listObject;
-	float *vec = NULL;
-	PyObject *retval;
-	int x;
-
-	if( !PyArg_ParseTuple( args, "O!", &PyList_Type, &listObject ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected list\n" ) );
 
-	if( PyList_Size( listObject ) != 3 )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "only 3d eulers are supported\n" );
+	PyObject *listObject = NULL;
+	int size, i;
+	float eul[3];
 
-	vec = PyMem_Malloc( 3 * sizeof( float ) );
-	for( x = 0; x < 3; x++ ) {
-		if( !PyArg_Parse
-		    ( PyList_GetItem( listObject, x ), "f", &vec[x] ) )
-			return EXPP_ReturnPyObjError( PyExc_TypeError,
-						      "python list not parseable\n" );
+	size = PySequence_Length(args);
+	if (size == 1) {
+		listObject = PySequence_GetItem(args, 0);
+		if (PySequence_Check(listObject)) {
+			size = PySequence_Length(listObject);
+		} else { // Single argument was not a sequence
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_TypeError, 
+				"Mathutils.Euler(): 3d numeric sequence expected\n");
+		}
+	} else if (size == 0) {
+		//returns a new empty 3d euler
+		return (PyObject *) newEulerObject(NULL, Py_NEW); 
+	} else {
+		listObject = EXPP_incr_ret(args);
 	}
+	if (size != 3) { // Invalid euler size
+		Py_XDECREF(listObject);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError, 
+			"Mathutils.Euler(): 3d numeric sequence expected\n");
+	}
+	for (i=0; i<size; i++) {
+		PyObject *e, *f;
 
-	retval = ( PyObject * ) newEulerObject( vec );
-
-	PyMem_Free( vec );
-	return retval;
+		e = PySequence_GetItem(listObject, i);
+		if (e == NULL) { // Failed to read sequence
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_RuntimeError, 
+				"Mathutils.Euler(): 3d numeric sequence expected\n");
+		}
+		f = PyNumber_Float(e);
+		if(f == NULL) { // parsed item not a number
+			Py_DECREF(e);
+			Py_XDECREF(listObject);
+			return EXPP_ReturnPyObjError(PyExc_TypeError, 
+				"Mathutils.Euler(): 3d numeric sequence expected\n");
+		}
+		eul[i]=PyFloat_AS_DOUBLE(f);
+		EXPP_decr2(f,e);
+	}
+	Py_DECREF(listObject);
+	return (PyObject *) newEulerObject(eul, Py_NEW);
 }
-
-
-//***************************************************************************
-//Begin Euler Util
-
-static PyObject *M_Mathutils_CopyEuler( PyObject * self, PyObject * args )
+//#############################DEPRECATED################################
+//#######################################################################
+//----------------------------------Mathutils.CopyMat() -----------------
+//copies a matrix into a new matrix
+PyObject *M_Mathutils_CopyMat(PyObject * self, PyObject * args)
 {
-	EulerObject *eulU;
-	float *eul = NULL;
-	PyObject *retval;
-
-	if( !PyArg_ParseTuple( args, "O!", &euler_Type, &eulU ) )
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"expected Euler types" ) );
-
-	eul = PyMem_Malloc( 3 * sizeof( float ) );
-	eul[0] = eulU->eul[0];
-	eul[1] = eulU->eul[1];
-	eul[2] = eulU->eul[2];
-
-	retval = ( PyObject * ) newEulerObject( eul );
-	PyMem_Free( eul );
-	return retval;
+	PyObject *matrix = NULL;
+
+	printf("Mathutils.CopyMat(): Deprecated :use Mathutils.Matrix() to copy matrices\n");
+	matrix = M_Mathutils_Matrix(self, args);
+	if(matrix == NULL)
+		return NULL; //error string already set if we get here
+	else
+		return matrix;
 }
-
-static PyObject *M_Mathutils_RotateEuler( PyObject * self, PyObject * args )
+//----------------------------------Mathutils.CopyVec() -----------------
+//makes a new vector that is a copy of the input
+PyObject *M_Mathutils_CopyVec(PyObject * self, PyObject * args)
+{
+	PyObject *vec = NULL;
+
+	printf("Mathutils.CopyVec(): Deprecated: use Mathutils.Vector() to copy vectors\n");
+	vec = M_Mathutils_Vector(self, args);
+	if(vec == NULL)
+		return NULL; //error string already set if we get here
+	else
+		return vec;
+}
+//----------------------------------Mathutils.CopyQuat() --------------
+//Copies a quaternion to a new quat
+PyObject *M_Mathutils_CopyQuat(PyObject * self, PyObject * args)
+{
+	PyObject *quat = NULL;
+
+	printf("Mathutils.CopyQuat(): Deprecated:use Mathutils.Quaternion() to copy vectors\n");
+	quat = M_Mathutils_Quaternion(self, args);
+	if(quat == NULL)
+		return NULL; //error string already set if we get here
+	else
+		return quat;
+}
+//----------------------------------Mathutils.CopyEuler() ---------------
+//copies a euler to a new euler
+PyObject *M_Mathutils_CopyEuler(PyObject * self, PyObject * args)
 {
-	EulerObject *Eul;
+	PyObject *eul = NULL;
+
+	printf("Mathutils.CopyEuler(): Deprecated:use Mathutils.Euler() to copy vectors\n");
+	eul = M_Mathutils_Euler(self, args);
+	if(eul == NULL)
+		return NULL; //error string already set if we get here
+	else
+		return eul;
+}
+//----------------------------------Mathutils.RotateEuler() ------------
+//rotates a euler a certain amount and returns the result
+//should return a unique euler rotation (i.e. no 720 degree pitches :)
+PyObject *M_Mathutils_RotateEuler(PyObject * self, PyObject * args)
+{
+	EulerObject *Eul = NULL;
 	float angle;
 	char *axis;
-	int x;
 
-	if( !PyArg_ParseTuple
-	    ( args, "O!fs", &euler_Type, &Eul, &angle, &axis ) )
-		return ( EXPP_ReturnPyObjError
-			 ( PyExc_TypeError,
-			   "expected euler type & float & string" ) );
+	if(!PyArg_ParseTuple(args, "O!fs", &euler_Type, &Eul, &angle, &axis))
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			   "Mathutils.RotateEuler(): expected euler type & float & string");
 
-	angle *= ( float ) ( Py_PI / 180 );
-	for( x = 0; x < 3; x++ ) {
-		Eul->eul[x] *= ( float ) ( Py_PI / 180 );
-	}
-	euler_rot( Eul->eul, angle, *axis );
-	for( x = 0; x < 3; x++ ) {
-		Eul->eul[x] *= ( float ) ( 180 / Py_PI );
+	printf("Mathutils.RotateEuler(): Deprecated:use Euler.rotate() to rotate a euler\n");
+	Euler_Rotate(Eul, Py_BuildValue("fs", angle, axis));
+	return EXPP_incr_ret(Py_None);
+}
+//----------------------------------Mathutils.MatMultVec() --------------
+//COLUMN VECTOR Multiplication (Matrix X Vector)
+PyObject *M_Mathutils_MatMultVec(PyObject * self, PyObject * args)
+{
+	MatrixObject *mat = NULL;
+	VectorObject *vec = NULL;
+	PyObject *retObj = NULL;
+
+	//get pyObjects
+	if(!PyArg_ParseTuple(args, "O!O!", &matrix_Type, &mat, &vector_Type, &vec))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.MatMultVec(): MatMultVec() expects a matrix and a vector object - in that order\n");
+
+	printf("Mathutils.MatMultVec(): Deprecated: use matrix * vec to perform column vector multiplication\n");
+	EXPP_incr2((PyObject*)vec, (PyObject*)mat);
+	retObj = column_vector_multiplication(mat, vec);
+	if(!retObj){
+		return NULL;
 	}
 
-	return EXPP_incr_ret( Py_None );
+	EXPP_decr2((PyObject*)vec, (PyObject*)mat);
+	return retObj;
 }
-
-//***************************************************************************
-// Function:      Mathutils_Init     
-//***************************************************************************
-PyObject *Mathutils_Init( void )
+//----------------------------------Mathutils.VecMultMat() ---------------
+//ROW VECTOR Multiplication - Vector X Matrix
+PyObject *M_Mathutils_VecMultMat(PyObject * self, PyObject * args)
 {
-	PyObject *mod =
-		Py_InitModule3( "Blender.Mathutils", M_Mathutils_methods,
-				M_Mathutils_doc );
-	return ( mod );
+	MatrixObject *mat = NULL;
+	VectorObject *vec = NULL;
+	PyObject *retObj = NULL;
+
+	//get pyObjects
+	if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec, &matrix_Type, &mat))
+		return EXPP_ReturnPyObjError(PyExc_TypeError, 
+			"Mathutils.VecMultMat(): VecMultMat() expects a vector and matrix object - in that order\n");
+
+	printf("Mathutils.VecMultMat(): Deprecated: use vec * matrix to perform row vector multiplication\n");
+	EXPP_incr2((PyObject*)vec, (PyObject*)mat);
+	retObj = row_vector_multiplication(vec, mat);
+	if(!retObj){
+		return NULL;
+	}
+
+	EXPP_decr2((PyObject*)vec, (PyObject*)mat);
+	return retObj;
 }
+//#######################################################################
+//#############################DEPRECATED################################
diff --git a/source/blender/python/api2_2x/Mathutils.h b/source/blender/python/api2_2x/Mathutils.h
index 7d34187656e..1365693e691 100644
--- a/source/blender/python/api2_2x/Mathutils.h
+++ b/source/blender/python/api2_2x/Mathutils.h
@@ -29,14 +29,48 @@
  *
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */
+//Include this file for access to vector, quat, matrix, euler, etc...
 
 #ifndef EXPP_Mathutils_H
 #define EXPP_Mathutils_H
 
-
-
+#include <Python.h>
+#include "vector.h"
+#include "matrix.h"
+#include "quat.h"
+#include "euler.h"
 #include "Types.h"
 
 PyObject *Mathutils_Init( void );
+PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat);
+PyObject *column_vector_multiplication(MatrixObject * mat, VectorObject* vec);
+
+PyObject *M_Mathutils_Rand(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_Vector(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_CrossVecs(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_DotVecs(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_AngleBetweenVecs(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_MidpointVecs(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_ProjectVecs(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_RotationMatrix(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_TranslationMatrix(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_ScaleMatrix(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_ShearMatrix(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_CrossQuats(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_DotQuats(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_DifferenceQuats(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_Slerp(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_Euler(PyObject * self, PyObject * args);
+//DEPRECATED	
+PyObject *M_Mathutils_CopyMat(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_CopyVec(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_CopyQuat(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_CopyEuler(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_RotateEuler(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_MatMultVec(PyObject * self, PyObject * args);
+PyObject *M_Mathutils_VecMultMat(PyObject * self, PyObject * args);
 
 #endif				/* EXPP_Mathutils_H */
diff --git a/source/blender/python/api2_2x/NMesh.c b/source/blender/python/api2_2x/NMesh.c
index 61e4a6f513c..2d2d9cc039c 100644
--- a/source/blender/python/api2_2x/NMesh.c
+++ b/source/blender/python/api2_2x/NMesh.c
@@ -58,12 +58,12 @@
 #include "BLI_blenlib.h"
 #include "BLI_arithb.h"
 #include "MEM_guardedalloc.h"
-
+#include "BKE_utildefines.h"
 #include "blendef.h"
 #include "mydevice.h"
 
 #include "Object.h"
-#include "vector.h"
+#include "Mathutils.h"
 #include "constant.h"
 #include "gen_utils.h"
 
@@ -759,12 +759,12 @@ static PyObject *NMVert_getattr( PyObject * self, char *name )
 	BPy_NMVert *mv = ( BPy_NMVert * ) self;
 
 	if( !strcmp( name, "co" ) || !strcmp( name, "loc" ) )
-		return newVectorProxy( mv->co, 3 );
+		return newVectorObject(mv->co,3,Py_WRAP);
 
 	else if( strcmp( name, "no" ) == 0 )
-		return newVectorProxy( mv->no, 3 );
+		return newVectorObject(mv->no,3,Py_WRAP);
 	else if( strcmp( name, "uvco" ) == 0 )
-		return newVectorProxy( mv->uvco, 3 );
+		return newVectorObject(mv->uvco,3,Py_WRAP);
 	else if( strcmp( name, "index" ) == 0 )
 		return PyInt_FromLong( mv->index );
 	else if( strcmp( name, "sel" ) == 0 )
diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c
index 67a94a8b4fd..55ab29d8cac 100644
--- a/source/blender/python/api2_2x/Object.c
+++ b/source/blender/python/api2_2x/Object.c
@@ -38,28 +38,28 @@
 #include "Object.h"
 #include "NLA.h"
 #include "logic.h"
-#include <blendef.h>
+#include "blendef.h"
 
-#include <DNA_scene_types.h>
-#include <DNA_mesh_types.h>
-#include <DNA_curve_types.h>
+#include "DNA_scene_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_curve_types.h"
 #include "DNA_object_force.h"
-#include <DNA_property_types.h>
+#include "DNA_property_types.h"
 
-#include <BKE_depsgraph.h>
-#include <BKE_font.h>
-#include <BKE_property.h>
-#include <BKE_mball.h>
-#include <BKE_softbody.h>
+#include "BKE_depsgraph.h"
+#include "BKE_font.h"
+#include "BKE_property.h"
+#include "BKE_mball.h"
+#include "BKE_softbody.h"
 
-#include <BIF_editview.h>
-#include <BSE_editipo.h>
-#include <BSE_edit.h>
+#include "BIF_editview.h"
+#include "BSE_editipo.h"
+#include "BSE_edit.h"
 
 #include "Ipo.h"
 #include "Lattice.h"
 #include "modules.h"
-
+#include "Mathutils.h"
 #include "constant.h"
 /* only used for oops location get/set at the moment */
 #include "DNA_oops_types.h" 
@@ -1109,21 +1109,20 @@ static PyObject *Object_getDrawType( BPy_Object * self )
 
 static PyObject *Object_getEuler( BPy_Object * self )
 {
-	EulerObject *eul;
+	float eul[3];
 
-	eul = ( EulerObject * ) newEulerObject( NULL );
-	eul->eul[0] = self->object->rot[0];
-	eul->eul[1] = self->object->rot[1];
-	eul->eul[2] = self->object->rot[2];
+	eul[0] = self->object->rot[0];
+	eul[1] = self->object->rot[1];
+	eul[2] = self->object->rot[2];
 
-	return ( PyObject * ) eul;
+	return ( PyObject * ) newEulerObject( eul, Py_WRAP );
 
 }
 
 static PyObject *Object_getInverseMatrix( BPy_Object * self )
 {
 	MatrixObject *inverse =
-		( MatrixObject * ) newMatrixObject( NULL, 4, 4 );
+		( MatrixObject * ) newMatrixObject( NULL, 4, 4, Py_NEW);
 	Mat4Invert( (float ( * )[4])*inverse->matrix, self->object->obmat );
 
 	return ( ( PyObject * ) inverse );
@@ -1170,35 +1169,30 @@ static PyObject *Object_getMaterials( BPy_Object * self, PyObject * args )
 
 static PyObject *Object_getMatrix( BPy_Object * self, PyObject * args )
 {
-	PyObject *matrix;
+	float matrix[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+  	                 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
 	char *space = "worldspace";	/* default to world */
 
 	if( !PyArg_ParseTuple( args, "|s", &space ) ) {
 		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
 						"expected a string or nothing" ) );
 	}
-	//new matrix
-	matrix = newMatrixObject( NULL, 4, 4 );
 
 	if( BLI_streq( space, "worldspace" ) ) {	/* Worldspace matrix */
 		disable_where_script( 1 );
 		where_is_object( self->object );
 		disable_where_script( 0 );
-		Mat4CpyMat4((float ( * )[4]) *( ( MatrixObject * ) matrix )->matrix,
-			     self->object->obmat );
 	} else if( BLI_streq( space, "localspace" ) ) {	/* Localspace matrix */
-		object_to_mat4( self->object,
-				( float ( * )[4] ) *( ( MatrixObject * ) matrix )->matrix );
-		/* old behavior, prior to 2.34, check this method's doc string: */
+		object_to_mat4( self->object, (float (*)[4])matrix );
+		return newMatrixObject(matrix,4,4,Py_NEW);
 	} else if( BLI_streq( space, "old_worldspace" ) ) {
-		Mat4CpyMat4( (float ( * )[4]) *( ( MatrixObject * ) matrix )->matrix,
-			     self->object->obmat );
+		/* old behavior, prior to 2.34, check this method's doc string: */
 	} else {
 		return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
 				"wrong parameter, expected nothing or either 'worldspace' (default),\n\
 'localspace' or 'old_worldspace'" ) );
 	}
-	return matrix;
+	return newMatrixObject((float*)self->object->obmat,4,4,Py_WRAP);
 }
 
 static PyObject *Object_getName( BPy_Object * self )
@@ -1378,7 +1372,7 @@ static PyObject *Object_getBoundBox( BPy_Object * self )
 				   does not have its own memory,
 				   we must create vectors that allocate space */
 
-				vector = newVectorObject( NULL, 3 );
+				vector = newVectorObject( NULL, 3, Py_NEW);
 				memcpy( ( ( VectorObject * ) vector )->vec,
 					tmpvec, 3 * sizeof( float ) );
 				PyList_SET_ITEM( bbox, i, vector );
@@ -1399,7 +1393,7 @@ static PyObject *Object_getBoundBox( BPy_Object * self )
 
 		/* create vectors referencing object bounding box coords */
 		for( i = 0; i < 8; i++ ) {
-			vector = newVectorObject( vec, 3 );
+			vector = newVectorObject( vec, 3, Py_WRAP );
 			PyList_SET_ITEM( bbox, i, vector );
 			vec += 3;
 		}
diff --git a/source/blender/python/api2_2x/Object.h b/source/blender/python/api2_2x/Object.h
index 0c629f325ce..52bdbd27bf2 100644
--- a/source/blender/python/api2_2x/Object.h
+++ b/source/blender/python/api2_2x/Object.h
@@ -35,34 +35,31 @@
 
 #include <Python.h>
 #include <stdio.h>
-#include <BDR_editobject.h>
-#include <BKE_armature.h>
-#include <BKE_curve.h>
-#include <BKE_global.h>
-#include <BKE_library.h>
-#include <BKE_lattice.h>
-#include <BKE_main.h>
-#include <BKE_mesh.h>
-#include <BKE_object.h>
-#include <BKE_scene.h>
-#include <BKE_displist.h>	/* for makeDispList */
-#include <BKE_font.h>		/* for text_to_font */
-#include <BLI_arithb.h>
-#include <BLI_blenlib.h>
-#include <DNA_armature_types.h>
-#include <DNA_action_types.h>
-#include <DNA_ID.h>
-#include <DNA_listBase.h>
-#include <DNA_scene_types.h>
-#include <DNA_userdef_types.h>
-#include <DNA_view3d_types.h>
-#include <DNA_action_types.h>
+#include "BDR_editobject.h"
+#include "BKE_armature.h"
+#include "BKE_curve.h"
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_lattice.h"
+#include "BKE_main.h"
+#include "BKE_mesh.h"
+#include "BKE_object.h"
+#include "BKE_scene.h"
+#include "BKE_displist.h"	/* for makeDispList */
+#include "BKE_font.h"		/* for text_to_font */
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+#include "DNA_armature_types.h"
+#include "DNA_action_types.h"
+#include "DNA_ID.h"
+#include "DNA_listBase.h"
+#include "DNA_scene_types.h"
+#include "DNA_userdef_types.h"
+#include "DNA_view3d_types.h"
+#include "DNA_action_types.h"
 
 #include "gen_utils.h"
-#include "vector.h"
-#include "matrix.h"
-#include "euler.h"
-#include "quat.h"
+
 
 /* The Object PyType Object defined in Object.c */
 extern PyTypeObject Object_Type;
diff --git a/source/blender/python/api2_2x/Window.c b/source/blender/python/api2_2x/Window.c
index 236275742be..96e33245bf0 100644
--- a/source/blender/python/api2_2x/Window.c
+++ b/source/blender/python/api2_2x/Window.c
@@ -34,29 +34,29 @@
 #include <Python.h>
 #include <stdio.h>
 
-#include <blendef.h>		/* OBACT */
-#include <BDR_editobject.h>	/* enter / leave editmode */
-#include <BKE_global.h>
-#include <BKE_library.h>
-#include <BKE_object.h>		/* for during_script() and during_scriptlink() */
-#include <BKE_scene.h>		/* scene_find_camera() */
-#include <BIF_usiblender.h>
-#include <BIF_mywindow.h>
-#include <BSE_headerbuttons.h>
-#include <BSE_filesel.h>
-#include <BIF_editmesh.h>	/* for undo_push_mesh() */
-#include <BIF_screen.h>
-#include <BIF_space.h>
-#include <BIF_drawtext.h>
-#include <BIF_mywindow.h> /* L/M/R_MOUSE bitflags */
-#include <BIF_spacetypes.h>
-#include <mydevice.h>
-#include <DNA_view3d_types.h>
-#include <DNA_screen_types.h>
-#include <DNA_space_types.h>
-#include <DNA_scene_types.h>
-#include <DNA_text_types.h>
-#include <DNA_vec_types.h>	/* for rcti struct */
+#include "blendef.h"		/* OBACT */
+#include "BDR_editobject.h"	/* enter / leave editmode */
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_object.h"		/* for during_script() and during_scriptlink() */
+#include "BKE_scene.h"		/* scene_find_camera() */
+#include "BIF_usiblender.h"
+#include "BIF_mywindow.h"
+#include "BSE_headerbuttons.h"
+#include "BSE_filesel.h"
+#include "BIF_editmesh.h"	/* for undo_push_mesh() */
+#include "BIF_screen.h"
+#include "BIF_space.h"
+#include "BIF_drawtext.h"
+#include "BIF_mywindow.h" /* L/M/R_MOUSE bitflags */
+#include "BIF_spacetypes.h"
+#include "mydevice.h"
+#include "DNA_view3d_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_text_types.h"
+#include "DNA_vec_types.h"	/* for rcti struct */
 
 #include "windowTheme.h"
 #include "gen_utils.h"
@@ -856,7 +856,7 @@ static PyObject *M_Window_GetViewMatrix( PyObject * self )
 
 	viewmat =
 		( PyObject * ) newMatrixObject( ( float * ) G.vd->viewmat, 4,
-						4 );
+						4, Py_WRAP );
 
 	if( !viewmat )
 		return EXPP_ReturnPyObjError( PyExc_MemoryError,
@@ -880,7 +880,7 @@ static PyObject *M_Window_GetPerspMatrix( PyObject * self )
 
 	perspmat =
 		( PyObject * ) newMatrixObject( ( float * ) G.vd->persmat, 4,
-						4 );
+						4, Py_WRAP );
 
 	if( !perspmat )
 		return EXPP_ReturnPyObjError( PyExc_MemoryError,
diff --git a/source/blender/python/api2_2x/euler.c b/source/blender/python/api2_2x/euler.c
index 6b72460ccd4..d5b7b61c8a7 100644
--- a/source/blender/python/api2_2x/euler.c
+++ b/source/blender/python/api2_2x/euler.c
@@ -29,329 +29,384 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
-#include "euler.h"
+#include "BLI_arithb.h"
+#include "BKE_utildefines.h"
+#include "Mathutils.h"
+#include "gen_utils.h"
+#include "BLI_blenlib.h"
 
-//doc strings
+//-------------------------DOC STRINGS ---------------------------
 char Euler_Zero_doc[] = "() - set all values in the euler to 0";
-char Euler_Unique_doc[] =
-	"() - sets the euler rotation a unique shortest arc rotation - tests for gimbal lock";
-char Euler_ToMatrix_doc[] =
-	"() - returns a rotation matrix representing the euler rotation";
-char Euler_ToQuat_doc[] =
-	"() - returns a quaternion representing the euler rotation";
-
-//methods table
+char Euler_Unique_doc[] ="() - sets the euler rotation a unique shortest arc rotation - tests for gimbal lock";
+char Euler_ToMatrix_doc[] =	"() - returns a rotation matrix representing the euler rotation";
+char Euler_ToQuat_doc[] = "() - returns a quaternion representing the euler rotation";
+char Euler_Rotate_doc[] = "() - rotate a euler by certain amount around an axis of rotation";
+//-----------------------METHOD DEFINITIONS ----------------------
 struct PyMethodDef Euler_methods[] = {
-	{"zero", ( PyCFunction ) Euler_Zero, METH_NOARGS,
-	 Euler_Zero_doc},
-	{"unique", ( PyCFunction ) Euler_Unique, METH_NOARGS,
-	 Euler_Unique_doc},
-	{"toMatrix", ( PyCFunction ) Euler_ToMatrix, METH_NOARGS,
-	 Euler_ToMatrix_doc},
-	{"toQuat", ( PyCFunction ) Euler_ToQuat, METH_NOARGS,
-	 Euler_ToQuat_doc},
+	{"zero", (PyCFunction) Euler_Zero, METH_NOARGS, Euler_Zero_doc},
+	{"unique", (PyCFunction) Euler_Unique, METH_NOARGS, Euler_Unique_doc},
+	{"toMatrix", (PyCFunction) Euler_ToMatrix, METH_NOARGS, Euler_ToMatrix_doc},
+	{"toQuat", (PyCFunction) Euler_ToQuat, METH_NOARGS, Euler_ToQuat_doc},
+	{"rotate", (PyCFunction) Euler_Rotate, METH_VARARGS, Euler_Rotate_doc},
 	{NULL, NULL, 0, NULL}
 };
-
-/*****************************/
-//    Euler Python Object   
-/*****************************/
-
-//euler methods
-PyObject *Euler_ToQuat( EulerObject * self )
+//-----------------------------METHODS----------------------------
+//----------------------------Euler.toQuat()----------------------
+//return a quaternion representation of the euler
+PyObject *Euler_ToQuat(EulerObject * self)
 {
-	float *quat;
+	float eul[3];
+	float quat[4];
 	int x;
 
-	for( x = 0; x < 3; x++ ) {
-		self->eul[x] *= ( float ) ( Py_PI / 180 );
+	for(x = 0; x < 3; x++) {
+		eul[x] = self->eul[x] * ((float)Py_PI / 180);
 	}
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	EulToQuat( self->eul, quat );
-	for( x = 0; x < 3; x++ ) {
-		self->eul[x] *= ( float ) ( 180 / Py_PI );
-	}
-	return ( PyObject * ) newQuaternionObject( quat );
+	EulToQuat(eul, quat);
+	if(self->data.blend_data)
+		return (PyObject *) newQuaternionObject(quat, Py_WRAP);
+	else
+		return (PyObject *) newQuaternionObject(quat, Py_NEW);
 }
-
-PyObject *Euler_ToMatrix( EulerObject * self )
+//----------------------------Euler.toMatrix()---------------------
+//return a matrix representation of the euler
+PyObject *Euler_ToMatrix(EulerObject * self)
 {
-	float *mat;
+	float eul[3];
+	float mat[9] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
 	int x;
 
-	for( x = 0; x < 3; x++ ) {
-		self->eul[x] *= ( float ) ( Py_PI / 180 );
+	for(x = 0; x < 3; x++) {
+		eul[x] = self->eul[x] * ((float)Py_PI / 180);
 	}
-	mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
-	EulToMat3( self->eul, ( float ( * )[3] ) mat );
-	for( x = 0; x < 3; x++ ) {
-		self->eul[x] *= ( float ) ( 180 / Py_PI );
-	}
-	return ( PyObject * ) newMatrixObject( mat, 3, 3 );
+	EulToMat3(eul, (float (*)[3]) mat);
+	if(self->data.blend_data)
+		return (PyObject *) newMatrixObject(mat, 3, 3 , Py_WRAP);
+	else	
+		return (PyObject *) newMatrixObject(mat, 3, 3 , Py_NEW);
 }
-
-PyObject *Euler_Unique( EulerObject * self )
+//----------------------------Euler.unique()-----------------------
+//sets the x,y,z values to a unique euler rotation
+PyObject *Euler_Unique(EulerObject * self)
 {
-	float heading, pitch, bank;
-	float pi2 = ( float ) Py_PI * 2.0f;
-	float piO2 = ( float ) Py_PI / 2.0f;
-	float Opi2 = 1.0f / pi2;
+	double heading, pitch, bank;
+	double pi2 =  Py_PI * 2.0f;
+	double piO2 = Py_PI / 2.0f;
+	double Opi2 = 1.0f / pi2;
 
 	//radians
-	heading = self->eul[0] * ( float ) ( Py_PI / 180 );
-	pitch = self->eul[1] * ( float ) ( Py_PI / 180 );
-	bank = self->eul[2] * ( float ) ( Py_PI / 180 );
+	heading = self->eul[0] * (float)Py_PI / 180;
+	pitch = self->eul[1] * (float)Py_PI / 180;
+	bank = self->eul[2] * (float)Py_PI / 180;
 
 	//wrap heading in +180 / -180
-	pitch += ( float ) Py_PI;
-	pitch -= ( float ) floor( pitch * Opi2 ) * pi2;
-	pitch -= ( float ) Py_PI;
-
-
-	if( pitch < -piO2 ) {
-		pitch = ( float ) -Py_PI - pitch;
-		heading += ( float ) Py_PI;
-		bank += ( float ) Py_PI;
-	} else if( pitch > piO2 ) {
-		pitch = ( float ) Py_PI - pitch;
-		heading += ( float ) Py_PI;
-		bank += ( float ) Py_PI;
+	pitch += Py_PI;
+	pitch -= floor(pitch * Opi2) * pi2;
+	pitch -= Py_PI;
+
+
+	if(pitch < -piO2) {
+		pitch = -Py_PI - pitch;
+		heading += Py_PI;
+		bank += Py_PI;
+	} else if(pitch > piO2) {
+		pitch = Py_PI - pitch;
+		heading += Py_PI;
+		bank += Py_PI;
 	}
 	//gimbal lock test
-	if( fabs( pitch ) > piO2 - 1e-4 ) {
+	if(fabs(pitch) > piO2 - 1e-4) {
 		heading += bank;
 		bank = 0.0f;
 	} else {
-		bank += ( float ) Py_PI;
-		bank -= ( float ) ( floor( bank * Opi2 ) ) * pi2;
-		bank -= ( float ) Py_PI;
+		bank += Py_PI;
+		bank -= (floor(bank * Opi2)) * pi2;
+		bank -= Py_PI;
 	}
 
-	heading += ( float ) Py_PI;
-	heading -= ( float ) ( floor( heading * Opi2 ) ) * pi2;
-	heading -= ( float ) Py_PI;
+	heading += Py_PI;
+	heading -= (floor(heading * Opi2)) * pi2;
+	heading -= Py_PI;
 
 	//back to degrees
-	self->eul[0] = heading * ( float ) ( 180 / Py_PI );
-	self->eul[1] = pitch * ( float ) ( 180 / Py_PI );
-	self->eul[2] = bank * ( float ) ( 180 / Py_PI );
+	self->eul[0] = heading * 180 / (float)Py_PI;
+	self->eul[1] = pitch * 180 / (float)Py_PI;
+	self->eul[2] = bank * 180 / (float)Py_PI;
 
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Euler_Zero( EulerObject * self )
+//----------------------------Euler.zero()-------------------------
+//sets the euler to 0,0,0
+PyObject *Euler_Zero(EulerObject * self)
 {
 	self->eul[0] = 0.0;
 	self->eul[1] = 0.0;
 	self->eul[2] = 0.0;
 
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-static void Euler_dealloc( EulerObject * self )
+//----------------------------Euler.rotate()-----------------------
+//rotates a euler a certain amount and returns the result
+//should return a unique euler rotation (i.e. no 720 degree pitches :)
+PyObject *Euler_Rotate(EulerObject * self, PyObject *args)
 {
-	/* since we own this memory... */
-	PyMem_Free( self->eul );
+	float angle = 0.0f;
+	char *axis;
+	int x;
 
-	PyObject_DEL( self );
-}
+	if(!PyArg_ParseTuple(args, "fs", &angle, &axis)){
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"euler.rotate():expected angle (float) and axis (x,y,z)");
+	}
+	if(!STREQ3(axis,"x","y","z")){
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"euler.rotate(): expected axis to be 'x', 'y' or 'z'");
+	}
 
-static PyObject *Euler_getattr( EulerObject * self, char *name )
+	//covert to radians
+	angle *= ((float)Py_PI / 180);
+	for(x = 0; x < 3; x++) {
+		self->eul[x] *= ((float)Py_PI / 180);
+	}
+	euler_rot(self->eul, angle, *axis);
+	//convert back from radians
+	for(x = 0; x < 3; x++) {
+		self->eul[x] *= (180 / (float)Py_PI);
+	}
+
+	return (PyObject*)self;
+}
+//----------------------------dealloc()(internal) ------------------
+//free the py_object
+static void Euler_dealloc(EulerObject * self)
 {
-	if( ELEM3( name[0], 'x', 'y', 'z' ) && name[1] == 0 ) {
-		return PyFloat_FromDouble( self->eul[name[0] - 'x'] );
+	//only free py_data
+	if(self->data.py_data){
+		PyMem_Free(self->data.py_data);
 	}
-	return Py_FindMethod( Euler_methods, ( PyObject * ) self, name );
+	PyObject_DEL(self);
 }
+//----------------------------getattr()(internal) ------------------
+//object.attribute access (get)
+static PyObject *Euler_getattr(EulerObject * self, char *name)
+{
+	if(STREQ(name,"x")){
+		return PyFloat_FromDouble(self->eul[0]);
+	}else if(STREQ(name, "y")){
+		return PyFloat_FromDouble(self->eul[1]);
+	}else if(STREQ(name, "z")){
+		return PyFloat_FromDouble(self->eul[2]);
+	}
 
-static int Euler_setattr( EulerObject * self, char *name, PyObject * e )
+	return Py_FindMethod(Euler_methods, (PyObject *) self, name);
+}
+//----------------------------setattr()(internal) ------------------
+//object.attribute access (set)
+static int Euler_setattr(EulerObject * self, char *name, PyObject * e)
 {
-	float val;
+	PyObject *f = NULL;
+
+	f = PyNumber_Float(e);
+	if(f == NULL) { // parsed item not a number
+		return EXPP_ReturnIntError(PyExc_TypeError, 
+			"euler.attribute = x: argument not a number\n");
+	}
 
-	if( !PyArg_Parse( e, "f", &val ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "unable to parse float argument\n" );
+	if(STREQ(name,"x")){
+		self->eul[0] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "y")){
+		self->eul[1] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "z")){
+		self->eul[2] = PyFloat_AS_DOUBLE(f);
+	}else{
+		Py_DECREF(f);
+		return EXPP_ReturnIntError(PyExc_AttributeError,
+				"euler.attribute = x: unknown attribute\n");
+	}
 
-	if( ELEM3( name[0], 'x', 'y', 'z' ) && name[1] == 0 ) {
-		self->eul[name[0] - 'x'] = val;
-		return 0;
-	} else
-		return -1;
+	Py_DECREF(f);
+	return 0;
 }
-
-/* Eulers Sequence methods */
-static PyObject *Euler_item( EulerObject * self, int i )
+//----------------------------print object (internal)--------------
+//print the object to screen
+static PyObject *Euler_repr(EulerObject * self)
 {
-	if( i < 0 || i >= 3 )
-		return EXPP_ReturnPyObjError( PyExc_IndexError,
-					      "array index out of range\n" );
+	int i;
+	char buffer[48], str[1024];
+
+	BLI_strncpy(str,"[",1024);
+	for(i = 0; i < 3; i++){
+		if(i < (2)){
+			sprintf(buffer, "%.6f, ", self->eul[i]);
+			strcat(str,buffer);
+		}else{
+			sprintf(buffer, "%.6f", self->eul[i]);
+			strcat(str,buffer);
+		}
+	}
+	strcat(str, "](euler)");
 
-	return Py_BuildValue( "f", self->eul[i] );
+	return EXPP_incr_ret(PyString_FromString(str));
 }
-
-static PyObject *Euler_slice( EulerObject * self, int begin, int end )
+//---------------------SEQUENCE PROTOCOLS------------------------
+//----------------------------len(object)------------------------
+//sequence length
+static int Euler_len(EulerObject * self)
 {
-	PyObject *list;
-	int count;
-
-	if( begin < 0 )
-		begin = 0;
-	if( end > 3 )
-		end = 3;
-	if( begin > end )
-		begin = end;
+	return 3;
+}
+//----------------------------object[]---------------------------
+//sequence accessor (get)
+static PyObject *Euler_item(EulerObject * self, int i)
+{
+	if(i < 0 || i >= 3)
+		return EXPP_ReturnPyObjError(PyExc_IndexError,
+		"euler[attribute]: array index out of range\n");
 
-	list = PyList_New( end - begin );
+	return Py_BuildValue("f", self->eul[i]);
 
-	for( count = begin; count < end; count++ ) {
-		PyList_SetItem( list, count - begin,
-				PyFloat_FromDouble( self->eul[count] ) );
-	}
-	return list;
 }
-
-static int Euler_ass_item( EulerObject * self, int i, PyObject * ob )
+//----------------------------object[]-------------------------
+//sequence accessor (set)
+static int Euler_ass_item(EulerObject * self, int i, PyObject * ob)
 {
-	if( i < 0 || i >= 3 )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "array assignment index out of range\n" );
+	PyObject *f = NULL;
 
-	if( !PyNumber_Check( ob ) )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "Euler member must be a number\n" );
+	f = PyNumber_Float(ob);
+	if(f == NULL) { // parsed item not a number
+		return EXPP_ReturnIntError(PyExc_TypeError, 
+			"euler[attribute] = x: argument not a number\n");
+	}
 
-	if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "int or float expected\n" );
-	} else {
-		self->eul[i] = ( float ) PyFloat_AsDouble( ob );
+	if(i < 0 || i >= 3){
+		Py_DECREF(f);
+		return EXPP_ReturnIntError(PyExc_IndexError,
+			"euler[attribute] = x: array assignment index out of range\n");
 	}
+	self->eul[i] = PyFloat_AS_DOUBLE(f);
+	Py_DECREF(f);
 	return 0;
 }
-
-static int Euler_ass_slice( EulerObject * self, int begin, int end,
-			    PyObject * seq )
+//----------------------------object[z:y]------------------------
+//sequence slice (get)
+static PyObject *Euler_slice(EulerObject * self, int begin, int end)
 {
-	int count, z;
-
-	if( begin < 0 )
-		begin = 0;
-	if( end > 3 )
-		end = 3;
-	if( begin > end )
-		begin = end;
-
-	if( !PySequence_Check( seq ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "illegal argument type for built-in operation\n" );
-	if( PySequence_Length( seq ) != ( end - begin ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "size mismatch in slice assignment\n" );
-
-	z = 0;
-	for( count = begin; count < end; count++ ) {
-		PyObject *ob = PySequence_GetItem( seq, z );
-		z++;
-
-		if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
-			Py_DECREF( ob );
-			return -1;
-		} else {
-			if( !PyArg_Parse( ob, "f", &self->eul[count] ) ) {
-				Py_DECREF( ob );
-				return -1;
-			}
-		}
+	PyObject *list = NULL;
+	int count;
+
+	CLAMP(begin, 0, 3);
+	CLAMP(end, 0, 3);
+	begin = MIN2(begin,end);
+
+	list = PyList_New(end - begin);
+	for(count = begin; count < end; count++) {
+		PyList_SetItem(list, count - begin,
+				PyFloat_FromDouble(self->eul[count]));
 	}
-	return 0;
-}
 
-static PyObject *Euler_repr( EulerObject * self )
+	return list;
+}
+//----------------------------object[z:y]------------------------
+//sequence slice (set)
+static int Euler_ass_slice(EulerObject * self, int begin, int end,
+			     PyObject * seq)
 {
-	int i, maxindex = 3 - 1;
-	char ftoa[24];
-	PyObject *str1, *str2;
-
-	str1 = PyString_FromString( "[" );
-
-	for( i = 0; i < maxindex; i++ ) {
-		sprintf( ftoa, "%.4f, ", self->eul[i] );
-		str2 = PyString_FromString( ftoa );
-		if( !str1 || !str2 )
-			goto error;
-		PyString_ConcatAndDel( &str1, str2 );
-	}
+	int i, y, size = 0;
+	float eul[3];
 
-	sprintf( ftoa, "%.4f]\n", self->eul[maxindex] );
-	str2 = PyString_FromString( ftoa );
-	if( !str1 || !str2 )
-		goto error;
-	PyString_ConcatAndDel( &str1, str2 );
+	CLAMP(begin, 0, 3);
+	CLAMP(end, 0, 3);
+	begin = MIN2(begin,end);
 
-	if( str1 )
-		return str1;
+	size = PySequence_Length(seq);
+	if(size != (end - begin)){
+		return EXPP_ReturnIntError(PyExc_TypeError,
+			"euler[begin:end] = []: size mismatch in slice assignment\n");
+	}
 
-      error:
-	Py_XDECREF( str1 );
-	Py_XDECREF( str2 );
-	return EXPP_ReturnPyObjError( PyExc_MemoryError,
-				      "couldn't create PyString!\n" );
-}
+	for (i = 0; i < size; i++) {
+		PyObject *e, *f;
 
+		e = PySequence_GetItem(seq, i);
+		if (e == NULL) { // Failed to read sequence
+			return EXPP_ReturnIntError(PyExc_RuntimeError, 
+				"euler[begin:end] = []: unable to read sequence\n");
+		}
+		f = PyNumber_Float(e);
+		if(f == NULL) { // parsed item not a number
+			Py_DECREF(e);
+			return EXPP_ReturnIntError(PyExc_TypeError, 
+				"euler[begin:end] = []: sequence argument not a number\n");
+		}
+		eul[i] = PyFloat_AS_DOUBLE(f);
+		EXPP_decr2(f,e);
+	}
+	//parsed well - now set in vector
+	for(y = 0; y < 3; y++){
+		self->eul[begin + y] = eul[y];
+	}
+	return 0;
+}
+//-----------------PROTCOL DECLARATIONS--------------------------
 static PySequenceMethods Euler_SeqMethods = {
-	( inquiry ) 0,		/* sq_length */
-	( binaryfunc ) 0,	/* sq_concat */
-	( intargfunc ) 0,	/* sq_repeat */
-	( intargfunc ) Euler_item,	/* sq_item */
-	( intintargfunc ) Euler_slice,	/* sq_slice */
-	( intobjargproc ) Euler_ass_item,	/* sq_ass_item */
-	( intintobjargproc ) Euler_ass_slice,	/* sq_ass_slice */
+	(inquiry) Euler_len,						/* sq_length */
+	(binaryfunc) 0,								/* sq_concat */
+	(intargfunc) 0,								/* sq_repeat */
+	(intargfunc) Euler_item,					/* sq_item */
+	(intintargfunc) Euler_slice,				/* sq_slice */
+	(intobjargproc) Euler_ass_item,				/* sq_ass_item */
+	(intintobjargproc) Euler_ass_slice,			/* sq_ass_slice */
 };
-
+//------------------PY_OBECT DEFINITION--------------------------
 PyTypeObject euler_Type = {
-	PyObject_HEAD_INIT( NULL ) 
-	0,	/*ob_size */
-	"euler",		/*tp_name */
-	sizeof( EulerObject ),	/*tp_basicsize */
-	0,			/*tp_itemsize */
-	( destructor ) Euler_dealloc,	/*tp_dealloc */
-	( printfunc ) 0,	/*tp_print */
-	( getattrfunc ) Euler_getattr,	/*tp_getattr */
-	( setattrfunc ) Euler_setattr,	/*tp_setattr */
-	0,			/*tp_compare */
-	( reprfunc ) Euler_repr,	/*tp_repr */
-	0,			/*tp_as_number */
-	&Euler_SeqMethods,	/*tp_as_sequence */
+	PyObject_HEAD_INIT(NULL) 
+	0,											/*ob_size */
+	"euler",									/*tp_name */
+	sizeof(EulerObject),						/*tp_basicsize */
+	0,											/*tp_itemsize */
+	(destructor) Euler_dealloc,					/*tp_dealloc */
+	(printfunc) 0,								/*tp_print */
+	(getattrfunc) Euler_getattr,				/*tp_getattr */
+	(setattrfunc) Euler_setattr,				/*tp_setattr */
+	0,											/*tp_compare */
+	(reprfunc) Euler_repr,						/*tp_repr */
+	0,											/*tp_as_number */
+	&Euler_SeqMethods,							/*tp_as_sequence */
 };
-
-PyObject *newEulerObject( float *eul )
+//------------------------newEulerObject (internal)-------------
+//creates a new euler object
+/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ (i.e. it was allocated elsewhere by MEM_mallocN())
+  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ (i.e. it must be created here with PyMEM_malloc())*/
+PyObject *newEulerObject(float *eul, int type)
 {
 	EulerObject *self;
 	int x;
 
 	euler_Type.ob_type = &PyType_Type;
-
-	self = PyObject_NEW( EulerObject, &euler_Type );
-
-	/* 
-	   we own the self->eul memory and will free it later.
-	   if we received an input arg, copy to our internal array
-	*/
-
-	self->eul = PyMem_Malloc( 3 * sizeof( float ) );
-	if( ! self->eul )
-		return EXPP_ReturnPyObjError( PyExc_MemoryError,
-					      "newEulerObject:PyMem_Malloc failed" );
-	
-	if( !eul ) {
-		for( x = 0; x < 3; x++ ) {
-			self->eul[x] = 0.0f;
-		}
-	} else{
-		for( x = 0; x < 3; x++){
-			self->eul[x] = eul[x];
+	self = PyObject_NEW(EulerObject, &euler_Type);
+	self->data.blend_data = NULL;
+	self->data.py_data = NULL;
+
+	if(type == Py_WRAP){
+		self->data.blend_data = eul;
+		self->eul = self->data.blend_data;
+	}else if (type == Py_NEW){
+		self->data.py_data = PyMem_Malloc(3 * sizeof(float));
+		self->eul = self->data.py_data;
+		if(!eul) { //new empty
+			for(x = 0; x < 3; x++) {
+				self->eul[x] = 0.0f;
+			}
+		}else{
+			for(x = 0; x < 3; x++){
+				self->eul[x] = eul[x];
+			}
 		}
+	}else{ //bad type
+		return NULL;
 	}
-
-	return ( PyObject * ) self;
+	return (PyObject *) EXPP_incr_ret((PyObject *)self);
 }
+
diff --git a/source/blender/python/api2_2x/euler.h b/source/blender/python/api2_2x/euler.h
index 1c3b21f7ffc..1b5dca26df7 100644
--- a/source/blender/python/api2_2x/euler.h
+++ b/source/blender/python/api2_2x/euler.h
@@ -1,4 +1,3 @@
-
 /* 
  * $Id$
  *
@@ -35,33 +34,28 @@
 #ifndef EXPP_euler_h
 #define EXPP_euler_h
 
-#include "Python.h"
-#include "gen_utils.h"
-#include "Types.h"
-#include <BLI_arithb.h>
-#include "quat.h"
-#include "matrix.h"
-#include "BKE_utildefines.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-/*****************************/
-//    Euler Python Object   
-/*****************************/
-
 #define EulerObject_Check(v) ((v)->ob_type == &euler_Type)
 
 typedef struct {
-	PyObject_VAR_HEAD float *eul;
+	PyObject_VAR_HEAD 
+	struct{
+		float *py_data;		//python managed
+		float *blend_data;	//blender managed
+	}data;
+	float *eul;				//1D array of data (alias)
 } EulerObject;
 
+/*struct data contains a pointer to the actual data that the
+object uses. It can use either PyMem allocated data (which will
+be stored in py_data) or be a wrapper for data allocated through
+blender (stored in blend_data). This is an either/or struct not both*/
+
 //prototypes
-PyObject *newEulerObject( float *eul );
 PyObject *Euler_Zero( EulerObject * self );
 PyObject *Euler_Unique( EulerObject * self );
 PyObject *Euler_ToMatrix( EulerObject * self );
 PyObject *Euler_ToQuat( EulerObject * self );
+PyObject *Euler_Rotate( EulerObject * self, PyObject *args );
+PyObject *newEulerObject( float *eul, int type );
 
 #endif				/* EXPP_euler_h */
diff --git a/source/blender/python/api2_2x/gen_utils.c b/source/blender/python/api2_2x/gen_utils.c
index ba6878b0a5d..61cf8178510 100644
--- a/source/blender/python/api2_2x/gen_utils.c
+++ b/source/blender/python/api2_2x/gen_utils.c
@@ -30,10 +30,10 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */
 
-#include <DNA_text_types.h>
-#include <MEM_guardedalloc.h>
-#include <BLI_blenlib.h>
-#include <BIF_space.h>
+#include "DNA_text_types.h"
+#include "MEM_guardedalloc.h"
+#include "BLI_blenlib.h"
+#include "BIF_space.h"
 
 #include "gen_utils.h"
 #include "constant.h"
@@ -141,6 +141,31 @@ PyObject *EXPP_incr_ret_True()
 	return Py_BuildValue("i", 1);
 }
 
+void EXPP_incr2( PyObject * ob1, PyObject * ob2 )
+{
+  	    Py_INCREF( ob1 );
+  	    Py_INCREF( ob2 );
+}
+
+void EXPP_incr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 )
+{
+  	    Py_INCREF( ob1 );
+  	    Py_INCREF( ob2 );
+  	    Py_INCREF( ob3 );
+}
+
+void EXPP_decr2( PyObject * ob1, PyObject * ob2 )
+{
+  	    Py_DECREF( ob1 );
+  	    Py_DECREF( ob2 );
+}
+
+void EXPP_decr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 )
+{
+  	    Py_DECREF( ob1 );
+  	    Py_DECREF( ob2 );
+  	    Py_DECREF( ob3 );
+}
 /*****************************************************************************/
 /* Description: This function maps the event identifier to a string.	  */
 /*****************************************************************************/
diff --git a/source/blender/python/api2_2x/gen_utils.h b/source/blender/python/api2_2x/gen_utils.h
index 91021d970b9..df85c92dae4 100644
--- a/source/blender/python/api2_2x/gen_utils.h
+++ b/source/blender/python/api2_2x/gen_utils.h
@@ -39,17 +39,19 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <BKE_global.h>
-#include <BKE_main.h>
-#include <BPI_script.h>
+#include "BKE_global.h"
+#include "BKE_main.h"
+#include "BPI_script.h"
 
-#include <DNA_ID.h>
-#include <DNA_object_types.h>
-#include <DNA_material_types.h>
-#include <DNA_scriptlink_types.h>
-#include <DNA_listBase.h>
+#include "DNA_ID.h"
+#include "DNA_object_types.h"
+#include "DNA_material_types.h"
+#include "DNA_scriptlink_types.h"
+#include "DNA_listBase.h"
 
 #define Py_PI  3.14159265358979323846
+#define Py_WRAP 1024
+#define Py_NEW  2048
 
 /* 
    Py_RETURN_NONE
@@ -72,6 +74,10 @@ char *event_to_name( short event );
 float EXPP_ClampFloat( float value, float min, float max );
 int EXPP_ClampInt( int value, int min, int max );
 
+void EXPP_incr2( PyObject * ob1, PyObject * ob2 );
+void EXPP_incr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 );
+void EXPP_decr2( PyObject * ob1, PyObject * ob2 );
+void EXPP_decr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 );
 PyObject *EXPP_incr_ret( PyObject * object );
 PyObject *EXPP_incr_ret_True(void);
 PyObject *EXPP_incr_ret_False(void);
diff --git a/source/blender/python/api2_2x/matrix.c b/source/blender/python/api2_2x/matrix.c
index b50df287061..8b0add848a2 100644
--- a/source/blender/python/api2_2x/matrix.c
+++ b/source/blender/python/api2_2x/matrix.c
@@ -28,1010 +28,801 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
-#include "matrix.h"
+#include "BKE_utildefines.h"
+#include "BLI_arithb.h"
+#include "Mathutils.h"
+#include "gen_utils.h"
+#include "BLI_blenlib.h"
 
-//doc strings
+//-------------------------DOC STRINGS ---------------------------
 char Matrix_Zero_doc[] = "() - set all values in the matrix to 0";
-char Matrix_Identity_doc[] =
-	"() - set the square matrix to it's identity matrix";
+char Matrix_Identity_doc[] = "() - set the square matrix to it's identity matrix";
 char Matrix_Transpose_doc[] = "() - set the matrix to it's transpose";
 char Matrix_Determinant_doc[] = "() - return the determinant of the matrix";
-char Matrix_Invert_doc[] =
-	"() - set the matrix to it's inverse if an inverse is possible";
-char Matrix_TranslationPart_doc[] =
-	"() - return a vector encompassing the translation of the matrix";
-char Matrix_RotationPart_doc[] =
-	"() - return a vector encompassing the rotation of the matrix";
+char Matrix_Invert_doc[] =  "() - set the matrix to it's inverse if an inverse is possible";
+char Matrix_TranslationPart_doc[] = "() - return a vector encompassing the translation of the matrix";
+char Matrix_RotationPart_doc[] = "() - return a vector encompassing the rotation of the matrix";
 char Matrix_Resize4x4_doc[] = "() - resize the matrix to a 4x4 square matrix";
 char Matrix_toEuler_doc[] = "() - convert matrix to a euler angle rotation";
 char Matrix_toQuat_doc[] = "() - convert matrix to a quaternion rotation";
-
-//methods table
+//-----------------------METHOD DEFINITIONS ----------------------
 struct PyMethodDef Matrix_methods[] = {
-	{"zero", ( PyCFunction ) Matrix_Zero, METH_NOARGS,
-	 Matrix_Zero_doc},
-	{"identity", ( PyCFunction ) Matrix_Identity, METH_NOARGS,
-	 Matrix_Identity_doc},
-	{"transpose", ( PyCFunction ) Matrix_Transpose, METH_NOARGS,
-	 Matrix_Transpose_doc},
-	{"determinant", ( PyCFunction ) Matrix_Determinant, METH_NOARGS,
-	 Matrix_Determinant_doc},
-	{"invert", ( PyCFunction ) Matrix_Invert, METH_NOARGS,
-	 Matrix_Invert_doc},
-	{"translationPart", ( PyCFunction ) Matrix_TranslationPart,
-	 METH_NOARGS,
-	 Matrix_TranslationPart_doc},
-	{"rotationPart", ( PyCFunction ) Matrix_RotationPart, METH_NOARGS,
-	 Matrix_RotationPart_doc},
-	{"resize4x4", ( PyCFunction ) Matrix_Resize4x4, METH_NOARGS,
-	 Matrix_Resize4x4_doc},
-	{"toEuler", ( PyCFunction ) Matrix_toEuler, METH_NOARGS,
-	 Matrix_toEuler_doc},
-	{"toQuat", ( PyCFunction ) Matrix_toQuat, METH_NOARGS,
-	 Matrix_toQuat_doc},
+	{"zero", (PyCFunction) Matrix_Zero, METH_NOARGS, Matrix_Zero_doc},
+	{"identity", (PyCFunction) Matrix_Identity, METH_NOARGS, Matrix_Identity_doc},
+	{"transpose", (PyCFunction) Matrix_Transpose, METH_NOARGS, Matrix_Transpose_doc},
+	{"determinant", (PyCFunction) Matrix_Determinant, METH_NOARGS, Matrix_Determinant_doc},
+	{"invert", (PyCFunction) Matrix_Invert, METH_NOARGS, Matrix_Invert_doc},
+	{"translationPart", (PyCFunction) Matrix_TranslationPart, METH_NOARGS, Matrix_TranslationPart_doc},
+	{"rotationPart", (PyCFunction) Matrix_RotationPart, METH_NOARGS, Matrix_RotationPart_doc},
+	{"resize4x4", (PyCFunction) Matrix_Resize4x4, METH_NOARGS, Matrix_Resize4x4_doc},
+	{"toEuler", (PyCFunction) Matrix_toEuler, METH_NOARGS, Matrix_toEuler_doc},
+	{"toQuat", (PyCFunction) Matrix_toQuat, METH_NOARGS, Matrix_toQuat_doc},
 	{NULL, NULL, 0, NULL}
 };
-
-/*****************************/
-//    Matrix Python Object   
-/*****************************/
-
-PyObject *Matrix_toQuat( MatrixObject * self )
+//-----------------------------METHODS----------------------------
+//---------------------------Matrix.toQuat() ---------------------
+PyObject *Matrix_toQuat(MatrixObject * self)
 {
-	float *quat, *mat;
-
-	if( self->colSize < 3 ) {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "inappropriate matrix size\n" );
-	} else if( self->colSize > 2 ) {	//3 or 4 col
-		if( self->rowSize < 3 )	//3 or 4 row
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "inappropriate matrix size\n" );
-
-		mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
-		if( mat == NULL ) {
-			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-							"problem allocating matrix\n\n" ) );
-		}
-		mat[0] = self->matrix[0][0];
-		mat[1] = self->matrix[0][1];
-		mat[2] = self->matrix[0][2];
-		mat[3] = self->matrix[1][0];
-		mat[4] = self->matrix[1][1];
-		mat[5] = self->matrix[1][2];
-		mat[6] = self->matrix[2][0];
-		mat[7] = self->matrix[2][1];
-		mat[8] = self->matrix[2][2];
+	float quat[4];
+
+	//must be 3-4 cols, 3-4 rows, square matrix
+	if(self->colSize < 3 || self->rowSize < 3 || (self->colSize != self->rowSize)) {
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.toQuat(): inappropriate matrix size - expects 3x3 or 4x4 matrix\n");
+	} 
+	if(self->colSize == 3){
+        Mat3ToQuat((float (*)[3])*self->matrix, quat);
+	}else{
+		Mat4ToQuat((float (*)[4])*self->matrix, quat);
 	}
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	if( quat == NULL ) {
-		PyMem_Free( mat );
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating quat\n\n" ) );
-	}
-	Mat3ToQuat( ( float ( * )[3] ) mat, quat );
-
-	return ( PyObject * ) newQuaternionObject( quat );
+	
+	if(self->data.blend_data)
+		return (PyObject *) newQuaternionObject(quat, Py_WRAP);
+	else
+		return (PyObject *) newQuaternionObject(quat, Py_NEW);
 }
-
-
-PyObject *Matrix_toEuler( MatrixObject * self )
+//---------------------------Matrix.toEuler() --------------------
+PyObject *Matrix_toEuler(MatrixObject * self)
 {
-	float *eul, *mat;
+	float eul[3];
 	int x;
 
-	if( self->colSize < 3 ) {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "inappropriate matrix size\n" );
-	} else if( self->colSize > 2 ) {	//3 or 4 col
-		if( self->rowSize < 3 )	//3 or 4 row
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "inappropriate matrix size\n" );
-
-		mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
-		if( mat == NULL ) {
-			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-							"problem allocating mat\n\n" ) );
-		}
-		mat[0] = self->matrix[0][0];
-		mat[1] = self->matrix[0][1];
-		mat[2] = self->matrix[0][2];
-		mat[3] = self->matrix[1][0];
-		mat[4] = self->matrix[1][1];
-		mat[5] = self->matrix[1][2];
-		mat[6] = self->matrix[2][0];
-		mat[7] = self->matrix[2][1];
-		mat[8] = self->matrix[2][2];
-	}
-	eul = PyMem_Malloc( 3 * sizeof( float ) );
-	if( eul == NULL ) {
-		PyMem_Free( mat );
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating eul\n\n" ) );
-	}
-	Mat3ToEul( ( float ( * )[3] ) mat, eul );
-
-	for( x = 0; x < 3; x++ ) {
-		eul[x] *= ( float ) ( 180 / Py_PI );
-	}
-
-	return ( PyObject * ) newEulerObject( eul );
+	//must be 3-4 cols, 3-4 rows, square matrix
+	if(self->colSize !=3 || self->rowSize != 3) {
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.toQuat(): inappropriate matrix size - expects 3x3 matrix\n");
+	} 
+    Mat3ToEul((float (*)[3])*self->matrix, eul);
+	//have to convert to degrees
+	for(x = 0; x < 3; x++) {
+		eul[x] *= (float) (180 / Py_PI);
+	}
+	if(self->data.blend_data)
+		return (PyObject *) newEulerObject(eul, Py_WRAP);
+	else
+		return (PyObject *) newEulerObject(eul, Py_NEW);
 }
-
-PyObject *Matrix_Resize4x4( MatrixObject * self )
+//---------------------------Matrix.resize4x4() ------------------
+PyObject *Matrix_Resize4x4(MatrixObject * self)
 {
-	float *mat;
-	int x, row, col;
-
-	if( self->colSize == 4 && self->rowSize == 4 )
-		return EXPP_incr_ret( Py_None );
+	int x, first_row_elem, curr_pos, new_pos, blank_columns, blank_rows;
 
-	mat = PyMem_Malloc( 4 * 4 * sizeof( float ) );
-	if( mat == NULL ) {
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating mat\n\n" ) );
-	}
-	for( x = 0; x < 16; x++ ) {
-		mat[x] = 0.0f;
+	if(self->data.blend_data){
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"cannot resize wrapped data - only python matrices\n");
 	}
 
-	if( self->colSize == 2 ) {	//2x2, 2x3, 2x4
-		mat[0] = self->matrix[0][0];
-		mat[1] = self->matrix[0][1];
-		mat[4] = self->matrix[1][0];
-		mat[5] = self->matrix[1][1];
-		if( self->rowSize > 2 ) {
-			mat[8] = self->matrix[2][0];
-			mat[9] = self->matrix[2][1];
-		}
-		if( self->rowSize > 3 ) {
-			mat[12] = self->matrix[3][0];
-			mat[13] = self->matrix[3][1];
-		}
-		mat[10] = 1.0f;
-		mat[15] = 1.0f;
-	} else if( self->colSize == 3 ) {	//3x2, 3x3, 3x4
-		mat[0] = self->matrix[0][0];
-		mat[1] = self->matrix[0][1];
-		mat[2] = self->matrix[0][2];
-		mat[4] = self->matrix[1][0];
-		mat[5] = self->matrix[1][1];
-		mat[6] = self->matrix[1][2];
-		if( self->rowSize > 2 ) {
-			mat[8] = self->matrix[2][0];
-			mat[9] = self->matrix[2][1];
-			mat[10] = self->matrix[2][2];
-		}
-		if( self->rowSize > 3 ) {
-			mat[12] = self->matrix[3][0];
-			mat[13] = self->matrix[3][1];
-			mat[14] = self->matrix[3][2];
-		}
-		if( self->rowSize == 2 )
-			mat[10] = 1.0f;
-		mat[15] = 1.0f;
-	} else if( self->colSize == 4 ) {	//2x4, 3x4
-		mat[0] = self->matrix[0][0];
-		mat[1] = self->matrix[0][1];
-		mat[2] = self->matrix[0][2];
-		mat[3] = self->matrix[0][3];
-		mat[4] = self->matrix[1][0];
-		mat[5] = self->matrix[1][1];
-		mat[6] = self->matrix[1][2];
-		mat[7] = self->matrix[1][3];
-		if( self->rowSize > 2 ) {
-			mat[8] = self->matrix[2][0];
-			mat[9] = self->matrix[2][1];
-			mat[10] = self->matrix[2][2];
-			mat[11] = self->matrix[2][3];
-		}
-		if( self->rowSize == 2 )
-			mat[10] = 1.0f;
-		mat[15] = 1.0f;
+	self->data.py_data = PyMem_Realloc(self->data.py_data, (sizeof(float) * 16));
+	if(self->data.py_data == NULL) {
+		return EXPP_ReturnPyObjError(PyExc_MemoryError,
+			"matrix.resize4x4(): problem allocating pointer space\n\n");
 	}
-
-	PyMem_Free( self->matrix );
-	PyMem_Free( self->contigPtr );
-	self->contigPtr = PyMem_Malloc( 4 * 4 * sizeof( float ) );
-	if( self->contigPtr == NULL ) {
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating array space\n\n" ) );
+	self->contigPtr = self->data.py_data;  //force
+	self->matrix = PyMem_Realloc(self->matrix, (sizeof(float) * 4));
+	if(self->matrix == NULL) {
+		return EXPP_ReturnPyObjError(PyExc_MemoryError,
+			"matrix.resize4x4(): problem allocating pointer space\n\n");
 	}
-	self->matrix = PyMem_Malloc( 4 * sizeof( float * ) );
-	if( self->matrix == NULL ) {
-		PyMem_Free( self->contigPtr );
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating pointer space\n\n" ) );
+	//set row pointers
+	for(x = 0; x < 4; x++) {
+		self->matrix[x] = self->contigPtr + (x * 4);
 	}
-	for( x = 0; x < 4; x++ ) {
-		self->matrix[x] = self->contigPtr + ( x * 4 );
+	//move data to new spot in array + clean
+	for(blank_rows = (4 - self->rowSize); blank_rows > 0; blank_rows--){
+		for(x = 0; x < 4; x++){
+			self->contigPtr[(4 * (self->rowSize + (blank_rows - 1))) + x] = 0.0f;
+		}
 	}
-
-	for( row = 0; row < 4; row++ ) {
-		for( col = 0; col < 4; col++ ) {
-			self->matrix[row][col] = mat[( row * 4 ) + col];
+	for(x = 1; x <= self->rowSize; x++){
+		first_row_elem = (self->colSize * (self->rowSize - x));
+		curr_pos = (first_row_elem + (self->colSize -1));
+		new_pos = (4 * (self->rowSize - x )) + (curr_pos - first_row_elem);
+		for(blank_columns = (4 - self->colSize); blank_columns > 0; blank_columns--){
+			self->contigPtr[new_pos + blank_columns] = 0.0f;
+		}
+		for(curr_pos = curr_pos; curr_pos >= first_row_elem; curr_pos--){
+			self->contigPtr[new_pos] = self->contigPtr[curr_pos];
+			new_pos--;
 		}
 	}
-	PyMem_Free( mat );
-
-	self->colSize = 4;
 	self->rowSize = 4;
-
-	return EXPP_incr_ret( Py_None );
+	self->colSize = 4;
+	return (PyObject*)self;
 }
-
-PyObject *Matrix_TranslationPart( MatrixObject * self )
+//---------------------------Matrix.translationPart() ------------
+PyObject *Matrix_TranslationPart(MatrixObject * self)
 {
-	float *vec = NULL;
-	PyObject *retval;
+	float vec[4];
 
-	if( self->colSize < 3 ) {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "inappropriate matrix size\n" );
-	} else if( self->colSize > 2 ) {	//3 or 4 columns
-		if( self->rowSize < 4 )	//all 4 rows
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "inappropriate matrix size\n" );
-
-		vec = PyMem_Malloc( 3 * sizeof( float ) );
-		if( vec == NULL ) {
-			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-							"problem allocating vec\n\n" ) );
-		}
-		vec[0] = self->matrix[3][0];
-		vec[1] = self->matrix[3][1];
-		vec[2] = self->matrix[3][2];
+	if(self->colSize < 3 && self->rowSize < 4){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.translationPart: inappropriate matrix size\n");
 	}
 
-	retval =  ( PyObject * ) newVectorObject( vec, 3 );
-	PyMem_Free( vec );
-	return retval;
-}
+	vec[0] = self->matrix[3][0];
+	vec[1] = self->matrix[3][1];
+	vec[2] = self->matrix[3][2];
 
-PyObject *Matrix_RotationPart( MatrixObject * self )
+	return newVectorObject(vec, 3, Py_NEW);
+}
+//---------------------------Matrix.rotationPart() ---------------
+PyObject *Matrix_RotationPart(MatrixObject * self)
 {
-	float *mat;
-
-	if( self->colSize < 3 ) {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "inappropriate matrix size\n" );
-	} else if( self->colSize > 2 ) {	//3 or 4 col
-		if( self->rowSize < 3 )	//3 or 4 row
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "inappropriate matrix size\n" );
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
 
-		mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
-		if( mat == NULL ) {
-			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-							"problem allocating mat\n\n" ) );
-		}
-		mat[0] = self->matrix[0][0];
-		mat[1] = self->matrix[0][1];
-		mat[2] = self->matrix[0][2];
-		mat[3] = self->matrix[1][0];
-		mat[4] = self->matrix[1][1];
-		mat[5] = self->matrix[1][2];
-		mat[6] = self->matrix[2][0];
-		mat[7] = self->matrix[2][1];
-		mat[8] = self->matrix[2][2];
+	if(self->colSize < 3 && self->rowSize < 3){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.rotationPart: inappropriate matrix size\n");
 	}
 
-	return ( PyObject * ) newMatrixObject( mat, 3, 3 );
-}
+	mat[0] = self->matrix[0][0];
+	mat[1] = self->matrix[0][1];
+	mat[2] = self->matrix[0][2];
+	mat[3] = self->matrix[1][0];
+	mat[4] = self->matrix[1][1];
+	mat[5] = self->matrix[1][2];
+	mat[6] = self->matrix[2][0];
+	mat[7] = self->matrix[2][1];
+	mat[8] = self->matrix[2][2];
 
-PyObject *Matrix_Invert( MatrixObject * self )
+	return newMatrixObject(mat, 3, 3, Py_NEW);
+}
+//---------------------------Matrix.invert() ---------------------
+PyObject *Matrix_Invert(MatrixObject * self)
 {
-	float det;
-	int x, y, z;
-	float *mat = NULL;
-	float t;
-
-	if( self->rowSize != self->colSize )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "only square matrices are supported\n" );
+	
+	int x, y, z = 0;
+	float det = 0.0f;
+	PyObject *f = NULL;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
 
-	//calculate the determinant
-	if( self->rowSize == 2 ) {
-		det = Det2x2( self->matrix[0][0], self->matrix[0][1],
-			      self->matrix[1][0], self->matrix[1][1] );
-	} else if( self->rowSize == 3 ) {
-		det = Det3x3( self->matrix[0][0], self->matrix[0][1],
-			      self->matrix[0][2], self->matrix[1][0],
-			      self->matrix[1][1], self->matrix[1][2],
-			      self->matrix[2][0], self->matrix[2][1],
-			      self->matrix[2][2] );
-	} else if( self->rowSize == 4 ) {
-		det = Det4x4( (float ( * )[4]) *self->matrix );
-	} else {
-		return EXPP_ReturnPyObjError( PyExc_StandardError,
-					      "error calculating determinant for inverse()\n" );
+	if(self->rowSize != self->colSize){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.invert: only square matrices are supported\n");
 	}
 
-	if( det != 0 ) {
+	//calculate the determinant
+	f = Matrix_Determinant(self);
+	det = PyFloat_AS_DOUBLE(f);
 
+	if(det != 0) {
 		//calculate the classical adjoint
-		if( self->rowSize == 2 ) {
-			mat = PyMem_Malloc( self->rowSize * self->colSize *
-					    sizeof( float ) );
-			if( mat == NULL ) {
-				return ( EXPP_ReturnPyObjError
-					 ( PyExc_MemoryError,
-					   "problem allocating mat\n\n" ) );
-			}
+		if(self->rowSize == 2) {
 			mat[0] = self->matrix[1][1];
 			mat[1] = -self->matrix[1][0];
 			mat[2] = -self->matrix[0][1];
 			mat[3] = self->matrix[0][0];
-		} else if( self->rowSize == 3 ) {
-			mat = PyMem_Malloc( self->rowSize * self->colSize *
-					    sizeof( float ) );
-			if( mat == NULL ) {
-				return ( EXPP_ReturnPyObjError
-					 ( PyExc_MemoryError,
-					   "problem allocating mat\n\n" ) );
-			}
-			Mat3Adj( ( float ( * )[3] ) mat,( float ( * )[3] ) *self->matrix );
-		} else if( self->rowSize == 4 ) {
-			mat = PyMem_Malloc( self->rowSize * self->colSize *
-					    sizeof( float ) );
-			if( mat == NULL ) {
-				return ( EXPP_ReturnPyObjError
-					 ( PyExc_MemoryError,
-					   "problem allocating mat\n\n" ) );
-			}
-			Mat4Adj( ( float ( * )[4] ) mat, ( float ( * )[4] ) *self->matrix );
+		} else if(self->rowSize == 3) {
+			Mat3Adj((float (*)[3]) mat,(float (*)[3]) *self->matrix);
+		} else if(self->rowSize == 4) {
+			Mat4Adj((float (*)[4]) mat, (float (*)[4]) *self->matrix);
 		}
 		//divide by determinate
-		for( x = 0; x < ( self->rowSize * self->colSize ); x++ ) {
+		for(x = 0; x < (self->rowSize * self->colSize); x++) {
 			mat[x] /= det;
 		}
-
 		//set values
-		z = 0;
-		for( x = 0; x < self->rowSize; x++ ) {
-			for( y = 0; y < self->colSize; y++ ) {
+		for(x = 0; x < self->rowSize; x++) {
+			for(y = 0; y < self->colSize; y++) {
 				self->matrix[x][y] = mat[z];
 				z++;
 			}
 		}
-
 		//transpose
-		if( self->rowSize == 2 ) {
-			t = self->matrix[1][0];
-			self->matrix[1][0] = self->matrix[0][1];
-			self->matrix[0][1] = t;
-			
-/* 
-   Note: is the code below correct?  
-   transposing mat and not copying into self->matrix? 
-   s. swaney 11-oct-2004
-*/
-		} else if( self->rowSize == 3 ) {
-			Mat3Transp( ( float ( * )[3] ) mat );
-		} else if( self->rowSize == 4 ) {
-			Mat4Transp( ( float ( * )[4] ) mat );
-		}
+		Matrix_Transpose(self);
 	} else {
-		printf( "matrix does not have an inverse - none attempted\n" );
+		printf("Matrix.invert: matrix does not have an inverse\n");
 	}
-	PyMem_Free( mat );
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-
-PyObject *Matrix_Determinant( MatrixObject * self )
+//---------------------------Matrix.determinant() ----------------
+PyObject *Matrix_Determinant(MatrixObject * self)
 {
-	float det;
-
-	if( self->rowSize != self->colSize )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "only square matrices are supported\n" );
-
-	if( self->rowSize == 2 ) {
-		det = Det2x2( self->matrix[0][0], self->matrix[0][1],
-			      self->matrix[1][0], self->matrix[1][1] );
-	} else if( self->rowSize == 3 ) {
-		det = Det3x3( self->matrix[0][0], self->matrix[0][1],
-			      self->matrix[0][2], self->matrix[1][0],
-			      self->matrix[1][1], self->matrix[1][2],
-			      self->matrix[2][0], self->matrix[2][1],
-			      self->matrix[2][2] );
-	} else if( self->rowSize == 4 ) {
-		det = Det4x4( (float ( * )[4]) *self->matrix );
+	float det = 0.0f;
+
+	if(self->rowSize != self->colSize){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.determinant: only square matrices are supported\n");
+	}
+
+	if(self->rowSize == 2) {
+		det = Det2x2(self->matrix[0][0], self->matrix[0][1],
+					 self->matrix[1][0], self->matrix[1][1]);
+	} else if(self->rowSize == 3) {
+		det = Det3x3(self->matrix[0][0], self->matrix[0][1],
+					 self->matrix[0][2], self->matrix[1][0],
+					 self->matrix[1][1], self->matrix[1][2],
+					 self->matrix[2][0], self->matrix[2][1],
+					 self->matrix[2][2]);
 	} else {
-		return EXPP_ReturnPyObjError( PyExc_StandardError,
-					      "error in determinant()\n" );
+		det = Det4x4((float (*)[4]) *self->matrix);
 	}
 
 	return PyFloat_FromDouble( (double) det );
 }
 //---------------------------Matrix.transpose() ------------------
-
-PyObject *Matrix_Transpose( MatrixObject * self )
-
+PyObject *Matrix_Transpose(MatrixObject * self)
 {
-	float t;
+	float t = 0.0f;
 
-	if( self->rowSize != self->colSize )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "only square matrices are supported\n" );
+	if(self->rowSize != self->colSize){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.transpose: only square matrices are supported\n");
+	}
 
-	if( self->rowSize == 2 ) {
+	if(self->rowSize == 2) {
 		t = self->matrix[1][0];
 		self->matrix[1][0] = self->matrix[0][1];
 		self->matrix[0][1] = t;
-	} else if( self->rowSize == 3 ) {
-		Mat3Transp( (float ( * )[3])*self->matrix );
-	} else if( self->rowSize == 4 ) {
-		Mat4Transp( (float ( * )[4])*self->matrix );
-	} else
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"unable to transpose matrix\n" ) );
+	} else if(self->rowSize == 3) {
+		Mat3Transp((float (*)[3])*self->matrix);
+	} else {
+		Mat4Transp((float (*)[4])*self->matrix);
+	}
 
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Matrix_Zero( MatrixObject * self )
+//---------------------------Matrix.zero() -----------------------
+PyObject *Matrix_Zero(MatrixObject * self)
 {
 	int row, col;
 
-	for( row = 0; row < self->rowSize; row++ ) {
-		for( col = 0; col < self->colSize; col++ ) {
+	for(row = 0; row < self->rowSize; row++) {
+		for(col = 0; col < self->colSize; col++) {
 			self->matrix[row][col] = 0.0f;
 		}
 	}
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Matrix_Identity( MatrixObject * self )
+//---------------------------Matrix.identity(() ------------------
+PyObject *Matrix_Identity(MatrixObject * self)
 {
-	if( self->rowSize != self->colSize )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"only square matrices supported\n" ) );
+	if(self->rowSize != self->colSize){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix.identity: only square matrices are supported\n");
+	}
 
-	if( self->rowSize == 2 ) {
+	if(self->rowSize == 2) {
 		self->matrix[0][0] = 1.0f;
 		self->matrix[0][1] = 0.0f;
 		self->matrix[1][0] = 0.0f;
 		self->matrix[1][1] = 1.0f;
-	} else if( self->rowSize == 3 ) {
-		Mat3One( ( float ( * )[3] ) *self->matrix );
-	} else if( self->rowSize == 4 ) {
-		Mat4One( ( float ( * )[4] ) *self->matrix );
-	} else
-		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
-						"unable to create identity matrix\n" ) );
+	} else if(self->rowSize == 3) {
+		Mat3One((float (*)[3]) *self->matrix);
+	} else {
+		Mat4One((float (*)[4]) *self->matrix);
+	}
 
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-static void Matrix_dealloc( MatrixObject * self )
+//----------------------------dealloc()(internal) ----------------
+//free the py_object
+static void Matrix_dealloc(MatrixObject * self)
 {
-	PyMem_Free( self->contigPtr );
-	PyMem_Free( self->matrix );
-
-	PyObject_DEL( self );
+	Py_XDECREF(self->coerced_object);
+	PyMem_Free(self->matrix);
+	//only free py_data
+	if(self->data.py_data){
+		PyMem_Free(self->data.py_data);
+	}
+	PyObject_DEL(self);
 }
-
-static PyObject *Matrix_getattr( MatrixObject * self, char *name )
+//----------------------------getattr()(internal) ----------------
+//object.attribute access (get)
+static PyObject *Matrix_getattr(MatrixObject * self, char *name)
 {
-	if( strcmp( name, "rowSize" ) == 0 ) {
-		return PyInt_FromLong( ( long ) self->rowSize );
-	} else if( strcmp( name, "colSize" ) == 0 ) {
-		return PyInt_FromLong( ( long ) self->colSize );
+	if(STREQ(name, "rowSize")) {
+		return PyInt_FromLong((long) self->rowSize);
+	} else if(STREQ(name, "colSize")) {
+		return PyInt_FromLong((long) self->colSize);
 	}
 
-	return Py_FindMethod( Matrix_methods, ( PyObject * ) self, name );
+	return Py_FindMethod(Matrix_methods, (PyObject *) self, name);
 }
-
-static int Matrix_setattr( MatrixObject * self, char *name, PyObject * v )
+//----------------------------setattr()(internal) ----------------
+//object.attribute access (set)
+static int Matrix_setattr(MatrixObject * self, char *name, PyObject * v)
 {
 	/* This is not supported. */
-	return ( -1 );
+	return (-1);
 }
-
-static PyObject *Matrix_repr( MatrixObject * self )
+//----------------------------print object (internal)-------------
+//print the object to screen
+static PyObject *Matrix_repr(MatrixObject * self)
 {
-	PyObject *repr, *str;
 	int x, y;
-	char ftoa[24];
-
-	repr = PyString_FromString( "" );
-	if( !repr )
-		return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
-						"Attribute error in PyMatrix (repr)\n" ) );
-
-	for( x = 0; x < self->rowSize; x++ ) {
-		str = PyString_FromString( "[" );
-		PyString_ConcatAndDel( &repr, str );
-
-		for( y = 0; y < ( self->colSize - 1 ); y++ ) {
-			sprintf( ftoa, "%.4f, ", self->matrix[x][y] );
-			str = PyString_FromString( ftoa );
-			PyString_ConcatAndDel( &repr, str );
+	char buffer[48], str[1024];
+
+	BLI_strncpy(str,"",1024);
+	for(x = 0; x < self->rowSize; x++){
+		sprintf(buffer, "[");
+		strcat(str,buffer);
+		for(y = 0; y < (self->colSize - 1); y++) {
+			sprintf(buffer, "%.6f, ", self->matrix[x][y]);
+			strcat(str,buffer);
+		}
+		if(x < (self->rowSize-1)){
+			sprintf(buffer, "%.6f](matrix [row %d])\n", self->matrix[x][y], x);
+			strcat(str,buffer);
+		}else{
+			sprintf(buffer, "%.6f](matrix [row %d])", self->matrix[x][y], x);
+			strcat(str,buffer);
 		}
-		sprintf( ftoa, "%.4f]\n", self->matrix[x][y] );
-		str = PyString_FromString( ftoa );
-		PyString_ConcatAndDel( &repr, str );
 	}
-	return repr;
+
+	return EXPP_incr_ret(PyString_FromString(str));
 }
 
-//no support for matrix[x][y] so have to return by sequence index
-//will return a row from the matrix to support previous API
-//compatability
-static PyObject *Matrix_item( MatrixObject * self, int i )
+//---------------------SEQUENCE PROTOCOLS------------------------
+//----------------------------len(object)------------------------
+//sequence length
+static int Matrix_len(MatrixObject * self)
 {
-	float *vec = NULL;
-	PyObject *retval;
-	int x;
-
-	if( i < 0 || i >= self->rowSize )
-		return EXPP_ReturnPyObjError( PyExc_IndexError,
-					      "matrix row index out of range\n" );
-
-	vec = PyMem_Malloc( self->colSize * sizeof( float ) );
-	if( vec == NULL ) {
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating vec\n\n" ) );
-	}
-	for( x = 0; x < self->colSize; x++ ) {
-		vec[x] = self->matrix[i][x];
-	}
-
-	retval =( PyObject * ) newVectorObject( vec, self->colSize );
-	PyMem_Free( vec );
-	return retval;
+	return (self->colSize * self->rowSize);
 }
-
-static PyObject *Matrix_slice( MatrixObject * self, int begin, int end )
+//----------------------------object[]---------------------------
+//sequence accessor (get)
+//the wrapped vector gives direct access to the matrix data
+static PyObject *Matrix_item(MatrixObject * self, int i)
 {
-	PyObject *list;
-	int count, maxsize, x, y;
-
-	maxsize = self->colSize * self->rowSize;
-	if( begin < 0 )
-		begin = 0;
-	if( end > maxsize )
-		end = maxsize;
-	if( begin > end )
-		begin = end;
+	if(i < 0 || i >= self->rowSize)
+		return EXPP_ReturnPyObjError(PyExc_IndexError,
+		"matrix[attribute]: array index out of range\n");
 
-	list = PyList_New( end - begin );
-
-	for( count = begin; count < end; count++ ) {
-		x = ( int ) floor( ( double ) ( count / self->colSize ) );
-		y = count % self->colSize;
-		PyList_SetItem( list, count - begin,
-				PyFloat_FromDouble( self->matrix[x][y] ) );
-	}
-
-	return list;
+	return newVectorObject(self->matrix[i], self->colSize, Py_WRAP);
 }
-
-static int Matrix_ass_item( MatrixObject * self, int i, PyObject * ob )
+//----------------------------object[]-------------------------
+//sequence accessor (set)
+static int Matrix_ass_item(MatrixObject * self, int i, PyObject * ob)
 {
-	int maxsize, x, y;
+	int y, x, size = 0;
+	float vec[4];
 
-	maxsize = self->colSize * self->rowSize;
-	if( i < 0 || i >= maxsize )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "array assignment index out of range\n" );
-	if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "matrix member must be a number\n" );
+	if(i > self->rowSize || i < 0){
+		return EXPP_ReturnIntError(PyExc_TypeError,
+			"matrix[attribute] = x: bad row\n");
+	}
 
-	x = ( int ) floor( ( double ) ( i / self->colSize ) );
-	y = i % self->colSize;
-	self->matrix[x][y] = ( float ) PyFloat_AsDouble( ob );
+	if(PySequence_Check(ob)){
+		size = PySequence_Length(ob);
+		if(size != self->colSize){
+			return EXPP_ReturnIntError(PyExc_TypeError,
+				"matrix[attribute] = x: bad sequence size\n");
+		}
+		for (x = 0; x < size; x++) {
+			PyObject *m, *f;
 
-	return 0;
+			m = PySequence_GetItem(ob, x);
+			if (m == NULL) { // Failed to read sequence
+				return EXPP_ReturnIntError(PyExc_RuntimeError, 
+					"matrix[attribute] = x: unable to read sequence\n");
+			}
+			f = PyNumber_Float(m);
+			if(f == NULL) { // parsed item not a number
+				Py_DECREF(m);
+				return EXPP_ReturnIntError(PyExc_TypeError, 
+					"matrix[attribute] = x: sequence argument not a number\n");
+			}
+			vec[x] = PyFloat_AS_DOUBLE(f);
+			EXPP_decr2(m, f);
+		}
+		//parsed well - now set in matrix
+		for(y = 0; y < size; y++){
+			self->matrix[i][y] = vec[y];
+		}
+		return 0;
+	}else{
+		return EXPP_ReturnIntError(PyExc_TypeError,
+			"matrix[attribute] = x: expects a sequence of column size\n");
+	}
 }
-
-static int Matrix_ass_slice( MatrixObject * self, int begin, int end,
-			     PyObject * seq )
+//----------------------------object[z:y]------------------------
+//sequence slice (get)
+static PyObject *Matrix_slice(MatrixObject * self, int begin, int end)
 {
-	int count, maxsize, x, y, z;
-
-	maxsize = self->colSize * self->rowSize;
-	if( begin < 0 )
-		begin = 0;
-	if( end > maxsize )
-		end = maxsize;
-	if( begin > end )
-		begin = end;
 
-	if( !PySequence_Check( seq ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "illegal argument type for built-in operation\n" );
-	if( PySequence_Length( seq ) != ( end - begin ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "size mismatch in slice assignment\n" );
+	PyObject *list = NULL;
+	int count;
 
-	z = 0;
-	for( count = begin; count < end; count++ ) {
-		PyObject *ob = PySequence_GetItem( seq, z );
-		z++;
-		if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
-			return EXPP_ReturnIntError( PyExc_IndexError,
-						    "list member must be a number\n" );
+	CLAMP(begin, 0, self->rowSize);
+	CLAMP(end, 0, self->rowSize);
+	begin = MIN2(begin,end);
 
-		x = ( int ) floor( ( double ) ( count / self->colSize ) );
-		y = count % self->colSize;
-		if( !PyArg_Parse( ob, "f", &self->matrix[x][y] ) ) {
-			Py_DECREF( ob );
-			return -1;
-		}
+	list = PyList_New(end - begin);
+	for(count = begin; count < end; count++) {
+		PyList_SetItem(list, count - begin,
+				newVectorObject(self->matrix[count], self->colSize, Py_WRAP));
 	}
-	return 0;
-}
 
-static int Matrix_len( MatrixObject * self )
+	return EXPP_incr_ret(list);
+}
+//----------------------------object[z:y]------------------------
+//sequence slice (set)
+static int Matrix_ass_slice(MatrixObject * self, int begin, int end,
+			     PyObject * seq)
 {
-	return ( self->colSize * self->rowSize );
+	int i, x, y, size, sub_size = 0;
+	float mat[16];
+
+	CLAMP(begin, 0, self->rowSize);
+	CLAMP(end, 0, self->rowSize);
+	begin = MIN2(begin,end);
+
+	if(PySequence_Check(seq)){
+		size = PySequence_Length(seq);
+		if(size != (end - begin)){
+			return EXPP_ReturnIntError(PyExc_TypeError,
+				"matrix[begin:end] = []: size mismatch in slice assignment\n");
+		}
+		//parse sub items
+		for (i = 0; i < size; i++) {
+			//parse each sub sequence
+			PyObject *subseq;
+			subseq = PySequence_GetItem(seq, i);
+			if (subseq == NULL) { // Failed to read sequence
+				return EXPP_ReturnIntError(PyExc_RuntimeError, 
+					"matrix[begin:end] = []: unable to read sequence\n");
+			}
+			if(PySequence_Check(subseq)){
+				//subsequence is also a sequence
+				sub_size = PySequence_Length(subseq);
+				if(sub_size != self->colSize){
+					return EXPP_ReturnIntError(PyExc_TypeError,
+						"matrix[begin:end] = []: size mismatch in slice assignment\n");
+				}
+				for (y = 0; y < sub_size; y++) {
+					PyObject *m, *f;
+					m = PySequence_GetItem(subseq, y);
+					if (m == NULL) { // Failed to read sequence
+						return EXPP_ReturnIntError(PyExc_RuntimeError, 
+							"matrix[begin:end] = []: unable to read sequence\n");
+					}
+					f = PyNumber_Float(m);
+					if(f == NULL) { // parsed item not a number
+						Py_DECREF(m);
+						return EXPP_ReturnIntError(PyExc_TypeError, 
+							"matrix[begin:end] = []: sequence argument not a number\n");
+					}
+					mat[(i * self->colSize) + y] = PyFloat_AS_DOUBLE(f);
+					EXPP_decr2(f, m);
+				}
+			}else{
+				Py_DECREF(subseq);
+				return EXPP_ReturnIntError(PyExc_TypeError,
+					"matrix[begin:end] = []: illegal argument type for built-in operation\n");
+			}
+		}
+		//parsed well - now set in matrix
+		for(x = 0; x < (size * sub_size); x++){
+			self->matrix[begin + (int)floor(x / self->colSize)][x % self->colSize] = mat[x];
+		}
+		return 0;
+	}else{
+		return EXPP_ReturnIntError(PyExc_TypeError,
+			"matrix[begin:end] = []: illegal argument type for built-in operation\n");
+	}
 }
-
-static PyObject *Matrix_add( PyObject * m1, PyObject * m2 )
+//------------------------NUMERIC PROTOCOLS----------------------
+//------------------------obj + obj------------------------------
+static PyObject *Matrix_add(PyObject * m1, PyObject * m2)
 {
-	float *mat;
-	int matSize, rowSize, colSize, x, y;
-
-	if( ( !Matrix_CheckPyObject( m1 ) )
-	    || ( !Matrix_CheckPyObject( m2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-
-	if( ( ( MatrixObject * ) m1 )->flag > 0
-	    || ( ( MatrixObject * ) m2 )->flag > 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "cannot add scalar to a matrix\n" );
-
-	if( ( ( MatrixObject * ) m1 )->rowSize !=
-	    ( ( MatrixObject * ) m2 )->rowSize
-	    || ( ( MatrixObject * ) m1 )->colSize !=
-	    ( ( MatrixObject * ) m2 )->colSize )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "matrices must be the same same for this operation\n" );
+	int x, y;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+	MatrixObject *mat1 = NULL, *mat2 = NULL;
 
-	rowSize = ( ( ( MatrixObject * ) m1 )->rowSize );
-	colSize = ( ( ( MatrixObject * ) m1 )->colSize );
-	matSize = rowSize * colSize;
+	EXPP_incr2(m1, m2);
+	mat1 = (MatrixObject*)m1;
+	mat2 = (MatrixObject*)m2;
 
-	mat = PyMem_Malloc( matSize * sizeof( float ) );
-	if( mat == NULL ) {
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating mat\n\n" ) );
+	if(mat1->coerced_object || mat2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix addition: arguments not valid for this operation....\n");
+	}
+	if(mat1->rowSize != mat2->rowSize || mat1->colSize != mat2->colSize){
+		EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix addition: matrices must have the same dimensions for this operation\n");
 	}
-	for( x = 0; x < rowSize; x++ ) {
-		for( y = 0; y < colSize; y++ ) {
-			mat[( ( x * rowSize ) + y )] =
-				( ( MatrixObject * ) m1 )->matrix[x][y] +
-				( ( MatrixObject * ) m2 )->matrix[x][y];
+
+	for(x = 0; x < mat1->rowSize; x++) {
+		for(y = 0; y < mat1->colSize; y++) {
+			mat[((x * mat1->colSize) + y)] = mat1->matrix[x][y] + mat2->matrix[x][y];
 		}
 	}
 
-	return newMatrixObject( mat, rowSize, colSize );
+	EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+	return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW);
 }
-
-static PyObject *Matrix_sub( PyObject * m1, PyObject * m2 )
+//------------------------obj - obj------------------------------
+//subtraction
+static PyObject *Matrix_sub(PyObject * m1, PyObject * m2)
 {
-	float *mat;
-	int matSize, rowSize, colSize, x, y;
-
-	if( ( !Matrix_CheckPyObject( m1 ) )
-	    || ( !Matrix_CheckPyObject( m2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-
-	if( ( ( MatrixObject * ) m1 )->flag > 0
-	    || ( ( MatrixObject * ) m2 )->flag > 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "cannot subtract a scalar from a matrix\n" );
-
-	if( ( ( MatrixObject * ) m1 )->rowSize !=
-	    ( ( MatrixObject * ) m2 )->rowSize
-	    || ( ( MatrixObject * ) m1 )->colSize !=
-	    ( ( MatrixObject * ) m2 )->colSize )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "matrices must be the same same for this operation\n" );
+	int x, y;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+	MatrixObject *mat1 = NULL, *mat2 = NULL;
 
-	rowSize = ( ( ( MatrixObject * ) m1 )->rowSize );
-	colSize = ( ( ( MatrixObject * ) m1 )->colSize );
-	matSize = rowSize * colSize;
+	EXPP_incr2(m1, m2);
+	mat1 = (MatrixObject*)m1;
+	mat2 = (MatrixObject*)m2;
 
-	mat = PyMem_Malloc( matSize * sizeof( float ) );
-	if( mat == NULL ) {
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating mat\n\n" ) );
+	if(mat1->coerced_object || mat2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix addition: arguments not valid for this operation....\n");
+	}
+	if(mat1->rowSize != mat2->rowSize || mat1->colSize != mat2->colSize){
+		EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Matrix addition: matrices must have the same dimensions for this operation\n");
 	}
-	for( x = 0; x < rowSize; x++ ) {
-		for( y = 0; y < colSize; y++ ) {
-			mat[( ( x * rowSize ) + y )] =
-				( ( MatrixObject * ) m1 )->matrix[x][y] -
-				( ( MatrixObject * ) m2 )->matrix[x][y];
+
+	for(x = 0; x < mat1->rowSize; x++) {
+		for(y = 0; y < mat1->colSize; y++) {
+			mat[((x * mat1->colSize) + y)] = mat1->matrix[x][y] - mat2->matrix[x][y];
 		}
 	}
 
-	return newMatrixObject( mat, rowSize, colSize );
+	EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+	return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW);
 }
-
-static PyObject *Matrix_mul( PyObject * m1, PyObject * m2 )
+//------------------------obj * obj------------------------------
+//mulplication
+static PyObject *Matrix_mul(PyObject * m1, PyObject * m2)
 {
-	PyObject *retval;
-	int matSizeV, rowSizeV, colSizeV, rowSizeW, colSizeW, matSizeW, x, y,z;
-	MatrixObject *matV;
-	MatrixObject *matW;
-	float *mat = NULL;
-	float dot = 0;
-	
-
-	if( ( !Matrix_CheckPyObject( m1 ) )
-	    || ( !Matrix_CheckPyObject( m2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-
-	//get some vars
-	rowSizeV = ( ( ( MatrixObject * ) m1 )->rowSize );
-	colSizeV = ( ( ( MatrixObject * ) m1 )->colSize );
-	matSizeV = rowSizeV * colSizeV;
-	rowSizeW = ( ( ( MatrixObject * ) m2 )->rowSize );
-	colSizeW = ( ( ( MatrixObject * ) m2 )->colSize );
-	matSizeW = rowSizeW * colSizeW;
-	matV = ( ( MatrixObject * ) m1 );
-	matW = ( ( MatrixObject * ) m2 );
-
-	//coerced int or float for scalar multiplication
-	if( matW->flag > 1 || matW->flag > 2 ) {
-
-		if( rowSizeV != rowSizeW && colSizeV != colSizeW )
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "Matrix dimension error during scalar multiplication\n" );
-
-		mat = PyMem_Malloc( matSizeV * sizeof( float ) );
-		if( mat == NULL ) {
-			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-							"problem allocating mat\n\n" ) );
-		}
-		for( x = 0; x < rowSizeV; x++ ) {
-			for( y = 0; y < colSizeV; y++ ) {
-				mat[( ( x * rowSizeV ) + y )] =
-					matV->matrix[x][y] *
-					matW->matrix[x][y];
+	int x, y, z;
+	float scalar;
+	float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+	double dot = 0.0f;
+	MatrixObject *mat1 = NULL, *mat2 = NULL;
+	PyObject *f = NULL, *retObj = NULL;
+	VectorObject *vec = NULL;
+
+	EXPP_incr2(m1, m2);
+	mat1 = (MatrixObject*)m1;
+	mat2 = (MatrixObject*)m2;
+
+	if(mat1->coerced_object){
+		if (PyFloat_Check(mat1->coerced_object) || 
+			PyInt_Check(mat1->coerced_object)){	// FLOAT/INT * MATRIX
+			f = PyNumber_Float(mat1->coerced_object);
+			if(f == NULL) { // parsed item not a number
+				EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+				return EXPP_ReturnPyObjError(PyExc_TypeError, 
+					"Matrix multiplication: arguments not acceptable for this operation\n");
 			}
-		}
-		retval = ( PyObject* ) newMatrixObject( mat, rowSizeV, colSizeV );
-		PyMem_Free( mat );
-		return retval;
-	} else if( matW->flag == 0 && matV->flag == 0 ) {	//true matrix multiplication
-		if( colSizeV != rowSizeW ) {
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "Matrix multiplication undefined...\n" );
-		}
-
-		mat = PyMem_Malloc( ( rowSizeV * colSizeW ) *
-				    sizeof( float ) );
-		if( mat == NULL ) {
-			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-							"problem allocating mat\n\n" ) );
-		}
-		for( x = 0; x < rowSizeV; x++ ) {
-			for( y = 0; y < colSizeW; y++ ) {
-				for( z = 0; z < colSizeV; z++ ) {
-					dot += ( matV->matrix[x][z] *
-						 matW->matrix[z][y] );
+			scalar = PyFloat_AS_DOUBLE(f);
+			for(x = 0; x < mat2->rowSize; x++) {
+				for(y = 0; y < mat2->colSize; y++) {
+					mat[((x * mat2->colSize) + y)] = scalar * mat2->matrix[x][y];
 				}
-				mat[( ( x * rowSizeV ) + y )] = dot;
-				dot = 0;
 			}
+			EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+			return newMatrixObject(mat, mat2->rowSize, mat2->colSize, Py_NEW);
 		}
-		retval = ( PyObject* )  newMatrixObject( mat, rowSizeV, colSizeW );
-		PyMem_Free( mat );
-		return retval;
-	} else
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "Error in matrix_mul...\n" );
-}
-
-//coercion of unknown types to type MatrixObject for numeric protocols
-static int Matrix_coerce( PyObject ** m1, PyObject ** m2 )
-{
-	long *tempI;
-	double *tempF;
-	float *mat;
-	int x, matSize;
-
-	matSize =
-		( ( ( MatrixObject * ) * m1 )->rowSize ) *
-		( ( ( MatrixObject * ) * m1 )->rowSize );
-	if( Matrix_CheckPyObject( *m1 ) ) {
-		if( Matrix_CheckPyObject( *m2 ) ) {	//matrix & matrix
-			Py_INCREF( *m1 );
-			Py_INCREF( *m2 );
-			return 0;
-		} else {
-			if( VectorObject_Check( *m2 ) ) {	//matrix & vector?
-				printf( "use MatMultVec() for column vector multiplication\n" );
-				Py_INCREF( *m1 );
-				return 0;
-			} else if( PyNumber_Check( *m2 ) ) {	//& scalar?
-				if( PyInt_Check( *m2 ) ) {	//it's a int
-					tempI = PyMem_Malloc( 1 *
-							      sizeof( long ) );
-					if( tempI == NULL ) {
-						return ( EXPP_ReturnIntError
-							 ( PyExc_MemoryError,
-							   "problem allocating tempI\n\n" ) );
-					}
-					*tempI = PyInt_AsLong( *m2 );
-					mat = PyMem_Malloc( matSize *
-							    sizeof( float ) );
-					if( mat == NULL ) {
-						PyMem_Free( tempI );
-						return ( EXPP_ReturnIntError
-							 ( PyExc_MemoryError,
-							   "problem allocating mat\n\n" ) );
-					}
-					for( x = 0; x < matSize; x++ ) {
-						mat[x] = ( float ) *tempI;
-					}
-					PyMem_Free( tempI );
-					*m2 = newMatrixObject( mat,
-							       ( ( ( MatrixObject * ) * m1 )->rowSize ), ( ( ( MatrixObject * ) * m1 )->colSize ) );
-					( ( MatrixObject * ) * m2 )->flag = 1;	//int coercion
-					PyMem_Free( mat );
-					Py_INCREF( *m1 );
-					return 0;
-				} else if( PyFloat_Check( *m2 ) ) {	//it's a float
-					tempF = PyMem_Malloc( 1 *
-							      sizeof
-							      ( double ) );
-					if( tempF == NULL ) {
-						return ( EXPP_ReturnIntError
-							 ( PyExc_MemoryError,
-							   "problem allocating tempF\n\n" ) );
-					}
-					*tempF = PyFloat_AsDouble( *m2 );
-					mat = PyMem_Malloc( matSize *
-							    sizeof( float ) );
-					if( mat == NULL ) {
-						PyMem_Free( tempF );
-						return ( EXPP_ReturnIntError
-							 ( PyExc_MemoryError,
-							   "problem allocating mat\n\n" ) );
+	}else{
+		if(mat2->coerced_object){
+			if(VectorObject_Check(mat2->coerced_object)){ //MATRIX * VECTOR
+				vec = (VectorObject*)EXPP_incr_ret(mat2->coerced_object);
+				retObj = column_vector_multiplication(mat1, vec);
+				EXPP_decr3((PyObject*)mat1, (PyObject*)mat2, (PyObject*)vec);
+				return retObj;
+			}else if (PyFloat_Check(mat2->coerced_object) || 
+				PyInt_Check(mat2->coerced_object)){	// MATRIX * FLOAT/INT
+				f = PyNumber_Float(mat2->coerced_object);
+				if(f == NULL) { // parsed item not a number
+					EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Matrix multiplication: arguments not acceptable for this operation\n");
+				}
+				scalar = PyFloat_AS_DOUBLE(f);
+				for(x = 0; x < mat1->rowSize; x++) {
+					for(y = 0; y < mat1->colSize; y++) {
+						mat[((x * mat1->colSize) + y)] = scalar * mat1->matrix[x][y];
 					}
-					for( x = 0; x < matSize; x++ ) {
-						mat[x] = ( float ) *tempF;
+				}
+				EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+				return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW);
+			}
+		}else{  //MATRIX * MATRIX
+			if(mat1->colSize != mat2->rowSize){
+				EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+				return EXPP_ReturnPyObjError(PyExc_AttributeError,
+					"Matrix multiplication: matrix A rowsize must equal matrix B colsize\n");
+			}
+			for(x = 0; x < mat1->rowSize; x++) {
+				for(y = 0; y < mat2->colSize; y++) {
+					for(z = 0; z < mat1->colSize; z++) {
+						dot += (mat1->matrix[x][z] * mat2->matrix[z][y]);
 					}
-					PyMem_Free( tempF );
-					*m2 = newMatrixObject( mat,
-							       ( ( ( MatrixObject * ) * m1 )->rowSize ), ( ( ( MatrixObject * ) * m1 )->colSize ) );
-					( ( MatrixObject * ) * m2 )->flag = 2;	//float coercion
-					PyMem_Free( mat );
-					Py_INCREF( *m1 );
-					return 0;
+					mat[((x * mat1->rowSize) + y)] = dot;
+					dot = 0.0f;
 				}
 			}
-			//unknom2n type or numeric cast failure
-			printf( "attempting matrix operation m2ith unsupported type...\n" );
-			Py_INCREF( *m1 );
-			return 0;	//operation m2ill type check
+			return newMatrixObject(mat, mat1->rowSize, mat2->colSize, Py_NEW);
 		}
-	} else {
-		//1st not Matrix
-		printf( "numeric protocol failure...\n" );
-		return -1;	//this should not occur - fail
 	}
-	return -1;
-}
 
-//******************************************************************
-//                                      Matrix definition
-//******************************************************************
+	EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
+	return EXPP_ReturnPyObjError(PyExc_TypeError, 
+		"Matrix multiplication: arguments not acceptable for this operation\n");
+}
+//------------------------coerce(obj, obj)-----------------------
+//coercion of unknown types to type MatrixObject for numeric protocols
+/*Coercion() is called whenever a math operation has 2 operands that
+ it doesn't understand how to evaluate. 2+Matrix for example. We want to 
+ evaluate some of these operations like: (vector * 2), however, for math
+ to proceed, the unknown operand must be cast to a type that python math will
+ understand. (e.g. in the case above case, 2 must be cast to a vector and 
+ then call vector.multiply(vector, scalar_cast_as_vector)*/
+static int Matrix_coerce(PyObject ** m1, PyObject ** m2)
+{
+	PyObject *coerced = NULL;
+	if(!MatrixObject_Check(*m2)) {
+		if(VectorObject_Check(*m2) || PyFloat_Check(*m2) || PyInt_Check(*m2)) {
+			coerced = EXPP_incr_ret(*m2);
+			*m2 = newMatrixObject(NULL,3,3,Py_NEW);
+			((MatrixObject*)*m2)->coerced_object = coerced;
+		}else{
+			return EXPP_ReturnIntError(PyExc_TypeError, 
+				"matrix.coerce(): unknown operand - can't coerce for numeric protocols\n");
+		}
+	}
+	Py_INCREF(*m2);
+	Py_INCREF(*m1);
+	return 0;
+}
+//-----------------PROTCOL DECLARATIONS--------------------------
 static PySequenceMethods Matrix_SeqMethods = {
-	( inquiry ) Matrix_len,	/* sq_length */
-	( binaryfunc ) 0,	/* sq_concat */
-	( intargfunc ) 0,	/* sq_repeat */
-	( intargfunc ) Matrix_item,	/* sq_item */
-	( intintargfunc ) Matrix_slice,	/* sq_slice */
-	( intobjargproc ) Matrix_ass_item,	/* sq_ass_item */
-	( intintobjargproc ) Matrix_ass_slice,	/* sq_ass_slice */
+	(inquiry) Matrix_len,					/* sq_length */
+	(binaryfunc) 0,							/* sq_concat */
+	(intargfunc) 0,							/* sq_repeat */
+	(intargfunc) Matrix_item,				/* sq_item */
+	(intintargfunc) Matrix_slice,			/* sq_slice */
+	(intobjargproc) Matrix_ass_item,		/* sq_ass_item */
+	(intintobjargproc) Matrix_ass_slice,	/* sq_ass_slice */
 };
-
 static PyNumberMethods Matrix_NumMethods = {
-	( binaryfunc ) Matrix_add,	/* __add__ */
-	( binaryfunc ) Matrix_sub,	/* __sub__ */
-	( binaryfunc ) Matrix_mul,	/* __mul__ */
-	( binaryfunc ) 0,	/* __div__ */
-	( binaryfunc ) 0,	/* __mod__ */
-	( binaryfunc ) 0,	/* __divmod__ */
-	( ternaryfunc ) 0,	/* __pow__ */
-	( unaryfunc ) 0,	/* __neg__ */
-	( unaryfunc ) 0,	/* __pos__ */
-	( unaryfunc ) 0,	/* __abs__ */
-	( inquiry ) 0,		/* __nonzero__ */
-	( unaryfunc ) 0,	/* __invert__ */
-	( binaryfunc ) 0,	/* __lshift__ */
-	( binaryfunc ) 0,	/* __rshift__ */
-	( binaryfunc ) 0,	/* __and__ */
-	( binaryfunc ) 0,	/* __xor__ */
-	( binaryfunc ) 0,	/* __or__ */
-	( coercion ) Matrix_coerce,	/* __coerce__ */
-	( unaryfunc ) 0,	/* __int__ */
-	( unaryfunc ) 0,	/* __long__ */
-	( unaryfunc ) 0,	/* __float__ */
-	( unaryfunc ) 0,	/* __oct__ */
-	( unaryfunc ) 0,	/* __hex__ */
+	(binaryfunc) Matrix_add,				/* __add__ */
+	(binaryfunc) Matrix_sub,				/* __sub__ */
+	(binaryfunc) Matrix_mul,				/* __mul__ */
+	(binaryfunc) 0,							/* __div__ */
+	(binaryfunc) 0,							/* __mod__ */
+	(binaryfunc) 0,							/* __divmod__ */
+	(ternaryfunc) 0,						/* __pow__ */
+	(unaryfunc) 0,							/* __neg__ */
+	(unaryfunc) 0,							/* __pos__ */
+	(unaryfunc) 0,							/* __abs__ */
+	(inquiry) 0,							/* __nonzero__ */
+	(unaryfunc) 0,							/* __invert__ */
+	(binaryfunc) 0,							/* __lshift__ */
+	(binaryfunc) 0,							/* __rshift__ */
+	(binaryfunc) 0,							/* __and__ */
+	(binaryfunc) 0,							/* __xor__ */
+	(binaryfunc) 0,							/* __or__ */
+	(coercion) Matrix_coerce,				/* __coerce__ */
+	(unaryfunc) 0,							/* __int__ */
+	(unaryfunc) 0,							/* __long__ */
+	(unaryfunc) 0,							/* __float__ */
+	(unaryfunc) 0,							/* __oct__ */
+	(unaryfunc) 0,							/* __hex__ */
 };
-
+//------------------PY_OBECT DEFINITION--------------------------
 PyTypeObject matrix_Type = {
-	PyObject_HEAD_INIT( NULL )    /*   required python macro   */
-	0,	/*ob_size */
-	"Matrix",		/*tp_name */
-	sizeof( MatrixObject ),	/*tp_basicsize */
-	0,			/*tp_itemsize */
-	( destructor ) Matrix_dealloc,	/*tp_dealloc */
-	( printfunc ) 0,	/*tp_print */
-	( getattrfunc ) Matrix_getattr,	/*tp_getattr */
-	( setattrfunc ) Matrix_setattr,	/*tp_setattr */
-	0,			/*tp_compare */
-	( reprfunc ) Matrix_repr,	/*tp_repr */
-	&Matrix_NumMethods,	/*tp_as_number */
-	&Matrix_SeqMethods,	/*tp_as_sequence */
+	PyObject_HEAD_INIT(NULL)				/* required python macro */
+	0,										/*ob_size */
+	"Matrix",								/*tp_name */
+	sizeof(MatrixObject),					/*tp_basicsize */
+	0,										/*tp_itemsize */
+	(destructor) Matrix_dealloc,			/*tp_dealloc */
+	(printfunc) 0,							/*tp_print */
+	(getattrfunc) Matrix_getattr,			/*tp_getattr */
+	(setattrfunc) Matrix_setattr,			/*tp_setattr */
+	0,										/*tp_compare */
+	(reprfunc) Matrix_repr,					/*tp_repr */
+	&Matrix_NumMethods,						/*tp_as_number */
+	&Matrix_SeqMethods,						/*tp_as_sequence */
 };
-
-//******************************************************************
-//Function:                              newMatrixObject
-//******************************************************************
-PyObject *newMatrixObject( float *mat, int rowSize, int colSize )
+//------------------------newMatrixObject (internal)-------------
+//creates a new matrix object
+//self->matrix     self->contiguous_ptr (reference to data.xxx)
+//       [0]------------->[0]
+//                        [1]
+//                        [2]
+//       [1]------------->[3]
+//                        [4]
+//                        [5]
+//	             ....
+//self->matrix[1][1] = self->contiguous_ptr[4] = self->data.xxx_data[4]
+/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ (i.e. it was allocated elsewhere by MEM_mallocN())
+  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ (i.e. it must be created here with PyMEM_malloc())*/
+PyObject *newMatrixObject(float *mat, int rowSize, int colSize, int type)
 {
 	MatrixObject *self;
-	int row, col, x;
-
-	if( rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4 )
-		return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
-						"row and column sizes must be between 2 and 4\n" ) );
-
-	self = PyObject_NEW( MatrixObject, &matrix_Type );
+	int x, row, col;
 
-	//generate contigous memory space
-	self->contigPtr = PyMem_Malloc( rowSize * colSize * sizeof( float ) );
-	if( self->contigPtr == NULL ) {
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating array space\n\n" ) );
-	}
-	//create pointer array
-	self->matrix = PyMem_Malloc( rowSize * sizeof( float * ) );
-	if( self->matrix == NULL ) {
-		PyMem_Free( self->contigPtr );
-		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
-						"problem allocating pointer space\n\n" ) );
-	}
-	//pointer array points to contigous memory
-	for( x = 0; x < rowSize; x++ ) {
-		self->matrix[x] = self->contigPtr + ( x * colSize );
+	//matrix objects can be any 2-4row x 2-4col matrix
+	if(rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4){
+		return EXPP_ReturnPyObjError(PyExc_RuntimeError,
+			"matrix(): row and column sizes must be between 2 and 4\n");
 	}
 
-	if( mat ) {		//if a float array passed
-		for( row = 0; row < rowSize; row++ ) {
-			for( col = 0; col < colSize; col++ ) {
-				self->matrix[row][col] =
-					mat[( row * colSize ) + col];
-			}
+	matrix_Type.ob_type = &PyType_Type;
+	self = PyObject_NEW(MatrixObject, &matrix_Type);
+	self->data.blend_data = NULL;
+	self->data.py_data = NULL;
+	self->rowSize = rowSize;
+	self->colSize = colSize;
+	self->coerced_object = NULL;
+
+	if(type == Py_WRAP){
+		self->data.blend_data = mat;
+		self->contigPtr = self->data.blend_data;
+		//create pointer array
+		self->matrix = PyMem_Malloc(rowSize * sizeof(float *));
+		if(self->matrix == NULL) { //allocation failure
+			return EXPP_ReturnPyObjError( PyExc_MemoryError,
+				"matrix(): problem allocating pointer space\n");
+		}
+		//pointer array points to contigous memory
+		for(x = 0; x < rowSize; x++) {
+			self->matrix[x] = self->contigPtr + (x * colSize);
+		}
+	}else if (type == Py_NEW){
+		self->data.py_data = PyMem_Malloc(rowSize * colSize * sizeof(float));
+		if(self->data.py_data == NULL) { //allocation failure
+			return EXPP_ReturnPyObjError( PyExc_MemoryError,
+				"matrix(): problem allocating pointer space\n");
 		}
-	} else {		//or if NULL passed
-		for( row = 0; row < rowSize; row++ ) {
-			for( col = 0; col < colSize; col++ ) {
-				self->matrix[row][col] = 0.0f;
+		self->contigPtr = self->data.py_data;
+		//create pointer array
+		self->matrix = PyMem_Malloc(rowSize * sizeof(float *));
+		if(self->matrix == NULL) { //allocation failure
+			PyMem_Free(self->data.py_data);
+			return EXPP_ReturnPyObjError( PyExc_MemoryError,
+				"matrix(): problem allocating pointer space\n");
+		}
+		//pointer array points to contigous memory
+		for(x = 0; x < rowSize; x++) {
+			self->matrix[x] = self->contigPtr + (x * colSize);
+		}
+		//parse
+		if(mat) {	//if a float array passed
+			for(row = 0; row < rowSize; row++) {
+				for(col = 0; col < colSize; col++) {
+					self->matrix[row][col] = mat[(row * colSize) + col];
+				}
 			}
+		} else { //or if no arguments are passed return identity matrix
+			Matrix_Identity(self);
 		}
+	}else{ //bad type
+		return NULL;
 	}
-
-	//set size vars of matrix
-	self->rowSize = rowSize;
-	self->colSize = colSize;
-
-	//set coercion flag
-	self->flag = 0;
-
-	return ( ( PyObject * ) self );
+	return (PyObject *) EXPP_incr_ret((PyObject *)self);
 }
diff --git a/source/blender/python/api2_2x/matrix.h b/source/blender/python/api2_2x/matrix.h
index b40ec978159..9c114867786 100644
--- a/source/blender/python/api2_2x/matrix.h
+++ b/source/blender/python/api2_2x/matrix.h
@@ -33,37 +33,31 @@
 #ifndef EXPP_matrix_h
 #define EXPP_matrix_h
 
-#include "Python.h"
-#include "BLI_arithb.h"
-#include "vector.h"
-#include "gen_utils.h"
-#include "Types.h"
-#include "quat.h"
-#include "euler.h"
+#define MatrixObject_Check(v) ((v)->ob_type == &matrix_Type)
 
-#define Matrix_CheckPyObject(v) ((v)->ob_type == &matrix_Type)
-
-/*****************************/
-/*    Matrix Python Object   */
-/*****************************/
 typedef float **ptRow;
-
 typedef struct _Matrix {
-	PyObject_VAR_HEAD  /*     standard python macro  */
-	ptRow matrix;
-	float *contigPtr;
+	PyObject_VAR_HEAD 
+	struct{
+		float *py_data;		//python managed
+		float *blend_data;	//blender managed
+	}data;
+	ptRow matrix;			//ptr to the contigPtr (accessor)
+	float *contigPtr;		//1D array of data (alias)
 	int rowSize;
 	int colSize;
-	int flag;
-	//0 - no coercion
-	//1 - coerced from int
-	//2 - coerced from float
+	PyObject *coerced_object;
 } MatrixObject;
+/*coerced_object is a pointer to the object that it was
+coerced from when a dummy vector needs to be created from
+the coerce() function for numeric protocol operations*/
+
+/*struct data contains a pointer to the actual data that the
+object uses. It can use either PyMem allocated data (which will
+be stored in py_data) or be a wrapper for data allocated through
+blender (stored in blend_data). This is an either/or struct not both*/
 
-/*****************************************************************************/
-/* Python API function prototypes.					    */
-/*****************************************************************************/
-PyObject *newMatrixObject( float *mat, int rowSize, int colSize );
+//prototypes
 PyObject *Matrix_Zero( MatrixObject * self );
 PyObject *Matrix_Identity( MatrixObject * self );
 PyObject *Matrix_Transpose( MatrixObject * self );
@@ -74,5 +68,6 @@ PyObject *Matrix_RotationPart( MatrixObject * self );
 PyObject *Matrix_Resize4x4( MatrixObject * self );
 PyObject *Matrix_toEuler( MatrixObject * self );
 PyObject *Matrix_toQuat( MatrixObject * self );
+PyObject *newMatrixObject(float *mat, int rowSize, int colSize, int type);
 
 #endif				/* EXPP_matrix_H */
diff --git a/source/blender/python/api2_2x/quat.c b/source/blender/python/api2_2x/quat.c
index 35ef90aca2d..78944b9f7d5 100644
--- a/source/blender/python/api2_2x/quat.c
+++ b/source/blender/python/api2_2x/quat.c
@@ -29,545 +29,570 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
-#include "quat.h"
-
-//doc strings
-char Quaternion_Identity_doc[] =
-	"() - set the quaternion to it's identity (1, vector)";
-char Quaternion_Negate_doc[] =
-	"() - set all values in the quaternion to their negative";
+#include "BLI_arithb.h"
+#include "BKE_utildefines.h"
+#include "Mathutils.h"
+#include "gen_utils.h"
+#include "BLI_blenlib.h"
+
+//-------------------------DOC STRINGS ---------------------------
+char Quaternion_Identity_doc[] = "() - set the quaternion to it's identity (1, vector)";
+char Quaternion_Negate_doc[] = "() - set all values in the quaternion to their negative";
 char Quaternion_Conjugate_doc[] = "() - set the quaternion to it's conjugate";
 char Quaternion_Inverse_doc[] = "() - set the quaternion to it's inverse";
-char Quaternion_Normalize_doc[] =
-	"() - normalize the vector portion of the quaternion";
-char Quaternion_ToEuler_doc[] =
-	"() - return a euler rotation representing the quaternion";
-char Quaternion_ToMatrix_doc[] =
-	"() - return a rotation matrix representing the quaternion";
-
-//methods table
+char Quaternion_Normalize_doc[] = "() - normalize the vector portion of the quaternion";
+char Quaternion_ToEuler_doc[] = "() - return a euler rotation representing the quaternion";
+char Quaternion_ToMatrix_doc[] = "() - return a rotation matrix representing the quaternion";
+//-----------------------METHOD DEFINITIONS ----------------------
 struct PyMethodDef Quaternion_methods[] = {
-	{"identity", ( PyCFunction ) Quaternion_Identity, METH_NOARGS,
-	 Quaternion_Identity_doc},
-	{"negate", ( PyCFunction ) Quaternion_Negate, METH_NOARGS,
-	 Quaternion_Negate_doc},
-	{"conjugate", ( PyCFunction ) Quaternion_Conjugate, METH_NOARGS,
-	 Quaternion_Conjugate_doc},
-	{"inverse", ( PyCFunction ) Quaternion_Inverse, METH_NOARGS,
-	 Quaternion_Inverse_doc},
-	{"normalize", ( PyCFunction ) Quaternion_Normalize, METH_NOARGS,
-	 Quaternion_Normalize_doc},
-	{"toEuler", ( PyCFunction ) Quaternion_ToEuler, METH_NOARGS,
-	 Quaternion_ToEuler_doc},
-	{"toMatrix", ( PyCFunction ) Quaternion_ToMatrix, METH_NOARGS,
-	 Quaternion_ToMatrix_doc},
+	{"identity", (PyCFunction) Quaternion_Identity, METH_NOARGS, Quaternion_Identity_doc},
+	{"negate", (PyCFunction) Quaternion_Negate, METH_NOARGS, Quaternion_Negate_doc},
+	{"conjugate", (PyCFunction) Quaternion_Conjugate, METH_NOARGS, Quaternion_Conjugate_doc},
+	{"inverse", (PyCFunction) Quaternion_Inverse, METH_NOARGS, Quaternion_Inverse_doc},
+	{"normalize", (PyCFunction) Quaternion_Normalize, METH_NOARGS, Quaternion_Normalize_doc},
+	{"toEuler", (PyCFunction) Quaternion_ToEuler, METH_NOARGS, Quaternion_ToEuler_doc},
+	{"toMatrix", (PyCFunction) Quaternion_ToMatrix, METH_NOARGS, Quaternion_ToMatrix_doc},
 	{NULL, NULL, 0, NULL}
 };
-
-/* ****** prototypes ********** */
-PyObject *Quaternion_add( PyObject * q1, PyObject * q2 );
-PyObject *Quaternion_sub( PyObject * q1, PyObject * q2 );
-PyObject *Quaternion_mul( PyObject * q1, PyObject * q2 );
-int Quaternion_coerce( PyObject ** q1, PyObject ** q2 );
-
-
-/*****************************/
-//    Quaternion Python Object   
-/*****************************/
-
-PyObject *Quaternion_ToEuler( QuaternionObject * self )
+//-----------------------------METHODS------------------------------
+//----------------------------Quaternion.toEuler()------------------
+//return the quat as a euler
+PyObject *Quaternion_ToEuler(QuaternionObject * self)
 {
-	float *eul;
+	float eul[3];
 	int x;
 
-	eul = PyMem_Malloc( 3 * sizeof( float ) );
-	QuatToEul( self->quat, eul );
-
-	for( x = 0; x < 3; x++ ) {
-		eul[x] *= ( float ) ( 180 / Py_PI );
+	QuatToEul(self->quat, eul);
+	for(x = 0; x < 3; x++) {
+		eul[x] *= (180 / (float)Py_PI);
 	}
-	return ( PyObject * ) newEulerObject( eul );
+	if(self->data.blend_data)
+        return newEulerObject(eul, Py_WRAP);
+	else
+		return newEulerObject(eul, Py_NEW);
 }
-
-PyObject *Quaternion_ToMatrix( QuaternionObject * self )
+//----------------------------Quaternion.toMatrix()------------------
+//return the quat as a matrix
+PyObject *Quaternion_ToMatrix(QuaternionObject * self)
 {
-	float *mat;
-
-	mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
-	QuatToMat3( self->quat, ( float ( * )[3] ) mat );
+	float mat[9] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+	QuatToMat3(self->quat, (float (*)[3]) mat);
 
-	return ( PyObject * ) newMatrixObject( mat, 3, 3 );
+	if(self->data.blend_data)
+		return newMatrixObject(mat, 3, 3, Py_WRAP);
+	else
+		return newMatrixObject(mat, 3, 3, Py_NEW);
 }
-
+//----------------------------Quaternion.normalize()----------------
 //normalize the axis of rotation of [theta,vector]
-PyObject *Quaternion_Normalize( QuaternionObject * self )
+PyObject *Quaternion_Normalize(QuaternionObject * self)
 {
-	NormalQuat( self->quat );
-	return EXPP_incr_ret( Py_None );
+	NormalQuat(self->quat);
+	return (PyObject*)self;
 }
-
-PyObject *Quaternion_Inverse( QuaternionObject * self )
+//----------------------------Quaternion.inverse()------------------
+//invert the quat
+PyObject *Quaternion_Inverse(QuaternionObject * self)
 {
-	float mag = 0.0f;
+	double mag = 0.0f;
 	int x;
 
-	for( x = 1; x < 4; x++ ) {
+	for(x = 1; x < 4; x++) {
 		self->quat[x] = -self->quat[x];
 	}
-	for( x = 0; x < 4; x++ ) {
-		mag += ( self->quat[x] * self->quat[x] );
+	for(x = 0; x < 4; x++) {
+		mag += (self->quat[x] * self->quat[x]);
 	}
-	mag = ( float ) sqrt( mag );
-	for( x = 0; x < 4; x++ ) {
-		self->quat[x] /= ( mag * mag );
+	mag = sqrt(mag);
+	for(x = 0; x < 4; x++) {
+		self->quat[x] /= (mag * mag);
 	}
 
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Quaternion_Identity( QuaternionObject * self )
+//----------------------------Quaternion.identity()-----------------
+//generate the identity quaternion
+PyObject *Quaternion_Identity(QuaternionObject * self)
 {
 	self->quat[0] = 1.0;
 	self->quat[1] = 0.0;
 	self->quat[2] = 0.0;
 	self->quat[3] = 0.0;
 
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Quaternion_Negate( QuaternionObject * self )
+//----------------------------Quaternion.negate()-------------------
+//negate the quat
+PyObject *Quaternion_Negate(QuaternionObject * self)
 {
 	int x;
-
-	for( x = 0; x < 4; x++ ) {
+	for(x = 0; x < 4; x++) {
 		self->quat[x] = -self->quat[x];
 	}
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Quaternion_Conjugate( QuaternionObject * self )
+//----------------------------Quaternion.conjugate()----------------
+//negate the vector part
+PyObject *Quaternion_Conjugate(QuaternionObject * self)
 {
 	int x;
-
-	for( x = 1; x < 4; x++ ) {
+	for(x = 1; x < 4; x++) {
 		self->quat[x] = -self->quat[x];
 	}
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-static void Quaternion_dealloc( QuaternionObject * self )
+//----------------------------dealloc()(internal) ------------------
+//free the py_object
+static void Quaternion_dealloc(QuaternionObject * self)
 {
-	PyMem_Free( self->quat );
-	PyObject_DEL( self );
+	//only free py_data
+	if(self->data.py_data){
+		PyMem_Free(self->data.py_data);
+	}
+	PyObject_DEL(self);
 }
-
-static PyObject *Quaternion_getattr( QuaternionObject * self, char *name )
+//----------------------------getattr()(internal) ------------------
+//object.attribute access (get)
+static PyObject *Quaternion_getattr(QuaternionObject * self, char *name)
 {
-	double mag = 0.0f;
-	float *vec = NULL;
 	int x;
-	PyObject *retval;
-
-	if( ELEM4( name[0], 'w', 'x', 'y', 'z' ) && name[1] == 0 ) {
-		return PyFloat_FromDouble( self->quat[name[0] - 'w'] );
+	double mag = 0.0f;
+	float vec[3];
+
+	if(STREQ(name,"w")){
+		return PyFloat_FromDouble(self->quat[0]);
+	}else if(STREQ(name, "x")){
+		return PyFloat_FromDouble(self->quat[1]);
+	}else if(STREQ(name, "y")){
+		return PyFloat_FromDouble(self->quat[2]);
+	}else if(STREQ(name, "z")){
+		return PyFloat_FromDouble(self->quat[3]);
 	}
-	if( strcmp( name, "magnitude" ) == 0 ) {
-		for( x = 0; x < 4; x++ ) {
+	if(STREQ(name, "magnitude")) {
+		for(x = 0; x < 4; x++) {
 			mag += self->quat[x] * self->quat[x];
 		}
-		mag = ( float ) sqrt( mag );
-		return PyFloat_FromDouble( mag );
+		mag = sqrt(mag);
+		return PyFloat_FromDouble(mag);
 	}
-	if( strcmp( name, "angle" ) == 0 ) {
-
+	if(STREQ(name, "angle")) {
 		mag = self->quat[0];
-		mag = 2 * ( acos( mag ) );
-		mag *= ( 180 / Py_PI );
-		return PyFloat_FromDouble( mag );
+		mag = 2 * (acos(mag));
+		mag *= (180 / Py_PI);
+		return PyFloat_FromDouble(mag);
 	}
-	if( strcmp( name, "axis" ) == 0 ) {
-
-		mag = ( double ) ( self->quat[0] * ( Py_PI / 180 ) );
-		mag = 2 * ( acos( mag ) );
-		mag = sin( mag / 2 );
-		vec = PyMem_Malloc( 3 * sizeof( float ) );
-		for( x = 0; x < 3; x++ ) {
-			vec[x] = ( self->quat[x + 1] / ( ( float ) ( mag ) ) );
+	if(STREQ(name, "axis")) {
+		mag = self->quat[0] * (Py_PI / 180);
+		mag = 2 * (acos(mag));
+		mag = sin(mag / 2);
+		for(x = 0; x < 3; x++) {
+			vec[x] = (self->quat[x + 1] / mag);
 		}
-		Normalise( vec );
-		retval = ( PyObject * ) newVectorObject( vec, 3 );
-		PyMem_Free( vec );
-		return retval;
+		Normalise(vec);
+		return (PyObject *) newVectorObject(vec, 3, Py_NEW);
 	}
-	return Py_FindMethod( Quaternion_methods, ( PyObject * ) self, name );
-}
 
-static int Quaternion_setattr( QuaternionObject * self, char *name,
-			       PyObject * v )
+	return Py_FindMethod(Quaternion_methods, (PyObject *) self, name);
+}
+//----------------------------setattr()(internal) ------------------
+//object.attribute access (set)
+static int Quaternion_setattr(QuaternionObject * self, char *name, PyObject * q)
 {
-	float val;
-
-	if( !PyFloat_Check( v ) && !PyInt_Check( v ) ) {
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "int or float expected\n" );
-	} else {
-		if( !PyArg_Parse( v, "f", &val ) )
-			return EXPP_ReturnIntError( PyExc_TypeError,
-						    "unable to parse float argument\n" );
+	PyObject *f = NULL;
+
+	f = PyNumber_Float(q);
+	if(f == NULL) { // parsed item not a number
+		return EXPP_ReturnIntError(PyExc_TypeError, 
+			"quaternion.attribute = x: argument not a number\n");
+	}
+
+	if(STREQ(name,"w")){
+		self->quat[0] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "x")){
+		self->quat[1] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "y")){
+		self->quat[2] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "z")){
+		self->quat[3] = PyFloat_AS_DOUBLE(f);
+	}else{
+		Py_DECREF(f);
+		return EXPP_ReturnIntError(PyExc_AttributeError,
+				"quaternion.attribute = x: unknown attribute\n");
 	}
-	if( ELEM4( name[0], 'w', 'x', 'y', 'z' ) && name[1] == 0 ) {
-		self->quat[name[0] - 'w'] = val;
-	} else
-		return -1;
 
+	Py_DECREF(f);
 	return 0;
 }
-
-/* Quaternions Sequence methods */
-static PyObject *Quaternion_item( QuaternionObject * self, int i )
+//----------------------------print object (internal)--------------
+//print the object to screen
+static PyObject *Quaternion_repr(QuaternionObject * self)
 {
-	if( i < 0 || i >= 4 )
-		return EXPP_ReturnPyObjError( PyExc_IndexError,
-					      "array index out of range\n" );
+	int i;
+	char buffer[48], str[1024];
+
+	BLI_strncpy(str,"[",1024);
+	for(i = 0; i < 4; i++){
+		if(i < (3)){
+			sprintf(buffer, "%.6f, ", self->quat[i]);
+			strcat(str,buffer);
+		}else{
+			sprintf(buffer, "%.6f", self->quat[i]);
+			strcat(str,buffer);
+		}
+	}
+	strcat(str, "](quaternion)");
 
-	return Py_BuildValue( "f", self->quat[i] );
+	return EXPP_incr_ret(PyString_FromString(str));
 }
-
-static PyObject *Quaternion_slice( QuaternionObject * self, int begin,
-				   int end )
+//---------------------SEQUENCE PROTOCOLS------------------------
+//----------------------------len(object)------------------------
+//sequence length
+static int Quaternion_len(QuaternionObject * self)
 {
-	PyObject *list;
-	int count;
-
-	if( begin < 0 )
-		begin = 0;
-	if( end > 4 )
-		end = 4;
-	if( begin > end )
-		begin = end;
+	return 4;
+}
+//----------------------------object[]---------------------------
+//sequence accessor (get)
+static PyObject *Quaternion_item(QuaternionObject * self, int i)
+{
+	if(i < 0 || i >= 4)
+		return EXPP_ReturnPyObjError(PyExc_IndexError,
+		"quaternion[attribute]: array index out of range\n");
 
-	list = PyList_New( end - begin );
+	return Py_BuildValue("f", self->quat[i]);
 
-	for( count = begin; count < end; count++ ) {
-		PyList_SetItem( list, count - begin,
-				PyFloat_FromDouble( self->quat[count] ) );
-	}
-	return list;
 }
-
-static int Quaternion_ass_item( QuaternionObject * self, int i, PyObject * ob )
+//----------------------------object[]-------------------------
+//sequence accessor (set)
+static int Quaternion_ass_item(QuaternionObject * self, int i, PyObject * ob)
 {
-	if( i < 0 || i >= 4 )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "array assignment index out of range\n" );
-	if( !PyNumber_Check( ob ) )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "Quaternion member must be a number\n" );
-
-	if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "int or float expected\n" );
-	} else {
-		self->quat[i] = ( float ) PyFloat_AsDouble( ob );
+	PyObject *f = NULL;
+
+	f = PyNumber_Float(ob);
+	if(f == NULL) { // parsed item not a number
+		return EXPP_ReturnIntError(PyExc_TypeError, 
+			"quaternion[attribute] = x: argument not a number\n");
 	}
-	return 0;
-}
 
-static int Quaternion_ass_slice( QuaternionObject * self, int begin, int end,
-				 PyObject * seq )
-{
-	int count, z;
-
-	if( begin < 0 )
-		begin = 0;
-	if( end > 4 )
-		end = 4;
-	if( begin > end )
-		begin = end;
-
-	if( !PySequence_Check( seq ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "illegal argument type for built-in operation\n" );
-	if( PySequence_Length( seq ) != ( end - begin ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "size mismatch in slice assignment\n" );
-
-	z = 0;
-	for( count = begin; count < end; count++ ) {
-		PyObject *ob = PySequence_GetItem( seq, z );
-		z++;
-
-		if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
-			Py_DECREF( ob );
-			return -1;
-		} else {
-			if( !PyArg_Parse( ob, "f", &self->quat[count] ) ) {
-				Py_DECREF( ob );
-				return -1;
-			}
-		}
+	if(i < 0 || i >= 4){
+		Py_DECREF(f);
+		return EXPP_ReturnIntError(PyExc_IndexError,
+			"quaternion[attribute] = x: array assignment index out of range\n");
 	}
+	self->quat[i] = PyFloat_AS_DOUBLE(f);
+	Py_DECREF(f);
 	return 0;
 }
-
-static PyObject *Quaternion_repr( QuaternionObject * self )
+//----------------------------object[z:y]------------------------
+//sequence slice (get)
+static PyObject *Quaternion_slice(QuaternionObject * self, int begin, int end)
 {
-	int i, maxindex = 4 - 1;
-	char ftoa[24];
-	PyObject *str1, *str2;
-
-	str1 = PyString_FromString( "[" );
-
-	for( i = 0; i < maxindex; i++ ) {
-		sprintf( ftoa, "%.4f, ", self->quat[i] );
-		str2 = PyString_FromString( ftoa );
-		if( !str1 || !str2 )
-			goto error;
-		PyString_ConcatAndDel( &str1, str2 );
-	}
+	PyObject *list = NULL;
+	int count;
 
-	sprintf( ftoa, "%.4f]", self->quat[maxindex] );
-	str2 = PyString_FromString( ftoa );
-	if( !str1 || !str2 )
-		goto error;
-	PyString_ConcatAndDel( &str1, str2 );
+	CLAMP(begin, 0, 4);
+	CLAMP(end, 0, 4);
+	begin = MIN2(begin,end);
 
-	if( str1 )
-		return str1;
+	list = PyList_New(end - begin);
+	for(count = begin; count < end; count++) {
+		PyList_SetItem(list, count - begin,
+				PyFloat_FromDouble(self->quat[count]));
+	}
 
-      error:
-	Py_XDECREF( str1 );
-	Py_XDECREF( str2 );
-	return EXPP_ReturnPyObjError( PyExc_MemoryError,
-				      "couldn't create PyString!\n" );
+	return list;
 }
-
-
-PyObject *Quaternion_add( PyObject * q1, PyObject * q2 )
+//----------------------------object[z:y]------------------------
+//sequence slice (set)
+static int Quaternion_ass_slice(QuaternionObject * self, int begin, int end,
+			     PyObject * seq)
 {
-	float *quat = NULL;
-	PyObject *retval;
-	int x;
+	int i, y, size = 0;
+	float quat[4];
 
-	if( ( !QuaternionObject_Check( q1 ) )
-	    || ( !QuaternionObject_Check( q2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( QuaternionObject * ) q1 )->flag > 0
-	    || ( ( QuaternionObject * ) q2 )->flag > 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "cannot add a scalar and a quat\n" );
-
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	for( x = 0; x < 4; x++ ) {
-		quat[x] =
-			( ( ( QuaternionObject * ) q1 )->quat[x] ) +
-			( ( ( QuaternionObject * ) q2 )->quat[x] );
+	CLAMP(begin, 0, 4);
+	CLAMP(end, 0, 4);
+	begin = MIN2(begin,end);
+
+	size = PySequence_Length(seq);
+	if(size != (end - begin)){
+		return EXPP_ReturnIntError(PyExc_TypeError,
+			"quaternion[begin:end] = []: size mismatch in slice assignment\n");
 	}
 
-	retval =  ( PyObject * ) newQuaternionObject( quat );
-	PyMem_Free( quat );
-	return retval;
-}
+	for (i = 0; i < size; i++) {
+		PyObject *q, *f;
 
-PyObject *Quaternion_sub( PyObject * q1, PyObject * q2 )
+		q = PySequence_GetItem(seq, i);
+		if (q == NULL) { // Failed to read sequence
+			return EXPP_ReturnIntError(PyExc_RuntimeError, 
+				"quaternion[begin:end] = []: unable to read sequence\n");
+		}
+		f = PyNumber_Float(q);
+		if(f == NULL) { // parsed item not a number
+			Py_DECREF(q);
+			return EXPP_ReturnIntError(PyExc_TypeError, 
+				"quaternion[begin:end] = []: sequence argument not a number\n");
+		}
+		quat[i] = PyFloat_AS_DOUBLE(f);
+		EXPP_decr2(f,q);
+	}
+	//parsed well - now set in vector
+	for(y = 0; y < size; y++){
+		self->quat[begin + y] = quat[y];
+	}
+	return 0;
+}
+//------------------------NUMERIC PROTOCOLS----------------------
+//------------------------obj + obj------------------------------
+//addition
+static PyObject *Quaternion_add(PyObject * q1, PyObject * q2)
 {
-	float *quat = NULL;
-	PyObject *retval;
 	int x;
+	float quat[4];
+	QuaternionObject *quat1 = NULL, *quat2 = NULL;
+
+	EXPP_incr2(q1, q2);
+	quat1 = (QuaternionObject*)q1;
+	quat2 = (QuaternionObject*)q2;
 
-	if( ( !QuaternionObject_Check( q1 ) )
-	    || ( !QuaternionObject_Check( q2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( QuaternionObject * ) q1 )->flag > 0
-	    || ( ( QuaternionObject * ) q2 )->flag > 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "cannot subtract a scalar and a quat\n" );
-
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	for( x = 0; x < 4; x++ ) {
-		quat[x] =
-			( ( ( QuaternionObject * ) q1 )->quat[x] ) -
-			( ( ( QuaternionObject * ) q2 )->quat[x] );
+	if(quat1->coerced_object || quat2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Quaternion addition: arguments not valid for this operation....\n");
+	}
+	for(x = 0; x < 4; x++) {
+		quat[x] = quat1->quat[x] + quat2->quat[x];
 	}
-	retval = ( PyObject * ) newQuaternionObject( quat );
 
-	PyMem_Free( quat );
-	return retval;
+	EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+	return (PyObject *) newQuaternionObject(quat, Py_NEW);
 }
-
-PyObject *Quaternion_mul( PyObject * q1, PyObject * q2 )
+//------------------------obj - obj------------------------------
+//subtraction
+static PyObject *Quaternion_sub(PyObject * q1, PyObject * q2)
 {
-	float *quat = NULL;
-	PyObject *retval;
 	int x;
+	float quat[4];
+	QuaternionObject *quat1 = NULL, *quat2 = NULL;
+
+	EXPP_incr2(q1, q2);
+	quat1 = (QuaternionObject*)q1;
+	quat2 = (QuaternionObject*)q2;
 
-	if( ( !QuaternionObject_Check( q1 ) )
-	    || ( !QuaternionObject_Check( q2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( QuaternionObject * ) q1 )->flag == 0
-	    && ( ( QuaternionObject * ) q2 )->flag == 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "please use the dot or cross product to multiply quaternions\n" );
-
-	quat = PyMem_Malloc( 4 * sizeof( float ) );
-	//scalar mult by quat
-	for( x = 0; x < 4; x++ ) {
-		quat[x] =
-			( ( QuaternionObject * ) q1 )->quat[x] *
-			( ( QuaternionObject * ) q2 )->quat[x];
+	if(quat1->coerced_object || quat2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Quaternion addition: arguments not valid for this operation....\n");
+	}
+	for(x = 0; x < 4; x++) {
+		quat[x] = quat1->quat[x] - quat2->quat[x];
 	}
-	retval =  ( PyObject * ) newQuaternionObject( quat );
 
-	PyMem_Free( quat );
-	return retval;
+	EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+	return (PyObject *) newQuaternionObject(quat, Py_NEW);
 }
-
-//coercion of unknown types to type QuaternionObject for numeric protocols
-int Quaternion_coerce( PyObject ** q1, PyObject ** q2 )
+//------------------------obj * obj------------------------------
+//mulplication
+static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
 {
-	long *tempI = NULL;
-	double *tempF = NULL;
-	float *quat = NULL;
 	int x;
-
-	if( QuaternionObject_Check( *q1 ) ) {
-		if( QuaternionObject_Check( *q2 ) ) {	//two Quaternions
-			Py_INCREF( *q1 );
-			Py_INCREF( *q2 );
-			return 0;
-		} else {
-			if( PyNumber_Check( *q2 ) ) {
-				if( PyInt_Check( *q2 ) ) {	//cast scalar to Quaternion
-					tempI = PyMem_Malloc( 1 *
-							      sizeof( long ) );
-					*tempI = PyInt_AsLong( *q2 );
-					quat = PyMem_Malloc( 4 *
-							     sizeof( float ) );
-					for( x = 0; x < 4; x++ ) {
-						quat[x] = ( float ) *tempI;
-					}
-					PyMem_Free( tempI );
-					*q2 = newQuaternionObject( quat );
-					PyMem_Free( quat );
-					( ( QuaternionObject * ) * q2 )->flag = 1;	//int coercion
-					Py_INCREF( *q1 );  /* fixme:  is this needed? */
-					return 0;
-				} else if( PyFloat_Check( *q2 ) ) {	//cast scalar to Quaternion
-					tempF = PyMem_Malloc( 1 *
-							      sizeof
-							      ( double ) );
-					*tempF = PyFloat_AsDouble( *q2 );
-					quat = PyMem_Malloc( 4 *
-							     sizeof( float ) );
-					for( x = 0; x < 4; x++ ) {
-						quat[x] = ( float ) *tempF;
-					}
-					PyMem_Free( tempF );
-					*q2 = newQuaternionObject( quat );
-					PyMem_Free( quat );
-					( ( QuaternionObject * ) * q2 )->flag = 2;	//float coercion
-					Py_INCREF( *q1 );  /* fixme:  is this needed? */
-					return 0;
+	float quat[4], scalar, newVec[3];
+	double dot = 0.0f;
+	QuaternionObject *quat1 = NULL, *quat2 = NULL;
+	PyObject *f = NULL;
+	VectorObject *vec = NULL;
+
+	EXPP_incr2(q1, q2);
+	quat1 = (QuaternionObject*)q1;
+	quat2 = (QuaternionObject*)q2;
+
+	if(quat1->coerced_object){
+		if (PyFloat_Check(quat1->coerced_object) || 
+			PyInt_Check(quat1->coerced_object)){	// FLOAT/INT * QUAT
+			f = PyNumber_Float(quat1->coerced_object);
+			if(f == NULL) { // parsed item not a number
+				EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);	
+				return EXPP_ReturnPyObjError(PyExc_TypeError, 
+					"Quaternion multiplication: arguments not acceptable for this operation\n");
+			}
+			scalar = PyFloat_AS_DOUBLE(f);
+			for(x = 0; x < 4; x++) {
+				quat[x] = quat2->quat[x] * scalar;
+			}
+			EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+			return (PyObject *) newQuaternionObject(quat, Py_NEW);
+		}
+	}else{
+		if(quat2->coerced_object){
+			if (PyFloat_Check(quat2->coerced_object) || 
+				PyInt_Check(quat2->coerced_object)){	// QUAT * FLOAT/INT
+				f = PyNumber_Float(quat2->coerced_object);
+				if(f == NULL) { // parsed item not a number
+					EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Quaternion multiplication: arguments not acceptable for this operation\n");
+				}
+				scalar = PyFloat_AS_DOUBLE(f);
+				for(x = 0; x < 4; x++) {
+					quat[x] = quat1->quat[x] * scalar;
+				}
+				EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+				return (PyObject *) newQuaternionObject(quat, Py_NEW);
+			}else if(VectorObject_Check(quat2->coerced_object)){  //QUAT * VEC
+				vec = (VectorObject*)EXPP_incr_ret(quat2->coerced_object);
+				if(vec->size != 3){
+					EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Quaternion multiplication: only 3D vector rotations currently supported\n");
 				}
+				newVec[0] = quat1->quat[0]*quat1->quat[0]*vec->vec[0] + 
+							2*quat1->quat[2]*quat1->quat[0]*vec->vec[2] - 
+							2*quat1->quat[3]*quat1->quat[0]*vec->vec[1] + 
+							quat1->quat[1]*quat1->quat[1]*vec->vec[0] + 
+							2*quat1->quat[2]*quat1->quat[1]*vec->vec[1] + 
+							2*quat1->quat[3]*quat1->quat[1]*vec->vec[2] - 
+							quat1->quat[3]*quat1->quat[3]*vec->vec[0] - 
+							quat1->quat[2]*quat1->quat[2]*vec->vec[0];
+				newVec[1] = 2*quat1->quat[1]*quat1->quat[2]*vec->vec[0] + 
+							quat1->quat[2]*quat1->quat[2]*vec->vec[1] + 
+							2*quat1->quat[3]*quat1->quat[2]*vec->vec[2] + 
+							2*quat1->quat[0]*quat1->quat[3]*vec->vec[0] - 
+							quat1->quat[3]*quat1->quat[3]*vec->vec[1] + 
+							quat1->quat[0]*quat1->quat[0]*vec->vec[1] - 
+							2*quat1->quat[1]*quat1->quat[0]*vec->vec[2] - 
+							quat1->quat[1]*quat1->quat[1]*vec->vec[1];
+				newVec[2] = 2*quat1->quat[1]*quat1->quat[3]*vec->vec[0] + 
+							2*quat1->quat[2]*quat1->quat[3]*vec->vec[1] + 
+							quat1->quat[3]*quat1->quat[3]*vec->vec[2] - 
+							2*quat1->quat[0]*quat1->quat[2]*vec->vec[0] - 
+							quat1->quat[2]*quat1->quat[2]*vec->vec[2] + 
+							2*quat1->quat[0]*quat1->quat[1]*vec->vec[1] - 
+							quat1->quat[1]*quat1->quat[1]*vec->vec[2] + 
+							quat1->quat[0]*quat1->quat[0]*vec->vec[2];
+				EXPP_decr3((PyObject*)quat1, (PyObject*)quat2, (PyObject*)vec);
+				return newVectorObject(newVec,3,Py_NEW);
 			}
-			//unknown type or numeric cast failure
-			printf( "attempting quaternion operation with unsupported type...\n" );
-			Py_INCREF( *q1 );  /* fixme:  is this needed? */
-			return 0;	//operation will type check
+		}else{  //QUAT * QUAT (dot product)
+			for(x = 0; x < 4; x++) {
+				dot += quat1->quat[x] * quat1->quat[x];
+			}
+			EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+			return PyFloat_FromDouble(dot);
 		}
-	} else {
-		printf( "numeric protocol failure...\n" );
-		return -1;	//this should not occur - fail
 	}
-	return -1;
-}
 
+	EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
+	return EXPP_ReturnPyObjError(PyExc_TypeError, 
+		"Quaternion multiplication: arguments not acceptable for this operation\n");
+}
+//------------------------coerce(obj, obj)-----------------------
+//coercion of unknown types to type QuaternionObject for numeric protocols
+/*Coercion() is called whenever a math operation has 2 operands that
+ it doesn't understand how to evaluate. 2+Matrix for example. We want to 
+ evaluate some of these operations like: (vector * 2), however, for math
+ to proceed, the unknown operand must be cast to a type that python math will
+ understand. (e.g. in the case above case, 2 must be cast to a vector and 
+ then call vector.multiply(vector, scalar_cast_as_vector)*/
+static int Quaternion_coerce(PyObject ** q1, PyObject ** q2)
+{
+	PyObject *coerced = NULL;
+
+	if(!QuaternionObject_Check(*q2)) {
+		if(VectorObject_Check(*q2) || PyFloat_Check(*q2) || PyInt_Check(*q2)) {
+			coerced = EXPP_incr_ret(*q2);
+			*q2 = newQuaternionObject(NULL,Py_NEW);
+			((QuaternionObject*)*q2)->coerced_object = coerced;
+		}else{
+			return EXPP_ReturnIntError(PyExc_TypeError, 
+				"quaternion.coerce(): unknown operand - can't coerce for numeric protocols\n");
+		}
+	}
+	EXPP_incr2(*q1, *q2);
+	return 0;
+}
+//-----------------PROTCOL DECLARATIONS--------------------------
 static PySequenceMethods Quaternion_SeqMethods = {
-	( inquiry ) 0,		/* sq_length */
-	( binaryfunc ) 0,	/* sq_concat */
-	( intargfunc ) 0,	/* sq_repeat */
-	( intargfunc ) Quaternion_item,	/* sq_item */
-	( intintargfunc ) Quaternion_slice,	/* sq_slice */
-	( intobjargproc ) Quaternion_ass_item,	/* sq_ass_item */
-	( intintobjargproc ) Quaternion_ass_slice,	/* sq_ass_slice */
+	(inquiry) Quaternion_len,					/* sq_length */
+	(binaryfunc) 0,								/* sq_concat */
+	(intargfunc) 0,								/* sq_repeat */
+	(intargfunc) Quaternion_item,				/* sq_item */
+	(intintargfunc) Quaternion_slice,			/* sq_slice */
+	(intobjargproc) Quaternion_ass_item,		/* sq_ass_item */
+	(intintobjargproc) Quaternion_ass_slice,	/* sq_ass_slice */
 };
-
 static PyNumberMethods Quaternion_NumMethods = {
-	( binaryfunc ) Quaternion_add,	/* __add__ */
-	( binaryfunc ) Quaternion_sub,	/* __sub__ */
-	( binaryfunc ) Quaternion_mul,	/* __mul__ */
-	( binaryfunc ) 0,	/* __div__ */
-	( binaryfunc ) 0,	/* __mod__ */
-	( binaryfunc ) 0,	/* __divmod__ */
-	( ternaryfunc ) 0,	/* __pow__ */
-	( unaryfunc ) 0,	/* __neg__ */
-	( unaryfunc ) 0,	/* __pos__ */
-	( unaryfunc ) 0,	/* __abs__ */
-	( inquiry ) 0,		/* __nonzero__ */
-	( unaryfunc ) 0,	/* __invert__ */
-	( binaryfunc ) 0,	/* __lshift__ */
-	( binaryfunc ) 0,	/* __rshift__ */
-	( binaryfunc ) 0,	/* __and__ */
-	( binaryfunc ) 0,	/* __xor__ */
-	( binaryfunc ) 0,	/* __or__ */
-	( coercion ) Quaternion_coerce,	/* __coerce__ */
-	( unaryfunc ) 0,	/* __int__ */
-	( unaryfunc ) 0,	/* __long__ */
-	( unaryfunc ) 0,	/* __float__ */
-	( unaryfunc ) 0,	/* __oct__ */
-	( unaryfunc ) 0,	/* __hex__ */
+	(binaryfunc) Quaternion_add,				/* __add__ */
+	(binaryfunc) Quaternion_sub,				/* __sub__ */
+	(binaryfunc) Quaternion_mul,				/* __mul__ */
+	(binaryfunc) 0,								/* __div__ */
+	(binaryfunc) 0,								/* __mod__ */
+	(binaryfunc) 0,								/* __divmod__ */
+	(ternaryfunc) 0,							/* __pow__ */
+	(unaryfunc) 0,								/* __neg__ */
+	(unaryfunc) 0,								/* __pos__ */
+	(unaryfunc) 0,								/* __abs__ */
+	(inquiry) 0,								/* __nonzero__ */
+	(unaryfunc) 0,								/* __invert__ */
+	(binaryfunc) 0,								/* __lshift__ */
+	(binaryfunc) 0,								/* __rshift__ */
+	(binaryfunc) 0,								/* __and__ */
+	(binaryfunc) 0,								/* __xor__ */
+	(binaryfunc) 0,								/* __or__ */
+	(coercion)  Quaternion_coerce,				/* __coerce__ */
+	(unaryfunc) 0,								/* __int__ */
+	(unaryfunc) 0,								/* __long__ */
+	(unaryfunc) 0,								/* __float__ */
+	(unaryfunc) 0,								/* __oct__ */
+	(unaryfunc) 0,								/* __hex__ */
 
 };
-
+//------------------PY_OBECT DEFINITION--------------------------
 PyTypeObject quaternion_Type = {
-	PyObject_HEAD_INIT( NULL ) 
-	0,	/*ob_size */
-	"quaternion",		/*tp_name */
-	sizeof( QuaternionObject ),	/*tp_basicsize */
-	0,			/*tp_itemsize */
-	( destructor ) Quaternion_dealloc,	/*tp_dealloc */
-	( printfunc ) 0,	/*tp_print */
-	( getattrfunc ) Quaternion_getattr,	/*tp_getattr */
-	( setattrfunc ) Quaternion_setattr,	/*tp_setattr */
-	0,			/*tp_compare */
-	( reprfunc ) Quaternion_repr,	/*tp_repr */
-	&Quaternion_NumMethods,	/*tp_as_number */
-	&Quaternion_SeqMethods,	/*tp_as_sequence */
+	PyObject_HEAD_INIT(NULL) 
+	0,											/*ob_size */
+	"quaternion",								/*tp_name */
+	sizeof(QuaternionObject),					/*tp_basicsize */
+	0,											/*tp_itemsize */
+	(destructor) Quaternion_dealloc,			/*tp_dealloc */
+	(printfunc) 0,								/*tp_print */
+	(getattrfunc) Quaternion_getattr,			/*tp_getattr */
+	(setattrfunc) Quaternion_setattr,			/*tp_setattr */
+	0,											/*tp_compare */
+	(reprfunc) Quaternion_repr,					/*tp_repr */
+	&Quaternion_NumMethods,						/*tp_as_number */
+	&Quaternion_SeqMethods,						/*tp_as_sequence */
 };
-
-/** Creates a new quaternion object.
- * 
- * Memory for a new quaternion is allocated. The quaternion copies the given 
- * list of parameters or initializes to the identity, if a <code>NULL</code>
- * pointer is given as parameter. The memory will be freed in the dealloc
- * routine.
- * 
- * @param quat Pointer to a list of floats for the quanternion parameters w, x, y, z.
- * @return Quaternion Python object.
- * @see Quaternion_Identity
- */
-PyObject *newQuaternionObject( float *quat )
+//------------------------newQuaternionObject (internal)-------------
+//creates a new quaternion object
+/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ (i.e. it was allocated elsewhere by MEM_mallocN())
+  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ (i.e. it must be created here with PyMEM_malloc())*/
+PyObject *newQuaternionObject(float *quat, int type)
 {
 	QuaternionObject *self;
 	int x;
 
 	quaternion_Type.ob_type = &PyType_Type;
-
-	self = PyObject_NEW( QuaternionObject, &quaternion_Type );
-
-	self->quat = PyMem_Malloc( 4 * sizeof( float ) );
-
-	if( !quat ) {
-		Quaternion_Identity(self);
-	} else {
-		for( x = 0; x < 4; x++ ) {
-			self->quat[x] = quat[x];
+	self = PyObject_NEW(QuaternionObject, &quaternion_Type);
+	self->data.blend_data = NULL;
+	self->data.py_data = NULL;
+	self->coerced_object = NULL;
+
+	if(type == Py_WRAP){
+		self->data.blend_data = quat;
+		self->quat = self->data.blend_data;
+	}else if (type == Py_NEW){
+		self->data.py_data = PyMem_Malloc(4 * sizeof(float));
+		self->quat = self->data.py_data;
+		if(!quat) { //new empty
+			Quaternion_Identity(self);
+		}else{
+			for(x = 0; x < 4; x++){
+				self->quat[x] = quat[x];
+			}
 		}
+	}else{ //bad type
+		return NULL;
 	}
-	self->flag = 0;
-
-	return ( PyObject * ) self;
+	return (PyObject *) EXPP_incr_ret((PyObject *)self);
 }
diff --git a/source/blender/python/api2_2x/quat.h b/source/blender/python/api2_2x/quat.h
index a04e0ee7c37..8be94ef3f42 100644
--- a/source/blender/python/api2_2x/quat.h
+++ b/source/blender/python/api2_2x/quat.h
@@ -34,34 +34,27 @@
 #ifndef EXPP_quat_h
 #define EXPP_quat_h
 
-#include "Python.h"
-#include "gen_utils.h"
-#include "Types.h"
-#include <BLI_arithb.h>
-#include "euler.h"
-#include "matrix.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-/*****************************/
-//    Quaternion Python Object   
-/*****************************/
-
 #define QuaternionObject_Check(v) ((v)->ob_type == &quaternion_Type)
 
 typedef struct {
-	PyObject_VAR_HEAD float *quat;
-	int flag;
-	//0 - no coercion
-	//1 - coerced from int
-	//2 - coerced from float
+	PyObject_VAR_HEAD 
+	struct{
+		float *py_data;		//python managed
+		float *blend_data;	//blender managed
+	}data;
+	float *quat;				//1D array of data (alias)
+	PyObject *coerced_object;
 } QuaternionObject;
+/*coerced_object is a pointer to the object that it was
+coerced from when a dummy vector needs to be created from
+the coerce() function for numeric protocol operations*/
 
+/*struct data contains a pointer to the actual data that the
+object uses. It can use either PyMem allocated data (which will
+be stored in py_data) or be a wrapper for data allocated through
+blender (stored in blend_data). This is an either/or struct not both*/
 
 //prototypes
-PyObject *newQuaternionObject( float *quat );
 PyObject *Quaternion_Identity( QuaternionObject * self );
 PyObject *Quaternion_Negate( QuaternionObject * self );
 PyObject *Quaternion_Conjugate( QuaternionObject * self );
@@ -69,5 +62,6 @@ PyObject *Quaternion_Inverse( QuaternionObject * self );
 PyObject *Quaternion_Normalize( QuaternionObject * self );
 PyObject *Quaternion_ToEuler( QuaternionObject * self );
 PyObject *Quaternion_ToMatrix( QuaternionObject * self );
+PyObject *newQuaternionObject( float *quat, int type );
 
 #endif				/* EXPP_quat_h */
diff --git a/source/blender/python/api2_2x/vector.c b/source/blender/python/api2_2x/vector.c
index 049ed793de6..ff888df12f6 100644
--- a/source/blender/python/api2_2x/vector.c
+++ b/source/blender/python/api2_2x/vector.c
@@ -23,717 +23,656 @@
  * All rights reserved.
  *
  * 
- * Contributor(s): Willian P. Germano, Joseph Gilbert, Ken Hughes
+ * Contributor(s): Willian P. Germano & Joseph Gilbert, Ken Hughes
  *
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
-#include "vector.h"
+#include "BKE_utildefines.h"
+#include "Mathutils.h"
+#include "gen_utils.h"
+#include "BLI_blenlib.h"
 
-//doc strings
+//-------------------------DOC STRINGS ---------------------------
 char Vector_Zero_doc[] = "() - set all values in the vector to 0";
 char Vector_Normalize_doc[] = "() - normalize the vector";
 char Vector_Negate_doc[] = "() - changes vector to it's additive inverse";
 char Vector_Resize2D_doc[] = "() - resize a vector to [x,y]";
 char Vector_Resize3D_doc[] = "() - resize a vector to [x,y,z]";
 char Vector_Resize4D_doc[] = "() - resize a vector to [x,y,z,w]";
-
-//method table
+//-----------------------METHOD DEFINITIONS ----------------------
 struct PyMethodDef Vector_methods[] = {
-	{"zero", ( PyCFunction ) Vector_Zero, METH_NOARGS,
-	 Vector_Zero_doc},
-	{"normalize", ( PyCFunction ) Vector_Normalize, METH_NOARGS,
-	 Vector_Normalize_doc},
-	{"negate", ( PyCFunction ) Vector_Negate, METH_NOARGS,
-	 Vector_Negate_doc},
-	{"resize2D", ( PyCFunction ) Vector_Resize2D, METH_NOARGS,
-	 Vector_Resize2D_doc},
-	{"resize3D", ( PyCFunction ) Vector_Resize3D, METH_NOARGS,
-	 Vector_Resize2D_doc},
-	{"resize4D", ( PyCFunction ) Vector_Resize4D, METH_NOARGS,
-	 Vector_Resize2D_doc},
+	{"zero", (PyCFunction) Vector_Zero, METH_NOARGS, Vector_Zero_doc},
+	{"normalize", (PyCFunction) Vector_Normalize, METH_NOARGS, Vector_Normalize_doc},
+	{"negate", (PyCFunction) Vector_Negate, METH_NOARGS, Vector_Negate_doc},
+	{"resize2D", (PyCFunction) Vector_Resize2D, METH_NOARGS, Vector_Resize2D_doc},
+	{"resize3D", (PyCFunction) Vector_Resize3D, METH_NOARGS, Vector_Resize2D_doc},
+	{"resize4D", (PyCFunction) Vector_Resize4D, METH_NOARGS, Vector_Resize2D_doc},
 	{NULL, NULL, 0, NULL}
 };
-
-/******prototypes*************/
-PyObject *Vector_add( PyObject * v1, PyObject * v2 );
-PyObject *Vector_sub( PyObject * v1, PyObject * v2 );
-PyObject *Vector_mul( PyObject * v1, PyObject * v2 );
-PyObject *Vector_div( PyObject * v1, PyObject * v2 );
-int Vector_coerce( PyObject ** v1, PyObject ** v2 );
-
-
-/*****************************/
-//    Vector Python Object   
-/*****************************/
-
-//object methods
-PyObject *Vector_Zero( VectorObject * self )
+//-----------------------------METHODS----------------------------
+//----------------------------Vector.zero() ----------------------
+//set the vector data to 0,0,0
+PyObject *Vector_Zero(VectorObject * self)
 {
 	int x;
-	for( x = 0; x < self->size; x++ ) {
+	for(x = 0; x < self->size; x++) {
 		self->vec[x] = 0.0f;
 	}
-
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Vector_Normalize( VectorObject * self )
+//----------------------------Vector.normalize() -----------------
+//normalize the vector data to a unit vector
+PyObject *Vector_Normalize(VectorObject * self)
 {
-	float norm;
 	int x;
+	float norm = 0.0f;
 
-	norm = 0.0f;
-	for( x = 0; x < self->size; x++ ) {
+	for(x = 0; x < self->size; x++) {
 		norm += self->vec[x] * self->vec[x];
 	}
-	norm = ( float ) sqrt( norm );
-	for( x = 0; x < self->size; x++ ) {
+	norm = (float) sqrt(norm);
+	for(x = 0; x < self->size; x++) {
 		self->vec[x] /= norm;
 	}
-
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Vector_Negate( VectorObject * self )
+//----------------------------Vector.negate() --------------------
+//set the vector to it's negative -x, -y, -z
+PyObject *Vector_Negate(VectorObject * self)
 {
 	int x;
-	for( x = 0; x < self->size; x++ ) {
-		self->vec[x] = -( self->vec[x] );
+	for(x = 0; x < self->size; x++) {
+		self->vec[x] = -(self->vec[x]);
 	}
-
-	return EXPP_incr_ret( Py_None );
+	return (PyObject*)self;
 }
-
-PyObject *Vector_Resize2D( VectorObject * self )
+//----------------------------Vector.resize2D() ------------------
+//resize the vector to x,y
+PyObject *Vector_Resize2D(VectorObject * self)
 {
-	float x, y;
-
-	if( self->size == 4 || self->size == 3 ) {
-		x = self->vec[0];
-		y = self->vec[1];
-		PyMem_Free( self->vec );
-		self->vec = PyMem_Malloc( 2 * sizeof( float ) );
-		self->vec[0] = x;
-		self->vec[1] = y;
-		self->size = 2;
+	if(self->data.blend_data){
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"vector.resize2d(): cannot resize wrapped data - only python vectors\n");
 	}
 
-	return EXPP_incr_ret( Py_None );
+	self->data.py_data = 
+		PyMem_Realloc(self->data.py_data, (sizeof(float) * 2));
+	if(self->data.py_data == NULL) {
+		return EXPP_ReturnPyObjError(PyExc_MemoryError,
+			"vector.resize2d(): problem allocating pointer space\n\n");
+	}
+	self->vec = self->data.py_data;  //force
+	self->size = 2;
+	return (PyObject*)self;
 }
-
-PyObject *Vector_Resize3D( VectorObject * self )
+//----------------------------Vector.resize3D() ------------------
+//resize the vector to x,y,z
+PyObject *Vector_Resize3D(VectorObject * self)
 {
-	float x, y, z;
-
-	if( self->size == 2 ) {
-		x = self->vec[0];
-		y = self->vec[1];
-		PyMem_Free( self->vec );
-		self->vec = PyMem_Malloc( 3 * sizeof( float ) );
-		self->vec[0] = x;
-		self->vec[1] = y;
-		self->vec[2] = 0.0f;
-		self->size = 3;
-	} else if( self->size == 4 ) {
-		x = self->vec[0];
-		y = self->vec[1];
-		z = self->vec[2];
-		PyMem_Free( self->vec );
-		self->vec = PyMem_Malloc( 3 * sizeof( float ) );
-		self->vec[0] = x;
-		self->vec[1] = y;
-		self->vec[2] = z;
-		self->size = 3;
-	}
-
-	return EXPP_incr_ret( Py_None );
-}
+	if(self->data.blend_data){
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"vector.resize3d(): cannot resize wrapped data - only python vectors\n");
+	}
 
-PyObject *Vector_Resize4D( VectorObject * self )
-{
-	float x, y, z;
-
-	if( self->size == 2 ) {
-		x = self->vec[0];
-		y = self->vec[1];
-		PyMem_Free( self->vec );
-		self->vec = PyMem_Malloc( 4 * sizeof( float ) );
-		self->vec[0] = x;
-		self->vec[1] = y;
-		self->vec[2] = 0.0f;
-		self->vec[3] = 1.0f;
-		self->size = 4;
-	} else if( self->size == 3 ) {
-		x = self->vec[0];
-		y = self->vec[1];
-		z = self->vec[2];
-		PyMem_Free( self->vec );
-		self->vec = PyMem_Malloc( 4 * sizeof( float ) );
-		self->vec[0] = x;
-		self->vec[1] = y;
-		self->vec[2] = z;
-		self->vec[3] = 1.0f;
-		self->size = 4;
-	}
-
-	return EXPP_incr_ret( Py_None );
+	self->data.py_data = 
+		PyMem_Realloc(self->data.py_data, (sizeof(float) * 3));
+	if(self->data.py_data == NULL) {
+		return EXPP_ReturnPyObjError(PyExc_MemoryError,
+			"vector.resize3d(): problem allocating pointer space\n\n");
+	}
+	self->vec = self->data.py_data;  //force
+	if(self->size == 2){
+		self->data.py_data[2] = 0.0f;
+	}
+	self->size = 3;
+	return (PyObject*)self;
 }
-
-static void Vector_dealloc( VectorObject * self )
+//----------------------------Vector.resize4D() ------------------
+//resize the vector to x,y,z,w
+PyObject *Vector_Resize4D(VectorObject * self)
 {
-	/* if we own this memory we must delete it */
-	if( self->delete_pymem )
-		PyMem_Free( self->vec );
+	if(self->data.blend_data){
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"vector.resize4d(): cannot resize wrapped data - only python vectors\n");
+	}
 
-	PyObject_DEL( self );
+	self->data.py_data = 
+		PyMem_Realloc(self->data.py_data, (sizeof(float) * 4));
+	if(self->data.py_data == NULL) {
+		return EXPP_ReturnPyObjError(PyExc_MemoryError,
+			"vector.resize4d(): problem allocating pointer space\n\n");
+	}
+	self->vec = self->data.py_data;  //force
+	if(self->size == 2){
+		self->data.py_data[2] = 0.0f;
+		self->data.py_data[3] = 0.0f;
+	}else if(self->size == 3){
+		self->data.py_data[3] = 0.0f;
+	}
+	self->size = 4;
+	return (PyObject*)self;
 }
-
-static PyObject *Vector_getattr( VectorObject * self, char *name )
+//----------------------------dealloc()(internal) ----------------
+//free the py_object
+static void Vector_dealloc(VectorObject * self)
 {
-	if( self->size == 4 && ELEM4( name[0], 'x', 'y', 'z', 'w' )
-	    && name[1] == 0 ) {
-		if( ( name[0] ) == ( 'w' ) ) {
-			return PyFloat_FromDouble( self->vec[3] );
-		} else {
-			return PyFloat_FromDouble( self->vec[name[0] - 'x'] );
-		}
-	} else if( self->size == 3 && ELEM3( name[0], 'x', 'y', 'z' )
-		   && name[1] == 0 )
-		return PyFloat_FromDouble( self->vec[name[0] - 'x'] );
-	else if( self->size == 2 && ELEM( name[0], 'x', 'y' ) && name[1] == 0 )
-		return PyFloat_FromDouble( self->vec[name[0] - 'x'] );
-
-	if( ( strcmp( name, "length" ) == 0 ) ) {
-		if( self->size == 4 ) {
-			return PyFloat_FromDouble( sqrt
-						   ( self->vec[0] *
-						     self->vec[0] +
-						     self->vec[1] *
-						     self->vec[1] +
-						     self->vec[2] *
-						     self->vec[2] +
-						     self->vec[3] *
-						     self->vec[3] ) );
-		} else if( self->size == 3 ) {
-			return PyFloat_FromDouble( sqrt
-						   ( self->vec[0] *
-						     self->vec[0] +
-						     self->vec[1] *
-						     self->vec[1] +
-						     self->vec[2] *
-						     self->vec[2] ) );
-		} else if( self->size == 2 ) {
-			return PyFloat_FromDouble( sqrt
-						   ( self->vec[0] *
-						     self->vec[0] +
-						     self->vec[1] *
-						     self->vec[1] ) );
-		} else
-			return EXPP_ReturnPyObjError( PyExc_AttributeError,
-						      "can only return the length of a 2D ,3D or 4D vector\n" );
-	}
-
-	return Py_FindMethod( Vector_methods, ( PyObject * ) self, name );
+	//only free py_data
+	if(self->data.py_data){
+		PyMem_Free(self->data.py_data);
+	}
+	PyObject_DEL(self);
 }
+//----------------------------getattr()(internal) ----------------
+//object.attribute access (get)
+static PyObject *Vector_getattr(VectorObject * self, char *name)
+{
+	int x;
+	double dot = 0.0f;
+
+	if(STREQ(name,"x")){
+		return PyFloat_FromDouble(self->vec[0]);
+	}else if(STREQ(name, "y")){
+		return PyFloat_FromDouble(self->vec[1]);
+	}else if(STREQ(name, "z")){
+		if(self->size > 2){
+			return PyFloat_FromDouble(self->vec[2]);
+		}else{
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"vector.z: illegal attribute access\n");
+		}
+	}else if(STREQ(name, "w")){
+		if(self->size > 3){
+			return PyFloat_FromDouble(self->vec[3]);
+		}else{
+			return EXPP_ReturnPyObjError(PyExc_AttributeError,
+				"vector.w: illegal attribute access\n");
+		}
+	}else if(STREQ2(name, "length", "magnitude")) {
+		for(x = 0; x < self->size; x++){
+			dot += (self->vec[x] * self->vec[x]);
+		}
+		return PyFloat_FromDouble(sqrt(dot));
+	}
 
-static int Vector_setattr( VectorObject * self, char *name, PyObject * v )
+	return Py_FindMethod(Vector_methods, (PyObject *) self, name);
+}
+//----------------------------setattr()(internal) ----------------
+//object.attribute access (set)
+static int Vector_setattr(VectorObject * self, char *name, PyObject * v)
 {
-	float val;
-	int valTemp;
-
-	if( !PyFloat_Check( v ) ) {
-		if( !PyInt_Check( v ) ) {
-			return EXPP_ReturnIntError( PyExc_TypeError,
-						    "int or float expected\n" );
-		} else {
-			if( !PyArg_Parse( v, "i", &valTemp ) )
-				return EXPP_ReturnIntError( PyExc_TypeError,
-							    "unable to parse int argument\n" );
-			val = ( float ) valTemp;
+	PyObject *f = NULL;
+
+	f = PyNumber_Float(v);
+	if(f == NULL) { // parsed item not a number
+		return EXPP_ReturnIntError(PyExc_TypeError, 
+			"vector.attribute = x: argument not a number\n");
+	}
+
+	if(STREQ(name,"x")){
+		self->vec[0] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "y")){
+		self->vec[1] = PyFloat_AS_DOUBLE(f);
+	}else if(STREQ(name, "z")){
+		if(self->size > 2){
+			self->vec[2] = PyFloat_AS_DOUBLE(f);
+		}else{
+			Py_DECREF(f);
+			return EXPP_ReturnIntError(PyExc_AttributeError,
+				"vector.z = x: illegal attribute access\n");
 		}
-	} else {
-		if( !PyArg_Parse( v, "f", &val ) )
-			return EXPP_ReturnIntError( PyExc_TypeError,
-						    "unable to parse float argument\n" );
-	}
-	if( self->size == 4 && ELEM4( name[0], 'x', 'y', 'z', 'w' )
-	    && name[1] == 0 ) {
-		if( ( name[0] ) == ( 'w' ) ) {
-			self->vec[3] = val;
-		} else {
-			self->vec[name[0] - 'x'] = val;
+	}else if(STREQ(name, "w")){
+		if(self->size > 3){
+			self->vec[3] = PyFloat_AS_DOUBLE(f);
+		}else{
+			Py_DECREF(f);
+			return EXPP_ReturnIntError(PyExc_AttributeError,
+				"vector.w = x: illegal attribute access\n");
 		}
-	} else if( self->size == 3 && ELEM3( name[0], 'x', 'y', 'z' )
-		   && name[1] == 0 )
-		self->vec[name[0] - 'x'] = val;
-	else if( self->size == 2 && ELEM( name[0], 'x', 'y' ) && name[1] == 0 )
-		self->vec[name[0] - 'x'] = val;
-	else
-		return -1;
+	}else{
+		Py_DECREF(f);
+		return EXPP_ReturnIntError(PyExc_AttributeError,
+				"vector.attribute = x: unknown attribute\n");
+	}
 
+	Py_DECREF(f);
 	return 0;
 }
+//----------------------------print object (internal)-------------
+//print the object to screen
+static PyObject *Vector_repr(VectorObject * self)
+{
+	int i;
+	char buffer[48], str[1024];
+
+	BLI_strncpy(str,"[",1024);
+	for(i = 0; i < self->size; i++){
+		if(i < (self->size - 1)){
+			sprintf(buffer, "%.6f, ", self->vec[i]);
+			strcat(str,buffer);
+		}else{
+			sprintf(buffer, "%.6f", self->vec[i]);
+			strcat(str,buffer);
+		}
+	}
+	strcat(str, "](vector)");
 
-/* Vectors Sequence methods */
-static int Vector_len( VectorObject * self )
+	return EXPP_incr_ret(PyString_FromString(str));
+}
+//---------------------SEQUENCE PROTOCOLS------------------------
+//----------------------------len(object)------------------------
+//sequence length
+static int Vector_len(VectorObject * self)
 {
 	return self->size;
 }
-
-static PyObject *Vector_item( VectorObject * self, int i )
+//----------------------------object[]---------------------------
+//sequence accessor (get)
+static PyObject *Vector_item(VectorObject * self, int i)
 {
-	if( i < 0 || i >= self->size )
-		return EXPP_ReturnPyObjError( PyExc_IndexError,
-					      "array index out of range\n" );
+	if(i < 0 || i >= self->size)
+		return EXPP_ReturnPyObjError(PyExc_IndexError,
+		"vector[attribute]: array index out of range\n");
 
-	return Py_BuildValue( "f", self->vec[i] );
+	return Py_BuildValue("f", self->vec[i]);
 
 }
+//----------------------------object[]-------------------------
+//sequence accessor (set)
+static int Vector_ass_item(VectorObject * self, int i, PyObject * ob)
+{
+	PyObject *f = NULL;
 
-static PyObject *Vector_slice( VectorObject * self, int begin, int end )
+	f = PyNumber_Float(ob);
+	if(f == NULL) { // parsed item not a number
+		return EXPP_ReturnIntError(PyExc_TypeError, 
+			"vector[attribute] = x: argument not a number\n");
+	}
+
+	if(i < 0 || i >= self->size){
+		Py_DECREF(f);
+		return EXPP_ReturnIntError(PyExc_IndexError,
+			"vector[attribute] = x: array assignment index out of range\n");
+	}
+	self->vec[i] = PyFloat_AS_DOUBLE(f);
+	Py_DECREF(f);
+	return 0;
+}
+//----------------------------object[z:y]------------------------
+//sequence slice (get)
+static PyObject *Vector_slice(VectorObject * self, int begin, int end)
 {
-	PyObject *list;
+	PyObject *list = NULL;
 	int count;
 
-	if( begin < 0 )
-		begin = 0;
-	if( end > self->size )
-		end = self->size;
-	if( begin > end )
-		begin = end;
-
-	list = PyList_New( end - begin );
+	CLAMP(begin, 0, self->size);
+	CLAMP(end, 0, self->size);
+	begin = MIN2(begin,end);
 
-	for( count = begin; count < end; count++ ) {
-		PyList_SetItem( list, count - begin,
-				PyFloat_FromDouble( self->vec[count] ) );
+	list = PyList_New(end - begin);
+	for(count = begin; count < end; count++) {
+		PyList_SetItem(list, count - begin,
+				PyFloat_FromDouble(self->vec[count]));
 	}
 
 	return list;
 }
-
-static int Vector_ass_item( VectorObject * self, int i, PyObject * ob )
+//----------------------------object[z:y]------------------------
+//sequence slice (set)
+static int Vector_ass_slice(VectorObject * self, int begin, int end,
+			     PyObject * seq)
 {
-	if( i < 0 || i >= self->size )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "array assignment index out of range\n" );
-	if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
-		return EXPP_ReturnIntError( PyExc_IndexError,
-					    "vector member must be a number\n" );
+	int i, y, size = 0;
+	float vec[4];
 
-	self->vec[i] = ( float ) PyFloat_AsDouble( ob );
+	CLAMP(begin, 0, self->size);
+	CLAMP(end, 0, self->size);
+	begin = MIN2(begin,end);
 
-	return 0;
-}
+	size = PySequence_Length(seq);
+	if(size != (end - begin)){
+		return EXPP_ReturnIntError(PyExc_TypeError,
+			"vector[begin:end] = []: size mismatch in slice assignment\n");
+	}
 
-static int Vector_ass_slice( VectorObject * self, int begin, int end,
-			     PyObject * seq )
-{
-	int count, z;
-
-	if( begin < 0 )
-		begin = 0;
-	if( end > self->size )
-		end = self->size;
-	if( begin > end )
-		begin = end;
-
-	if( !PySequence_Check( seq ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "illegal argument type for built-in operation\n" );
-	if( PySequence_Length( seq ) != ( end - begin ) )
-		return EXPP_ReturnIntError( PyExc_TypeError,
-					    "size mismatch in slice assignment\n" );
-
-	z = 0;
-	for( count = begin; count < end; count++ ) {
-		PyObject *ob = PySequence_GetItem( seq, z );
-		z++;
-		if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
-			return EXPP_ReturnIntError( PyExc_IndexError,
-						    "list member must be a number\n" );
-
-		if( !PyArg_Parse( ob, "f", &self->vec[count] ) ) {
-			Py_DECREF( ob );
-			return -1;
+	for (i = 0; i < size; i++) {
+		PyObject *v, *f;
+
+		v = PySequence_GetItem(seq, i);
+		if (v == NULL) { // Failed to read sequence
+			return EXPP_ReturnIntError(PyExc_RuntimeError, 
+				"vector[begin:end] = []: unable to read sequence\n");
 		}
+		f = PyNumber_Float(v);
+		if(f == NULL) { // parsed item not a number
+			Py_DECREF(v);
+			return EXPP_ReturnIntError(PyExc_TypeError, 
+				"vector[begin:end] = []: sequence argument not a number\n");
+		}
+		vec[i] = PyFloat_AS_DOUBLE(f);
+		EXPP_decr2(f,v);
+	}
+	//parsed well - now set in vector
+	for(y = 0; y < size; y++){
+		self->vec[begin + y] = vec[y];
 	}
-
 	return 0;
 }
-
-static PyObject *Vector_repr( VectorObject * self )
+//------------------------NUMERIC PROTOCOLS----------------------
+//------------------------obj + obj------------------------------
+//addition
+static PyObject *Vector_add(PyObject * v1, PyObject * v2)
 {
-	int i, maxindex = self->size - 1;
-	char ftoa[24];
-	PyObject *str1, *str2;
-
-	str1 = PyString_FromString( "[" );
-
-	for( i = 0; i < maxindex; i++ ) {
-		sprintf( ftoa, "%.4f, ", self->vec[i] );
-		str2 = PyString_FromString( ftoa );
-		if( !str1 || !str2 )
-			goto error;
-		PyString_ConcatAndDel( &str1, str2 );
-	}
-
-	sprintf( ftoa, "%.4f]", self->vec[maxindex] );
-	str2 = PyString_FromString( ftoa );
-	if( !str1 || !str2 )
-		goto error;
-	PyString_ConcatAndDel( &str1, str2 );
-
-	if( str1 )
-		return str1;
-
-      error:
-	Py_XDECREF( str1 );
-	Py_XDECREF( str2 );
-	return EXPP_ReturnPyObjError( PyExc_MemoryError,
-				      "couldn't create PyString!\n" );
-}
+	int x, size;
+	float vec[4];
+	VectorObject *vec1 = NULL, *vec2 = NULL;
 
+	EXPP_incr2(v1, v2);
+	vec1 = (VectorObject*)v1;
+	vec2 = (VectorObject*)v2;
 
-PyObject *Vector_add( PyObject * v1, PyObject * v2 )
-{
-	float *vec;
-	int x;
-	PyObject *retval;
-
-	if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( VectorObject * ) v1 )->flag != 0
-	    || ( ( VectorObject * ) v2 )->flag != 0 )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "cannot add a scalar to a vector\n" );
-	if( ( ( VectorObject * ) v1 )->size !=
-	    ( ( VectorObject * ) v2 )->size )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "vectors must have the same dimensions for this operation\n" );
-
-	vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
-			    sizeof( float ) );
-
-	for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
-		vec[x] = ( ( VectorObject * ) v1 )->vec[x] +
-			( ( VectorObject * ) v2 )->vec[x];
-	}
-
-	retval = ( PyObject * ) newVectorObject( vec,
-						 ( ( ( VectorObject * ) v1 )->
-						   size ) );
-	PyMem_Free( vec );
-	return retval;
-}
+	if(vec1->coerced_object || vec2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Vector addition: arguments not valid for this operation....\n");
+	}
+	if(vec1->size != vec2->size){
+		EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+		"Vector addition: vectors must have the same dimensions for this operation\n");
+	}
 
-PyObject *Vector_sub( PyObject * v1, PyObject * v2 )
-{
-	float *vec;
-	int x;
-	PyObject *retval;
-
-	if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( VectorObject * ) v1 )->flag != 0
-	    || ( ( VectorObject * ) v2 )->flag != 0 )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "cannot subtract a scalar from a vector\n" );
-	if( ( ( VectorObject * ) v1 )->size !=
-	    ( ( VectorObject * ) v2 )->size )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "vectors must have the same dimensions for this operation\n" );
-
-	vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
-			    sizeof( float ) );
-
-	for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
-		vec[x] = ( ( VectorObject * ) v1 )->vec[x] -
-			( ( VectorObject * ) v2 )->vec[x];
-	}
-
-	retval = ( PyObject * ) newVectorObject( vec,
-						 ( ( ( VectorObject * ) v1 )->
-						   size ) );
-	PyMem_Free( vec );
-	return retval;
-}
+	size = vec1->size;
+	for(x = 0; x < size; x++) {
+		vec[x] = vec1->vec[x] +	vec2->vec[x];
+	}
 
-PyObject *Vector_mul( PyObject * v1, PyObject * v2 )
-{
-	float *vec;
-	int x;
-	PyObject *retval;
-
-	if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( VectorObject * ) v1 )->flag == 0
-	    && ( ( VectorObject * ) v2 )->flag == 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "please use the dot product or the cross product to multiply vectors\n" );
-	if( ( ( VectorObject * ) v1 )->size !=
-	    ( ( VectorObject * ) v2 )->size )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "vector dimension error during Vector_mul\n" );
-
-	vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
-			    sizeof( float ) );
-
-	for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
-		vec[x] = ( ( VectorObject * ) v1 )->vec[x] *
-			( ( VectorObject * ) v2 )->vec[x];
-	}
-
-	retval =  ( PyObject * ) newVectorObject( vec,
-						  ( ( ( VectorObject * ) v1 )->
-						    size ) );
-	PyMem_Free( vec );
-	return retval;
+	EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+	return (PyObject *) newVectorObject(vec, size, Py_NEW);
 }
-
-PyObject *Vector_div( PyObject * v1, PyObject * v2 )
+//------------------------obj - obj------------------------------
+//subtraction
+static PyObject *Vector_sub(PyObject * v1, PyObject * v2)
 {
-	float *vec;
-	int x;
-	PyObject *retval;
-
-	if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "unsupported type for this operation\n" );
-	if( ( ( VectorObject * ) v1 )->flag == 0
-	    && ( ( VectorObject * ) v2 )->flag == 0 )
-		return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
-					      "cannot divide two vectors\n" );
-	if( ( ( VectorObject * ) v1 )->flag != 0
-	    && ( ( VectorObject * ) v2 )->flag == 0 )
-		return EXPP_ReturnPyObjError( PyExc_TypeError,
-					      "cannot divide a scalar by a vector\n" );
-	if( ( ( VectorObject * ) v1 )->size !=
-	    ( ( VectorObject * ) v2 )->size )
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-					      "vector dimension error during Vector_mul\n" );
-
-	vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
-			    sizeof( float ) );
-
-	for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
-		vec[x] = ( ( VectorObject * ) v1 )->vec[x] /
-			( ( VectorObject * ) v2 )->vec[x];
-	}
-
-	retval =  ( PyObject * ) newVectorObject( vec,
-						  ( ( ( VectorObject * ) v1 )->
-						    size ) );
-	PyMem_Free( vec );
-	return retval;
-}
+	int x, size;
+	float vec[4];
+	VectorObject *vec1 = NULL, *vec2 = NULL;
 
-//coercion of unknown types to type VectorObject for numeric protocols
-int Vector_coerce( PyObject ** v1, PyObject ** v2 )
-{
-	long *tempI;
-	double *tempF;
-	float *vec;
-	int x;
+	EXPP_incr2(v1, v2);
+	vec1 = (VectorObject*)v1;
+	vec2 = (VectorObject*)v2;
+
+	if(vec1->coerced_object || vec2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Vector subtraction: arguments not valid for this operation....\n");
+	}
+	if(vec1->size != vec2->size){
+		EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+		"Vector subtraction: vectors must have the same dimensions for this operation\n");
+	}
 
-	if( VectorObject_Check( *v1 ) ) {
-		if( VectorObject_Check( *v2 ) ) {	//two vectors
-			Py_INCREF( *v1 );  /* fixme:  wahy are we bumping the ref count? */
-			Py_INCREF( *v2 );
-			return 0;
-		} else {
-			if( Matrix_CheckPyObject( *v2 ) ) {
-				printf( "vector/matrix numeric protocols unsupported...\n" );
-				Py_INCREF( *v1 );
-				return 0;	//operation will type check
-			} else if( *v2 == Py_None ) {
-				Py_INCREF(*v1);
-				Py_INCREF(Py_None);
-				return 0;
-			} else if( PyNumber_Check( *v2 ) ) {
-				if( PyInt_Check( *v2 ) ) {	//cast scalar to vector
-					tempI = PyMem_Malloc( 1 *
-							      sizeof( long ) );
-					*tempI = PyInt_AsLong( *v2 );
-					vec = PyMem_Malloc( ( ( ( VectorObject
-								  * ) *
-								v1 )->size ) *
-							    sizeof( float ) );
-					for( x = 0;
-					     x <  ( ( ( VectorObject * ) * v1 )->size );
-					     x++ ) {
-						vec[x] = ( float ) *tempI;
-					}
-					PyMem_Free( tempI );
-					*v2 = newVectorObject( vec,
-							       ( ( ( VectorObject * ) * v1 )->size ) );
-					( ( VectorObject * ) * v2 )->flag = 1;	//int coercion
-					Py_INCREF( *v1 );
-					return 0;
-				} else if( PyFloat_Check( *v2 ) ) {	//cast scalar to vector
-					tempF = PyMem_Malloc( 1 *
-							      sizeof
-							      ( double ) );
-					*tempF = PyFloat_AsDouble( *v2 );
-					vec = PyMem_Malloc( ( ( ( VectorObject
-								  * ) *
-								v1 )->size ) *
-							    sizeof( float ) );
-					for( x = 0;
-					     x <
-					     ( ( ( VectorObject * ) *
-						 v1 )->size ); x++ ) {
-						vec[x] = ( float ) *tempF;
-					}
-					PyMem_Free( tempF );
-					*v2 = newVectorObject( vec,
-							       ( ( ( VectorObject * ) * v1 )->size ) );
-					( ( VectorObject * ) * v2 )->flag = 2;	//float coercion
-					Py_INCREF( *v1 );
-					return 0;
+	size = vec1->size;
+	for(x = 0; x < size; x++) {
+		vec[x] = vec1->vec[x] -	vec2->vec[x];
+	}
+
+	EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+	return (PyObject *) newVectorObject(vec, size, Py_NEW);
+}
+//------------------------obj * obj------------------------------
+//mulplication
+static PyObject *Vector_mul(PyObject * v1, PyObject * v2)
+{
+	int x, size;
+	float vec[4], scalar, newVec[3];
+	double dot = 0.0f;
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+	PyObject *f = NULL, *retObj = NULL;
+	MatrixObject *mat = NULL;
+	QuaternionObject *quat = NULL;
+
+	EXPP_incr2(v1, v2);
+	vec1 = (VectorObject*)v1;
+	vec2 = (VectorObject*)v2;
+
+	if(vec1->coerced_object){
+		if (PyFloat_Check(vec1->coerced_object) || 
+			PyInt_Check(vec1->coerced_object)){	// FLOAT/INT * VECTOR
+			f = PyNumber_Float(vec1->coerced_object);
+			if(f == NULL) { // parsed item not a number
+				EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+				return EXPP_ReturnPyObjError(PyExc_TypeError, 
+					"Vector multiplication: arguments not acceptable for this operation\n");
+			}
+			scalar = PyFloat_AS_DOUBLE(f);
+			size = vec2->size;
+			for(x = 0; x < size; x++) {
+				vec[x] = vec2->vec[x] *	scalar;
+			}
+			EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+			return (PyObject *) newVectorObject(vec, size, Py_NEW);
+		}
+	}else{
+		if(vec2->coerced_object){
+			if(MatrixObject_Check(vec2->coerced_object)){ //VECTOR * MATRIX
+				mat = (MatrixObject*)EXPP_incr_ret(vec2->coerced_object);
+				retObj = row_vector_multiplication(vec1, mat);
+				EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)mat);
+				return retObj;
+			}else if (PyFloat_Check(vec2->coerced_object) || 
+				PyInt_Check(vec2->coerced_object)){	// VECTOR * FLOAT/INT
+				f = PyNumber_Float(vec2->coerced_object);
+				if(f == NULL) { // parsed item not a number
+					EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Vector multiplication: arguments not acceptable for this operation\n");
+				}
+				scalar = PyFloat_AS_DOUBLE(f);
+				size = vec1->size;
+				for(x = 0; x < size; x++) {
+					vec[x] = vec1->vec[x] *	scalar;
 				}
+				EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+				return (PyObject *) newVectorObject(vec, size, Py_NEW);
+			}else if(QuaternionObject_Check(vec2->coerced_object)){  //QUAT * VEC
+				quat = (QuaternionObject*)EXPP_incr_ret(vec2->coerced_object);
+				if(vec1->size != 3){
+					EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+					return EXPP_ReturnPyObjError(PyExc_TypeError, 
+						"Vector multiplication: only 3D vector rotations (with quats) currently supported\n");
+				}
+				newVec[0] = quat->quat[0]*quat->quat[0]*vec1->vec[0] + 
+							2*quat->quat[2]*quat->quat[0]*vec1->vec[2] - 
+							2*quat->quat[3]*quat->quat[0]*vec1->vec[1] + 
+							quat->quat[1]*quat->quat[1]*vec1->vec[0] + 
+							2*quat->quat[2]*quat->quat[1]*vec1->vec[1] + 
+							2*quat->quat[3]*quat->quat[1]*vec1->vec[2] - 
+							quat->quat[3]*quat->quat[3]*vec1->vec[0] - 
+							quat->quat[2]*quat->quat[2]*vec1->vec[0];
+				newVec[1] = 2*quat->quat[1]*quat->quat[2]*vec1->vec[0] + 
+							quat->quat[2]*quat->quat[2]*vec1->vec[1] + 
+							2*quat->quat[3]*quat->quat[2]*vec1->vec[2] + 
+							2*quat->quat[0]*quat->quat[3]*vec1->vec[0] - 
+							quat->quat[3]*quat->quat[3]*vec1->vec[1] + 
+							quat->quat[0]*quat->quat[0]*vec1->vec[1] - 
+							2*quat->quat[1]*quat->quat[0]*vec1->vec[2] - 
+							quat->quat[1]*quat->quat[1]*vec1->vec[1];
+				newVec[2] = 2*quat->quat[1]*quat->quat[3]*vec1->vec[0] + 
+							2*quat->quat[2]*quat->quat[3]*vec1->vec[1] + 
+							quat->quat[3]*quat->quat[3]*vec1->vec[2] - 
+							2*quat->quat[0]*quat->quat[2]*vec1->vec[0] - 
+							quat->quat[2]*quat->quat[2]*vec1->vec[2] + 
+							2*quat->quat[0]*quat->quat[1]*vec1->vec[1] - 
+							quat->quat[1]*quat->quat[1]*vec1->vec[2] + 
+							quat->quat[0]*quat->quat[0]*vec1->vec[2];
+				EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)quat);
+				return newVectorObject(newVec,3,Py_NEW);
+			}
+		}else{  //VECTOR * VECTOR
+			if(vec1->size != vec2->size){
+				EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+				return EXPP_ReturnPyObjError(PyExc_AttributeError,
+					"Vector multiplication: vectors must have the same dimensions for this operation\n");
 			}
-			//unknown type or numeric cast failure
-			printf( "attempting vector operation with unsupported type...\n" );
-			Py_INCREF( *v1 );
-			Py_INCREF( *v2 );
-			return 0;	//operation will type check
+			size = vec1->size;
+			//dot product
+			for(x = 0; x < size; x++) {
+				dot += vec1->vec[x] * vec2->vec[x];
+			}
+			EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+			return PyFloat_FromDouble(dot);
 		}
-	} else {
-		printf( "numeric protocol failure...\n" );
-		return -1;	//this should not occur - fail
 	}
-	return -1;
+
+	EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+	return EXPP_ReturnPyObjError(PyExc_TypeError, 
+		"Vector multiplication: arguments not acceptable for this operation\n");
 }
+//------------------------obj / obj------------------------------
+//division
+static PyObject *Vector_div(PyObject * v1, PyObject * v2)
+{
+	int x, size;
+	float vec[4];
+	VectorObject *vec1 = NULL, *vec2 = NULL;
+
+	EXPP_incr2(v1, v2);
+	vec1 = (VectorObject*)v1;
+	vec2 = (VectorObject*)v2;
+
+	if(vec1->coerced_object || vec2->coerced_object){
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+			"Vector division: arguments not valid for this operation....\n");
+	}
+	if(vec1->size != vec2->size){
+		EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+		return EXPP_ReturnPyObjError(PyExc_AttributeError,
+		"Vector division: vectors must have the same dimensions for this operation\n");
+	}
 
+	size = vec1->size;
+	for(x = 0; x < size; x++) {
+		vec[x] = vec1->vec[x] /	vec2->vec[x];
+	}
 
+	EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
+	return (PyObject *) newVectorObject(vec, size, Py_NEW);
+}
+//------------------------coerce(obj, obj)-----------------------
+//coercion of unknown types to type VectorObject for numeric protocols
+/*Coercion() is called whenever a math operation has 2 operands that
+ it doesn't understand how to evaluate. 2+Matrix for example. We want to 
+ evaluate some of these operations like: (vector * 2), however, for math
+ to proceed, the unknown operand must be cast to a type that python math will
+ understand. (e.g. in the case above case, 2 must be cast to a vector and 
+ then call vector.multiply(vector, scalar_cast_as_vector)*/
+static int Vector_coerce(PyObject ** v1, PyObject ** v2)
+{
+	PyObject *coerced = NULL;
+
+	if(!VectorObject_Check(*v2)) {
+		if(MatrixObject_Check(*v2) || PyFloat_Check(*v2) || PyInt_Check(*v2) || QuaternionObject_Check(*v2)) {
+			coerced = EXPP_incr_ret(*v2);
+			*v2 = newVectorObject(NULL,3,Py_NEW);
+			((VectorObject*)*v2)->coerced_object = coerced;
+		}else{
+			return EXPP_ReturnIntError(PyExc_TypeError, 
+				"vector.coerce(): unknown operand - can't coerce for numeric protocols\n");
+		}
+	}
+	EXPP_incr2(*v1, *v2);
+	return 0;
+}
+//-----------------PROTCOL DECLARATIONS--------------------------
 static PySequenceMethods Vector_SeqMethods = {
-	( inquiry ) Vector_len,	/* sq_length */
-	( binaryfunc ) 0,	/* sq_concat */
-	( intargfunc ) 0,	/* sq_repeat */
-	( intargfunc ) Vector_item,	/* sq_item */
-	( intintargfunc ) Vector_slice,	/* sq_slice */
-	( intobjargproc ) Vector_ass_item,	/* sq_ass_item */
-	( intintobjargproc ) Vector_ass_slice,	/* sq_ass_slice */
+	(inquiry) Vector_len,						/* sq_length */
+	(binaryfunc) 0,								/* sq_concat */
+	(intargfunc) 0,								/* sq_repeat */
+	(intargfunc) Vector_item,					/* sq_item */
+	(intintargfunc) Vector_slice,				/* sq_slice */
+	(intobjargproc) Vector_ass_item,			/* sq_ass_item */
+	(intintobjargproc) Vector_ass_slice,		/* sq_ass_slice */
 };
-
 static PyNumberMethods Vector_NumMethods = {
-	( binaryfunc ) Vector_add,	/* __add__ */
-	( binaryfunc ) Vector_sub,	/* __sub__ */
-	( binaryfunc ) Vector_mul,	/* __mul__ */
-	( binaryfunc ) Vector_div,	/* __div__ */
-	( binaryfunc ) 0,	/* __mod__ */
-	( binaryfunc ) 0,	/* __divmod__ */
-	( ternaryfunc ) 0,	/* __pow__ */
-	( unaryfunc ) 0,	/* __neg__ */
-	( unaryfunc ) 0,	/* __pos__ */
-	( unaryfunc ) 0,	/* __abs__ */
-	( inquiry ) 0,		/* __nonzero__ */
-	( unaryfunc ) 0,	/* __invert__ */
-	( binaryfunc ) 0,	/* __lshift__ */
-	( binaryfunc ) 0,	/* __rshift__ */
-	( binaryfunc ) 0,	/* __and__ */
-	( binaryfunc ) 0,	/* __xor__ */
-	( binaryfunc ) 0,	/* __or__ */
-	( coercion ) Vector_coerce,	/* __coerce__ */
-	( unaryfunc ) 0,	/* __int__ */
-	( unaryfunc ) 0,	/* __long__ */
-	( unaryfunc ) 0,	/* __float__ */
-	( unaryfunc ) 0,	/* __oct__ */
-	( unaryfunc ) 0,	/* __hex__ */
+	(binaryfunc) Vector_add,					/* __add__ */
+	(binaryfunc) Vector_sub,					/* __sub__ */
+	(binaryfunc) Vector_mul,					/* __mul__ */
+	(binaryfunc) Vector_div,					/* __div__ */
+	(binaryfunc) 0,								/* __mod__ */
+	(binaryfunc) 0,								/* __divmod__ */
+	(ternaryfunc) 0,							/* __pow__ */
+	(unaryfunc) 0,								/* __neg__ */
+	(unaryfunc) 0,								/* __pos__ */
+	(unaryfunc) 0,								/* __abs__ */
+	(inquiry) 0,								/* __nonzero__ */
+	(unaryfunc) 0,								/* __invert__ */
+	(binaryfunc) 0,								/* __lshift__ */
+	(binaryfunc) 0,								/* __rshift__ */
+	(binaryfunc) 0,								/* __and__ */
+	(binaryfunc) 0,								/* __xor__ */
+	(binaryfunc) 0,								/* __or__ */
+	(coercion)  Vector_coerce,					/* __coerce__ */
+	(unaryfunc) 0,								/* __int__ */
+	(unaryfunc) 0,								/* __long__ */
+	(unaryfunc) 0,								/* __float__ */
+	(unaryfunc) 0,								/* __oct__ */
+	(unaryfunc) 0,								/* __hex__ */
 
 };
-
+//------------------PY_OBECT DEFINITION--------------------------
 PyTypeObject vector_Type = {
-	PyObject_HEAD_INIT( NULL ) 0,	/*ob_size */
-	"vector",		/*tp_name */
-	sizeof( VectorObject ),	/*tp_basicsize */
-	0,			/*tp_itemsize */
-	( destructor ) Vector_dealloc,	/*tp_dealloc */
-	( printfunc ) 0,	/*tp_print */
-	( getattrfunc ) Vector_getattr,	/*tp_getattr */
-	( setattrfunc ) Vector_setattr,	/*tp_setattr */
-	0,			/*tp_compare */
-	( reprfunc ) Vector_repr,	/*tp_repr */
-	&Vector_NumMethods,	/*tp_as_number */
-	&Vector_SeqMethods,	/*tp_as_sequence */
+	PyObject_HEAD_INIT(NULL) 
+	0,											/*ob_size */
+	"vector",									/*tp_name */
+	sizeof(VectorObject),						/*tp_basicsize */
+	0,											/*tp_itemsize */
+	(destructor) Vector_dealloc,				/*tp_dealloc */
+	(printfunc) 0,								/*tp_print */
+	(getattrfunc) Vector_getattr,				/*tp_getattr */
+	(setattrfunc) Vector_setattr,				/*tp_setattr */
+	0,											/*tp_compare */
+	(reprfunc) Vector_repr,						/*tp_repr */
+	&Vector_NumMethods,							/*tp_as_number */
+	&Vector_SeqMethods,							/*tp_as_sequence */
 };
-
-
-/* 
- * create a Vector Object( vec, size )
- *
- *  Note: Vector now  uses copy semantics like STL containers.
- *   Memory for vec member is allocated on python stack.  
- *   We own this memory and will free it later. 
- *  
- * size arg is number of floats to alloc.
- *
- * if vec arg is NULL
- *   fill our vec with zeros
- *   initialize 4d vectors to zero in homogenous coords.
- * else
- *   vec param is copied into our local memory and always freed.
- */
-
-PyObject *newVectorObject( float *vec, int size )
+//------------------------newVectorObject (internal)-------------
+//creates a new vector object
+/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
+ (i.e. it was allocated elsewhere by MEM_mallocN())
+  pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
+ (i.e. it must be created here with PyMEM_malloc())*/
+PyObject *newVectorObject(float *vec, int size, int type)
 {
 	VectorObject *self;
 	int x;
 
 	vector_Type.ob_type = &PyType_Type;
-
-	self = PyObject_NEW( VectorObject, &vector_Type );
-
-	self->vec = PyMem_Malloc( size * sizeof( float ) );
-	self->delete_pymem = 1;	/* must free this alloc later */
-
-	if( !vec ) {
-		for( x = 0; x < size; x++ ) {
-			self->vec[x] = 0.0f;
-		}
-		if( size == 4 )  /* do the homogenous thing */
-			self->vec[3] = 1.0f;
-	} else {
-		for( x = 0; x < size; x++ ){
-			self->vec[x] = vec[x];
+	self = PyObject_NEW(VectorObject, &vector_Type);
+	self->data.blend_data = NULL;
+	self->data.py_data = NULL;
+	self->size = size;
+	self->coerced_object = NULL;
+
+	if(type == Py_WRAP){
+		self->data.blend_data = vec;
+		self->vec = self->data.blend_data;
+	}else if (type == Py_NEW){
+		self->data.py_data = PyMem_Malloc(size * sizeof(float));
+		self->vec = self->data.py_data;
+		if(!vec) { //new empty
+			for(x = 0; x < size; x++){
+				self->vec[x] = 0.0f;
+			}
+			if(size == 4)  /* do the homogenous thing */
+				self->vec[3] = 1.0f;
+		}else{
+			for(x = 0; x < size; x++){
+				self->vec[x] = vec[x];
+			}
 		}
+	}else{ //bad type
+		return NULL;
 	}
-
-	self->size = size;
-	self->flag = 0;
-
-	return ( PyObject * ) self;
+	return (PyObject *) EXPP_incr_ret((PyObject *)self);
 }
 
-
-/*
-  create a Vector that is a proxy for blender data.
-  we do not own this data, we NEVER free it.
-  Note: users must deal with bad pointer issue
-*/
-
-PyObject *newVectorProxy( float *vec, int size)
-{
-	VectorObject *proxy;
-
-	proxy = PyObject_NEW( VectorObject, &vector_Type );
-
-	proxy->delete_pymem = 0;	/* must NOT free this alloc later */
-
-	if( !vec || size < 1 ) {
-		return EXPP_ReturnPyObjError( PyExc_AttributeError,
-				       "cannot creat zero length vector proxy" );
-	}
-		
-	proxy->vec = vec;
-	proxy->size = size;
-	proxy->flag = 0;
-
-	return ( PyObject * ) proxy;
-}
-	
diff --git a/source/blender/python/api2_2x/vector.h b/source/blender/python/api2_2x/vector.h
index 40e5851359a..048fa1df8bc 100644
--- a/source/blender/python/api2_2x/vector.h
+++ b/source/blender/python/api2_2x/vector.h
@@ -33,40 +33,34 @@
 #ifndef EXPP_vector_h
 #define EXPP_vector_h
 
-#include "Python.h"
-#include "gen_utils.h"
-#include "Types.h"
-#include "matrix.h"
-#include "BKE_utildefines.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-/*****************************/
-//    Vector Python Object   
-/*****************************/
-
 #define VectorObject_Check(v) ((v)->ob_type == &vector_Type)
 
 typedef struct {
-	PyObject_VAR_HEAD float *vec;
+	PyObject_VAR_HEAD 
+	struct{
+		float *py_data;		//python managed
+		float *blend_data;	//blender managed
+	}data;
+	float *vec;				//1D array of data (alias)
 	int size;
-	int flag;
-	//0 - no coercion
-	//1 - coerced from int
-	//2 - coerced from float
-	int delete_pymem;	/* flag to delete the memory vec points at */
+	PyObject *coerced_object;
 } VectorObject;
+/*coerced_object is a pointer to the object that it was
+coerced from when a dummy vector needs to be created from
+the coerce() function for numeric protocol operations*/
+
+/*struct data contains a pointer to the actual data that the
+object uses. It can use either PyMem allocated data (which will
+be stored in py_data) or be a wrapper for data allocated through
+blender (stored in blend_data). This is an either/or struct not both*/
 
 //prototypes
-PyObject *newVectorObject( float *vec, int size );
-PyObject *newVectorProxy( float *vec, int size );
 PyObject *Vector_Zero( VectorObject * self );
 PyObject *Vector_Normalize( VectorObject * self );
 PyObject *Vector_Negate( VectorObject * self );
 PyObject *Vector_Resize2D( VectorObject * self );
 PyObject *Vector_Resize3D( VectorObject * self );
 PyObject *Vector_Resize4D( VectorObject * self );
+PyObject *newVectorObject(float *vec, int size, int type);
 
 #endif				/* EXPP_vector_h */