Advanced Search

C_R

1466 Reputation

19 Badges

4 years, 11 days
Contact C_R

MaplePrimes Activity


These are answers submitted by C_R

Minerr equivalent to NLPsolve?...

C_R 1466
September 30 2023
0 2

Attached you will find a way in Maple. Since the problem is nonlinear there can be more minima (local or global). That's most likely the reason why the result from Maple and Mathcad do not agree in a first attempt.

NLPsolve (and the Optimization package in general) has a bunch of options Minerr in a solve block does not seem to have. If you want to reproduce whatever Minerr does you have to go through all the options and their combinations. I would start with methods first.

 

 

restart

H := Vector(9, {(1) = 210.84, (2) = 218.19, (3) = 219.17, (4) = 222.27, (5) = 226.35, (6) = 228.45, (7) = 230.44, (8) = 234.65, (9) = 239.75})

Vector[column](%id = 36893491118738273692)

 (1)

Q := Vector(9, {(1) = 1800, (2) = 1750, (3) = 1730, (4) = 1700, (5) = 1650, (6) = 1635, (7) = 1600, (8) = 1570, (9) = 1500})

Vector[column](%id = 36893491118738263564)

 (2)

A := 330.156

330.156

 (3)

In Mathcad I used solve by using a solve block:

 

 

But what is the most efficient way to do this in Maple?

 

NULL

Supposing

Q^2in Mathcad is equivalent to `~`[`*`](Q, Q) in Maple

NULL

And in the same way

could be written using element wise operators

H = A*`~`[`-`](1, Q/Q0)-`~`[`*`](kf*Q, Q)-`~`[`*`](kl*`~`[`-`](Q, Qs), `~`[`-`](Q, Qs))

Vector[column](%id = 36893491118738273692) = Vector[column](%id = 36893491118738251396)

 (4)

"res_v:=(lhs-rhs)(?);#` vector of residuals`"

Vector[column](%id = 36893491118738227316)

 (5)

initial_points := {Q0 = 6413, Qs = 1416, kf = 10^(-5), kl = 10^(-5)}

{Q0 = 6413, Qs = 1416, kf = 1/100000, kl = 1/100000}

 (6)

with(Optimization)

[ImportMPS, Interactive, LPSolve, LSSolve, Maximize, Minimize, NLPSolve, QPSolve]

 (7)

res_l := convert(res_v, list)

[-119.316+594280.800/Q0+3240000*kf+kl*(1800-Qs)^2, -111.966+577773.000/Q0+3062500*kf+kl*(1750-Qs)^2, -110.986+571169.880/Q0+2992900*kf+kl*(1730-Qs)^2, -107.886+561265.200/Q0+2890000*kf+kl*(1700-Qs)^2, -103.806+544757.400/Q0+2722500*kf+kl*(1650-Qs)^2, -101.706+539805.060/Q0+2673225*kf+kl*(1635-Qs)^2, -99.716+528249.600/Q0+2560000*kf+kl*(1600-Qs)^2, -95.506+518344.920/Q0+2464900*kf+kl*(1570-Qs)^2, -90.406+495234.000/Q0+2250000*kf+kl*(1500-Qs)^2]

 (8)

LSSolve(res_l, initial_points)

[378.523243101364528, [Q0 = HFloat(6413.0), Qs = HFloat(1416.0), kf = HFloat(9.99999999995449e-6), kl = HFloat(9.99999999995449e-6)]]

 (9)

Same as initial points  

NLPSolve(add(map(`^`, res_l, 2)), initialpoint = initial_points)

[3.80383862075732582, [Q0 = HFloat(6411.783489433508), Qs = HFloat(1431.553974929293), kf = HFloat(5.797829593736934e-6), kl = HFloat(5.21635358612149e-5)]]

 (10)

NULL

NLPSolve does not give Minerr output as I would have expected from the description
https://support.ptc.com/help/mathcad/r9.0/en/PTC_Mathcad_Help/example_using_minerr_for_nonlinear_least_squares_fitting.html

 

 

Download SolveBlockQuestion-reply.mw

 

a subsway...

C_R 1466
September 27 2023
0 0

For comparision:
The best I could do with substitutions. What makes it tricky is the coefficient R1*R2 of s.

I spare out the sorting detail since its already twice as long as acers solution.

V = V1*R2/(C*R1*R2*s+R1+R2)

V = V1*R2/(C*R1*R2*s+R1+R2)

 (1)

R1*R2 = R12

R2*R1 = R12

 (2)

RS = R1+R2

RS = R1+R2

 (3)

algsubs(RS = R1+R2, algsubs(R1*R2 = R12, V = V1*R2/(C*R1*R2*s+R1+R2)))

