by Shelley Walsh ©2001
Simplifying expressions and solving equations are the two big main topics of algebra. Here are some tips for using Python to better understand these algebra topics, and also to help you check your work.
In algebra when you simplify an expression with variables in it you are making a general statement about all numbers. (Most of the time this means all Real Numbers, but sometimes we use other sets of numbers like the Complex Numbers or even smaller sets like only whole numbers.) But in any case, since this means that even a simple algebraic simplification like 2x+x=3x represents infinitely many statements about number, 2*2+2=3*2, 2*3+3=3*3, etc., etc., this might seem like an impossible thing to say with any sureness, except for that fact that there are a small number of known properties of numbers that we can build on for it, fairly obvious ones when we see them with numbers, but maybe they don't seem quite so obvious when we see them with variables, like the commutative, associative, and distributive properties, see my article Getting Rid of Parentheses. Let's see how we can represent this idea in Python.
In Python, like most other programming languages we can use variables as storage containers for numbers, so that if we want to use the same number in several place, particularly if it is a complicated one, we can do this without typing in the number again and again. For algebra understanding we can use this to test whether two expressions are equal for a given choice of the variable. A single equal sign is used for assignment, but a double equal sign is used to test whether two things are equal. When you write a==b, Python will return a 1 if they are equal and a 0 if they are not equal. You can even try this out with simple numbers.
>>> 2==2
1
>>> 2==4
0
>>> 5==6
0
>>> 8==3+5
1
Or we can test to see if 2x+3x=5x when x=4
>>> x=4
>>> #The single equal sign means assignment, it puts 4 into
the x container, so that x becomes a name for the number 4, and every
time I type x Python acts just like it would if I had typed 4. (This is
a Python comment, anything written after a # is ignored by Python, so I
will sometimes use this to explain what I am doing.
>>> 2*x+3*x==5*x
1
>>> #Then I can use a double equal sign to test whether the
algebraic simplification 2x+3x=5x is true when x is 4.
This doesn't guarantee that the simplification is right, though, because for that it needs to be true no matter what I set x to, but if I got a 0 to indicate that this was false, then I would know that this was a false identity, and if I tried this for several different values, I could figure that it was quite likely to be a true identity. Alternatively, to see what was going on better, I could ask it to tell me the values of the each of the two sides of the equation for a given x, and see for myself that they were equal.
>>> x=7
>>> 2*x+3*x==5*x
1
>>> 2*x+3*x
35
>>> 5*x
35
Of course I really know that the two are equal by better means. The identity comes from the distributive property, a property known to be true for all real numbers.
2x+3x=(2+3)x=5x
But trying it out with a few numbers still makes a good check and a good illustration of what such an identity means. In more complicated simplifications, you might even find it useful to check yourself and isolate where you went wrong.
Suppose you made the following false simplification, a kind that I have seen many students make.
2(x+5)-(x-1)=2x+10-x-1=x+9
Try it with a number, and see what happens
>>> x=5
>>> 2*(x+5)-(x-1)==2*x+10-x-1
0
We got a 0, which says that this is a false statement, so we must have done something wrong. If we can't find the mistake easily, we can try to isolate it by just looking at part of the simplification. Did we get rid of the first set of parentheses correctly? How about trying a different number for this just for variety.
>>> x=3
>>> 2*(x+5)==2*x+10
1
Yes, that seems all right at least for 3. Does it work for 5?
>>> x=5
>>> 2*(x+5)==2*x+10
1
Yes, so the looks likely that the mistake is in the other part.
>>> -(x-1)==-x-1
0
At this point if we haven't figured out what is wrong we might want to fool around with it a bit more, maybe looking at what the two sides are equal to for various x's, and maybe take apart smaller pieces, but it is likely that once you have isolated the problem to this part you will have realized that to remove the minus sign you need to change the signs of both terms.
>>> -(x-1)
-4
>>> -x-1
-6
>>> x-1
4
>>> -x
-5
>>> -x+1
-4
>>> -(x-1)==-x+1
1
Ah, that's better. Now put them together to see if that works now.
>>> 2*(x+5)-(x-1)==2*x+10-x+1
1
After we are sure about this, we can move on to further simplification. If you weren't sure about whether 2x-x=x, you could even try that out before doing it.
>>> 2*x-x==x
1
And if you want you could be lazy and get Python to check your arithmetic.
>>> 10+1==11
1
After that you could do two simplifications like this,
>>> 2*x+10-x+1==2*x-x+10+1==x+11
1
and if any of the steps is wrong for x=5, you would get a 0, but since we got a 1, we know both steps are correct at least for x=5. Then check to confirm that this works when you equate the original to its simplified form, and of course that also works for x=5.
>>> 2*(x+5)-(x-1)==x+11
1
Since there was nothing particularly special about the number 5, it is likely that this is a true identity, particularly because we at least think we got it from legitimate properties that are known to work for a real numbers, but to better illustrate what it means for this simplification to be correct, lets check it for some other numbers. Remember that when we say that the two are equal, we are saying a lot. What we are saying is that no matter what we set x to, we should get a 1, when we ask whether they are equal.
>>> x=8
>>> 2*(x+5)-(x-1)==x+11
1
>>> x=-2
>>> 2*(x+5)-(x-1)==x+11
1
If we get tired of writing down the expression each time, Python allows us to abbreviate it by giving it a name. In programming terminology and also mathematical terminology this is called a function. We can define two functions E1 and E2 to represent the the original and the simplified versions of our expression.
>>> def E1(x): return 2*(x+5)-(x-1)
...
>>> def E2(x): return x+11
...
These are not the same function for Python, it is rather picky about what it calls the same function. The have different names, which is enough to make them different functions, but also even in a mathematical sense it is reasonable to not think of them as the same function, because different operations are being done in them. In the first one we are adding 5 to a number and multiplying that by 2. Then we are subtracting 1 from the original number and then subtracting that from the first result. In the second one we are just adding 11 to the number.
>>> E1==E2
0
When we say they are equal, what we really mean is that they are equal for every real number x, we just leave out the 'for every real number' part, because we get tired of saying it all the time. That is in this case, no matter what number you use, if you add 5 to it and then multiply that by 2 and then subtract 1 from the original number, and subtract that from the first answer, you will get the same thing as if you just add 11 to the number. The way to show that with the functions is like this.
>>> E1(1)==E2(1)
1
>>> E1(7.)==E2(7.) #It is a good idea to put a decimal point
after the number, because otherwise Python will think that the answer
has to be an integer. It doesn't matter here, but it would mater if
there was division in the problem that didn't come out even.
1
There is another shortcut you can use if you really want to check it for a lot of numbers. You can use Python's map function. This allows you for form a list of numbers and evaluate the function at all of them at once.
>>> A=[1.,2.,3.,4.,5.,6.,7.,8.,]
>>> map(E1,A)
[12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0]
>>> map(E2,A)
[12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0]
>>> map(E1,A)==map(E2,A)
1
If we are still not convinced we can add a few more numbers to the
list.
>>> A=A+[1.2,3.32,.7,2.9]
>>> A
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 1.2, 3.3199999999999998,
0.69999999999999996, 2.8999999999999999]
>>> #The reason it displays like this is that it using binary
fractions and in binary 10ths are repeating decimals the same way
thirds are in decimal, so only very close approximations for them can
be stored. Then when the get converted back to decimal, they look a bit
funny.
>>> map(E1,A)==map(E2,A)
0
What's happening here? Could it be that there is something wrong with our simplification, and even though it worked for all those other numbers, it doesn't work for some of these new ones? Certainly a possibility, but more likely it has something to do with those binary approximations of the tenths. Let's look more closely by displaying the maps.
>>> map(E1,A)
[12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 12.200000000000001,
14.32, 11.700000000000001, 13.9]
>>> map(E2,A)
[12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 12.199999999999999,
14.32, 11.699999999999999, 13.9]
Just as I thought, and this also illustrates further that these expressions don't represent the same mathematical operations. Different things are being done in each of them that make a difference in the accuracy of calculation, but theoretically if the calculations were done perfectly they would come out to be equal for all of these numbers.
We can also express what it means for the one expression to simplify to the other in terms of the map function. When we say the two expressions are equal, what this means in terms of map is that if we could make a list A that had all of the real numbers in it, which of course would take forever, then we would still get map(E1,A)==map(E2,A) to give us a 1 as long as we could get the computer to compute them perfectly accurately.
>>> x=2.
>>> 3/(1+3/x)==(3*x)/(x*(1+3/x))
1
>>> 3/(1+3/x)==(3*x)/(x+3)
1
>>> (5-1/(x+2))/(1+3/(1+3/x))==(5-1/(x+2))/(1+(3*x)/(x+3))
1
>>>
(5-1/(x+2))/(1+3/(1+3/x))==(5*(x+2)*(x+3)-(x+3))/((x+2)*(x+3)+3*x*(x+2))
0
>>> from Numeric import *
>>> A=(5-1/(x+2))/(1+3/(1+3/x))
>>> B=(5*(x+2)*(x+3)-(x+3))/((x+2)*(x+3)+3*x*(x+2))
>>> around(A,4)==around(B,4)
1
>>> B=((5*(x+2)-1)*(x+3))/((x+2)*((x+3)+3*x))
>>> around(A,4)==around(B,4)
1
>>> B=((5*x+10-1)*(x+3))/((x+2)*(4*x+3))
>>> A==B
0
>>> around(A,4)==around(B,4)
1
>>> B=((5*x+9)*(x+3))/((x+2)*(4*x+3))
>>> A==B
0
>>> around(A,4)==around(B,4)
1
>>> def E1(x): return (5-1/(x+2))/(1+3/(1+3/x))
...
>>> def E2(x): return ((5*x+9)*(x+3))/((x+2)*(4*x+3))
...
>>> X=[1.,2.,3.,4.,5.,6.,-1.,-2.,-3.,.3,.1,1.9,3.2,pi]
>>> map(E1,X),map(E2,X)
Traceback (most recent call last):
File "<input>", line 1, in ?
File "<input>", line 1, in E1
ZeroDivisionError: float division
>>> X=[1.,2.,3.,4.,5.,6.,-1.,.3,.1,1.9,3.2,pi]
>>> map(E1,X),map(E2,X)
([2.666666666666667, 2.1590909090909087, 1.9199999999999999,
1.7807017543859647, 1.6894409937888197, 1.625, -8.0,
3.5869565217391304, 4.124649859943978, 2.1927914852443151,
1.8865628042843232, 1.8959763797413469], [2.6666666666666665,
2.1590909090909092, 1.9199999999999999, 1.7807017543859649,
1.68944099378882, 1.625, -8.0, 3.5869565217391304, 4.124649859943978,
2.1927914852443156, 1.886562804284323, 1.8959763797413471])
>>> def E(x): return E1(x)-E2(x)
...
>>> map(E,X)
[4.4408920985006262e-16, -4.4408920985006262e-16, 0.0,
-2.2204460492503131e-16, -2.2204460492503131e-16, 0.0, 0.0, 0.0, 0.0,
-4.4408920985006262e-16, 2.2204460492503131e-16,
-2.2204460492503131e-16]
>>> def F1(x): return around(E1(x),4)
...
>>> def F2(x): return around(E2(x),4)
...
>>> map(F1,X)==map(F2,X)
1
>>> map(F1,X)
[2.6667000000000001, 2.1591, 1.9199999999999999, 1.7806999999999999,
1.6894, 1.625, -8.0, 3.5870000000000002, 4.1246, 2.1928000000000001,
1.8866000000000001, 1.8959999999999999]
>>> map(F2,X)
[2.6667000000000001, 2.1591, 1.9199999999999999, 1.7806999999999999,
1.6894, 1.625, -8.0, 3.5870000000000002, 4.1246, 2.1928000000000001,
1.8866000000000001, 1.8959999999999999]
>>> def diff(x): return around(E1(x)-E2(x),4)
...
>>> map(diff,X)
[0.0, -0.0, 0.0, -0.0, -0.0, 0.0, 0.0, 0.0, 0.0, -0.0, 0.0, -0.0]
>>> X=[5.,6.,7.,8.,9.,928.]
>>> map(diff,X)
[-0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
>>> x=347.
>>> (5*x+3)/5==x+3
0
>>> around((5*x+3)/5,4)==around(x+3,4)
0
>>>
>>> x=54.2
>>> sqrt(x**2+1)==x+1
0
>>> around(sqrt(x**2+1),4)==around(x+1,4)
0
In solving equations we are using the variable in a very different
way. This time instead of representing every possible number, it
represents a particular number that we are trying to find. We can
represent this in Python by imagining that someone has assigned a
number to a variable before you arrived on this scene, and it is no
longer visible without scrolling up, and the person who did it won't
let you scroll. So for example suppose this friend typed in
>>> x=3.
and then pressed the return key enough times so that it was out of
site, and then typed in
>>> 2*x+7==13
1
To solve this equation your task is to find out what would happen if
you typed x and then the return key without doing it. The further
restrictions are that you can't type in any other expression either,
but to make things a little easier for you, you can type in equations
to check to see if they are true including even guesses for x like
x==4. One method indeed of solving an equation like this would be this
guess and check method, and for many complicated equations, that is the
only method that will work.
But for a simple one like this one, there are other more efficient methods. We know that the two quantities 2*x+7 and 13 represent the same number, so if we do the same thing to both of them, they will still represent the same number. Perhaps we can do that in such a way that it becomes clearer what x has to be. If we subtract 7 from both of them the left side will simplify to something less complicated, so perhaps that will help.
>>> 2*x+7-7==13-7
1
Okay, the left side simplifies to 2*x, which means that it is equal
to 2*x for ever x. All we need here is for that to be true for this
particular x, but since we don't yet know what x is, we can only do
things that work for all x's. The right side can be simplified, simply
by doing the arithmetic, and if you are lazy about that you can even
let Python do it for you.
>>> 13-7
6
So now we know that we should be able to type 2*x==6 and get a 1
returned indicating that it is true.
>>> 2*x==6
1
And sure enough, it worked.
Now we could probably guess the right answer even if we didn't
already know what it was, but lets make it even easier by dividing both
sides by 2. And by the way, you don't really need to know what to do in
each case. If you didn't know that dividing both sides by 2 was a good
idea in an equation like this, you could try something else and see
what happened, like try subtracting 2 from both sides, and see if that
does you any good. But going on...
>>> 2*x/2==6/2
1
>>> x==3 #simplifying, and now it is clear what will happen if
I ask Python what x is. It will tell me it is 3, so let's check.
1
>>> x
3.0
Recently I thought of an interesting way to practice solving equations and the understanding of it based on this idea, which is to make use of modules. Instead of having someone type in x=3 or whatever, what you can do is store some equations with their solutions in a module and import the module in the IDE. Here is a sample module that I created for this called Equations. It is stored as Equations.py, because all modules need the py extension.
import random #This is for use when there is more than one solution
to an equation.
import Numeric #This module has all of the fancy mathematical functions
and also something I needed for when an equation has more than one
solution.
def rand(n):
#returns a random whole number between 0 and n-1 inclusive
return int(Numeric.floor(n*random.random()))
def roun(x):
#shorthand notation for a numeric function for rounding to 4 decimal
points, useful to distinguish and error for roundoff error
return Numeric.around(x,4)
#Now for the main part. This is where you type in the equations and
their solutions hidden from the solver's view.
#problem is a list of equations written in quotes, so that the solver
can display them using the print command.
#solution is a dictionary that associates with each equation a solution.
problem=[]
solution={}
problem.append("x+2==7")
solution[problem[0]]=5.
problem.append("2*x+4==10")
solution[problem[1]]=3.
choice=rand(2) #In this example the third equation has two solutions,
so to be somewhat fancy, I have made it choose between them randomly.
problem.append("x**2-5*x+6==0")
solution[problem[2]]=[2.,3.][choice]
After creating a module like this you put it away, that is close its window and/or quit the text editor that you created it with, and then open the Python IDE and import it like this.
>>> import Equations
Then let's make some abbreviations so that we don't have to type as much.
>>> p=Equations.problem
>>> s=Equations.solution
These are the storage locations of the problems and solutions. To access a variable in a module that you have imported, you have to type the module name as well as the variable name, but to save typing you can name it anything you want.
Next we have it print the first problem. Python indexes lists starting with 0, so we have to think of it as problem 0, and we use square brackets to tell it which list member we want.
>>> print p[0]
x+2==7
The solution is stored in s[p[0]], so if we set x to that, then the equation should be true.
>>> x=s[p[0]]
>>> x+2==7
1
Now this is exactly like the situation when we are solving an equation. x is a name for a definite number. If we cheated and typed x and pressed the return key, we would get that number. In the above two lines Python took that number and added it to 2 and compared the answer with 7. After determining that they were equal, it returned a 1. So x is a definite number, but we just don't know what it is, and we want to figure out what it is without having Python tell us any answers to calculations involving it. The Algebra method for doing this is to use the very simple knowledge that if two things are equal and you do the same thing to both of them, they will still be equal.
>>> x+2-2==7-2
1
>>> x==5
1
Now that we think we know what x is, we can test it by asking it to display it.
>>> x
5.0
And of course, since we proceeded by simple correct logic, we were right.
Now for the next problem.
>>> print p[1]
2*x+4==10
Again we can start by assigning the stored answer to x and checking
to see that it really does solve the equation without knowing what it
is.
>>> x=s[p[1]]
>>> 2*x+4==10
1
Then again we can solve the equation by doing the same thing to both sides of the equation until it becomes clear what x has to be.
>>> 2*x+4-4==10-4
1
>>> 2*x==6
1
>>> 2*x/2==6/2
1
>>> x==3
1
>>> x
3.0
Now for the 3rd problem, which is a bit more complicated.
>>> print p[2]
x**2-5*x+6==0
>>> x=s[p[2]]
>>> x**2-5*x+6==0
1
For this one there isn't an immediate clear way to get there by doing something to both side, so we have to use another trick. If we factor it we can use the principle of zero products, which says that the only way for the product of two numbers to be 0 is for one or the other to be 0. (See my Quadratic Equations article.)
>>> (x-2)*(x-3)==0
1
FOIL, which comes from the distributive property and a couple of other properties says that this factored version of the left side is equal to the original left side for every real number x, so in particular, it will be equal for this x, and indeed Python recognized that is was.
Once we know that the product of these two numbers x-2 and x-3 is 0, then the principle of 0 products tells us that one of them must be 0. Python understands the word 'or', so we can check that too.
>>> x-2==0 or x-3==0
1
Then by adding something to both sides in both cases, we can get a
bit closer to knowing what is stored in this variable x
>>> x==2 or x==3
1
But unfortunately, we can't get any farther. The information given to us was not enough to completely determine what x was. We call {2,3} the solution set for the equation, because from the information given by the equation, they are the only numbers that x could be, but this means that we can't totally predict what will happen when we type x and press the return key. Indeed, since I programmed it to choose randomly between the two, I really didn't know which of them it would be, so the only safe statement I could make and know a 1 would return was the one I wrote, x==2 or x==3, either x==2 alone or x==3 alone could have returned a 0. So now let's peek, and see which one it is.
>>> x
3.0
And now it's your turn. You are welcome to copy my module and put your own equations into it. Get a friend or a teacher to put some in that they know answers to. Copy them from a text book and get the answers for the back of the book or you could even make them up by working backward. Have you friend start with the solution, and write an equation it satisfies. Making up equations can also help your understanding. After someone has made up some and stored them in the module, you can try solving them they way I did above. I have tried it with a few other examples, and it works pretty well mostly. (See the next section for what to do when it doesn't.)
Like with simplifying expressions, you can use this technique to understand solving a great variety of equations, and as I find the time, I will add more examples to this article.
One slight problem I have had that you have to be careful with is the rondo error that I mentioned in the section on simplifying. Occasionally when you have done everything right it will give you a 0 for an intermediate step. This applies to both simplifying and solving. That is why I included the roun function in the module. If you think you have done everything right, but you get a zero for a step. Try applying Equations.roun to both sides of the equation. This will check that they are equal to 4 decimal places, and it is unlike that you would have done something wrong in such a way that it would only effect it beyond the 4th decimal place.
>>> def test(x): return not (x>2 or x<1) or
(x-1)*(x-2)>0
...
>>> A=range(-20,20)
>>> A
[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6,
-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19]
>>> A=range(-200,200)
>>> A=range(-20,20,.1)
Traceback (most recent call last):
File "<input>", line 1, in ?
ValueError: range() arg 3 must not be zero
>>> range.__doc__
'range([start,] stop[, step]) -> list of integers\n\nReturn a list
containing an arithmetic progression of integers.\nrange(i, j) returns
[i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\nWhen step is given,
it specifies the increment (or decrement).\nFor example, range(4)
returns [0, 1, 2, 3]. The end point is omitted!\nThese are exactly the
valid indices for a list of 4 elements.'
>>> A=range(-200,200)
>>> B=map(lambda x: x*.1,A)
>>> B
[-20.0, -19.900000000000002, -19.800000000000001, -19.700000000000003,
-19.600000000000001, -19.5, -19.400000000000002, -19.300000000000001,
-19.200000000000003, -19.100000000000001, -19.0, -18.900000000000002,
-18.800000000000001, -18.699999999999999, -18.600000000000001, -18.5,
-18.400000000000002, -18.300000000000001, -18.199999999999999,
-18.100000000000001, -18.0, -17.900000000000002, -17.800000000000001,
-17.699999999999999, -17.600000000000001, -17.5, -17.400000000000002,
-17.300000000000001, -17.199999999999999, -17.100000000000001, -17.0,
-16.900000000000002, -16.800000000000001, -16.699999999999999,
-16.600000000000001, -16.5, -16.400000000000002, -16.300000000000001,
-16.199999999999999, -16.100000000000001, -16.0, -15.9,
-15.800000000000001, -15.700000000000001, -15.600000000000001, -15.5,
-15.4, -15.300000000000001, -15.200000000000001, -15.100000000000001,
-15.0, -14.9, -14.800000000000001, -14.700000000000001,
-14.600000000000001, -14.5, -14.4, -14.300000000000001,
-14.200000000000001, -14.100000000000001, -14.0, -13.9,
-13.800000000000001, -13.700000000000001, -13.600000000000001, -13.5,
-13.4, -13.300000000000001, -13.200000000000001, -13.100000000000001,
-13.0, -12.9, -12.800000000000001, -12.700000000000001,
-12.600000000000001, -12.5, -12.4, -12.300000000000001,
-12.200000000000001, -12.100000000000001, -12.0, -11.9,
-11.800000000000001, -11.700000000000001, -11.600000000000001, -11.5,
-11.4, -11.300000000000001, -11.200000000000001, -11.100000000000001,
-11.0, -10.9, -10.800000000000001, -10.700000000000001,
-10.600000000000001, -10.5, -10.4, -10.300000000000001,
-10.200000000000001, -10.100000000000001, -10.0, -9.9000000000000004,
-9.8000000000000007, -9.7000000000000011, -9.6000000000000014, -9.5,
-9.4000000000000004, -9.3000000000000007, -9.2000000000000011,
-9.0999999999999996, -9.0, -8.9000000000000004, -8.8000000000000007,
-8.7000000000000011, -8.5999999999999996, -8.5, -8.4000000000000004,
-8.3000000000000007, -8.2000000000000011, -8.0999999999999996, -8.0,
-7.9000000000000004, -7.8000000000000007, -7.7000000000000002,
-7.6000000000000005, -7.5, -7.4000000000000004, -7.3000000000000007,
-7.2000000000000002, -7.1000000000000005, -7.0, -6.9000000000000004,
-6.8000000000000007, -6.7000000000000002, -6.6000000000000005, -6.5,
-6.4000000000000004, -6.3000000000000007, -6.2000000000000002,
-6.1000000000000005, -6.0, -5.9000000000000004, -5.8000000000000007,
-5.7000000000000002, -5.6000000000000005, -5.5, -5.4000000000000004,
-5.3000000000000007, -5.2000000000000002, -5.1000000000000005, -5.0,
-4.9000000000000004, -4.8000000000000007, -4.7000000000000002,
-4.6000000000000005, -4.5, -4.4000000000000004, -4.2999999999999998,
-4.2000000000000002, -4.1000000000000005, -4.0, -3.9000000000000004,
-3.8000000000000003, -3.7000000000000002, -3.6000000000000001, -3.5,
-3.4000000000000004, -3.3000000000000003, -3.2000000000000002,
-3.1000000000000001, -3.0, -2.9000000000000004, -2.8000000000000003,
-2.7000000000000002, -2.6000000000000001, -2.5, -2.4000000000000004,
-2.3000000000000003, -2.2000000000000002, -2.1000000000000001, -2.0,
-1.9000000000000001, -1.8, -1.7000000000000002, -1.6000000000000001,
-1.5, -1.4000000000000001, -1.3, -1.2000000000000002,
-1.1000000000000001, -1.0, -0.90000000000000002, -0.80000000000000004,
-0.70000000000000007, -0.60000000000000009, -0.5, -0.40000000000000002,
-0.30000000000000004, -0.20000000000000001, -0.10000000000000001, 0.0,
0.10000000000000001, 0.20000000000000001, 0.30000000000000004,
0.40000000000000002, 0.5, 0.60000000000000009, 0.70000000000000007,
0.80000000000000004, 0.90000000000000002, 1.0, 1.1000000000000001,
1.2000000000000002, 1.3, 1.4000000000000001, 1.5, 1.6000000000000001,
1.7000000000000002, 1.8, 1.9000000000000001, 2.0, 2.1000000000000001,
2.2000000000000002, 2.3000000000000003, 2.4000000000000004, 2.5,
2.6000000000000001, 2.7000000000000002, 2.8000000000000003,
2.9000000000000004, 3.0, 3.1000000000000001, 3.2000000000000002,
3.3000000000000003, 3.4000000000000004, 3.5, 3.6000000000000001,
3.7000000000000002, 3.8000000000000003, 3.9000000000000004, 4.0,
4.1000000000000005, 4.2000000000000002, 4.2999999999999998,
4.4000000000000004, 4.5, 4.6000000000000005, 4.7000000000000002,
4.8000000000000007, 4.9000000000000004, 5.0, 5.1000000000000005,
5.2000000000000002, 5.3000000000000007, 5.4000000000000004, 5.5,
5.6000000000000005, 5.7000000000000002, 5.8000000000000007,
5.9000000000000004, 6.0, 6.1000000000000005, 6.2000000000000002,
6.3000000000000007, 6.4000000000000004, 6.5, 6.6000000000000005,
6.7000000000000002, 6.8000000000000007, 6.9000000000000004, 7.0,
7.1000000000000005, 7.2000000000000002, 7.3000000000000007,
7.4000000000000004, 7.5, 7.6000000000000005, 7.7000000000000002,
7.8000000000000007, 7.9000000000000004, 8.0, 8.0999999999999996,
8.2000000000000011, 8.3000000000000007, 8.4000000000000004, 8.5,
8.5999999999999996, 8.7000000000000011, 8.8000000000000007,
8.9000000000000004, 9.0, 9.0999999999999996, 9.2000000000000011,
9.3000000000000007, 9.4000000000000004, 9.5, 9.6000000000000014,
9.7000000000000011, 9.8000000000000007, 9.9000000000000004, 10.0,
10.100000000000001, 10.200000000000001, 10.300000000000001, 10.4, 10.5,
10.600000000000001, 10.700000000000001, 10.800000000000001, 10.9, 11.0,
11.100000000000001, 11.200000000000001, 11.300000000000001, 11.4, 11.5,
11.600000000000001, 11.700000000000001, 11.800000000000001, 11.9, 12.0,
12.100000000000001, 12.200000000000001, 12.300000000000001, 12.4, 12.5,
12.600000000000001, 12.700000000000001, 12.800000000000001, 12.9, 13.0,
13.100000000000001, 13.200000000000001, 13.300000000000001, 13.4, 13.5,
13.600000000000001, 13.700000000000001, 13.800000000000001, 13.9, 14.0,
14.100000000000001, 14.200000000000001, 14.300000000000001, 14.4, 14.5,
14.600000000000001, 14.700000000000001, 14.800000000000001, 14.9, 15.0,
15.100000000000001, 15.200000000000001, 15.300000000000001, 15.4, 15.5,
15.600000000000001, 15.700000000000001, 15.800000000000001, 15.9, 16.0,
16.100000000000001, 16.199999999999999, 16.300000000000001,
16.400000000000002, 16.5, 16.600000000000001, 16.699999999999999,
16.800000000000001, 16.900000000000002, 17.0, 17.100000000000001,
17.199999999999999, 17.300000000000001, 17.400000000000002, 17.5,
17.600000000000001, 17.699999999999999, 17.800000000000001,
17.900000000000002, 18.0, 18.100000000000001, 18.199999999999999,
18.300000000000001, 18.400000000000002, 18.5, 18.600000000000001,
18.699999999999999, 18.800000000000001, 18.900000000000002, 19.0,
19.100000000000001, 19.200000000000003, 19.300000000000001,
19.400000000000002, 19.5, 19.600000000000001, 19.700000000000003,
19.800000000000001, 19.900000000000002]
>>> map(test,B)
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> def ifthen(x,y): return not x or y
...
>>> def test(x): return ifthen(x<1 or
x>2,(x-1)*(x-2)>0)
...
>>> map(test,B)
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> def iff(x,y): return (not x or y) and (not y or x)
...
>>> def test(x): return iff(x**2-5*x+6==0,x==2 or x==3)
...
>>> map(test,B)
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> test(2)
1
>>> test(3)
1
>>> A=[100,200,300,400,500]
>>> map(test,A)
[1, 1, 1, 1, 1]
>>> def test(x): return (x+1)*(x+2)==x**2+3*x+2
...
>>> rest(5)
Traceback (most recent call last):
File "<input>", line 1, in ?
NameError: name 'rest' is not defined
>>> test(5)
1
>>> map(test,A)
[1, 1, 1, 1, 1]
>>> map(test,B)
[1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0,
0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1,
0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1,
1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0,
0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1,
1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1,
0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0,
1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1,
1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1,
0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1]
>>> import Numeric
>>> def roun(x): return Numeric.around(x,4)
...
>>> def test(x):return round((x+1)*(x+2))==roun(x**2+3*x+2)
...
>>> map(test,B)
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> def test(x): return roun((x+1)*(x+2))==roun(x**2+5*x+6)
...
>>> map(test,B)
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> def test(x): return roun((x+1)*(x+2))==roun(x**2+3*x+2)
...
>>> map(test,B)
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Mathematics Articles
Getting Rid of Parentheses
Quadratic
Equations
Python Articles
[under construction]
Home Page
MathHelp
Math
100
Math 101
Math 107
Math 108