MaplePrimes - answers and comments on Question, manipulating numerator and denominator

using ``()

pagan — Thu, 19 Jan 2012 21:40:04 Z

restart:

e:= (g^n) / (g^n -1);

                                         n  
                                        g   
                                 e := ------
                                       n    
                                      g  - 1

# This next use of ``() is to prevent expansion done by the `numer` and `denom` commands.
mult := g^(``(-n)); 

                                         (-n)
                                mult := g    

# This next use of ``() is to prevent automatic cancellation of g^(``(-n)) term.
new:=``(numer(e)*mult)/``(denom(e)*mult); 

                                     / n  (-n)\   
                                     \g  g    /   
                           new := ----------------
                                  // n    \  (-n)\
                                  \\g  - 1/ g    /

# Now use the `expand` command in two ways, to get rid of both uses of ``().
expand(map(expand,numer(new))) / expand(map(expand,denom(new)));
                                     1   
                                   ------
                                       1 
                                   1 - --
                                        n
                                       g

If you're curious, you can see the effect of that last operation as in two substeps

map(expand,numer(new)) / map(expand,denom(new));

                                    (1)   
                                  --------
                                  /    1 \
                                  |1 - --|
                                  |     n|
                                  \    g /

expand(%);

                                     1   
                                   ------
                                       1 
                                   1 - --
                                        n
                                       g

And, of course, most of this is not necessary and can be done more neatly, except that you have written that you wanted to see the form of `new` above explicitly.

``() simplify and expand

Christopher2222 — Fri, 20 Jan 2012 22:59:44 Z

Thanks, so this is how I ended up showing it.

It is essentially what you showed me, just a very slight variation. The ``() helps quite a bit. I wanted to use Maple and manipulate an answer Maple gave with minimal user modification afterwards to attain my output. So after setting up the first step using delayed syntax, all that was needed were the simplify and expand commands to finish it off.

Download numerdenom.mw

manipulating numerator and denominator

SmsmAdly — Wed, 04 Jan 2017 14:41:33 Z

Download manipulating_numerator_and_denominator.mw

h := g^n/(g^n-1);
"(->)"

1
------
1
1 - --
n
g

#in command

"(->)"

1/expand(solve(% = 1/denominator, denominator));

more neatly

Christopher2222 — Thu, 19 Jan 2012 22:46:04 Z

So, curiously, how can it be done more neatly?

delay

pagan — Fri, 20 Jan 2012 19:11:36 Z

@Christopher2222 You asked to see that form as shown by `new` above. Something has to be done, to delay the cancellation and allow that form to be printed.

How terse, or "neat" you want to make it can depend on how much you're willing to accept specialized routines (or syntax, like with applyrule).

restart:

hold := eval(``): # or just use ``() itself (your choice)
release := z->expand(expand(numer(z)))
              /expand(expand(denom(z))):



e := (g^n) / (g^n -1);

                                n  
                               g   
                             ------
                              n    
                             g  - 1

c := g^(-n);

                              (-n)
                             g    

new := hold(numer(e)*c)/hold(denom(e)*c); 

                           / n  (-n)\   
                           \g  g    /   
                        ----------------
                        // n    \  (-n)\
                        \\g  - 1/ g    /

release(new);

                               1   
                             ------
                                 1 
                             1 - --
                                  n
                                 g