Future

As the summer starts to wind down, I wanted to write about where Touch of Math is headed in the next few weeks. As of now, I plan to stop working on the project at the end of the summer, when school starts up again. That means I have until then to implement all the features that I want to have done as well as leave the project in a stable and developer-friendly (relatively) state so that it can be used without my maintenance. Of course, I will gladly help anyone who wants to pick up and work on the project to do so, as Touch of Math will not have reached its full potential by the end of the summer.

Anyway I have to get back to work, it turns out these things don't create/fix themselves

Zach

Update

Touch of Math supports basic undo functionality now. Normally we would wait to post until a few more features were implemented (e.g. redo), but I am going on vacation for two weeks or so, and will most likely not be able to work on the project until I return.

Zach

Equation History

Touch of Math now shows you the history of your equation as you manipulate it. As you change your equation, the previous state is frozen and displayed in gray above the current equation. It's basic, but it is a solid step towards the ultimate goal of interactive history (undo/redo, etc.)

On a side note, progress should be much quicker now that we are in the summer session of RCOS, with hopefully little to no other work getting in the way.

Enjoy,

Zach

Variable Substitution

That's right, Touch of Math now has a functional variable replacement feature. This feature allows a user to substitute other values in for existing variables in the expression.

In other news, we had our first RCOS presentation of the semester which, while short, ended with a nice "ooooo" from the audience when we demoed the new variable substitution feature (which was fixed only minutes before the presentation).

Let's hope this is a sign of good things to come.

Zach

New Semester

I would like to start off by apologizing for not having posted here since October. Last semester started off promising but did not result in nearly as much progress in Touch of Math as hoped and was not acceptable by any means. This is the part where I would normally cite lack of time, too much schoolwork, etc. but instead I will move on and just get straight to what did get accomplished and what the plans for this semester are.

In its current state, Touch of Math is able to distinguish between constants, and editable variables. Also, the project is now capable of displaying special characters (right now it's just a few greek letters, like sigma and pi, but the framework is there so it's easy to add more). Another current feature is the ability to have variables with subscripts, by using an underscore, as well as the ability to have multi-character variables by putting them in quotes.

There is one other "feature" although it was more of a proof of concept: the ability to replace variables (only editable ones, not constants) with other variables or numbers. The reason I say it was a proof of concept is the fact that it is only implemented in the front end. That is to say, replacing a variable literally just replaces the displayed html with a different character, and in no way is tied back to the underlying equation.

With that said, let me mention the goals we have for this semester. The first one is obviously to hook up the partially implemented variable replacement feature mentioned above so that it actually works (there's also this small bug where it treats numbers as editable variables...).

The major goal of this semester is to overhaul the way the user interacts with the expression. This involves implementing a way to change which scope the user is manipulating within (moving a variable within a parenthetical statement vs. moving the whole parenthetical statement and interacting with another part of the expression). This is critical to Touch of Math being a fully functional equation editor/manipulator/solver.

Also on the list of things to accomplish this semester is an interactive history. Interactive in the sense that the user will be able to see the equation's history and—thanks to suggestions from fellow RCOS members—they will see the operations performed between that state and the next one (like a little "-2" on both sides of the equation, etc.)

All of these plus additional smaller features not worth spelling out here are on the plate for this semester and with this new year's clean slate so to speak (yes I know it's February), I believe most, if not all, can and will be realized by the time school lets out for the summer.

I leave you with all of that and with the promise of more posts (and soon too, not in four months like this one). In case you don't know already, the whole project is on github at https://github.com/jlabarbera11/TouchOfMath.

Zach

Minor Release

Minor release 0.2.5: https://github.com/jlabarbera11/TouchOfMath

Last week I gave a demo of Touch of Math to RCOS in which I showed off the new (and still buggy) features between the last code release and now. I cleaned up the code from the demo and am releasing it as our promised "maintenance" release.

Now that we have gotten going on the project again, we are excited to be working towards the next major release whose proposed features include:

– distinguishing between variables, numbers, and constants

– variables next to each other signify multiplication

– displaying of special characters (e.g. greek letters such as σ or β)

– displaying of subscripts and multi-character variables

