Re: Rationalize denominator of a complex value formula using Abs
- To: mathgroup at smc.vnet.net
- Subject: [mg40416] Re: Rationalize denominator of a complex value formula using Abs
- From: gauer at ras.sk.ca
- Date: Fri, 4 Apr 2003 01:31:04 -0500 (EST)
- References: <3179.142.3.102.202.1048799953.squirrel@www.ras.sk.ca>
- Sender: owner-wri-mathgroup at wolfram.com
I think I've basically answered my own question, so here was/is the answer
(just replace all instances of Sign(x) by Abs(x)/x) and I think I've found
a rationalization of the denominator which obeys the parity. I'll see if
Mathematica allows for further Simplification of this form later on (and
after it hopefully does do so, run my test values through it).
Sample Sectuples (and should return the same sets of at most four ordered
pairs for all sectuples of the form: (x+Iy)*[a,b,h,g,f,c] under this
vector/scalar functional arithmetic) are:
{[2,-5/2,-3,-1/2,-4/2,6], [13,-9,37,1,7,-2], [12,-23/2,10,-25/2,13,-14],
[55,-30,39,-40,-24,-464], [1,-Sqrt[3],3,3,-2,5], [9,4,-3,2,5,1]}
note: not all of the sectuple examples abide with the rules (the
conditions 1, 2, 3 mentioned in the 1st message); it is up to the
interested reader to find out which ones don't, and, once the reader gets
the hang of using real-only sectuples, I'd be interested in seeing which
if any complex-valued sectuple-samples he can construct, as I do need
some. I personally haven't yet had the time to run the sample sectuples
through from Start at: equation 1 -> equation 3 to see that things will be
returned in the same order, but I do know that 1->2, even when trying to
modify wth Abs signs, was not co-operating for all sectuples.
I used a combination of TargetFunctions, Extension, Cancel, Simplify,
Apart, Together, Expand, TrigToExp, etc and their specific options to get
from 1->3, but if someone knows of a quicker pattern to get from 1 -> 3 ->
2, I'm interested in listening...
<call this equation set 3 - I know that it looks long and ugly in this
form but at least in this form, I think've got better chances at doing
cancellations and further Simplifying at a later time>
{{{{-((b*g)/(a*b - h^2)) + (f*h)/(a*b - h^2) + (a*E^(I/2*Arg[-((a*(-(b*c)
+ f^2) + b*g^2 + h*(-2*f*g + c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))]*
Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h
*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*Sqrt[Abs[-a + b + Sqrt[(a - b)^2 + 4*h^2]]])/(2*Sqrt[2]*h^2*(a*b
- h^2)^2) - (b*E^(I/2*Arg[-((a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))*(-a + b +
Sqrt[(a - b)^2 + 4*h^2]))]*Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*
Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*
(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))^2]]*Sqrt[Abs[-a + b + Sqrt[(a - b)^2 +
4*h^2]]])/(2*Sqrt[2]*h^2*(a*b - h^2)^2) + (E^(I/2*Arg[-((a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))]*
Sign[-(a*b*h) + h^3]^2)*Sqrt[(a - b)^2 + 4*h^2]*Sqrt[a^2*b^2*h^2*Sqrt[(a*
(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c)
+ f^2) + b*g^2 + h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))^2]]*Sqrt[Abs[-a + b + Sqrt[(a - b)^2 + 4*h^2]]])/(2*
Sqrt[2]*h^2*(-(a*b) + h^2)^2)}, {-((a*f)/(a*b - h^2)) + (g*h)/(a*b -h^2) +
(E^(I/2*Arg[-((a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*(-a + b +
Sqrt[(a - b)^2 + 4*h^2]))]*Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*
Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*
(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))^2]]*Sqrt[Abs[-a + b + Sqrt[(a - b)^2 +
4*h^2]]])/(Sqrt[2]*h*(-(a*b) + h^2)^2)}}}, {{{-((b*g)/(a*b - h^2)) +
(f*h)/(a*b - h^2) - (a*E^(I/2*Arg[-((a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))]*Sign[-(a*b*h) +
h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]
-2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2] + h^6*
Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2]]*Sqrt[Abs[-a + b +
Sqrt[(a - b)^2 + 4*h^2]]])/(2*Sqrt[2]*h^2*(a*b - h^2)^2) + (b*E^(I/2*
Arg[-((a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*(-a + b + Sqrt[(a -
b)^2 + 4*h^2]))]*Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c)
+ f^2) + b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) +
b*g^2 + h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 +
h*(-2*f*g + c*h))^2]]*Sqrt[Abs[-a + b + Sqrt[(a - b)^2 +
4*h^2]]])/(2*Sqrt[2]*h^2*(a*b - h^2)^2) - (E^(I/2*Arg[-((a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g
+ c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))]*Sign[-(a*b*h) +
h^3]^2)*Sqrt[(a - b)^2 + 4*h^2]*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) +
b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 +
h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*
Sqrt[Abs[-a + b + Sqrt[(a - b)^2 + 4*h^2]]])/(2*Sqrt[2]*h^2*(-(a*b) +
h^2)^2)}, {-((a*f)/(a*b - h^2)) + (g*h)/(a*b - h^2) -
(E^(I/2*Arg[-((a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*(-a + b +
Sqrt[(a - b)^2 + 4*h^2]))]*
Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 +
h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 +
h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*Sqrt[
Abs[-a + b + Sqrt[(a - b)^2 + 4*h^2]]])/(Sqrt[2]*h*(-(a*b) + h^2)^2)}}},
{{{-((b*g)/(a*b - h^2)) + (f*h)/(a*b - h^2) + (a*E^(I/2*Arg[(a*(-(b*c) +
f^2) + b*g^2 + h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])]*
Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 +
h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 +
h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*
Sqrt[Abs[a - b + Sqrt[(a - b)^2 + 4*h^2]]])/(2*Sqrt[2]*h^2*
(a*b - h^2)^2) - (b*E^(I/2*Arg[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h)
*(a - b + Sqrt[(a - b)^2 + 4*h^2])]*Sign[-(a*b*h) + h^3]^2)*
Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h)^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))^2]]*
Sqrt[Abs[a - b + Sqrt[(a - b)^2 + 4*h^2]]])/(2*Sqrt[2]*h^2*(a*
b - h^2)^2) - (E^(I/2*Arg[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*
(a - b + Sqrt[(a - b)^2 + 4*h^2])]*Sign[-(a*b*h) + h^3]^2)*
Sqrt[(a - b)^2 + 4*h^2]*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*
(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*Sqrt[Abs[a - b + Sqrt[(a - b)^2 +
4*h^2]]])/(2*Sqrt[2]*h^2*(-(a*b) + h^2)^2)}, {-((a*f)/(a*b - h^2)) +
(g*h)/(a*b - h^2) + (E^(I/2*Arg[(a*
(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 +
4*h^2])]*Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) +
b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*Sqrt[Abs[a - b + Sqrt[(a - b)^2 + 4*h^2]]])/(Sqrt[2]*h*(-(a*b)
+ h^2)^2)}}}, {{{-((b*g)/(a*b - h^2)) + (f*h)/(a*b - h^2) - (a*E^(I/2*
Arg[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2
+ 4*h^2])]*Sign[-(a*b*h) + h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2]]*Sqrt[Abs[a - b + Sqrt[(a - b)^2 +
4*h^2]]])/(2*Sqrt[2]*h^2*(a*b - h^2)^2) + (b*E^(I/2*Arg[(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g
+ c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])]*Sign[-(a*b*h)
+ h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2]]*Sqrt[Abs[a - b + Sqrt[(a - b)^2 +
4*h^2]]])/(2*Sqrt[2]*h^2*(a*b - h^2)^2) + (E^(I/2*Arg[(a*(-(b*c) + f^2) +
b*g^2 + h*(-2*f*g
+ c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])]*Sign[-(a*b*h)
+ h^3]^2)*Sqrt[(a - b)^2 + 4*h^2]*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g +
c*h))^2]]*Sqrt[Abs[a - b + Sqrt[(a - b)^2 + 4*h^2]]])/
(2*Sqrt[2]*h^2*(-(a*b) + h^2)^2)}, {-((a*f)/(a*b - h^2))
+ (g*h)/(a*b - h^2) - (E^(I/2*Arg[(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])]*Sign[-(a*b*h)
+ h^3]^2)*Sqrt[a^2*b^2*h^2*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2] - 2*a*b*h^4*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2] + h^6*Sqrt[(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))^2]]*Sqrt[Abs[a - b + Sqrt[(a - b)^2 + 4*h^2]]])/(Sqrt[2]*h*(-(a*b)
+ h^2)^2)}}}}
Kai wrote in his first message:
> I am given a set of four ordered pairs of formulae of six variables:
<call this equation set 1 in a better viewable form>
{{{{((-(b*g) + f*h)*(a*b - h^2)*(-a + b + Sqrt[(a - b)^2 + 4*h^2]) +
Sqrt[2]*Sqrt[-((-(a*b*h) + h^3)^2*(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g
+ c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))])/((-(a*b) + h^2)^2*(-a + b
+ Sqrt[(a - b)^2 + 4*h^2]))},{(a*f - g*h)/(-(a*b) + h^2) + Sqrt[-((-(a*b*h)
+ h^3)^2*(a*(-(b*c) + f^2) + b*g^2 + h*(-2*f*g + c*h))*(-a + b
+ Sqrt[(a - b)^2 + 4*h^2]))]/(Sqrt[2]*h*(-(a*b) + h^2)^2)}}},
{{{(-((b*g - f*h)*(a*b - h^2)*(-a + b + Sqrt[(a - b)^2
+ 4*h^2])) - Sqrt[2]*Sqrt[-((-(a*b*h) + h^3)^2*(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))])/((-(a*b)
+ h^2)^2*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))}, {-(2*h*(-(a*f)
+ g*h)*(-(a*b) + h^2) + Sqrt[2]*Sqrt[-((-(a*b*h) + h^3)^2*(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))*(-a + b + Sqrt[(a - b)^2 + 4*h^2]))])/
(2*h*(-(a*b) + h^2)^2)}}},{{{(-((b*g - f*h)*(a*b - h^2)*(a - b
+ Sqrt[(a - b)^2 + 4*h^2])) - Sqrt[2]*Sqrt[(-(a*b*h) + h^3)^2*(a*(-(b*c)
+ f^2) + b*g^2 + h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])])/
((-(a*b) + h^2)^2*(a - b + Sqrt[(a - b)^2 + 4*h^2]))}, {(a*f - g*h)/
(-(a*b) + h^2) + Sqrt[(-(a*b*h) + h^3)^2*(a*(-(b*c) + f^2) + b*g^2
+ h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])]/
(Sqrt[2]*h*(-(a*b) + h^2)^2)}}},{{{((-(b*g) + f*h)*(a*b - h^2)*(a - b
+ Sqrt[(a - b)^2 + 4*h^2]) + Sqrt[2]*Sqrt[(-(a*b*h) + h^3)^2*(a*(-(b*c)
+ f^2) + b*g^2 + h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])])/
((-(a*b) + h^2)^2*(a - b + Sqrt[(a - b)^2 + 4*h^2]))},{-(2*h*(-(a*f)
+ g*h)*(-(a*b) + h^2) + Sqrt[2]*Sqrt[(-(a*b*h) + h^3)^2*(a*(-(b*c) + f^2)
+ b*g^2 + h*(-2*f*g + c*h))*(a - b + Sqrt[(a - b)^2 + 4*h^2])])/
(2*h*(-(a*b) + h^2)^2)}}}}
> I refer to the six variables as a (complex valued) sectuple, with
> interesting cases usually occurring with real values, and such that each
> of:
>
> i) hh-ab=/=0 (Cases interested in: replace '=/=' with '<', '>',
> respectively),
> ii) (abc-2fgh-aff-bgg-chh)/(ab-hh)=/=0 (Cases interested in: replace
> '=/=' with '<', '>', respectively),
> and,
> iii) a=/=b (Cases interested in: replace '=/=' with '<', '>',
> respectively)
>
> occur (ie, cases i, ii, iii hold simultaneously, but the subcases can
> (and might need to) be broken down further).
>
> I would like to get the equations into the following form, but also
> respecting the complex-valued arithmetic (so that when I later
> define the second as a general sectuple function, it should produce some
> real and some complex values when assigned real-valued sectuples):
>
Cases[Run seperate cases of the interesting If conditions
<call this equation set 2>
{{{{\[Alpha] + (Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[a - b + Sqrt[Abs[(a - b)^2
+ 4*h^2]]]])/(Sqrt[2]*(a*b - h^2))},{\[Beta]
+ (Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[-a + b + Sqrt[Abs[(a - b)^2 +
4*h^2]]]])/(Sqrt[2]*(a*b - h^2))}}}, {{{\[Alpha] +
(Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[a - b + Sqrt[Abs[(a - b)^2 +
4*h^2]]]])/(Sqrt[2]*(-(a*b) + h^2))},
{-\[Beta] -(Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[-a + b + Sqrt[Abs[(a - b)^2
+ 4*h^2]]]])/(Sqrt[2]*(-(a*b) + h^2))}}},
{{{\[Alpha] - (Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[-a + b + Sqrt[Abs[(a - b)^2
+ 4*h^2]]]])/(Sqrt[2]*(-(a*b) + h^2))},{\[Beta]
+ (Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[-a + b - Sqrt[Abs[(a - b)^2 +
4*h^2]]]])/(Sqrt[2]*(-(a*b) + h^2))}}}, {{{\[Alpha]
+ (Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[a - b - Sqrt[Abs[(a - b)^2 + 4*h^2]]]])/
(Sqrt[2]*(-(a*b) + h^2))}, {-\[Beta] - (Sqrt[Abs[\[Zeta]]]*Sqrt[Abs[-a
+ b -Sqrt[Abs[(a - b)^2 + 4*h^2]]]])/(Sqrt[2]*(-(a*b) + h^2))}}}},
print(particular case set, formula style for the case set)], where
abbreviations of \[Alpha] -> (-(b*g) + f*h)/(a*b - h^2),
\[Beta] -> (-(a*f) + g*h)/(a*b - h^2),
\[Zeta] -> Det[{{a, h, g}, {h, b, f}, {g, f, c}}] can occur.
> In some cases, when multiplying across square roots, absolute value
> arithmetic need be enforced (I would prefer to not introduce trig and
> exp arithmetic rules using exptotrig and trigtoexp). In fact, when
> running a few tests on these equations, I had found that by changing a
> few Abs signs on sqrts, that I could reproduce identical results between
> the two formulae.
>
> So, the main question is then: if Mathematica's root command likes to
> take a certain parity in computing the nth root (n integer) of value^k,
> 0<k<n, can we force it to return n distinct values, and, if we
> rationalize the denominator, can I ensure the list's set(value)[k] is
> returned in the same order when using formula 1 and formula 2,
> regardless of whether value is left in the generalized equation form
> (the case conditions can be added in here, but I would prefer to see as
> few as possible, and to keep further subcase breakdowns as simple as
> possible) or in the numerical list of values form?
>
> How can I get Mathematica to return all possible formulae values, given
> that I've not yet chosen a sectuple?
>
> [ Can I somehow define p/m "the plus or minus typographical symbol, as
> found in the button toolkits" and m/p to have the same rules of addition
> and subtraction, multiplication, division, root extration, raising of
> powers, etc that any other regular formula would have if somehow just
> wrote '+', '-' (p/m would need the property that (-1)*p/m(a, b)=m/p(a,
> b) to keep parity, and such that replace and/or simplify could simplify
> k=p/m(a,b), in the same way that replace replaces (a+b)->k?)? I don't
> fully understand how all of the abbreviating rules of Hold, etc can work
> for me, and would rather not have to override operator definitions to
> make them look "too concise" - means: be thorough; I don't use pattern
> matching rules too often if I can get away with it, mainly since I find
> this part of the Mathematica book harder to understand. ]
>
> I would like to generate a more effecient coding scheme than just
> writing a few nested for(j,k,l=1 to 2 do (-1^j,k,l)) loops to switch the
> signs whenever I come across a new formula possibility.
>
> The following idea for complex numbers scaled to the unit circle would
> work in a similar fashion, but for my formulae (but for unscaled
> numbers):
>
> \!\(\(\tFor[k = 1, k < 30, {a\_k := FullSimplify[\@\(\((\((1 +
> I)\)\/\@2) \)\^\(k\/2\)\)\%3\ \((\(\(-I\) - \@3\)\/2)\)\^3],
> Print[a\_k]}, \(++k\)]\)\)
>
> System specifics: Pentium II 350 Mhz, 64 Meg Ram, Window 98, Mathematica
> 3.0, and sometimes get "Out of Memory. Exiting." returns when trying to
> further manipulate these and similar formulae. Upgrade of
> software/hardware is not an option for me at this time.
>
> Thanks for any help which anyone might be able to offer me.
> Kai G. Gauer
The following ideas occurred to me only after searching the version 4's
documentation centre and finding out more about options such as
TargetFunctions, Extension, Cancel, Simplify, Apart, Together, Expand,
FullSimplify, TrigToExp, ExcludedForms, etc and which options can be used
with each other when doing polynomial arithmetic. Incidently, does anyone
know of any simple pattern matching code for building 3-by-1
terms_sometimes_scrambled((x^2-6x+9)-4y^2)=+/-((x-3), 2y) with (you figure
out what duty the +/- operator should do in general for this case), and
2-by-2 (see any Gr 10 math text; just check for the right section)
multinomial factoring arithmetic rules (by this, I would even later on
mean that the coeffecients can be picked symbolically, and not just fixed
as numbers right away), as well as also showing what Simplify's
pattern-matching could possibly be seeking in each step-by-step-by-step of
a "Complete_The_Square" simplification operation into FullSimplify et
aliad for version 3 (I'd personally have been much happier using only an
option similar to ExcludedForms, but which instead could only chase after
particularily specified IncludedForms for Version3 - and I may decide to
look harder for this type of idea before I consider an upgrade to >v4.2 -
note that this pseudo-bug could possibly affect my decision to choose a
new favourite programming language, mind you - and it still is
Mathematica)