Prev: Solving ODE with discontinuous shock perturbation [was: Modification
Next: Remote Kernel
From: Joseph Gwinn on 7 Mar 2010 04:12
I have been using Mathematica 7 to do the grunt work in solving some
transmission-line problems, using the exponential form of the equations.

A typical form would be S1 = Exp[k1*x + I*omega*(t+tau)], describing signal one,
where K1 is the attenuation in nepers per meter, I is the square root of minus
one, omega is the angular frequency in radians per second, t is time and tau is
a fixed time delay, t and tau being in seconds.

Often I need the complex conjugate of S1, so I write Conjugate[S1]. The problem
is that Mathematica does nothing useful, leaving the explicit Conjugate[] in the
output expression, which after a very few steps generates a mathematically
correct but incomprehensible algebraic hairball.

Clearly Mathematica feels that it lack sufficient information to proceed. In
particular, it has no way to know that all variables are real until explicitly
told.

One way to solve this problem is
FullSimplify[Conjugate[S1],Element[_Symbol,Reals]], and this often works.

But equally often, it works too well, yielding the trignometric expansion of the
desired exponential-form answer. Nor is it clear why it sometimes works and
sometimes works too well.

Using Simplify[] instead of FullSimplify[] doesn't seem to work at all.


So my questions are:

1. What controls FullSimplify[]'s behaviour here?

2. What other ways are there to cause Mathematica to apply the Conjugate[]
without holding back?


Thanks,

Joe Gwinn

From: David Park on 8 Mar 2010 06:10
Joe,

Have you tried ComplexExpand? It assumes that all symbols are Reals, unless
specified otherwise. Also check its TargetFunctions option.


David Park
djmpark(a)comcast.net
http://home.comcast.net/~djmpark/




From: Joseph Gwinn [mailto:joegwinn(a)comcast.net]

I have been using Mathematica 7 to do the grunt work in solving some
transmission-line problems, using the exponential form of the equations.

A typical form would be S1 = Exp[k1*x + I*omega*(t+tau)], describing signal
one,
where K1 is the attenuation in nepers per meter, I is the square root of
minus
one, omega is the angular frequency in radians per second, t is time and tau
is
a fixed time delay, t and tau being in seconds.

Often I need the complex conjugate of S1, so I write Conjugate[S1]. The
problem
is that Mathematica does nothing useful, leaving the explicit Conjugate[] in
the
output expression, which after a very few steps generates a mathematically
correct but incomprehensible algebraic hairball.

Clearly Mathematica feels that it lack sufficient information to proceed.
In
particular, it has no way to know that all variables are real until
explicitly
told.

One way to solve this problem is
FullSimplify[Conjugate[S1],Element[_Symbol,Reals]], and this often works.

But equally often, it works too well, yielding the trignometric expansion of
the
desired exponential-form answer. Nor is it clear why it sometimes works and

sometimes works too well.

Using Simplify[] instead of FullSimplify[] doesn't seem to work at all.


So my questions are:

1. What controls FullSimplify[]'s behaviour here?

2. What other ways are there to cause Mathematica to apply the Conjugate[]
without holding back?


Thanks,

Joe Gwinn



From: AES on 8 Mar 2010 06:11
In article <hmvqlg$1gg$1(a)smc.vnet.net>,
Joseph Gwinn <joegwinn(a)comcast.net> wrote:

> A typical form would be S1 = Exp[k1*x + I*omega*(t+tau)], describing
> signal one, where K1 is the attenuation in nepers per meter, I is the
> square root of minus one, omega is the angular frequency in radians
> per second, t is time and tau is a fixed time delay, t and tau being
> in seconds.
>
> Often I need the complex conjugate of S1, so I write Conjugate[S1].

You don't know what a firestorm you may ignite with this query.

How would you do this on paper? All the other factors in your
expression you know are going to be purely real, so you really
just want to change I to -I, right? (How else does one take a
CC in the real world?)

And so in Mathematica you might write

S1Complex = S1 /. {I -> -I}

If you try this, you'll find that sometimes it works just fine -- and
sometimes it doesn't -- and Mathematica gives you no warning
anywhere in the elementary discussions of /. or -> or I that you
shouldn't do this, or why you shouldn't.

So don't do it this way (but don't expect a lot of sympathy from
this group for people doing elementary phasor analyses like
you're doing, who are misled by this line of thinking).

From: Sjoerd C. de Vries on 8 Mar 2010 06:12
Hi Joe,

I think ComplexExpand will be helpful for you. It make Mathematica
assume all variables in the contained expression are real. To improve
readibility of Conjugate you might want to input it as esc-conj-esc
(at the end of the expression, perhaps between parenthesis), so that
you only have the superscripted star.

Cheers -- Sjoerd


On Mar 7, 11:12 am, Joseph Gwinn <joegw...(a)comcast.net> wrote:
> I have been using Mathematica 7 to do the grunt work in solving some
> transmission-line problems, using the exponential form of the equations.
>
> A typical form would be S1 = Exp[k1*x + I*omega*(t+tau)], describing signal one,
> where K1 is the attenuation in nepers per meter, I is the square root of minus
> one, omega is the angular frequency in radians per second, t is time and tau is
> a fixed time delay, t and tau being in seconds.
>
> Often I need the complex conjugate of S1, so I write Conjugate[S1]. The problem
> is that Mathematica does nothing useful, leaving the explicit Conjugate[] in the
> output expression, which after a very few steps generates a mathematically
> correct but incomprehensible algebraic hairball.
>
> Clearly Mathematica feels that it lack sufficient information to proceed. In
> particular, it has no way to know that all variables are real until explicitly
> told.
>
> One way to solve this problem is
> FullSimplify[Conjugate[S1],Element[_Symbol,Reals]], and this often works.
>
> But equally often, it works too well, yielding the trignometric expansion of the
> desired exponential-form answer. Nor is it clear why it sometimes works and
> sometimes works too well.
>
> Using Simplify[] instead of FullSimplify[] doesn't seem to work at all.
>
> So my questions are:
>
> 1. What controls FullSimplify[]'s behaviour here?
>
> 2. What other ways are there to cause Mathematica to apply the Conjugate[]
> without holding back?
>
> Thanks,
>
> Joe Gwinn


From: Joe Gwinn on 8 Mar 2010 06:14
Bob,

At 8:54 AM -0500 3/7/10, Bob Hanlon wrote:
>Use ComplexExpand
>
>S1 = Exp[k1*x + I*omega*(t + tau)];
>
>S1 // Conjugate
>
>E^Conjugate[I*omega*(t + tau) + k1*x]
>
>S1 // Conjugate // ComplexExpand
>
>E^(k1*x)*Cos[omega*(t + tau)] -
> I*E^(k1*x)*Sin[omega*(t + tau)]
>
>S1 // Conjugate // ComplexExpand // FullSimplify
>
>E^(k1*x - I*omega*(t + tau))

I recall trying ComplexExpand, but it always worked too well, giving
trig, just as with FullSimplify[], so I had forgotten it.

But ComplexExpand[]//TrigToExp seems to work, and isn't too ugly.


Thanks,

Joe


>Bob Hanlon
>
>---- Joseph Gwinn <joegwinn(a)comcast.net> wrote:
>
>=============
>I have been using Mathematica 7 to do the grunt work in solving some
>transmission-line problems, using the exponential form of the equations.
>
>A typical form would be S1 = Exp[k1*x + I*omega*(t+tau)], describing
>signal one,
>where K1 is the attenuation in nepers per meter, I is the square root of minus
>one, omega is the angular frequency in radians per second, t is time
>and tau is
>a fixed time delay, t and tau being in seconds.
>
>Often I need the complex conjugate of S1, so I write Conjugate[S1].
>The problem
>is that Mathematica does nothing useful, leaving the explicit
>Conjugate[] in the
>output expression, which after a very few steps generates a mathematically
>correct but incomprehensible algebraic hairball.
>
>Clearly Mathematica feels that it lack sufficient information to proceed. In
>particular, it has no way to know that all variables are real until explicitly
>told.
>
>One way to solve this problem is
>FullSimplify[Conjugate[S1],Element[_Symbol,Reals]], and this often works.
>
>But equally often, it works too well, yielding the trignometric
>expansion of the
>desired exponential-form answer. Nor is it clear why it sometimes works and
>sometimes works too well.
>
>Using Simplify[] instead of FullSimplify[] doesn't seem to work at all.
>
>
>So my questions are:
>
>1. What controls FullSimplify[]'s behaviour here?
>
>2. What other ways are there to cause Mathematica to apply the Conjugate[]
>without holding back?
>
>
>Thanks,
>
>Joe Gwinn


 |  Next  |  Last
Pages: 1 2 3
Prev: Solving ODE with discontinuous shock perturbation [was: Modification
Next: Remote Kernel