dharr

Dr. David Harrington

5535 Reputation

21 Badges

19 years, 182 days
University of Victoria
Professor or university staff
Victoria, British Columbia, Canada

Social Networks and Content at Maplesoft.com

Maple Application Center
I am a professor of chemistry at the University of Victoria, BC, Canada, where my research areas are electrochemistry and surface science. I have been a user of Maple since about 1990.

MaplePrimes Activity


These are replies submitted by dharr

@MaPal93 

  1. What am I doing wrong when solving the reduced form system?
    Nothing, the expressions are just too complicated. You substitute the solution of a quartic into a complicated eqn and then that eq is very complicated.
  2. Am I understanding correctly that, in contrast to the provided example in the answer, only real solutions exist here (even if lambda_2 \= lambda_3)?
    I don't think you can tell much about this.
  3. lambda_2 (l2[1]) and lambda_3 (l3[1]) are pretty much nonspecular (i.e., very different in size and form), while in the example provided in the answer the solutions are specular/very similar to each other, am I wrong?
    In my solution, the stepwise equation get more complicated (admittedly only slightly). I think this is general. Of course if you have the same values they potentially can be simplified to the same thing, but once there are radicals, then that is not easy to do. You also don't know that you have picked out the right roots; they might be different.

You are assuming the first value from allvalues is real, but this will depend on your parameters. Only for numeric coefficients is the first RootOf real (if there is a real root).

240124_specular_equations_nonspecular_solutions_dharr.mw

 

Presumably, the reason that f(0.2342493224)  is not changed to f(0.2342)  is because to get 4 place accuracy in the value of the function might require more than 4 place accuracy in its argument.

@acer Thanks. Obvious in highsight, I should have gone straight to seq.

@Nicole Sharp 

I think that getting different results depending in units present or not does seem strange, as does different results for numbers being expressed in different forms (exact or float). These differences seem to be becuase there is different analysis going on behind the scenes. Those can certainly be considered areas for improvement, but I don't think something can be considered a bug unless it returns the wrong answer. A numerical calculation is expected to have a small error. Since Maple works in the complex domain a small imaginary part is no different from a small error in a real answer, which is why the fnormal and simplify/zero postprocessing seems to me to be the correct way to go.

A similar comment applies to "There should be an option in the Maple settings to instruct Maple that all integrations should only give real results and thus Maple can then automatically try alternative integration methods whenever a non-real result is detected." But what you really mean is "if the integrand is always real then the integral should return real", or otherwise you do not allow for integration involving complex quantities. But a small change to the arguments of some functions in the integrand can make them complex, and then you are back to the same problem. The RealDomain package tries to solve this for some functions (but not int), and does not seem to work as well as might be expected.

There is also the possibility of trying different methods to get a real result. But for a really difficult problem, the time taken for this might be quite long, so you would want this only as an option. Many Maple routines do allow you to specify a list of methods or exclude some methods or exclude symbolic preprocessing (which would perhaps help most here). But for integration, the symbolic part can be powerful, say in detecting singularities that might otherwise be missed and that might be degrading accuracy.

@Nicole Sharp To apply fnormal and simplify/zero to the arguments of Quantity, you need a bit of advanced Maple. If q is the expression containing Quantity(..., ...),, then use

subsindets(q, specfunc(Quantity), x -> map(y->simplify(fnormal(y,23),zero), x));

This means every time we see the specific function Quantity, we apply the procedure given, which receives Quantity(a,b). The map over x does it for each of the ops of Quantity, which are the arguments a and b. For each of these, we apply the procedure y->simplify(fnormal(y,23),zero). For your case this yields

subsindets.mw

@C_R The numeric option for int, int(..., numeric), works identically to the eval/Int. (I think it was introduced to be a bit more intuitive than evalf/int and a similar syntax was already in place for dsolve.)  It happens that for the _Dexp method and these examples the results are all real.

Int_vs_numeric.mw

In one of Nicole's examples I tried all the high-digits methods and always got a complex result. This was for one with an infinite limit. The help page suggests there can be symbolic preprocessing for this case. There is also interaction with Units and Quantites-with-errors, which I think are more fickle (buggy?) than in their absence.

@Nicole Sharp I changed _s to Unit(s). Then numeric integration to infinity gives a complex value that fnormal can handle.

restart;

with(Units) :
Digits:=32;