– interactive history (i.e. viewing and loading previous states)

We will keep you posted on the progress of this next major version,

Zach and Joe

Still Alive

Yes, A Touch Of Math is still alive, and we are indeed still developing it. We would like to apologize for the blatant lack of progress since last spring. A Touch Of Math had a longer summer than most, and when you add in our project lead shuffle, we ended up well into Fall.

As we gear things back up, we will be rolling out a maintenance release that ties up all the loose ends from between the last code release and now. This won't have many new features, but it will give us a more up-to-date, stable codebase for us to develop on this semester.

Look out for this update in the near future, we'll post again when its ready,

Zach and Joe

Version 0.2 Release!

Well here it is, the code release promised by us in our last post. It is available at https://github.com/jlabarbera11/TouchOfMath for your downloading pleasure.

To run it, simply view index.html in a web browser. To use it, type your equation into the text box, and click the display button (or hit enter). Currently, it supports addition, subtraction, multiplication, division, exponents, and summations. Dragging an element and releasing it on an element located on the other side of the equals sign will cause the original element (and any companion elements) to be subtracted/divided over to the other side.

Touch of Math works on iOS devices too, although it hasn't been thoroughly tested on iPads or Iphone 4's, so heads up. Also, multitouch is unfortunately not yet supported, but it is in the works for release in a future version.

It is worth noting that there are some font/formatting inconsistencies between the major browsers, so for the best experience, Firefox, Chrome, and Safari are recommended. Also, it may sadden you to know that Touch of Math currently doesn't run at all in Internet Explorer, but don't fret, compatibility will come.

With all that being said, just download it and give it a try, this release isn't perfect (hence the 0.2 version number), but it should give a good idea of what the core functionality of Touch of Math is about.

Enjoy,

Zach and Joe

Progress

We apologize for the lack of regular blog posts and/or code pushes, but we promise progress is indeed being made.

A good amount has happened since the last post, we gave another presentation, showing off our fledgling, new frontend. In addition, the backend has seen many improvements, both in terms of functionality and in terms of stability/mathematical accuracy.

The frontend utilizes individually draggable <div> tags instead of the single big <canvas> tag that the original version used. Also, the equation is displayed in a more traditional and natural way (e.g. denominators being below numerators, exponents being superscripts, etc.).

As far as future versions, we will continue to improve the stability of the backend while implementing more functions (i.e. math operators). Additionally, we plan to add features such as one-sided operations and history/undo/redo.

And not to be forgotten, Touch of Math will soon be true to its name. That is to say, we intend to add touch support to our current frontend, as well as some new gestures that take advantage of multitouch recognition.

The code containing all of our current features—and maybe even some additional features—will be available within the week!

That's all for now, we will post again when the new code is available,

Zach and Joe

Our first presentation

Hey,

Sorry not too much has been happening in this project so far, we've had a bunch of exams/job applications going on this month. But as a lot of this is getting wrapped up for now, so hopefully you will start to see updates more often.

We gave our first presentation of the semester about a month ago, and followed with several two-week goals. These were:

Design and implement a user interface

Correctly format input

Define rules for one-sided arithmetic

On the first, we hoped to use Mathjax as our interface. However, though we could display our equations, getting feedback on what terms were clicked, where they were moved, etc. was proving difficult. So instead we hoped to write our own displayer. We were able to construct an xml string from our backend, but we're still tinkering with a nice display/feedback to the backend.

The third is to avoid writing specific code for each case, much like what happened our first semester. This has been done by determining which operations will be supported, and what common rules govern them. We hope to implement:

Commutativity (a+b -> b+a)

Distribution (a(b+c) -> ab + bc)

Factoring (x^2 + 2x + 2 -> (x+1)^2) and vice versa

