I'm jumping back into the .Math library - this took a back seat after the 1.0 release.
I'm focusing on speeding up the processing by using consistent and
better coding practices. This includes more thorough exception handling
along with simple but effective code changes. For instance,
replacing
stringToken == “+”
with
stringToken.Equals(“+“)
I'm also paying attention to object usage and destruction to make
certain the library plays nice with the garbage collector. While
there is nothing that is alarming or causing poor performance, I'm
applying lessons I've been learning with DevStudio. This tool is
a lot of fun and eye-opening and it's very useful when run in
conjunction with unit tests.
I keep coming back to the idea of flattening the processing
structure into a linear solution pattern rather than relying on the
call stack. I have a simple object structure in mind to modify
the existing code to run effectively in this manner, but now it's
a matter of finding the time to do it. The other problem is that
this solution isn't something I'm pressed for right now, no one is
complaining about performance and the benefits would only be useful if
someone is performing 100's of millions of calculations during the
run. It's really just an academic exercise at this point, but
it's the last hurdle staring me in the face. I'm writing
up a document to explain the processing structure and the
differences between the two. I'll post it shortly and place a
link to it in my blog.