cleaned docstrings for sets
Dealt with python2.5 incompatibility
fix Add._eval_subs
Make is_comparable an ordinary property.

* Remove is_comparable from the old assumption system.
* Remove hardcoded fallback to evalf() to evaluate assumptions
  is_positive, is_negative, etc. This behavior is now implemented in
  Expr._eval_is_positive and Expr._eval_is_negative. Classes that relied
  on the fallback must now inherit these methods or invoke them
  explicitly (see Add._eval_is_positive for the latter case).
* This fixes the wrong result I.is_comparable == None
* Fix atan2.eval(): only divide by x if x.is_zero is False
Clean up sympy/functions/elementary/tests/test_complexes

* Replace inner function tn() with module-level N_equals(), and remove
  unneeded indirection via test_numerically().
* Remove XFAIL for passing test for 2453.
Remove now unused _eval_is_comparable methods.
Remove uses of is_comparable in sympy/core/numbers.py
Add tests for is_number
Added tutorial Russian translation of the new format: tutorial.ru.po
Remove old tutorial Russian translation: tutorial.ru.txt
Updated doc/Makefile: added 'htmli18n' in help string
Update russian translation of tutorial.
Merge pull request #1140 from smichr/subs

fix Add._eval_subs
add sort=True keyword to __print_Boolean
Merge pull request #1136 from smichr/bool-sort

do not sort Implies arguments
Merge pull request #1141 from rlamy/comparable

Move is_comparable out of the assumption system
3164: cse watches for production of non-Basic
Merge pull request #1133 from mrocklin/intersection

Intersection Set Class
watch for exp when rejoining bkey in powsimp
3109: Pow._eval_power rules more accurate

The rules for combining (x**a)**b into x**(a*b) have been updated;
the conditions are enumerated in Pow._eval_power. The same sort of thing
should also be done to exp (see issue 3109).

Here are comments about the old rules:

Formerly-

The following was ok:
-        if other.is_integer:
-            return Pow(b, e * other)

The condition that other.is_real should not be added; if e is complex then
the joined exponent may not be valid, e.g. (3**(4*I))**(1/2) != 3**(2*I)
        if b.is_nonnegative and (e.is_real or other.is_real):
-            return Pow(b, e * other)

ok:
-        if e.is_even and b.is_real: # hence b is pos and e is real
-            return Pow(abs(b), e * other)

only valid if e.is_real and then it's true whether other is real or not
-        if abs(e) < S.One and other.is_real:
-            return Pow(b, e * other)

ok (if that's how exp_polar should behave)
-        if b.is_polar:
-            return Pow(b, e * other)

The rules above are missing the handling of possible complex powers where
e.is_real is False and abs(e) < S.Pi/abs(log(b)) and the simple case where
other is a multiple of 1/2 and abs(e) < S.Pi/abs(log(b))

This function can be used to test whether two exponents should combine.
if False is printed, then (e**a)**b should not become e**(a*b) and the
difference between (e**a)**b and e**(a*b) is printed.

>>> def foo(a,b,e=E):

...  ib=S(1)/b;print abs(a*log(e)/pi).n() < 1
...  return ((e**a).n()**ib - e**(a*ib)).n(chop=1e-10)
...
>>> foo(2*I,3,6*I)
False
0.0892124078593689 - 0.601228142633338*I
>>> foo(I/3,3,6*I)
True
0