## Items tagged with assumptions

How do I assume variables as  Matrixs for calculation?

assume(M11::Matrix);
assume(M12::Matrix);
assume(M21::Matrix);
assume(M22::Matrix);
assume(A::Matrix);

A := M12*M21+M11;
M12 M21 + M11
solve(A = 0, M12);
Warning, solve may be ignoring assumptions on the input variables.
M11
- ---
M21
solve(A = 0, M12, useassumptions = true);
M11
- ---
M21

How can I get solution being a matrix?
Thank you very much !!!

## What are these notations?...

I don' t understand what do these notations stand for? I know that there are some notations like these in Maple. How can I find meanings of the all of them?

## Check if an expression is greater than another, ba...

Hi.

I have 2 expressions, the first expression cosist of x´s and y´s, the other expression consits only of x´s

I wanna test the relation between those 2 expression to check wether A>B giving the condition that 2y<x

I have tried this:

```assume(2y<x);

is(A>B);```

the problem is that maple returns FAIL, I could put in values to check and it works, but that is not really what im trying to acomplish.

Thanks

## process of simplification with assumption...

What is the Maple command to simplify  -x^(a)+x^n  to zero under the assumption that a=n?

I have attempted the following command

simplify(-x^(a)+x^n) assuming a=n;

However, it did not produce zero. The following command however produces zero

subs(a=n,-x^(a)+x^n);

How to do this operation using assumptions. How to inform Maple to assume that a=n.

## Verifying positiveness...

Hi,

how can I check in maple if my variable P is positive (always or only for some certain conditions)

with assumptions

a>0,b>0,c>0,d>0,e>0,f>0,g>0 and a>c,e,g

I need to prove that P is always positive with that assumptions, how?

## Problem with solve command...

Hi,

I am designing a power transformer using Maple, and I am trying to solve for the minimum number of turns around my core for the desired effect. The equations to solve include numbers of turns (must be positive integers) and other constraints (positive floats).

To validate my worksheet, I am beta-testing it on an existing transformer, so I know of at least one solution that works. But when I submit the equations to Maple, it can't find the solution I know with integer solutions.

The equation is :

SOL := `assuming`([solve({N__2/N__1 = m__t, k__c*L__L(g__ap*Unit('m'), N__1)*I__M__pk = (1/2)*V__sec*T__res/m__t, g__ap <= 2*10^(-3), B__max(g__ap*Unit('m'), N__1, I__M__pk) <= B__max__core}, {N__1, N__2, g__ap, I__M__pk}, UseAssumptions)], [N__1::posint, N__2::posint, g__ap::positive])

{N__1 = 7.701193685, N__2 = 12.50000000*N__1, I__M__pk = (-1.855203719*10^9*g__ap^2+1.523613883*10^11*g__ap+5.590656409*10^6)*Unit('A')/(5.000000*10^6+2.43902439*10^8*g__ap), I__M__pk = (-1.100291349*10^11*g__ap^2+9.036307746*10^12*g__ap+3.315727980*10^8)*Unit('A')/(N__1^2*(5.000000*10^6+2.43902439*10^8*g__ap)), g__ap <= 0.2000000000e-2, 0. < g__ap}

Except I know there is a solution with N__1 = 6 and N_82 = 75. If I force n__1:=75 and solve again for the other variables, the solution is OK :

X := `assuming`([solve({N__2/N__1 = m__t, k__c*L__L(g__ap*Unit('m'), N__1)*I__M__pk = (1/2)*V__sec*T__res/m__t, g__ap <= 2*10^(-3), B__max(g__ap*Unit('m'), N__1, I__M__pk) <= B__max__core}, {N__2, g__ap, I__M__pk}, UseAssumptions)], [N__2::posint, g__ap::positive])

X := {N__2 = 75., I__M__pk = -0.3759328777e-1*Unit('Wb')*(8.130081300*10^10*g__ap^2-6.676951220*10^12*g__ap-2.45000000*10^8)/(Unit('H')*(5.000000*10^6+2.43902439*10^8*g__ap)), g__ap <= 0.2000000000e-2, 0. < g__ap}

I am a bit puzzled about why Maple doesn't find this solution...

Thank you very much for your help.

## Problem with integral...

After manually working out answer for problem 4-4 in Mathews & Walker's Mathematical Methods of Physics , I tried to check my solution with maple2015. Briefly the problem involves inputs periodic with period T, being transformed into outputs, through a kernal G.  The net result is that all input frequencies omega periodic in T are multiplied by (omega_0/omega)^2, except for constant frequency which transforms to zero.  The problem asks to evaluate the kernal G.

