cleaned up some is_a<> vs. is_exactly_a<> stuff

[ginac.git] / ginac / mul.cpp

diff --git a/ginac/mul.cpp b/ginac/mul.cpp
index 28233b302ebc1b1485b390c055df10586136c6c7..63f6381d27c4e960500b0d3b7ab2770576d36aec 100644 (file)
--- a/ginac/mul.cpp
+++ b/ginac/mul.cpp
@@ -141,25 +141,32 @@ void mul::print(const print_context & c, unsigned level) const
                while (it != itend) {
 
                        // If the first argument is a negative integer power, it gets printed as "1.0/<expr>"
-                       if (it == seq.begin() && ex_to<numeric>(it->coeff).is_integer() && it->coeff.info(info_flags::negative)) {
-                               if (is_a<print_csrc_cl_N>(c))
+                       bool needclosingparenthesis = false;
+                       if (it == seq.begin() && it->coeff.info(info_flags::negint)) {
+                               if (is_a<print_csrc_cl_N>(c)) {
                                        c.s << "recip(";
-                               else
+                                       needclosingparenthesis = true;
+                               } else
                                        c.s << "1.0/";
                        }
 
                        // If the exponent is 1 or -1, it is left out
                        if (it->coeff.is_equal(_ex1) || it->coeff.is_equal(_ex_1))
                                it->rest.print(c, precedence());
-                       else {
+                       else if (it->coeff.info(info_flags::negint))
                                // Outer parens around ex needed for broken gcc-2.95 parser:
-                               (ex(power(it->rest, abs(ex_to<numeric>(it->coeff))))).print(c, level);
-                       }
+                               (ex(power(it->rest, -ex_to<numeric>(it->coeff)))).print(c, level);
+                       else
+                               // Outer parens around ex needed for broken gcc-2.95 parser:
+                               (ex(power(it->rest, ex_to<numeric>(it->coeff)))).print(c, level);
+
+                       if (needclosingparenthesis)
+                               c.s << ")";
 
                        // Separator is "/" for negative integer powers, "*" otherwise
                        ++it;
                        if (it != itend) {
-                               if (ex_to<numeric>(it->coeff).is_integer() && it->coeff.info(info_flags::negative))
+                               if (it->coeff.info(info_flags::negint))
                                        c.s << "/";
                                else
                                        c.s << "*";
@@ -186,8 +193,6 @@ void mul::print(const print_context & c, unsigned level) const
                                c.s << "(";
                }
 
-               bool first = true;
-
                // First print the overall numeric coefficient
                numeric coeff = ex_to<numeric>(overall_coeff);
                if (coeff.csgn() == -1)
@@ -213,17 +218,51 @@ void mul::print(const print_context & c, unsigned level) const
 
                // Then proceed with the remaining factors
                epvector::const_iterator it = seq.begin(), itend = seq.end();
-               while (it != itend) {
-                       if (!first) {
-                               if (is_a<print_latex>(c))
-                                       c.s << ' ';
+               if (is_a<print_latex>(c)) {
+
+                       // Separate factors into those with negative numeric exponent
+                       // and all others
+                       exvector neg_powers, others;
+                       while (it != itend) {
+                               GINAC_ASSERT(is_exactly_a<numeric>(it->coeff));
+                               if (ex_to<numeric>(it->coeff).is_negative())
+                                       neg_powers.push_back(recombine_pair_to_ex(expair(it->rest, -(it->coeff))));
                                else
-                                       c.s << '*';
+                                       others.push_back(recombine_pair_to_ex(*it));
+                               ++it;
+                       }
+
+                       if (!neg_powers.empty()) {
+
+                               // Factors with negative exponent are printed as a fraction
+                               c.s << "\\frac{";
+                               mul(others).eval().print(c);
+                               c.s << "}{";
+                               mul(neg_powers).eval().print(c);
+                               c.s << "}";
+
                        } else {
-                               first = false;
+
+                               // All other factors are printed in the ordinary way
+                               exvector::const_iterator vit = others.begin(), vitend = others.end();
+                               while (vit != vitend) {
+                                       c.s << ' ';
+                                       vit->print(c, precedence());
+                                       ++vit;
+                               }
+                       }
+
+               } else {
+
+                       bool first = true;
+                       while (it != itend) {
+                               if (!first)
+                                       c.s << '*';
+                               else
+                                       first = false;
+                               recombine_pair_to_ex(*it).print(c, precedence());
+                               ++it;
                        }
-                       recombine_pair_to_ex(*it).print(c, precedence());
-                       ++it;
                }
 
                if (precedence() <= level) {