Difference between revisions of "Maple/Simultaneous Equations"

From PrattWiki
Jump to navigation Jump to search
(Solve Equations)
 
(15 intermediate revisions by the same user not shown)
Line 2: Line 2:
 
This page focuses on using Maple to find both the symbolic and the numeric solutions to equations obtained from electric circuits.  It assumes that you have already taken the steps in [[Maple/Initialization and Documentation]] to start Maple and begin documenting your work.
 
This page focuses on using Maple to find both the symbolic and the numeric solutions to equations obtained from electric circuits.  It assumes that you have already taken the steps in [[Maple/Initialization and Documentation]] to start Maple and begin documenting your work.
  
==Defining Variables and Equations==
+
== Very Basic Example ==
 +
The example code below assumes you are running a worksheet in Maple. There is a finished example at the end of this section. Imagine you have the equation $$ax=d$$ and you want to solve for $$x$$. You can do this in Maple as follows:
 +
 
 +
=== Initialization ===
 +
You are not explicitly required to include the <code>restart</code> command in a worksheet, but it does help if you end up making edits later and need to re-run everything from scratch.  Go ahead and put
 +
<syntaxhighlight>
 +
restart
 +
</syntaxhighlight>
 +
as the first executable in your worksheet.
 +
 
 +
=== Define Equations ===
 
In Maple, the way you define a variable is by typing the name of the
 
In Maple, the way you define a variable is by typing the name of the
 
variable, followed by the symbols ''':=''', followed by whatever items
 
variable, followed by the symbols ''':=''', followed by whatever items
 
you want to store in the variable.  Note the importance of the colon
 
you want to store in the variable.  Note the importance of the colon
directly in front of the equals sign - without it, Maple will ''not'' assign a value to a variable but will merely print out the
+
directly in front of the equals sign - without it, Maple will ''not'' assign a value to a variable but will merely print out the equation you typed.
equation you typed.
 
 
One benefit of this is you can define variables to hold on to
 
One benefit of this is you can define variables to hold on to
 
equations and then use those variables later, in concert with Maple's
 
equations and then use those variables later, in concert with Maple's
solver, to get answers for the unknowns.  Let us assume that we want to
+
solver, to get answers for the unknowns.  Given that, we will define a variable <code>eqn1</code> to store the equation $$ax=d$$:
 +
<syntaxhighlight>
 +
eqn1:=a*x=d
 +
</syntaxhighlight>
 +
 
 +
=== Solve Equations ===
 +
The easiest way to solve an equation (or a system of equations) is to use the <code>solve</code> command.  The most formal, and flexible, way to use this command is to give it a set of equations (surrounded by curly brackets) and a list of variables (surrounded by square brackets).  The result will be an expression, set of expressions, list of expressions, or list of list of expressions depending on the nature and number of the equations and the solutions.  For example, if you add the code:
 +
<syntaxhighlight>
 +
soln1 := solve({eqn1}, [x])
 +
</syntaxhighlight>
 +
then Maple will produce a variable called <code>soln1</code> that has a list with a list with an expression; specifically, $$soln1 := [[x = \frac{d}{a}]]$$
 +
 
 +
=== Make Substitutions ===
 +
Now that you have symbolic answers, you can make numerical substitutions for those symbols using the <code>subs</code> command.  The subs command expects a series of equalities to define the substitutions followed by a single item into which to make those substitutions.  For example, to see what x is when d is 10, you can write:
 +
<syntaxhighlight>
 +
subs(d = 10, soln1)
 +
</syntaxhighlight>
 +
and you will get the new list of lists $$[[x = \frac{10}{a}]]$$.  If you want to see multiple substitutions, you can put them all at the start of the soln command:
 +
<syntaxhighlight>
 +
subs(a=3, d = 10, soln1)
 +
</syntaxhighlight>
 +
will give $$[[x = \frac{10}{3}]]$$
 +
 
 +
=== Full Example ===
 +
