When using Manipuate, I simplified the equation by removing the occupancy function from the mix and allowing the v[t] and p1[t] be constants rather than functions. Is there a way to reintroduce these easily? I originally thought I could use the code you constructed and then a replace command that would replace v->v[t] and p1->p1[t] but I can't seem to find something that will substitute just portions of an equation. Even after this replacement, I am concerned the code wouldn't work in Manipulate since based off what you have shown me, it seems to be very sensitive to the type of problem I am working on.

EDIT: Using /. (thanks for teaching me about that) I was able to replace what I needed so that the equations read how I want them to (i.e. include the functions p1[t] and v[t] as you define in your earlier code. The issue with using Manipulate to graph them persists however.

Hi Carolyn,

There was an additional problem, and it's somewhat advanced. It has to do with how Plot and Manipulate localize variables. The short solution is that all of the parameters being manipulated should appear explicitly within the Plot expression. I attach this as a notebook.

You should also study the way the result of DSolve is being used to define the functions we want from its output. DSolve outputs rules, and we use these to generate expressions, which are themselves used as the templates for function definitions. And so these templates allow us to define the functions as having their parameters as arguments, as well as the independent variable t.

I'm not usually this helpful ;-). But it is 95 degrees heading for 100 here in the state of Washington. We prefer 65-75. So I'm indoors amusing myself with Mathematica.

Best, David

Attachments:

In the lines after DSolve, you are using == rather than = to define functions. For example:

ffc[t_] == E^(t (-dr + (-1 + 2 p1) v))

Should be

ffc[t_] = E^(t (-dr + (-1 + 2 p1) v)) ( = is short for Set )

Or most often

ffc[t_] := E^(t (-dr + (-1 + 2 p1) v)) ( := is short for SetDelayed)

The difference is that = will evaluate the right hand side before using it as a template to define the function. := defers the evaluation of the RHS until the function is invoked. Unless you know you need to evaluate the RHS, := (SetDelayed) is the usual choice.

== asserts equality in an equation, or tests for equality in a conditional. So none of these actually defined a function.

When you get blank plots there are two good steps to take. The first, and most useful, is to take the expression being plotted, by itself, and use a rule replace to evaluate it at a numerical value. For example, if the independent variable in the expression is x, evaluate expression/.x->10, or some real number in the domain. You need it to return a numerical result, because that's what Plot needs. If it doesn't, you will see what it is in the expression that is preventing evaluation from yielding a number.The second is to make a simple-as-possible plot for the expression, meaning without Manipulate.

So, first rewrite your functions with :=

Then try evaluating the expression you are plotting with a number.

Best,

David

.

Hi Carolyn, I think you saw incorrect code I posted, before I managed to correct it. Sorry for the confusion.

Regarding the check for undefined symbols -- it is actually not necessary. But what I am checking is to see that the equations after the parameters are replaced with numerical values do not contain undefined values. They can contain the functions being solved for ( as some f[t] ) or other functions of independent or dependent variable which will resolve to numerical values. But if there are still symbolic parameters NDSolve will return the system unevaluated. It has to be able to get numerical values as it integrates. This can be seen in any case since these undefined symbols will be in the returned and partially evaluated result, but I often check first since it's easier to read. I am just performing the Replace on the equation set and checking that it's ready for NDSolve. (See below.)

/. is a short form infix operator for Replace.

In[13]:= Replace[x, x -> a]

Out[13]= a

Can be written as

In[15]:= x /. x -> a

Out[15]= a

Mathematica is a great symbolic algebra tool, and I prefer to work in symbols as long as convenient, and use a list of rules to substitute numerical values when I want numerical results, or for functions that require them, like NDSolve.

And since rules can be defined using patterns, and used within function definitions, they are often a convenient and readable way to define functions:

In[16]:= swap[z_] := z /. {x_, y_} -> {y, x}

In[17]:= swap[{a, b}]

Out[17]= {b, a}

It is worth noting that Mathematica is a rules engine. When you evaluate an expression, Mathematica's evaluation engine looks to see if any rule may be applied. Here "rules" are those established by built-in functions or by user definitions made by assignments. If it does, it applies the rule, giving precedence to the most specific. (That's at the heart of the recursive function definition.) After applying the rule, it looks again. And it keeps going until it obtains a result to which no rule applies. That is also why when you give a function and invalid argument it returns unevaluated. It looked, nothing applied, so the main evaluation loop terminates and gives you the first result to which no rule applied -- Which in this case is your input.

You can easily change parameter values in the code above by changing the rule list values. But by using these methods, we can go further with NDSolve. We could define a function which has one or more of the parameter values as arguments, and uses Replace to put them in the equation set before using Replace for the parameter set as a whole. Then we have a function which can be passed an argument and generate a solution set. We could even use the solutions within our function definition to determine values at some time t, and return those values. Then we could, for example, plot some terminal concentrations as a function of one or more parameter values. Complicated function are often defined within a Module.

Mathematica is a bit of a steep learning curve, but once you have it, you have a Swiss Army Knife. It is really worth it. There is a resource I might have mentioned called The Virtual Book which can be found online, or by searching for it in the help system. It's good reading.

Kind regards, David

Ok so if I reformulate them as differential equations, then they can be solved using DSolve as follows:

DSolve[{c'[t] == c[t] (p1*v - (1 - p1) v - dr),
  p'[t] == c[t] (1 - p1) v + p[t] (p1v - (1 - p1) v - dr),
  d'[t] == p[t] (1 - p1) v + d[t] (1 - dr)}, {c, p, d}, t]

How do I proceed from here?

The t[i] is a type and should instead be d[i]. I changed this in the original question. Thanks for catching that. David, your code is much more eloquent than mine; thanks for the lesson recursive functions! I feel like I have a good handle on them but remain confused as to how I should incorporate the second rule, explained at the bottom of my post. Ideally at the end, I would like to be able to input different values for the variables and observe the behavior of the graphs as i changes.

Welcome to Wolfram Community Carolyn !

A few comments / questions:

• You should carefully review the code you posted for typos. At least in the 3rd loop there is missing code in Subscript[dr, ] after coma. Note your code is formatted properly - you know it because you see syntax coloring. Click "Edit" in bottom right corner of your post to correct typos. But keep proper code formatting using the 1st button above or simply starting each code line with 4 spaces.

• What do you mean "there are symbolically" ? That you do not specify values p1, dr, etc. numerically and want formulas in terms of these variables?

• Is there any reference (article, Wikipedia, etc.) to these equations? Perhaps we could find a more efficient way to compute your results.

• Keep in mind you can attach files to posts. Also this is very useful to read if you have not yet.