Technically Correct

Math, Can't Outrun It

2011-12-14T22:57:00.000-08:00

So my next big push is going to involve, adding a new function clone() to gladius.math to allow for cloning of matrices without incurring a new allocation. New branch created for this: https://github.com/saecob/gladius.math/tree/alpha

Simple enough with a source and destination parameter, copy one into the other. The next step is to bring transform.js in line with the api. The difficulty now is understanding the linear algebra used.

Scale()
Rotate()
Translate()

Coming up with some clever tests and resources for this bit of code will be part of the challenge.

After getting things sorted out with transform, one last pass over the unit tests to add some variety will need to be done. After this maybe it will be time to take a look at our Algorithm scripts.

Progress Central

2011-12-12T17:42:00.000-08:00

Today after my exam i decided to knock out a bunch of implementations for Gladius.Math. We now have a 90% complete implementation of the new API and its exciting. Check it out here: https://github.com/saecob/gladius.math

The main work was done to Matrices of the 3x3 and 4x4 variety and of course the ever loved test scripts to go along with them. The biggest change to get used to is definitely the addition of matrix lists as parameters for almost all of the matrix implementations.

Because of this, i decided to iterate through the matrix list in each respective function and call the base Matrix class to complete the additions. This looping system may have a pretty big impact on performance for long lists of matrices but for now it seems to be working fine.

Along the way while updating Matrix4, i managed to break the transform methods as they were relying on the old method calls to multiply. A simple fix but it will go in along with my next big update. All i would need to do is to add the 2 matrices being multiplied to a list and pass that parameter.

The next big update will include Quaternion and Transform method implementations and tests, along with some way to allow a developer to clone a matrix/vector without incurring a new allocation.

End In Sight

2011-12-01T05:05:00.001-08:00