Automatically loading the Units[Simple] subpackage
 

32

c := 299792458*Unit(m)/Unit(s) :
h := 662607015*10^(-8)*10^(-34)*Unit(J)/Unit(Hz) :
k := 1380649*10^(-6)*10^(-23)*Unit(J)/Unit(K) :
lambda_V_max := 750*Unit(nm) :
lambda_V_min := 380*Unit(nm) :
T_Sol := 5772.0*Unit(K) :
T0_Sol := 5772*Unit(K) :

evalf(Pi*int(2*c^2*h/((exp(c*h/(k*lambda*T_Sol)) - 1)*lambda^5), lambda = 0*Unit(m) .. infinity*Unit(m),numeric = true));
fnormal(%);
simplify(%,zero);

(62938592.470335950467548474587301-0.31415926535897932384626433832795e-44*I)*Units:-Unit(kg/s^3)

(62938592.470335950467548474587301-0.*I)*Units:-Unit(kg/s^3)

62938592.470335950467548474587301*Units:-Unit(kg/s^3)

 

Download numeric_integration.mw

shoot expects the shooting parameters to be given in a list before output=listprocedure, something like [alpha = 0., beta =0.]. Actually I'm not sure if you can only have one parameter. I still didn't get it to work, and would need to understand the code better to figure that out. Perhaps author Doug Meade can help - he is on Mapleprimes

@Nicole Sharp I would expect, since the integrand doesn't involve any complicated functions, that the numeric integration always provides a real result. For me (version 2023.2.1) this is true even for the infinite limit: 

Digits:=32;
Pi*int(2*299792458^2*662607015*10^(-8)*10^(-34)/((exp(299792458*662607015*10^(-8)*10^(-34)/(1380649*10^(-6)*10^(-23)*lambda*5772)) - 1)*lambda^5), lambda = 0 .. infinity,numeric);

which gives

@dharr In this case, doing the integral numerically leads to a real answer differing in the last three places from evalf of the exact result at 32 digits

Digits:=32;
Mnum := (T, lambda_min, lambda_max) -> Pi*int(2*c^2*h/((exp(c*h/(k*lambda*T)) - 1)*lambda^5),
  lambda = lambda_min .. lambda_max, numeric) :
Mnum(T0_Sol, lambda_V_min, lambda_V_max);

@Nicole Sharp I agree; there certainly seems no reason that derive couldn't be any expression. And I also agree about updating the fundamental constants. Especially since many now have exact defined values that won't change in the future.

@Pemudahijrah01 ... and put a colon ":" at the end of the last line so you don't get your large output problem again. And use "local gamma;" at the beginning so gamma does not have a spcial meaning. (Like linalg, these were feedbacks you got on your earlier post.)

It seems that the form of the derive equation is very restrictive. From the help page, "In the derive_eqn equation of the form 'derive'=derive_obj, the derive_obj expression is typically a product of rational powers of numerics, Maple constants, and physical constant identifiers (for example, symbols). Exceptions are the abs function, and a sum with dimensionally consistent summands."
So perhaps you can only have one or the other and not a mix of these two types. If that is the reason, then there should at least be a warning or error message.

Here is a workaround:

restart;

with(Units[Standard]):with(ScientificConstants):

AddConstant(Solar_equatorial_radius, symbol = r[e,Sol], value = 696342., uncertainty = 65., units = km) ;

AddConstant(Solar_flattening, symbol = f[Sol], value = 0.000009) ;

AddConstant(Solar_eccentricity, symbol = e[Sol], derive = 1 - f[Sol]) ;

AddConstant(Solar_polar_radius, symbol = r[p,Sol], derive = r[e,Sol]*e[Sol]) ;

AddConstant(Solar_nonradius, symbol = x[Sol], derive = f[Sol]*r[e,Sol]) ;

evalf(Constant(r[e,Sol],units));

696342000.*Units:-Unit(m)

evalf(Constant(f[Sol],units));

0.9e-5

evalf(Constant(r[p,Sol],units));

696335732.9*Units:-Unit(m)

-696342e3*(0.000009-1)

696335732.9

evalf(Constant(x[Sol],units));

6267.078000*Units:-Unit(m)

NULL

Download constants.mw

