1858b: do not factor univariate nonsepar

    Just as the routine need not start when the whole expression is
    univariate, it also does not need to end with factoring if the
    nonseparated terms are univariate.
1858b: separatevars edits
1858b: add common_prefix and common_suffix to iterables

    These functions can be used when looking for common
    noncommutative sequences.
1858b: add factor_nc
1858b: factor_nc can extract powers: (A**2 + A*B*A) -> A*(A + B*A)
3040: mask off nc terms in gcd_terms
1858b: move factor_nc to exprtools and use in factor

    factor_nc was modified to handle more nc expressions; tests
    were added for this.
Merge pull request #422 from smichr/1858b

1858b (1811) separatevars modifications and noncommutative factoring
Add parameter list to verbose output
Improve indentation while printing function/class names in verbose mode
Handle the cases where class might have subclass

It happens sometimes (once while I was testing) that a class contained
another object that inspect recgnized as a class. We need to handle such
cases. In this scenario, we ignore because we are concerned only with top
level classes and functions/methods
fixed bug in issue 3142; added test for it; fixed error in test
and added a comment to it.
added is_square check to is_identity
Merge pull request #1119 from pernici/sqden2

fixed bug in issue 3142; added test for it; fixed error in test
Function parameters might not always be (small) simple strings

Sometimes function parameters might not be simple strings.
In that case, convert the parameters readable using str().

Also, in addition -- sometimes the parameters are too large
for any use. For example a class being passed, or a large
list which inspect converts to a large sting. Hence,
truncate above a threshold.
Overhaul function and class processing into functions

The model for giving doctest coverage follows the steps:

1. Get the list of members in a module
2. If the member is a function - process
3. If it's a class
  -> Process class
  -> Process function members of the class

Currently this was being done completely inside the code of
coverage definition. I have split the task into, process_function
and process_class. Thus the code looks much easier and modular
to read and understand.
Add usage to option parser
Mul non-recursive is_positive
nonrecursive is_positive and is_negative for Mul

    If one encodes the attributes as follows:

        -2 nonpositive (sign is 0 or -1)
	-1 negative
	 0 zero (sign unknown)
	 1 positive
	 2 nonnegative (sign is 0 or 1)

    then if factors are recoded to these values according to their
    attributes then the product can be computed and checked for the
    attribute of being positive or negative.

    e.g. neg*neg*pos*nonpos*neg*nonneg
         -1 * -1 * 1 * -2 * -1 * 2 = 4 so the answer is 2-like: nonneg

    The only way to be purely negative or positive is to not have
    any +/-2 factors; the way to be *not* positive or negative is
    to have the right sign (e.g. to be nonnegative the sign must be 0
    or 1 which is what the 2 -- and greater -- positive values encode.
name changes on test variables

    While debugging, it was confusing to work with variables whose
    names had no correspondence with their attribute type (e.g. n
    for a positive variable).