## dharr

Dr. David Harrington

## 6389 Reputation

20 years, 12 days
University of Victoria
Professor or university staff

## Social Networks and Content at Maplesoft.com

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

## seq...

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

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.

## fnormal inside Quantity...

@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

## Int vs int(..., numeric)...

@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.

## numeric integration...

@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;

 > 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);

 >

## syntax...

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

## numeric integration...

@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

## numerical integral...

@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);```

## limitations...

@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.

## colon...

@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.)

## restricted form of derived expression...

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));

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

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

 > -696342e3*(0.000009-1)

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

 >

## interesting...

@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...

## another look...

@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(%);

 > 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(%);

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])));

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);

Find all 6 roots

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

 >

## strange result...

@nm Nice use of remove_RootOf; I didn't know about that. When I evalf([%]) your result I get

[[0.6114019859 = 0., 0.2874388753 = 0., 0.1011591386 = 0.]],

but none of these correspond to the expected result, so I'm confused about that.

## evaluation is OK...

@fnavarro If I just evaluate the expression at Digits=40 I don't see a problem, there are no strange values in pts:

```restart;
Digits:=40;
pts:=[seq([x,x*exp(-x)],x=0..20,0.2)]:
plots:-pointplot(pts,connect);```

I agree if you look at the points in the plot structure for the regular plot without adaptive = true, they look strange, but as  @Preben Alsholm points out this is a function of the adaptive routine. Perhaps you have an specific example not involving plot.

 First 12 13 14 15 16 17 18 Last Page 14 of 66
﻿