V = V1*R2/(C*R12*s+RS)

 (4)

(`@`(numer, rhs))(V = V1*R2/(C*R12*s+RS))/RS

V1*R2/RS

 (5)

expand((`@`(denom, rhs))(V = V1*R2/(C*R12*s+RS))/RS)

C*s*R12/RS+1

 (6)

V = V1*R2/(RS*(C*s*R12/RS+1))

V = V1*R2/(RS*(C*s*R12/RS+1))

 (7)

subs(RS = R1+R2, isolate(R1*R2 = R12, R12), V = V1*R2/(RS*(C*s*R12/RS+1)))

V = V1*R2/((R1+R2)*(C*s*R2*R1/(R1+R2)+1))

 (8)

NULL

Download subsway.mw

General technique...

C_R 1466
September 27 2023
0 0

Your parameters still do not match. In the following I have tried to show how the substitution should be done and what needs to be changed.

NULLOriginal expression

((D@@2)(theta))(eta) = -(-D[t]*epsilon*(-gamma+beta)*(D(theta))(eta)+beta*(D[B]*epsilon*(mu-lambda)*(D(phi))(eta)+(1/2)*nu*(f(eta)*sin(alpha)+eta*cos(alpha))))*(D(theta))(eta)/(beta*sigma)

((D@@2)(theta))(eta) = -(-D[t]*epsilon*(-gamma+beta)*(D(theta))(eta)+beta*(D[B]*epsilon*(mu-lambda)*(D(phi))(eta)+(1/2)*nu*(f(eta)*sin(alpha)+eta*cos(alpha))))*(D(theta))(eta)/(beta*sigma)

 (1)

with the following indeterminates

indets(((D@@2)(theta))(eta) = -(-D[t]*epsilon*(-gamma+beta)*(D(theta))(eta)+beta*(D[B]*epsilon*(mu-lambda)*(D(phi))(eta)+(1/2)*nu*(f(eta)*sin(alpha)+eta*cos(alpha))))*(D(theta))(eta)/(beta*sigma))

{alpha, beta, epsilon, eta, lambda, mu, nu, sigma, D[B], D[t], cos(alpha), f(eta), sin(alpha), (D(phi))(eta), (D(theta))(eta), ((D@@2)(theta))(eta)}

 (2)

Expressions to substitute (in the form of an equation. Do not use the assignment operator :=     )

Pr = nu/sigma

Pr = nu/sigma

 (3)

Isolate an indeterminate you want to replace

isolate(Pr = nu/sigma, sigma)

sigma = nu/Pr

 (4)

Substitute it into (1)

subs(sigma = nu/Pr, ((D@@2)(theta))(eta) = -(-D[t]*epsilon*(-gamma+beta)*(D(theta))(eta)+beta*(D[B]*epsilon*(mu-lambda)*(D(phi))(eta)+(1/2)*nu*(f(eta)*sin(alpha)+eta*cos(alpha))))*(D(theta))(eta)/(beta*sigma))

((D@@2)(theta))(eta) = -(-D[t]*epsilon*(-gamma+beta)*(D(theta))(eta)+beta*(D[B]*epsilon*(mu-lambda)*(D(phi))(eta)+(1/2)*nu*(f(eta)*sin(alpha)+eta*cos(alpha))))*(D(theta))(eta)*Pr/(beta*nu)

 (5)

Now you have Pr appearing which gets you closer to the result you are looking for.

Similarly you have to proceed for the other parameters with  the goal to remove all indeterminates you do not wantfrom your original expression . To get an overview what indeterminates are used in a expression use the indets command.

For your target expression

((D@@2)(theta))(eta) = -(1/2)*Pr*(D(theta))(eta)*eta*cos(alpha)-(1/2)*Pr*(D(theta))(eta)*sin(alpha)*f(eta)-N[b]*(D(theta))(eta)*(D(phi))(eta)-N[t]*(D(theta))(eta)

((D@@2)(theta))(eta) = -(1/2)*Pr*(D(theta))(eta)*eta*cos(alpha)-(1/2)*Pr*(D(theta))(eta)*sin(alpha)*f(eta)-N[b]*(D(theta))(eta)*(D(phi))(eta)-N[t]*(D(theta))(eta)

 (6)

you get

indets(((D@@2)(theta))(eta) = -(1/2)*Pr*(D(theta))(eta)*eta*cos(alpha)-(1/2)*Pr*(D(theta))(eta)*sin(alpha)*f(eta)-N[b]*(D(theta))(eta)*(D(phi))(eta)-N[t]*(D(theta))(eta))

{Pr, alpha, eta, N[b], N[t], cos(alpha), f(eta), sin(alpha), (D(phi))(eta), (D(theta))(eta), ((D@@2)(theta))(eta)}

 (7)