[https://maple.cloud/app/6117497218662400/VeryBasicLA VeryBasicLA.mw] on MapleCloud
 +
 
 +
== More Complicated Example ==
 +
Let us now assume that we want to
 
solve the following equations:
 
solve the following equations:
 
<center><math>
 
<center><math>
Line 20: Line 56:
 
</math></center>
 
</math></center>
 
where ''x'', ''y'', and ''z'' are unknowns, ''a'' through ''i'' are known
 
where ''x'', ''y'', and ''z'' are unknowns, ''a'' through ''i'' are known
coefficients, and ''j'' through ''l'' are known variables.  To teach
+
coefficients, and ''j'' through ''l'' are known variables.  There is a finished example at the end of this section.
Maple about these equations, you would create three variables, each
+
=== Initialization ===
holding on to one of the equationsAt the prompt, type:
+
Go ahead and put
 +
<syntaxhighlight>
 +
restart
 +
</syntaxhighlight>
 +
as the first executable in your worksheet.
 +
 
 +
=== Define Equations ===
 +
Now there are three different equations to store; you could store all three in a single variable containing a set or you could define three variables and then include them in a set in a solve commandWe will do the latter, so at the prompt, type:
 
<source lang=text>
 
<source lang=text>
 
eqn1:=a*x+b*y+c*z=j
 
eqn1:=a*x+b*y+c*z=j
Line 30: Line 73:
 
Note that each time you hit return to go to the next line, Maple
 
Note that each time you hit return to go to the next line, Maple
 
processes your input and reports back what it has done.  It will also
 
processes your input and reports back what it has done.  It will also
number the outputs for you so you can refer to them later.
+
number the outputs for you so you can refer to them later. As an aside, if you try to copy and paste this whole block, when you hit return, you will get a parsing error.  Maple is trying to interpret the whole group as one long string of code and gets confused at the end of the first equation.  To fix this, if you copy and paste multiple lines of codes, you can end them with a semi-colon:
At this point, Maple now has three variables, each of
+
<source lang=text>
which defined as an equation.  It is perfectly happy having undefined
+
eqn1:=a*x+b*y+c*z=j;
items in the equations.
+
eqn2:=d*x+e*y+f*z=k;
 +
eqn3:=g*x+h*y+i*z=l;
 +
</source>
 +
The three lines will now be in a single execution group and all three will run when you hit return at the end of that line.
 +
 
 +
Whichever way you entered and ran the code, at this point, Maple now has three variables, each of which defined as an equation.  It is perfectly happy having undefined items in the equations.  Note that in Maple the complex number $$\sqrt{-1}$$ is given with a capital $$I$$; you must avoid using $$I$$ as a variable in Maple.  We are using lower case $$i$$, which is fine.
  
==Solving Equations With Maple==
+
===Solve Equations With Maple===
To solve the equations, all you need to do is use Maple's built in
+
Now we just need to give the <code>solve</code> command a set of equations and a list of variablesNote that you need to give a complete list of the unknowns for a system even if yuo are only looking for the value of one of themThat is to say, even if we are just trying to solve $$x$$, we still need to let Maple know that $$x$$, $$y$$, and $$z$$ are the unknowns -- anything '''not''' listed as an unknown variable is considered known, and thus a system can become overconstrained and not have a solution.  Add the line:
'''solve''' functionOne of the best ways to use the '''solve'''
 
function is to give it a list of the equations and an array of items
 
for which to solveIn the equations above, for example, there are
 
three equations with a total of fifteen symbols - we need to tell
 
Maple which ones are unknown and it will assume that the others are
 
known.  Add the line:
 
 
<source lang=text>
 
<source lang=text>
solve({eqn1, eqn2, eqn3}, [x, y, z])
+
soln1:=solve({eqn1, eqn2, eqn3}, [x, y, z])
 
</source>
 
</source>
and note that the equations are bracketed with curly braces while the
+
Hit return, and you will once again note that Maple produces a list of lists of expressions for the solution.  
unknowns are in a list set off with square brackets.  Hit return, and
+
 
you will note that Maple produces a list - set off with double
+
As an aside, if we had not included the variable list and
brackets - containing the answers for ''x'', ''y'', and ''z'' in terms of
 
the other variables. If we had not included the variable list and
 
 
instead had asked
 
instead had asked
 
<source lang=text>
 
<source lang=text>
solve({eqn1, eqn2, eqn3})
+
soln2:=solve({eqn1, eqn2, eqn3})
 
</source>
 
</source>
 
Maple would have given all possible combinations of all 15 symbols that
 
Maple would have given all possible combinations of all 15 symbols that
Line 59: Line 99:
 
''x'' to work with as an unknown by typing:
 
''x'' to work with as an unknown by typing:
 
<source lang=text>
 
<source lang=text>
solve({eqn1, eqn2, eqn3}, [x])
+
soln3:=solve({eqn1, eqn2, eqn3}, [x])
 
</source>
 
</source>
the answer would come back as empty because no value
+
the answer would come back as an empty list empty because no value
of ''x'' satisfies the three equations for arbitrary values of the other
+
of ''x'' satisfies the three equations for arbitrary values of the other 14 variables.
14 variables.
 
  
In order to use these solutions, you should give them a name.  Click
+
=== Make Substitutions ===
at the start of the '''solve''' line and pre-pend it with '''MySoln:=''' so it resembles:
+
Now that you have the symbolic answers to the variables ''x'', ''y'', and ''z'', you may want to substitute the actual coefficient values to
<source lang=text>
+
obtain a numerical solution.  In the simple example above we put the substitution expressions directly into the <code>subs</code>command.  Given that we may want to re-use those expressions, or that we may have multiple sets of substitutions, another way to use the <code>subs</code> command is to generate a list
MySoln:=solve({eqn1, eqn2, eqn3}, [x, y, z])
+
of the known values then tell Maple to substitute in the numerical
</source>
+
values.  Add the following
This will assign the solution list to a variable that we can use
 
later.
 
 
 
==Substituting Values==
 
Now that you have the symbolic answers to the variables ''x'', ''y'', and
 
''z'', you may want to substitute the actual coefficient values to
 
obtain a numerical solution.  One way to do this is to generate a list
 
of the known values, then tell Maple to substitute in the numerical
 
values by using the built-in '''subs''' command.  Add the following
 
 
lines of code:
 
lines of code:
 
<source lang=text>
 
<source lang=text>
Vals := {a=-1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10, k=11, l=12}
+
Vals := a=-1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10, k=11, l=12
subs(Vals, MySoln)
+
subs(Vals, soln1)
 
</source>
 
</source>
The list in '''MySoln''' will now be shown with numerical values
+
Remember if you cut and paste these into a single group you will need to add a semi-colon after the first line or else you will get a parsing error.
instead of symbols.  Note that you have ''not'' made any actual
+
The list of lists in <code>soln1</code> will now be shown with numerical valuesinstead of symbols.  Note that you have ''not'' made any actual changes to any of the variables - you have just asked Maple to show you what they would look like given the particular substitutions presented in '''Vals'''.  This is a very powerful tool, since you can substitute in a variety of values to see how one or more parameters influence a particular variable or variables.
changes to any of the variables - you have just asked Maple to show
 
you what they would look like given the particular substitutions
 
presented in '''Vals'''.  This is a very powerful tool, since you can
 
substitute in a variety of values to see how one or more parameters
 
influence a particular variable or variables.
 
  
'''Note:''' unlike MATLAB, Maple defines <math>\sqrt{-1}</math> as an upper-case <code>I</code> instead of lower case <code>i</code>.  You should therefore avoid re-defining <code>I</code> in Maple; using the lower case version as a variable is perfectly fine.
 
  
 
<!--
 
<!--
Line 131: Line 155:
 
</source>
 
</source>
 
-->
 
-->
 +
=== Full Example ===
 +
[https://maple.cloud/app/4991629096255488/More+Complicated+LA MoreComplicatedLA.mw] on MapleCloud; note this includes code from the following two sections as well.
  
===Multiple and Dependent Substitution Lists===
+
==Multiple and Dependent Substitution Lists==
 
If you have several sets of equations you want to use for substitution
 
If you have several sets of equations you want to use for substitution
 
- including some which are dependent on values set in other equations,
 
- including some which are dependent on values set in other equations,
Line 158: Line 184:
 
To get ''m'' in terms of ''r'', ''s'', ''t'', and ''u'', you could write:
 
To get ''m'' in terms of ''r'', ''s'', ''t'', and ''u'', you could write:
 
<source lang=text>
 
<source lang=text>
MyEqn:=m=p+q;
+
eqn1:=m=p+q;
SubsList1:=p=r*s, q=t-u;
+
sublist1:=p=r*s, q=t-u;
subs(SubsList1, MyEqn);
+
subs(sublist1, eqn1);
 
</source>
 
</source>
 
If you want to get ''m'''s numerical value, you must ''first'' get ''m''
 
If you want to get ''m'''s numerical value, you must ''first'' get ''m''
Line 166: Line 192:
 
in the numbers for those variables.  Specifically:
 
in the numbers for those variables.  Specifically:
 
<source lang=text>
 
<source lang=text>
MyEqn:=m=p+q;
+
eqn1:=m=p+q;
SubsList1:=p=r*s, q=t-u;
+
sublist1:=p=r*s, q=t-u;
SubsList2:=r=1, s=2, t=3, u=4;
+
sublist2:=r=1, s=2, t=3, u=4;
subs(SubsList1, SubsList2, MyEqn);
+
subs(sublist1, sublist2, eqn1);
 
</source>
 
</source>
 +
This will show $$m=1$$; again, Maple has not made the variable $$m$$ equal to the number 1, it is just showing what things would be ilke if the substitutions were made.
  
 
Putting the equations in the wrong order will end up yielding an
 
Putting the equations in the wrong order will end up yielding an
answer that is still in terms of  ''r'', ''s'', ''t'', and ''u''.  The reason
+
answer that is still in terms of  ''r'', ''s'', ''t'', and ''u''.  The reason is that <code>subs</code> ''only'' makes substitutions into the last entry in the argument list. <code>
is that <code>subs</code> ''only'' makes substitutions into the last entry
+
subs(sublist2, sublist2, eqn1);</code> will yield $$m=rs+t-u$$.
in the argument list.
 
  
 +
== Extracting Expressions from Lists (or Lists of Lists) ==
 
Sometimes, you will need to take equations out of a set of brackets to
 
Sometimes, you will need to take equations out of a set of brackets to
use them.  For example, assume that you have some
+
use them.  For example, assume that you are looking back at the worksheet where you solved three linear algebra equations for $$x$$, $$y$$, and $$z$$.  Imagine you have some
variable you want to calculate called </code>alpha</code>, which has a formula
+
variables you want to calculate called </code>alpha</code> and <code>beta</code>, which has formulas
 
of:
 
of:
 
<center><math>
 
<center><math>
 
\begin{align}
 
\begin{align}
\alpha&=x+y+z
+
\alpha&=x+y+z\\
 +
\beta&=y*z
 
\end{align}
 
\end{align}
 
</math></center>
 
</math></center>
You can put in the solutions for ''x'', ''y'', and ''z'' to get <code>alpha</code>  
+
You can put in the solutions for ''x'', ''y'', and ''z'' to get <code>alpha</code> and <code>beta</code>  
 
in terms of those characters.  What makes
 
in terms of those characters.  What makes
 
this a bit difficult is that <code>MySoln</code> is given as a
 
this a bit difficult is that <code>MySoln</code> is given as a
 
single-row matrix and <code>subs</code> just wants the equations
 
single-row matrix and <code>subs</code> just wants the equations
themselves.  To extract only the equations, you can write:
+
themselves.  If you just type <code>soln1</code> in the worksheet, you will get a list of lists.  To extract only the expressions, you can write:
 +
<source lang=text>
 +
soln1[][]
 +
</source>
 +
and you will instead see a comma-separated collecting of expressions without any brackets.  The default index for a list is '''everything''' - you could also write
 
<source lang=text>
 
<source lang=text>
subs(MySoln[1][], Vals, ThingToSubInFor)
+
soln1[1][]
 
</source>
 
</source>
Go ahead and add the line
+
here and that would grab the first inner list and then all the items from that inner list (Maple is 1-indexed, similar to MATLAB and different from Python).
 +
 
 +
In the worksheet where you solved for the three equations, go ahead and add the lines
 
<source lang=text>
 
<source lang=text>
subs(MySoln[1][], Vals, alpha)
+
aux1:=alpha=x+y+z
 +
aux2:=beta=y*x
 +
subs(soln1[1][], {aux1, aux2})
 
</source>
 
</source>
to the end of your worksheet.
+
to the end of your worksheet.  Note that since we want all the substitutions to go into two different items, those items are collected in a set with curly brackets; you can also collect them in a list if you would like.  The rest of this command will be a set (or list) showing your auxiliary equations using the symbols solved for in <code>soln1</code>.
  
 +
Now imagine you want the numerical values for $$\alpha$$ and $$\beta$$ based on the symbolic solutions in <code>soln1</code> and the numerical values in <code>vals</code>. 
 
Again - the order is important - you need to first substitute in the
 
Again - the order is important - you need to first substitute in the
 
equations for the variables higher in the dependency list, ''then'' give values to the
 
equations for the variables higher in the dependency list, ''then'' give values to the
 
known quantities, then substitute all that into whatever is in the
 
known quantities, then substitute all that into whatever is in the
final argument of <code>subs</code>.  
+
final argument of <code>subs</code>. If you try <code>subs(vals, soln1[1][], {aux1, aux2})</code> you will not see any changes - the <code>vals</code> list will not find any of $$a$$ through $$l$$ in the auxiliary equations because those substitutions have not happened yet.  On the other hand, if you run <code>subs(vals, soln1[1][], {aux1, aux2})</code> you will get numerical values for $$\alpha$$ and $$\beta$$.
Run the entire script and make sure that <math>\alpha</math> is
 
<math>\frac{1}{3}</math> when everything gets substituted in.
 
  
 
==Cleaning Things Up==
 
==Cleaning Things Up==
Line 215: Line 250:
 
decimal digits to use.  For example,   
 
decimal digits to use.  For example,   
 
<source lang=text>
 
<source lang=text>
simplify(expand(alpha))
+
simplify(expand(thing))
 
</source>
 
</source>
will produce the most symbolically simplified version of <math>\alpha</math> while
+
will produce the most symbolically simplified version of a thing while
 
<source lang=text>
 
<source lang=text>
evalf[8](subs(Vals, alpha))
+
evalf[8](thing)
 
</source>
 
</source>
will produce a floating point result for <math>\alpha</math>.  With practice, you
+
will produce a floating point result for thing.  With practice, you
 
will see how best to combine <code>evalf</code>, <code>simplify</code>, and <code>expand</code> to get the form of answer you want.
 
will see how best to combine <code>evalf</code>, <code>simplify</code>, and <code>expand</code> to get the form of answer you want.
  

Latest revision as of 23:32, 13 January 2024

Introduction

This page focuses on using Maple to find both the symbolic and the numeric solutions to equations obtained from electric circuits. It assumes that you have already taken the steps in Maple/Initialization and Documentation to start Maple and begin documenting your work.

Very Basic Example

The example code below assumes you are running a worksheet in Maple. There is a finished example at the end of this section. Imagine you have the equation $$ax=d$$ and you want to solve for $$x$$. You can do this in Maple as follows:

Initialization

You are not explicitly required to include the restart command in a worksheet, but it does help if you end up making edits later and need to re-run everything from scratch. Go ahead and put

restart

as the first executable in your worksheet.

Define Equations

In Maple, the way you define a variable is by typing the name of the variable, followed by the symbols :=, followed by whatever items you want to store in the variable. Note the importance of the colon directly in front of the equals sign - without it, Maple will not assign a value to a variable but will merely print out the equation you typed. One benefit of this is you can define variables to hold on to equations and then use those variables later, in concert with Maple's solver, to get answers for the unknowns. Given that, we will define a variable eqn1 to store the equation $$ax=d$$:

eqn1:=a*x=d

Solve Equations

The easiest way to solve an equation (or a system of equations) is to use the solve command. The most formal, and flexible, way to use this command is to give it a set of equations (surrounded by curly brackets) and a list of variables (surrounded by square brackets). The result will be an expression, set of expressions, list of expressions, or list of list of expressions depending on the nature and number of the equations and the solutions. For example, if you add the code:

soln1 := solve({eqn1}, [x])

then Maple will produce a variable called soln1 that has a list with a list with an expression; specifically, $$soln1 := [[x = \frac{d}{a}]]$$

Make Substitutions

Now that you have symbolic answers, you can make numerical substitutions for those symbols using the subs command. The subs command expects a series of equalities to define the substitutions followed by a single item into which to make those substitutions. For example, to see what x is when d is 10, you can write:

subs(d = 10, soln1)

and you will get the new list of lists $$[[x = \frac{10}{a}]]$$. If you want to see multiple substitutions, you can put them all at the start of the soln command:

subs(a=3, d = 10, soln1)

will give $$[[x = \frac{10}{3}]]$$

Full Example

VeryBasicLA.mw on MapleCloud

More Complicated Example

Let us now assume that we want to solve the following equations:

\( \begin{align} ax+by+cz&=j\\ dx+ey+fz&=k\\ gx+hy+iz&=l \end{align} \)

where x, y, and z are unknowns, a through i are known coefficients, and j through l are known variables. There is a finished example at the end of this section.

Initialization

Go ahead and put

restart

as the first executable in your worksheet.

Define Equations

Now there are three different equations to store; you could store all three in a single variable containing a set or you could define three variables and then include them in a set in a solve command. We will do the latter, so at the prompt, type:

eqn1:=a*x+b*y+c*z=j
eqn2:=d*x+e*y+f*z=k
eqn3:=g*x+h*y+i*z=l

Note that each time you hit return to go to the next line, Maple processes your input and reports back what it has done. It will also number the outputs for you so you can refer to them later. As an aside, if you try to copy and paste this whole block, when you hit return, you will get a parsing error. Maple is trying to interpret the whole group as one long string of code and gets confused at the end of the first equation. To fix this, if you copy and paste multiple lines of codes, you can end them with a semi-colon:

eqn1:=a*x+b*y+c*z=j;
eqn2:=d*x+e*y+f*z=k;
eqn3:=g*x+h*y+i*z=l;

The three lines will now be in a single execution group and all three will run when you hit return at the end of that line.

Whichever way you entered and ran the code, at this point, Maple now has three variables, each of which defined as an equation. It is perfectly happy having undefined items in the equations. Note that in Maple the complex number $$\sqrt{-1}$$ is given with a capital $$I$$; you must avoid using $$I$$ as a variable in Maple. We are using lower case $$i$$, which is fine.

Solve Equations With Maple

Now we just need to give the solve command a set of equations and a list of variables. Note that you need to give a complete list of the unknowns for a system even if yuo are only looking for the value of one of them. That is to say, even if we are just trying to solve $$x$$, we still need to let Maple know that $$x$$, $$y$$, and $$z$$ are the unknowns -- anything not listed as an unknown variable is considered known, and thus a system can become overconstrained and not have a solution. Add the line:

soln1:=solve({eqn1, eqn2, eqn3}, [x, y, z])

Hit return, and you will once again note that Maple produces a list of lists of expressions for the solution.

As an aside, if we had not included the variable list and instead had asked

soln2:=solve({eqn1, eqn2, eqn3})

Maple would have given all possible combinations of all 15 symbols that would satisfy the equations. Conversely, if we had given Maple only x to work with as an unknown by typing:

soln3:=solve({eqn1, eqn2, eqn3}, [x])

the answer would come back as an empty list empty because no value of x satisfies the three equations for arbitrary values of the other 14 variables.

Make Substitutions

Now that you have the symbolic answers to the variables x, y, and z, you may want to substitute the actual coefficient values to obtain a numerical solution. In the simple example above we put the substitution expressions directly into the subscommand. Given that we may want to re-use those expressions, or that we may have multiple sets of substitutions, another way to use the subs command is to generate a list of the known values then tell Maple to substitute in the numerical values. Add the following lines of code:

Vals := a=-1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10, k=11, l=12
subs(Vals, soln1)

Remember if you cut and paste these into a single group you will need to add a semi-colon after the first line or else you will get a parsing error. The list of lists in soln1 will now be shown with numerical valuesinstead of symbols. Note that you have not made any actual changes to any of the variables - you have just asked Maple to show you what they would look like given the particular substitutions presented in Vals. This is a very powerful tool, since you can substitute in a variety of values to see how one or more parameters influence a particular variable or variables.


Full Example

MoreComplicatedLA.mw on MapleCloud; note this includes code from the following two sections as well.

Multiple and Dependent Substitution Lists

If you have several sets of equations you want to use for substitution - including some which are dependent on values set in other equations, you can still use subs -- you just need to be careful about the order of the substitutions. As an example, imagine some variable:

\( \begin{align} m&=p+q \end{align} \)

where

\( \begin{align} p&=r*s\\ q&=t-u \end{align} \)

and

\( \begin{align} r&=1 & t&=3\\ s&=2 & u&=4 \end{align} \)

To get m in terms of r, s, t, and u, you could write:

eqn1:=m=p+q;
sublist1:=p=r*s, q=t-u;
subs(sublist1, eqn1);

If you want to get m's numerical value, you must first get m in terms of r, s, t, and u, and then you can substitute in the numbers for those variables. Specifically:

eqn1:=m=p+q;
sublist1:=p=r*s, q=t-u;
sublist2:=r=1, s=2, t=3, u=4;
subs(sublist1, sublist2, eqn1);

This will show $$m=1$$; again, Maple has not made the variable $$m$$ equal to the number 1, it is just showing what things would be ilke if the substitutions were made.

Putting the equations in the wrong order will end up yielding an answer that is still in terms of r, s, t, and u. The reason is that subs only makes substitutions into the last entry in the argument list. subs(sublist2, sublist2, eqn1); will yield $$m=rs+t-u$$.

Extracting Expressions from Lists (or Lists of Lists)

Sometimes, you will need to take equations out of a set of brackets to use them. For example, assume that you are looking back at the worksheet where you solved three linear algebra equations for $$x$$, $$y$$, and $$z$$. Imagine you have some variables you want to calculate called alpha and beta, which has formulas of:

\( \begin{align} \alpha&=x+y+z\\ \beta&=y*z \end{align} \)

You can put in the solutions for x, y, and z to get alpha and beta in terms of those characters. What makes this a bit difficult is that MySoln is given as a single-row matrix and subs just wants the equations themselves. If you just type soln1 in the worksheet, you will get a list of lists. To extract only the expressions, you can write:

soln1[][]

and you will instead see a comma-separated collecting of expressions without any brackets. The default index for a list is everything - you could also write

soln1[1][]

here and that would grab the first inner list and then all the items from that inner list (Maple is 1-indexed, similar to MATLAB and different from Python).

In the worksheet where you solved for the three equations, go ahead and add the lines

aux1:=alpha=x+y+z
aux2:=beta=y*x
subs(soln1[1][], {aux1, aux2})

to the end of your worksheet. Note that since we want all the substitutions to go into two different items, those items are collected in a set with curly brackets; you can also collect them in a list if you would like. The rest of this command will be a set (or list) showing your auxiliary equations using the symbols solved for in soln1.

Now imagine you want the numerical values for $$\alpha$$ and $$\beta$$ based on the symbolic solutions in soln1 and the numerical values in vals. Again - the order is important - you need to first substitute in the equations for the variables higher in the dependency list, then give values to the known quantities, then substitute all that into whatever is in the final argument of subs. If you try subs(vals, soln1[1][], {aux1, aux2}) you will not see any changes - the vals list will not find any of $$a$$ through $$l$$ in the auxiliary equations because those substitutions have not happened yet. On the other hand, if you run subs(vals, soln1[1][], {aux1, aux2}) you will get numerical values for $$\alpha$$ and $$\beta$$.

Cleaning Things Up

Many times, Maple will produce an expression that is more complicated than it needs to be. To get what it considers to be the simplest form, use the simplify(expand( )) compound function. The expand will take the expression and represent it using as many simple terms as necessary while simplify will recombine them in the most compact form. Finally, to get a decimal value, use the evalf[N]( ) function, where N represents the number of decimal digits to use. For example,

simplify(expand(thing))

will produce the most symbolically simplified version of a thing while

evalf[8](thing)

will produce a floating point result for thing. With practice, you will see how best to combine evalf, simplify, and expand to get the form of answer you want.

Memory Issues

A major issue to consider with Maple is its memory. At the end of the worksheet above, there are several variables that are defined, including x, y, and z. If you go back near the beginning, click in the line where eqn1 is defined, and hit return, you will notice that where x, y, and z were before, their symbolic solutions from much further down the worksheet are being used. This is why the restart command is so helpful - if you need to to run a worksheet again, it is best to always start from scratch. A shortcut for running an entire worksheet is the !!! button at the top of the window.