Maple2015 correctly evaluated the integral for a constant input, a cosine input, and a sine input, but gave undefined when I tried an exponential(i*x) input which is just a linear combination of the two previous inputs.  I found this interesting because the integral is finite, well defined, and only has an absolute function (in the kernal), which may cause Maple problems, as it correctly evaluated integral when I split it into two regions.  Interestingly if instead of working with a period of T, I used 2*pi, and redfined my G function accordingly, Maple evaluated the exp input integral without any problems.  So the problem appears to be with the T variable, but I correctly used assumptions of T>0, and 0<t<T, so I am not sure why it would work correctly when I use T=2*pi, but failed when using a general period T.  Any help would be welcome.

 >
 >
 >
 >
 Originally T, renamed T~:   Involved in the following expressions with properties     T-t assumed RealRange(Open(0),infinity)   is assumed to be: real   also used in the following assumed objects   [T-t] assumed RealRange(Open(0),infinity)
 >
 Originally t, renamed t~:   Involved in the following expressions with properties     T-t assumed RealRange(Open(0),infinity)   is assumed to be: RealRange(Open(0),infinity)   also used in the following assumed objects   [T-t] assumed RealRange(Open(0),infinity)
 >
 >
 Originally n, renamed n~:   is assumed to be: AndProp(integer,RealRange(1,infinity))
 >
 (1)
 >
 (2)
 >
 (3)
 >
 (4)
 >
 (5)
 >
 (6)
 >
 (7)
 >
 >
 (8)
 >
 (9)

## Calculation takes long time...

I am currently trying to solve a geometric problem where I have to calculate angles in two connected four bar linkages parallel to a serial chain of rotatory joints (closed-loop kinematic chain).

The angle is calculated with

> alpha:=arctan(exp_y, exp_x):

The expressions exp_y and exp_x contain long products of sines and cosines of 6 other time-dependant angles, square roots of these products, constant geometric lengths (not time-dependant) and constant geometric angles (not time-dependant).

The lenghts are already assumed positive

` > assume (l1>0): # similar for all lengths l2, l3, ...`

The time dependant angles are defined as

`> qJ_t := Matrix(6, 1, [qJ1(t), qJ2(t), qJ3(t), qJ4(t), qJ5(t), qJ6(t)]): # generalized coordinates of the system in the sense of technical mechanics`

Other assumptions are not set, since the angles can be positive as well as negative.

Calculating this expression takes up to two days on a fast computer. In my opinion this takes much too long compared to other calculations with similar amount of variables (more complex robotic structures).Also, the arctan function does not "calculate" a result, it just writes down "arctan(...)".

Is there a way to speed up this calculation e.g. by using more assumptions?

On the arctan help page, the examples suggest that Maple is trying to already simplify the solution e.g. by drawing Pi out of the solution.

## Remove Assumptions ...

I am having trouble removing assumptions that are stored within expresssions.

Example code:

`assume(l1>0): # this assumptions later helps to find a solution for a geometric problem with two four-bar-linkages`
`a := sqrt(l1);`
`save a, "test.m";`
`restart;`
`read "test.m"`
`a; # the assumptions are stored within the saved data`
`l1:='l1'; # try to remove the assumption`
`a; # assumption in a still existing`
`subs({l1=2}, a); # nothing happens: I can not access l1 any more`
`subs({l1~=2}, a); # This does not work either, nothing changes in a`

So my question is: How do I remove the assumption within a stored expression?

My main problem lies in the handling of the expression with assumptions. At some point, I want to generate Matlab code, and the codegen-command gives me:

Warning, the following variable name replacements were made: l1~ -> cg

## PDE to solve numerically...

I want to solve numerically the PDE:

u_xx + u_yy= = u^{1/2}+(u_x)^2/(u)^{3/2}