@acer My understanding is that the minimal polynomial is the lowest degree polynomial (with rational coefficients since you didn't specify an extension field) that u1 with index=1 for both RootOfs is a root of. Since that u1 value is not the one corresponding to the desired trig expression, is it only coincidence that in this case the desired root is another root of the minimal polynomial? There is something special in this case that of the 6 roots only three are distinct, so does this work more generally? I suppose it can always be tried and checked...

@dharr I took a closer look at why @acer's solution doesn't lead to the solutions in the form with the square root, which Maple cannot simplify further.

restart;

expected:=(1+cos(arctan(3/4)/3))/3;evalf(%);

1/3+(1/3)*cos((1/3)*arctan(3/4))

.6590276223

alpha[1]:=evalc(convert(RootOf(60*_Z^3 - 60*_Z^2 + 15*_Z - 1,index=1),radical));evalf(%);
alpha[2]:=evalc(convert(RootOf(60*_Z^3 - 60*_Z^2 + 15*_Z - 1,index=2),radical));evalf(%);
alpha[3]:=evalc(convert(RootOf(60*_Z^3 - 60*_Z^2 + 15*_Z - 1,index=3),radical));evalf(%);

-(1/6)*cos((1/3)*arctan(3/4))+1/3-(1/6)*3^(1/2)*sin((1/3)*arctan(3/4))

.1090390090

-(1/6)*cos((1/3)*arctan(3/4))+1/3+(1/6)*3^(1/2)*sin((1/3)*arctan(3/4))

.2319333686

1/3+(1/3)*cos((1/3)*arctan(3/4))

.6590276223

The simplify here is the key to finding the simpler (factored) form of the quadratic). (a here stands in for the RootOf above).

quad[1]:=RootOf(simplify(eval(4*_Z^2 + (4*a - 4)*_Z + 4*a^2 - 4*a + 1,a=alpha[1])));
quad[2]:=RootOf(simplify(eval(4*_Z^2 + (4*a - 4)*_Z + 4*a^2 - 4*a + 1,a=alpha[2])));
quad[3]:=RootOf(simplify(eval(4*_Z^2 + (4*a - 4)*_Z + 4*a^2 - 4*a + 1,a=alpha[3])));

RootOf((cos((1/3)*arctan(3/4))-3*_Z+1)*(3^(1/2)*sin((1/3)*arctan(3/4))-cos((1/3)*arctan(3/4))-6*_Z+2))

RootOf(-(cos((1/3)*arctan(3/4))-3*_Z+1)*(3^(1/2)*sin((1/3)*arctan(3/4))+cos((1/3)*arctan(3/4))+6*_Z-2))

RootOf(36*_Z^2+(12*cos((1/3)*arctan(3/4))-24)*_Z+4*cos((1/3)*arctan(3/4))^2-4*cos((1/3)*arctan(3/4))+1)

The quadratic doesn't obviously factor in the "native" form, so using allvalues before substituting in the alpha's leads to pesky square roots.

factor(4*_Z^2 + (4*a - 4)*_Z + 4*a^2 - 4*a + 1);

4*_Z^2+4*_Z*a+4*a^2-4*_Z-4*a+1

Find all 6 roots

rts[1]:=[allvalues(quad[1])];evalf(%);
rts[2]:=[allvalues(quad[2])];evalf(%);
rts[3]:=[allvalues(quad[3])];evalf(%);

[-(1/6)*cos((1/3)*arctan(3/4))+1/3+(1/6)*3^(1/2)*sin((1/3)*arctan(3/4)), 1/3+(1/3)*cos((1/3)*arctan(3/4))]

[.2319333686, .6590276223]

[-(1/6)*cos((1/3)*arctan(3/4))+1/3-(1/6)*3^(1/2)*sin((1/3)*arctan(3/4)), 1/3+(1/3)*cos((1/3)*arctan(3/4))]

[.1090390090, .6590276223]

[-(1/6)*cos((1/3)*arctan(3/4))+1/3-(1/6)*(-3*cos((1/3)*arctan(3/4))^2+3)^(1/2), -(1/6)*cos((1/3)*arctan(3/4))+1/3+(1/6)*(-3*cos((1/3)*arctan(3/4))^2+3)^(1/2)]

[.1090390091, .2319333685]

rts[1][2];
rts[2][2];

1/3+(1/3)*cos((1/3)*arctan(3/4))

1/3+(1/3)*cos((1/3)*arctan(3/4))

 

Download RootOfX.mw

2 3 4 5 6 7 8 Last Page 4 of 56