Please, how do I find the minimum of the real part of a complex function? I tried min ( ) function it didn't work.
Find attached the fileFinding_min_zero.mw
| |
Parameters
|
| |
| > |
gamma1 := .1093:
alpha3 := -0.1104e-2:
k[1] := 6*10^(-12):
d:= 0.2e-3:
xi:= -0.01:
theta0:= 0.1e-3:
eta[1]:= 0.240e-1:
alpha:= 1-alpha3^2/(gamma1*eta[1]):
c:= alpha3*xi*alpha/(eta[1]*(4*k[1]*q^2/d^2-alpha3*xi/eta[1])):
theta_init:= theta0*sin(Pi*z/d):
n:= 10:
|
|
| |
Set q as a complex
|
| |
Assume  and subsitute the result into g and equate the real and complex part to zero, and solve for x and y.
| > |
f := subs(q = x+I*y, g):
b1 := evalc(Re(f)) = 0:
b2 := evalc(Im(f)) = 0:
|
| |
Compute the Special Asymptotes
|
| |
This asymptote is coming from the  from the definition of 
|
| |
Compute Odd asymptote
|
| |
First, Since  , then an asymptote occurs at  In general, we have
Next, we compute the entry of the Oddasymptotes that is close to qstar (special asymptote) as assign it to
ModifiedOaddAsym, and then find the minimum of the ModifiedOaddAsym. Searchall Function returns
the index of an entry in a list.
| > |
OddAsymptotes := Vector[row]([seq(evalf((1/2*(2*j+1))*Pi), j = 0 .. n)]);
ModifiedOddAsym := abs(`~`[`-`](OddAsymptotes, qstar));
qstarTemporary := min(ModifiedOddAsym);
indexOfqstar2 := SearchAll(qstarTemporary, ModifiedOddAsym);
qstar2 := OddAsymptotes(indexOfqstar2);
|
|
|
(4.2.1) |
|
| |
Compute x and y
|
| |
Here, we solve for  and  within the min. and max. of qstar2 and qstar, and substitute the results into  .
| > |
AreThereComplexRoots := type(true, 'truefalse');
try
soln1:= fsolve({b1, b2}, {x = min(qstar2, qstar) .. max(qstar2, qstar), y = 0 .. infinity});
soln2:= fsolve({b1, b2}, {x = min(qstar2, qstar) .. max(qstar2, qstar), y = -infinity .. 0});
qcomplex1 := subs(soln1, x+I*y);
qcomplex2 := subs(soln2, x+I*y);
catch:
AreThereComplexRoots := type(FAIL, 'truefalse');
end try;
|
|
|
(4.3.1) |
|
| |
Compute the rest of the Roots
|
| |
In this section we compute the roots between each asymptotes.
| > |
OddAsymptotes := Vector[row]([seq(evalf((1/2)*(2*j+1)*Pi), j = 0 .. n)]);
AllAsymptotes := sort(Vector[row]([OddAsymptotes, qstar]));
if AreThereComplexRoots then
gg := [qcomplex1, qcomplex2, op(Roots(g, q = 0.1e-3 .. AllAsymptotes[1])), seq(op(Roots(g, q = AllAsymptotes[i] .. AllAsymptotes[i+1])), i = 1 .. n)];
elif not AreThereComplexRoots then
gg := [op(Roots(g, q = 0.1e-3 .. AllAsymptotes[1])), seq(op(Roots(g, q = AllAsymptotes[i] .. AllAsymptotes[i+1])), i = 1 .. n)];
end if:
|
|
![AllAsymptotes := Vector(4, {(1) = ` 1 .. 12 `*Vector[row], (2) = `Data Type: `*anything, (3) = `Storage: `*rectangular, (4) = `Order: `*Fortran_order})](/view.aspx?sf=233954_question/e578678531aa1d5ac8a8cd458e7c69a5.gif)
|
(4.4.1) |
|
| |
Compute the  time constants
|
| |
| > |
for i to m do
p[i] := gamma1*alpha/(4*k[1]*qq[i]^2/d^2-alpha3*xi/eta[1]);
end do;
|
|
|
(4.7.1) |
| |
Minimum of the Re( )
|
| |
| > |
for i to m do
p[i] := min(Re(gamma1*alpha/(4*k[1]*qq[i]^2/d^2-alpha3*xi/eta[1])));
end do;
|
|
|
(4.7.1.1) |
| > |
## I expected 0.20459 but return all the entries in the list.
|
|
|
|
|
Download Finding_min_zero.mw
