I found that algorithm. http://en.wikipedia.org/wiki/Strassen_algorithm

I think the extra calculations may actually slow it down in Lua because of all the adding that goes on. I can see how things like servers could benefit from the optimization, especially if they're in a low level language, but I'll probably just stick with the common algorithm.

I had never heard about that algorithm before, though. Thanks

- Windows Nspire 3.2 Student.
- Windows Nspire 3.2 Teacher.
- Mac Nspire 3.2 Student.
- Mac Nspire 3.2 Teacher.
(not PC/Mac software not uploaded yet...)

I just downloaded the student software from here, so the main news article should probably be updated. I don't know about the teacher software.

The script editor looks very handy for writing Lua. They also have updated documentation here for the new functions.

Here is a link with all the minute details of damage calculation. http://www.smogon.com/dp/articles/damage_formula
You probably won't want to make it this complicated but it should have all the formulas you need. (This is for Diamond and Perl so the formulas could be slightly different depending on which generation you're writing the program for for)

It depends on how you want it to be used. If you want the inputs passed as arguments, I would say make a library full of functions. If you want the user to enter information in text boxes and such I would make one large program. Of course you could make both using your library functions in a program that collects the input from the user. Then you could use it both ways.

Good Luck!

First of all, I have no idea what math teachers would say about any of this. I was playing around with some stuff, and I stumbled upon it. I read a few things to confirm I was right.

 There are ways of looking at it: rotating the coordinate system or rotating all the points. I think the second way is a bit more intuitive. That’s also the way I found it.



This is the basic setup for rotating a point.

First, we need to describe the point you want to rotate relative to the point of rotation and in terms of an angle from standard position.

Let’s say the original point has coordinates of (x_i, y_i) and the point of rotation has coordinates of (x_center, y_center).

Since unit circle trigonometry is based off a circle at the origin, let’s temporarily translate everything to the origin. Since we are working based on how the points are relative to the point of rotation and not a “fixed” point, we can move the whole system as long as we move it back. To do this, all we have to do is subtract (x_center, y_center) from both points. This puts the point of rotation at the origin and the other point at (x_i- x_center, y_i - y_center).

When you rotate an object around a point, the points are always the same distance from each other. This means if you draw a circle with the point of rotation at the center and the point you want to rotate on the circle, the rotated point will also be on the circle. Since we know the coordinates of the two points, we can use the distance formula to find this distance.

√((x_i - x_center)² + (y_i - y_center)²)

Now by dropping a right triangle down from the point, we can find the angle between the point and standard position.

tan(θ) = o / h

tan(θ) = (x_i - x_center)/(y_i - y_center)

θ = arctan(x_i - x_center)/(y_i - y_center)

Now we have everything needed to express the original point using angles.

(Distance*cos(θ), Distance*sin(θ))

To rotate the point, just add the desired angle of rotation.

Since we have to move everything back to their original position, we need to add (x_center, y_center)

To put everything together, you would end up with these equations:

x_new = √((x_i - x_center)² + (y_i - y_center)²)*cos(arctan(x_i - x_center)/(y_i - y_center)+ θ_rotation)+ x_center

y_new = √((x_i - x_center)² + (y_i - y_center)²)*sin(arctan(x_i - x_center)/(y_i - y_center)+ θ_rotation)+ y_center

where (x_new, y_new) is the rotated point.

This looks terrible and is a pain to type so let’s simplify it. According to the linear combination of sine and cosine, a*sin(θ)+b*cos(θ)= √(a²+ b²)*cos(θ - arctan(b/a)).
The second half shows a very near resemblance to our two equations.

The shifts on the ends of the equations wouldn’t matter because if the above statement is true wouldn’t a*sin(θ)+b*cos(θ) + 5= √(a²+ b²)*cos(θ - arctan(b/a)) +5?

Starting with the x equation, a would be y_i - y_center because it is on the bottom of the fraction in the arctan.

That means that b is x_i - x_center

In this case we need to make θ =-θ_rotation so we can change the sign in front of the θ_rotation (a double negative)

Also because cos(θ)= cos(-θ) we can then distribute a negative through

x_new = √((x_i - x_center)² + (y_i - y_center)²)*cos( (-θ_rotation)- arctan(x_i - x_center)/(y_i - y_center))+ x_center

now that it matches the formula we can write it as

x_new = (y_i - y_center)*sin(-θ_rotation) + (x_i - x_center)*cos(-θ_rotation)  + x_center

Because cos(θ)= cos(-θ) and -sin(θ)= sin(-θ) it can be written like

x_new = (x_i - x_center)*cos(θ_rotation) - (y_i - y_center)*sin(θ_rotation) + x_center

It’s a similar process for the ys but we need to change the sine into a cosine

cos(θ)= sin(90-θ) because a right triangle’s angles add up to 180 and one is already 90 (pi and pi/2 if you prefer)

so in this case we need 90-θ_rotation instead (the negative distributes into the arctan but we need that negative anyway)

now that the sine is a cosine we can do the same thing as last time.

y_new = (y_i - y_center)*sin(90-θ_rotation) + (x_i - x_center)*cos(90-θ_rotation)  + y_center

Now we can switch the sines (punny)

y_new = (y_i - y_center)*cos(θ_rotation) + (x_i - x_center)*sin(θ_rotation)  + y_center

In the end these are the equations

x_new = (x_i - x_center)*cos(θ_rotation) - (y_i - y_center)*sin(θ_rotation) + x_center

y_new = (y_i - y_center)*cos(θ_rotation) + (x_i - x_center)*sin(θ_rotation)  + y_center

These are similar to the equations in the Wikipedia article (except those are for rotating around the origin).

To use these equations just plug in the coordinates of the points and make θ_rotation how much you want to rotate it by.

Just so you know it works to put other parametric equations in for (x_i, y_i) to rotate all the points in the equations thus rotating the equations

If anything needs clairification, I’m happy to explain. Once again I explored this by myself so I don’t know how it is taught in schools.

Is this the type of thing you're looking for?

http://en.wikipedia.org/wiki/Rotation_(mathematics)

I understand what you're saying. I learn about series next year.

Wolfram Alpha is great but it feels frustrating that it now costs money to use all of its cool new features (and a couple of its old features).
Since it's still getting new things added to it, it's fine that it doesn't always show exactly what I want, yet. (I'll wait until it can read minds.)

(but sadly rarely usable on complex cases )

On what sort of cases is it unusable?

A good quote to try:

As I would not be a slave, so I would not be a master. This expresses my idea of democracy. -Abraham Lincoln