Logarithmic operations (There's several of them)

Variable combination (2x + 3x -> 5x)

Solver

So far, most of these rules have been defined, and we hope to write them up as soon as possible.

That's all we have to say for now, but you'll hear from us soon

Zach and Joe

New Year, New Code

School officially started about a week ago, which means Touch of Math is back in full swing. We have a new member, Zach, who will help out on the front end of things. Our goal is to use MathJax to render our equations. We plan to add a ton of new gestures too, including those for one-sided manipulations (distribution, association, logarithms?, etc).

On the back end side of things, we're looking a a totally new data structure. Currently in use is an n-ary tree that replaces our original binary tree. This removes a lot of the problems we were having with subtraction and division, as well as allows easier use for operations that aren't binary.

Also, we've been putting significant time into a lot of the suggestions that were given to us over last semester. Most notably, look for a history/undo feature, and custom features later on. We've already got more math than just +,-,*,/, and we plan to add higher mathematical operations still.

That's really all for now, we're looking forward to another great semester of development. Our newest code is here, and our original can be found here.

Thanks again!

The Last Presentation of the Year

Hey,

So we gave our final presentation of Touch of Math last Friday. You can see the Prezi (which worked this time!) at http://prezi.com/wogbvom-nhxy/touch-of-math-2/ and our latest code can be tested here: http://touchmath.dyndns.org/multitouchdemo/demo2.html

So the presentation, I'd say, was a success. Most of the algebraic math is there, there's just a few small kinks to work out. We also introduced our newest feature, merging, which gives us some evaluation methods. We hope to build on this as much as we can.

As last time, we got several more ideas to implement, including a history, higher order math, etc. They're all excellent ideas, and once we do some more bug-fixing, you'll start seeing them worked in.

Also, next semester we may have another developer working with us to help with our front end stuff. I don't want to say too much more about it, since nothing's final, but I'm really excited to work with him in the Spring.

That's all for now, we'll keep you posted through the winter of anything new going on with Touch of Math.

- Alex and Joe

Getting There, and a contender: Mathination

Hi all,

This Saturday Joe and I will be doing a demo. Check out
the current release at http//touchmath.dyndns.org/demo/demo.html.

These are the current features:
- *, /, +, -
- swapping additive groups
- swapping multiplicative groups
- limited evaluation

These just need a few touchups and the core math is finished.
We'll be improving these with some multi touch gestures and
keyboard input for the desktop. The next step will be getting
this out to some people to play with.

If you've been reading, we've shifted plans. Earlier this week
we discovered that, on the 15th of October, Matthew Self published
his iPad Mathination software.
We haven't played with it yet, but it looks quite good. Kudos to
Matthew Self for releasing first viable contender in the touch-math space.
This is exactly what we had in mind at the start of our project in September.

Before discovering Mathination, we were gearing up to abstract our
tree manipulations to a more functional approach that decouples
operators from code, and lets you define new operators without writing
more code.

But this will have to wait for now. Matthew Self's project puts some pressure on us to get basic algebra finalized ASAP. And I feel confident that we will bridge this gap, pending aesthetics, just momentarily.

Once we do this, we're interested in getting this software out to people learning and teaching algebra. They'll want prepared problems, history, and hints.


Thanks for reading,
Alex

PS you can see it in action here: http//touchmath.dyndns.org/demo/demo.html.
And you can pull the code here: github.com/adc/digiti

Today's Presentation

Hi, Alex here.

Today we hit our second presentation.

After giving up on our prezi, we decided to jump to demo. Joe passed around his iPod touch and showed people the demo on the projector, and walked them through the features.

Here are a few quotes:

Alex (confused): "Why are you guys laughing?"
RCOS "It's cool!"

Alex : "And , I'd like to than Joe. Work with a math major! They make good partners"
Joe (CS) : "I'm not a math major!"


We got TONS of feedback, and we really appreciated the interest and enthusiasm. It feels to me that the project is on the right track.

Okay so before we had this: http://touchmath.dyndns.org/demo0/canvas_test.html.
It looks okay, but it's pretty awkward and has a bunch of errors. Joe fixed fixed all of this with his grouping implementation: http://touchmath.dyndns.org/demo/demo.html. Check it out. This is really nice!

This definitely makes my week. Way to be

Feedback
- Add a history! (Brendan Ashby)
- It'd be great to add recursion operators! (Genesis emulator dude)
- Add calculus, limits, summations (Peter Hajas)
- Add diffeq! (Graylin)
- You should get some users. See what younger kids think (Moorthy)

Minor fixes that should be done:
- improved parenthesis
- cleaning up "1"s in division and multiplication
- adding exponents

Major things
- evaluation?
- new gestures
- generators for resolving equations

Doing things smarter

Ok, so we have a basic thing going. Soon enough gestures for multiplication, division, and factoring will be in.

Right now they're being done on a case-by-case basis though. That's not too good. It's really bad actually. Instead we should be doing all of this with a solver.

A solver is something that recursively applies algebra rules until it reaches a desired form. Here's a link to javascript->prolog (http://ioctl.org/logic/prolog1). That's basically all we need.

This is really a math problem, which declarative programming can be rather good at. So what should queries look like?

Part of the difficulty is just identifying what needs to be solved. The user makes some gestures involving different symbols. For simple additivity this is taking a symbol, a for instance, and trying to get it on the other side of the the '=' operator.

So, a recursive solver would just start going through possible operations on a that may lead to this. A Prolog-like approach would be especially good, with cuts and all that jazz. But aah, that link doesn't have cuts. hMmmm. But, what's this? OMG http://yieldprolog.sourceforge.net/
That looks quite promising. As does this project. Awesome!

Addition

Hi,

A basic proof of concept Joe and * made is floating online.

Currently only addition is supported. We're still thinking up the gestures for dealing with products and divisors.

Joe has also gotten Safari Mobile compatible event recognition going over here: touchmath.dyndns.org/movement_test.html . On the todo list is abstracting our javascript events for supporting loads of different html5 capable browsers and devices.

To use the interface, input an infix expression. It gets converted into an expression tree. And as you manipulate symbols in the infix equation, the underlying expression tree readjusts to match what you're doing. If the tree doesn't like what you're doing, syntactically or algebraically, it will resist the change. Otherwise it will give you the go ahead.

Once products are together, we'll add in exponents, then combine the blocky shapes into a more aesthetic form.

One thing to note at the moment is that the algebraic expression manipulations are not very formally defined. This is something we're saving for a second iteration through this stage. As an end of semester goal we're looking to fully support +,-,/,*,^, and parentheses. These are pretty trivial, and should not require a highly formal approach.

As we prepare for adding in calculus and other cool math, the semantics become more complex. It'd be great to create some grammars that can take care of all these things

Some dangling thoughts and questions for our readers:

1) Currently, we're not using any libraries. Are any out there recommended? Should we use prototype.js? JQuery? What about building a desktop app with node.js?