My assumptions are that  |sqrt(2)u_x/u|<<1 (but I cannot neglect the first term since its in my first order approximation of another PDE.

So I tried solving by using pdsolve in maple, but to no cigar.

Here's the maple file:

 >
 >

## a few integrals in Maple...

Trying a few integrals in Maple -- doesn't seem to handle them very well. Any workarounds please?

f1(p,b):= 1/(p^2 + b^2)^2 ;

f2(p,b):= exp(-p/b)^2;

T1pbm := Int(q*f1(q, b)*ln((p+q)^2+m^2), q = 0 .. infinity);

T2pbm := Int(q*f1(q, b)*ln((p-q)^2+m^2), q = 0 .. infinity);

with(IntegrationTools):

PT1 := evalf(Parts(T1pbm, q*f1(q, b), ln((p+q)^2+m^2)));

PT2 := evalf(Parts(T2pbm, q*f1(q, b), ln((p-q)^2+m^2)));

Ev := evalf(-pi*c*Int*(p*f1(p, b)*(PT1-PT2), p = 0 .. infinity))

## Solve a symbolic inequality...

Hello every one,

Is any one knows how to solve the following inequality with assumptions that all parameters are real positive and k<1 and delta > c*alpha

(1/2)*((alpha*k^2-3*alpha*k-2*beta)*sqrt(delta^2*(k-1)*(k-2)*(c*alpha-delta)^2)-k*delta*(alpha*k^2-3*alpha*k+2*alpha-2*beta)*(c*alpha-delta))/(delta^2*(alpha*k^2-3*alpha*k-2*beta))<0

I tried the following code but it  dosn't make sense:

u:=(1/2)*((alpha*k^2-3*alpha*k-2*beta)*sqrt(delta^2*(k-1)*(k-2)*(c*alpha-delta)^2)-k*delta*(alpha*k^2-3*alpha*k+2*alpha-2*beta)*(c*alpha-delta))/(delta^2*(alpha*k^2-3*alpha*k-2*beta))

solve({u < 0,alpha > 0, beta > 0, c > 0, delta > 0, delta > c*alpha, k > 0, k < 1, })

In fact I want to know under which circumastances the above inequality is negative.

THX

## How to solve a system of equation in the real doma...

What is the best way to solve for the simple equation X^2+y^2=1[m]^2 symbolically for either x or y? I actually have a huge list of equations and want to solve the group but my problem boils down to the issue here where I get two possible solutions though using the assumption one is clearly negative and the assumption used should exclude negative results (see attempt below). Also solve doesn't seem to work with units either...  any ideas? Can I give the variables units in a meaningful way?

--------------------------------------------------------------------------------------------------------------------------

restart;

with(RealDomain);
f := x^2+y^2 = 1;

x^2+y^2 = 1

assume(y > 0)

a := y > 0

y1 = solve(f, y, useassumptions = true)

y1 = (sqrt(-x^2+1), -sqrt(-x^2+1))

y2 = solve({a, f}, y)

y2 = ({y = sqrt(-x^2+1)}, {y = -sqrt(-x^2+1)})

-------------------------------------------------------------------------------------------

Why is y = -sqrt(-x^2+1) a solution?

Also, how do I use units when trying to solve

-------------------------------------------------------------------------------------------

restart;
f := x^2+y^2 = Unit('m')^2;
x^2+y^2 = Unit('m')^2

assume(x > 0);
assume(y > 0);
d = solve(f, y, useassumptions = true);

Error, (in Units:-Standard:-+) the units `m^2` and `1` have incompatible dimensions

---------------------------------------------------------------------------------------------

THANKS!

## Solve taking forever then not finding a solution...

Hi MaplePrime-ers,

I'm using the following piece of code to (i) solve the system of symbolically, so I can (ii) evaluate equations quickly at many points of time.  This works quite well for 4 defined values, but I'm having problems adding a 5th defined value.  Specifically, solve leaves the "solution may be lost" message after taking forever.  As the symbolic solution will be run mulitple times by a optimziation algorithm, I'd ideally like to get the solve time under 2 minutes.  I've attached both executed worksheets.  Is there anything I can do to have solve work as I intend?

This first code snippet achieves what I would like to do Series_noGear.mw:

#Interconnection Equations
eq2[1] := FD_T + EM2_T = 0;
eq2[2] := ICE_T + GEN_T = 0;
eq2[3] := EM2_A + GEN_A + BAT_A = 0;
eq2[4] := -FD_W + EM2_W = 0;
eq2[5] := -ICE_W + GEN_W = 0;
eq2[6] := -EM2_V + GEN_V = 0;
eq2[7] := -EM2_V + BAT_V = 0;

#ICE
eq_c[1] := ICE_mdot_g= ICE_T * ICE_W;

#BAT
eq_c[2] := BAT_V = 271;

#EM2
EM2_ReqPow_eq := (-148.3) + (4.267)*abs(EM2_W) + (12.77)*abs(EM2_T) + (-0.0364)*abs(EM2_W)^2 + ( 1.16)*abs(EM2_W)*abs(EM2_T) + (-0.258)*abs(EM2_T)^2 + ( 0.0001181)*abs(EM2_W)^3 + (-0.0005994)*abs(EM2_W)^2*abs(EM2_T) + ( 0.0001171)*abs(EM2_W)*abs(EM2_T)^2 + (0.001739 )*abs(EM2_T)^3 + (-1.245e-07 )*abs(EM2_W)^4 + ( 1.2e-06)*abs(EM2_W)^3*abs(EM2_T) + ( -1.584e-06)*abs(EM2_W)^2*abs(EM2_T)^2 + ( 4.383e-07)*abs(EM2_W)*abs(EM2_T)^3 + (-2.947e-06)*abs(EM2_T)^4;
eq_c[3] := EM2_P = piecewise( EM2_T * EM2_W = 0, 0, EM2_W*EM2_T < 0,-1 * EM2_ReqPow_eq, EM2_ReqPow_eq);
eq_c[4] := EM2_A = EM2_P/EM2_V;

#GEN
GEN_ReqPow_eq:= (-5.28e-12) + ( 3.849e-14)*abs(GEN_W) + (-71.9)*abs(GEN_T) + (-1.168e-16)*abs(GEN_W)^2 +(1.296)*abs(GEN_W)*abs(GEN_T) + (2.489)*abs(GEN_T)^2 + (1.451e-19)*abs(GEN_W)^3 + (0.0001326)*abs(GEN_W)^2*abs(GEN_T) + (-0.008141)*abs(GEN_W)*abs(GEN_T)^2 + (-0.004539)*abs(GEN_T)^3 +(-6.325e-23)*abs(GEN_W)^4 + (-2.091e-07)*abs(GEN_W)^3*abs(GEN_T) + ( 3.455e-06)*abs(GEN_W)^2*abs(GEN_T)^2 + ( 2.499e-05)*abs(GEN_W)*abs(GEN_T)^3 + (-5.321e-05)*abs(GEN_T)^4;

eq_c[5] := GEN_P = piecewise(GEN_T * GEN_W = 0, 0, GEN_W*GEN_T < 0,-1 * GEN_ReqPow_eq, GEN_ReqPow_eq);
eq_c[6] := GEN_A = GEN_P/GEN_V;

#assumptions
assume(BAT_V::nonnegative);
assume(FD_W::nonnegative);

termeqs := {eq_c[1],eq_c[2],eq_c[3],eq_c[4],eq_c[5],eq_c[6]};

sys_eqs2 := termeqs union convert(eq2,set);

drivers2:= {ICE_T,ICE_W,FD_T,FD_W};
symvarnames2:=select(type,indets(convert(sys_eqs2,list)),name);
notdrivers2:=symvarnames2 minus drivers2;

sol2:=solve(sys_eqs2,notdrivers2) assuming real;

symb_sol2:=unapply(sol2,[drivers2[]]);

symb_sol2(1,2,3,5);

#Enumerate (there will generally be about 40, not 3)

count := 0;
for i1 from 1 to 3 do
for i2 from 1 to 3 do
for i3 from 1 to 3 do
for i4 from 1 to 3 do
count := count + 1;
solsol2(count) := symb_sol2(i1,i2,i3,i4);
od;
od;
od;
od;
count;

This second code snippet includes the changes in bold, which make solve take forever Series_addGear.mw:

#Interconnection Equations
eq2[1] := FD_T + EM2_T = 0;
eq2[2] := ICE_T + GBb_T = 0;
eq2[3] := EM2_A + GEN_A + BAT_A = 0;
eq2[4] := -FD_W + EM2_W = 0;
eq2[5] := -ICE_W + GBb_W = 0;
eq2[6] := -EM2_V + GEN_V = 0;
eq2[7] := -EM2_V + BAT_V = 0;
eq2[8] := GBa_T + GEN_T = 0;
eq2[9] := -GBa_W + GEN_W = 0;

#ICE
eq_c[1] := ICE_mdot_g= ICE_T * ICE_W;

#BAT
eq_c[2] := BAT_V = 271;

#EM2
EM2_ReqPow_eq := (-148.3) + (4.267)*abs(EM2_W) + (12.77)*abs(EM2_T) + (-0.0364)*abs(EM2_W)^2 + ( 1.16)*abs(EM2_W)*abs(EM2_T) + (-0.258)*abs(EM2_T)^2 + ( 0.0001181)*abs(EM2_W)^3 + (-0.0005994)*abs(EM2_W)^2*abs(EM2_T) + ( 0.0001171)*abs(EM2_W)*abs(EM2_T)^2 + (0.001739 )*abs(EM2_T)^3 + (-1.245e-07 )*abs(EM2_W)^4 + ( 1.2e-06)*abs(EM2_W)^3*abs(EM2_T) + ( -1.584e-06)*abs(EM2_W)^2*abs(EM2_T)^2 + ( 4.383e-07)*abs(EM2_W)*abs(EM2_T)^3 + (-2.947e-06)*abs(EM2_T)^4;
eq_c[3] := EM2_P = piecewise( EM2_T * EM2_W = 0, 0, EM2_W*EM2_T < 0,-1 * EM2_ReqPow_eq, EM2_ReqPow_eq);
eq_c[4] := EM2_A = EM2_P/EM2_V;

#GEN
GEN_ReqPow_eq:= (-5.28e-12) + ( 3.849e-14)*abs(GEN_W) + (-71.9)*abs(GEN_T) + (-1.168e-16)*abs(GEN_W)^2 +(1.296)*abs(GEN_W)*abs(GEN_T) + (2.489)*abs(GEN_T)^2 + (1.451e-19)*abs(GEN_W)^3 + (0.0001326)*abs(GEN_W)^2*abs(GEN_T) + (-0.008141)*abs(GEN_W)*abs(GEN_T)^2 + (-0.004539)*abs(GEN_T)^3 +(-6.325e-23)*abs(GEN_W)^4 + (-2.091e-07)*abs(GEN_W)^3*abs(GEN_T) + ( 3.455e-06)*abs(GEN_W)^2*abs(GEN_T)^2 + ( 2.499e-05)*abs(GEN_W)*abs(GEN_T)^3 + (-5.321e-05)*abs(GEN_T)^4;

eq_c[5] := GEN_P = piecewise(GEN_T * GEN_W = 0, 0, GEN_W*GEN_T < 0,-1 * GEN_ReqPow_eq, GEN_ReqPow_eq);
eq_c[6] := GEN_A = GEN_P/GEN_V;

#GB
eq_c[7] := GBb_T = -1/GB_R * GBa_T;
eq_c[8] := GBb_W = GB_R * GBa_W;

assume(BAT_V::nonnegative);
assume(FD_W::nonnegative);
assume(GB_R::nonnegative);

termeqs := {eq_c[1],eq_c[2],eq_c[3],eq_c[4],eq_c[5],eq_c[6],eq_c[7],eq_c[8]};

sys_eqs2 := termeqs union convert(eq2,set);

drivers2:= {GB_R,ICE_T,ICE_W,FD_T,FD_W};
symvarnames2:=select(type,indets(convert(sys_eqs2,list)),name);
notdrivers2:=symvarnames2 minus drivers2;

sol2:=solve(sys_eqs2,notdrivers2) assuming real;

symb_sol2:=unapply(sol2,[drivers2[]]);

Does assume make solve work faster, or just complicate things?  Any help is greatly appreciated!

Series_noGear.mw

## How to solve this system of equations with Maple?...

I am trying to solve a system of equations with Maple 16, but it keeps returning an error message. I have the following very simple code:

_________________________________________

assume(lambda > 0);
assume(kappa > 0);
assume(omega > 0);

assume(a >= 0);
assume(alpha, 'real');
assume(b >= 0);
assume(beta, 'real');
assume(m >= 0);
assume(mu, 'real');
assume(n >= 0);
assume(nu, 'real');
assume(t >= 0);
assume(tau, 'real');
assume(p >= 0);
assume(psi, 'real');
assume(d >= 0);
assume(delta, 'real');
assume(r >= 0);
assume(rho, 'real');
assume(x >= 0);
assume(xi, 'real');

solve({d^2*lambda^2+r^2*kappa^2+(x^2-1)*omega^2 = 0, (a^2-1)*lambda^2+m^2*kappa^2+t^2*omega^2 = 0, a*exp(-I*alpha)*b*exp(I*beta)*lambda^2+m*exp(-I*mu)*n*exp(I*nu)*kappa^2+t*exp(-I*tau)*p*exp(I*psi)*omega^2 = 0, a*exp(-I*alpha)*d*exp(I*delta)*lambda^2+m*exp(-I*mu)*r*exp(I*rho)*kappa^2+t*exp(-I*tau)*x*exp(I*xi)*omega^2 = 0, b*exp(-I*beta)*d*exp(I*delta)*lambda^2+n*exp(-I*nu)*r*exp(I*rho)*kappa^2+p*exp(-I*psi)*x*exp(I*xi)*omega^2 = 0}, {a, b, d, m, mu, n, nu, p, psi, r, rho, t, tau, x, xi, alpha, beta, delta}, useassumptions, maxsols = 10)

_________________________________________

When this piece of code is executed, I receive the following error message:

Error, (in Engine:-Tarjan) invalid input: subs received {0 <= x_8, 0 <= x_10, 0 <= x_12}, which is not valid for its 1st argument

What does this mean? How can I find solutions to this system of equations? (I know that there exists at least one solution, and I am figuring out whether there exist more.)

Any help would be greatly appreciated.

 1 2 Page 1 of 2
﻿