You can compare which indeterminates are used in the original and the target to determine what has to be removed from the original

`minus`({alpha, beta, epsilon, eta, lambda, mu, nu, sigma, D[B], D[t], cos(alpha), f(eta), sin(alpha), (D(phi))(eta), (D(theta))(eta), ((D@@2)(theta))(eta)}, {Pr, alpha, eta, N[b], N[t], cos(alpha), f(eta), sin(alpha), (D(phi))(eta), (D(theta))(eta), ((D@@2)(theta))(eta)})

{beta, epsilon, lambda, mu, nu, sigma, D[B], D[t]}

 (8)

The indeterminates above have to be removed from the original and(!) these ones should appear in the target

`minus`({Pr, alpha, eta, N[b], N[t], cos(alpha), f(eta), sin(alpha), (D(phi))(eta), (D(theta))(eta), ((D@@2)(theta))(eta)}, {alpha, beta, epsilon, eta, lambda, mu, nu, sigma, D[B], D[t], cos(alpha), f(eta), sin(alpha), (D(phi))(eta), (D(theta))(eta), ((D@@2)(theta))(eta)})

{Pr, N[b], N[t]}

 (9)

You have to do this with additional relations, which are your parameter expressions.

Pr = nu/sigma, N[b] = epsilon*D[B](mu-lambda)/sigma, N[t] = epsilon*D[t](gamma-beta)/(gamma*sigma), Le = nu/D[B]

Pr = nu/sigma, N[b] = epsilon*(D[B](mu)-D[B](lambda))/sigma, N[t] = epsilon*(D[t](gamma)-D[t](beta))/(gamma*sigma), Le = nu/D[B]

 (10)

indets({Le = nu/D[B], Pr = nu/sigma, N[b] = epsilon*(D[B](mu)-D[B](lambda))/sigma, N[t] = epsilon*(D[t](gamma)-D[t](beta))/(gamma*sigma)})

{Le, Pr, beta, epsilon, lambda, mu, nu, sigma, D[B], N[b], N[t], D[B](lambda), D[B](mu), D[t](beta)}

 (11)

{Le, Pr, beta, lambda, mu, nu, sigma, `ε`, D[B], N[b], N[t], D[B](lambda), D[B](mu), D[t](beta)}and D[t](gamma)

The parameters highlighted in red are neither in the original nor in the target. Substituting your parameter expressions (somehow rearranged -> see isolate above) in the original will introduce them in to the result.
That is what I called mismatch.

NULL

Further observations:

• 

Make clear whether the D in D[B](lambda), D[B](mu), D[t](beta), D[t](gamma) is meant to be the differential operator  or used to name variables or parameters.

• 

If the subscripts in D[B](lambda), D[B](mu), D[t](beta), D[t](gamma)are meant to be subscripts and not elements of an indexed object rather use two under scores __ to enter the subscript.
• 

gamma (i.e. gamma) in D[t](gamma)is a constant in Maple that evaluates to a number. It is dangerous to use it as a name.

NULL

Download parameter_mismatch.mw

Collect...

C_R 1466
September 22 2023
0 0

In your simple example 

L1 := -L*(k - 1);
collect(L1, L);
                           (-k + 1) L

preserves a "simplified" factor (sign of your original factor has changed). Collect should also work in more complex cases unless there are other sub-expressions where you don't want to collect L. In those cases changing the sign of the factor like this

Lm := (simplify(k*sqrt(L*L)) assuming (0 < L));
L1 := (factor(-L + Lm) assuming (0 < L and 0 < Lm and 0 <= k));

might work as well.

Working backward...

C_R 1466
September 17 2023
4 0

Infolevel confirms that dsolve integrates a first order ode

intde := int(x^2*diff(y(x), x)/(x^2 - 1), x) = int(y(x)^(1/2), x)^(-2/3);
infolevel[dsolve] := 5;
dsolve(intde);
Methods for first order ODEs:
--- Trying classification methods ---
trying homogeneous types:
differential order: 1; looking for linear symmetries
trying exact
<- exact successful

If you additionally increase printlevel up to 50 you will find the ODE (which can also be derived by differention of the original equation w.r.t. to x).

Edit: In this way Maple reduces the inital equation to a first oder equation.

Then appropriate methods are applied


 

This is the first order integroDE Maple integrates. An ODE without integral that integrates to the same result would be this one


To get there, you have to find a way to convert the right handside of your problem like this (i.e. getting the integration out of the denominator): 

The attachment shows where the above right hand side comes from.

integrode_backward.mw

A base like that with a z-axis?Any prefe...

C_R 1466
September 13 2023
1 2

A base like that with a z-axis?