2) There doesn't seem to be a mouseUp event in Safari's mobile touch...whaat

3) Any good papers on computer aided interactive algebra?

Thanks,

Alex & Joe

Some Basic Features

David Doria had some great feedback after last Friday's presentation. Here's a list he put together of things both he and us would like to see ASAP

1) Addition Balancing

Initial state:

A = B+ C

Final state:
A - C = B

2) Multiplicative Balancing

Initial state:
A = B C

Final state:
A/C = B

3) Expand (distributive property (additive and multiplicative))
Initial state:
((x-2)*(x-4))

Final state:
x^2-6*x+8

4) Factoring (inverse of 3)

After last Saturday's meeting, we're sort of close to achieving this right now. More posts coming after today's session

A Smart EQN Interface

Joe LaBarbera and Alex Rad here, we'd like to welcome you to the decade of multitouch.

Working for the Rensselaer Center for Open Source, we'll be designing and building an interactive equation interface. The idea is to augment human mathematical abilities with software that both expands educational capacity and greatly improves analysis capability.

For education, calculators can be a mixed blessing. On the negative side, some students tend to become overly dependent on the analytical capabilities of the more capable hardware. This can utterly destroys their mathematical abilities. We're hoping to make something where this just isn't an issue.

The design behind a really smart equation editor is a also a bit different than your normal form-based formula editor. W're trying to augment, not replace, human analytical capability. Rather than writing on a piece of paper, a user can manipulate symbols on a screen. And with the advent of multi-touch capable devices, these manipulations will match and possibly surpass the intuition of a pen.

For more information check out this poorly put together presentation Alex Rad made last Friday here.

Thanks,

Joe & Alex