So the end of the school term is fast approaching and I am definitely feeling the crunch. I pushed up a new commit to my Github account (https://github.com/saecob/gladius.math/tree/develop) under the develop branch in preparation for a major pull request for implementations of all Matrix functions.

Everything seems to be working fine, except for inverse().

Not exactly sure what is wrong yet but i think i may have missed a movement of some sort with the matrix indexes. Ill take a look at it during the day today.

Next up: Matrix3 and finally Matrix4 which already has implementations but needs to be brought in line with the API.
Also, I need to change some of the tests for Matrix as the API now states that our functions should accept an array of Matrices which is not being tested as of yet.

Check back tonight.

The Matrix, Is Out There

2011-11-27T23:45:00.001-08:00

After getting started with the new matrix implementations, having the input parameters as a list of matrices is turning out to be a bit more of a pain than anticipated.

The main downside is the fact that we now have to iterate through the list of matrices in order to perform add(), subtract(), multiply() on each. We also have to save the results of the previous additions and pass those on for the next set. Something like this:

I haven't run any speed tests but this seems like it may be slow, but for now it will have to do.

Now for my two concerns regarding the API and reality.

Our add(), subtract(), and multiply() functions all take 2 parameters, ml, the list of matrices and result, the optional variable in which we will store our result. The API specifies that if the list is only one matrix long then we will return the one matrix. What if the result parameter has values in it and the list only has one matrix? then we will not add the two properly. Maybe this will never happen, ill wait to ask in iRC.
The inverse(m) function returns the inverse of the given matrix. A square matrix will only have an inverse if the determinant of that matrix is not zero. This situation is not covered in the api.

That is about it for now, going to get these cleared up and then move forward.

Boys Are Back In Town

2011-11-24T17:47:00.001-08:00

So I've managed to get myself in gear and get contributing to Math.Gladius again. The math library underwent a massive refactoring in which it was broken down in to small chunks consisting of a script for each size of Vector and Matrix object.

When I left off, work had been completed to Vector through to Vector4 tests included. Now I am beginning to work on the Matrix functions. There are a few differences in the way we deal with matrices, such as the operation functions (+, -, /, *) taking a list of matrices.

Check it out: https://github.com/alankligman/gladius.math/wiki/Math-api-reference

I will assume the input is always valid, so from there I'll just have to figure out a clever way of:

Finding out how many Matrices there are in the list
Performing the required operation quickly and efficiently

I'll have more later tonight.

Equality Among Floats

2011-10-04T16:08:00.000-07:00

Well the Gladius Math library is coming along swimmingly and is taking shape very quickly now that we have the API outline almost complete. (https://github.com/alankligman/gladius.math) Check out the wiki section.

After implementing the functions for 2 dimensional vectors [x,y] an interesting issue presented itself in the form of one glaring logic error and a unit test case issue.

In our library we have a function, normalize(v1, result); which returns a unit vector with same direction as the given vector v1. Result is the optional parameter in which we store the resulting vector. Our code for this function was as follows:

// Return a Vector(result) with same direction as v having unit length
normalize: function( v, result ) {
   for( var i = 0, len = v.length; i < len; ++ i ) {
     result[i] = v[i] / len;
   }

   return result;
}

Normalizing a vector is done by calculating its length and dividing each component by the length. At first glance this code looks to be correct but we will quickly see how a small flaw ruins any results this function returns.

The problem caused by len = v.length. When we use v.length it is in fact returning the length of the array holding our vector, in this case [x,y] which would cause the function to just divide components by 2.

By changing the code to len = vector.length(v); we open up the next set of problems. Vector lengths (http://en.wikipedia.org/wiki/Euclidean_vector#Length)

By calculating the absolute length of vectors, some pretty unpleasant numbers can be returned as a result. For example, when we call normalize() for the vector v1 = [12,-5] the resulting vector is expressed as v2 = [(12/13), (-5/13)]. This would not be a problem if a computer were able to show the results as the above expression but of course it can not and it will return a float with a set number of decimals.
This problem is compounded when you start to add other operations on the resulting vector which will continue to use the float representation of the result. This is very evident in the unit tests:

You can see above that the expected results and the computed results are identical up until the sixth digit after the decimal. For all intensive purposes this is "equal", we now have to add an equal(v1, v2, e) function which will compare 2 vectors up to a set number of decimals for use to call them equal.

And that is what i'm working on now, as well as figuring out how to compare only a set number of decimals in the Qunit tests.

Unit Tests, Love Hate

2011-10-01T00:12:00.000-07:00

Today I decided to try and get some unit tests created for the matrix functions which I implemented in yesterdays push (https://github.com/saecob/gladius.math/tree/Matrix2).

After spending some time identifying how unit tests are launched (index.html),

I created my own test script with the name Math.Matrix2.js which tests 2 x 2 matrices.

When I first ran the newly created test, I noticed that none of the coded implementations of any size matrix had been tested. After further inspection, the matrix functions seem to be direct logic and code copies of all the implemented vector functions.

At first glance this doesn't seem to be such a big problem but I don't think that they correlate exactly.

The second issue which came about from these discoveries is, that at the moment I feel like I am implementing and adding functions arbitrarily not knowing if they will even be useful to someone using the library.

For example, we have a function rotate() which creates a rotation matrix given a Quaternion(http://en.wikipedia.org/wiki/Quaternion). This function is implemented under matrix4 functions, i.e 4x4 matrices.

The question is: Do we need this function for 2x2 and 3x3 matrices as well?

        // Construct a 2x2 rotation matrix from a Quaternion.
        rotate: function() {
            if( 0 === arguments.length ) {
                return Matrix( 4, that.matrix2.identity );
            } else if( 1 === arguments.length ) {
                var v = arguments[0];
                var r = v[0];
//              return Matrix( 4, [] );
            // Todo (Quaternion = w + xi + yj + zk)
            } else {
                return Matrix( 4, arguments );
            }
        }
    };

It seems like it would be a good idea to collaborate with the different areas of the project (Physics, Rendering, etc.) and come up with an interface with a list of functions, parameters, and return types/values so that everything put in Gladius.Math is useful as a library.

An Ode To Math

2011-09-29T23:15:00.000-07:00

Recently I decided to contribute to the Gladius/Paladin (https://github.com/alankligman/gladius) open source project, more specifically, the Gladius.Math(https://github.com/alankligman/gladius.math) library. Having only recently decided to get involved with the project, I was feeling a little overwhelmed but excited as well.

The issues/tickets I have decided to work on are the implementations of several math functions involving various size matrices and vectors.

In order to scope this correctly I decided to start with all the functions for 2x2 matrices, then 3x3 and so forth. For each matrix size from 2x2 to 4x4 there are a number of functions which perform various operations, or specifically:

Translate
Scale
Rotate

Everyone loves wiki links:
Translations - http://en.wikipedia.org/wiki/Translation_%28geometry%29
Scaling - http://en.wikipedia.org/wiki/Scaling_%28geometry%29
Rotations - http://en.wikipedia.org/wiki/Rotation_matrix

Also an interesting read: http://knol.google.com/k/matrices-for-3d-applications-translation-rotation#

For my first push I implemented these functions for 2x2 matrices. The unit testing will be the next major focus in order to determine performance and test logic.

Take a look at the code yourself : https://github.com/saecob/gladius.math/commit/20caebde7578ca3a772440a7bc2b2421740b51e6#L0R548

While coding I noticed that there were a number of basic matrix functions which were missing and a number which didn't seem to be present in other math libraries which i used for code examples.

If I'm going to spend some time with this library I think I'll need to look at some other game engine math libraries to see if there are functions which would help to include.

To Git, Or Not To Git

2011-09-29T15:24:00.000-07:00

After being introduced to GitHub (www.github.com) a few weeks ago, I thought that things were pretty straight forward and easy to use, that is until you actually start doing some work of course.

The Git Bash tool, used to communicate with the Git server and to organized your branches and repositories, uses many different commands to do these things which I found very difficult to remember when it came down to working with them.

Luckily Git provides lots of support and guides to help new users like me along. Here are some which I found helpful.

http://help.github.com/ - The main hub of information on all things Git
http://help.github.com/git-cheat-sheets/ - A compilation of cheat sheets and quick guides to using the bash commands.

I found these resources very helpful and I thought I would share.