gcd_pf_pow_pow: deobfuscate a little bit (no functional changes).
authorAlexei Sheplyakov <varg@theor.jinr.ru>
Mon, 25 Aug 2008 12:57:38 +0000 (16:57 +0400)
committerJens Vollinga <jensv@nikhef.nl>
Wed, 27 Aug 2008 14:22:59 +0000 (16:22 +0200)
Use

if (foo)
return bar();
return baz();

instead of

if (foo) {
return bar();
} else {
return baz();
}

This makes the code a little bit more readable.

ginac/normal.cpp

index 6392e3f144648814b384f71ea4d612e3b683c84f..09773d37489693a4854964f129002abb186b2c5b 100644 (file)
@@ -1647,8 +1647,9 @@ static ex gcd_pf_pow_pow(const ex& a, const ex& b, ex* ca, ex* cb)
        const ex& exp_a = a.op(1);
        ex pb = b.op(0);
        const ex& exp_b = b.op(1);
+
+       // a = p^n, b = p^m, gcd = p^min(n, m)
        if (p.is_equal(pb)) {
-               // a = p^n, b = p^m, gcd = p^min(n, m)
                if (exp_a < exp_b) {
                        if (ca)
                                *ca = _ex1;
@@ -1662,31 +1663,30 @@ static ex gcd_pf_pow_pow(const ex& a, const ex& b, ex* ca, ex* cb)
                                *cb = _ex1;
                        return power(p, exp_b);
                }
-       } else {
-               ex p_co, pb_co;
-               ex p_gcd = gcd(p, pb, &p_co, &pb_co, false);
-               if (p_gcd.is_equal(_ex1)) {
-                       // a(x) = p(x)^n, b(x) = p_b(x)^m, gcd (p, p_b) = 1 ==>
-                       // gcd(a,b) = 1
+       }
+
+       ex p_co, pb_co;
+       ex p_gcd = gcd(p, pb, &p_co, &pb_co, false);
+       // a(x) = p(x)^n, b(x) = p_b(x)^m, gcd (p, p_b) = 1 ==> gcd(a,b) = 1
+       if (p_gcd.is_equal(_ex1)) {
                        if (ca)
                                *ca = a;
                        if (cb)
                                *cb = b;
                        return _ex1;
                        // XXX: do I need to check for p_gcd = -1?
-               } else {
-                       // there are common factors:
-                       // a(x) = g(x)^n A(x)^n, b(x) = g(x)^m B(x)^m ==>
-                       // gcd(a, b) = g(x)^n gcd(A(x)^n, g(x)^(n-m) B(x)^m
-                       if (exp_a < exp_b) {
-                               return power(p_gcd, exp_a)*
-                                       gcd(power(p_co, exp_a), power(p_gcd, exp_b-exp_a)*power(pb_co, exp_b), ca, cb, false);
-                       } else {
-                               return power(p_gcd, exp_b)*
-                                       gcd(power(p_gcd, exp_a - exp_b)*power(p_co, exp_a), power(pb_co, exp_b), ca, cb, false);
-                       }
-               } // p_gcd.is_equal(_ex1)
-       } // p.is_equal(pb)
+       }
+
+       // there are common factors:
+       // a(x) = g(x)^n A(x)^n, b(x) = g(x)^m B(x)^m ==>
+       // gcd(a, b) = g(x)^n gcd(A(x)^n, g(x)^(n-m) B(x)^m
+       if (exp_a < exp_b) {
+               ex pg =  gcd(power(p_co, exp_a), power(p_gcd, exp_b-exp_a)*power(pb_co, exp_b), ca, cb, false);
+               return power(p_gcd, exp_a)*pg;
+       } else {
+               ex pg = gcd(power(p_gcd, exp_a - exp_b)*power(p_co, exp_a), power(pb_co, exp_b), ca, cb, false);
+               return power(p_gcd, exp_b)*pg;
+       }
 }
 
 static ex gcd_pf_pow(const ex& a, const ex& b, ex* ca, ex* cb)