Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

Given the following equation and rule, how would I Solve the equation for tr, k and c?

eq = T == tr - E^(-k * t)*c;
rule = {t -> {0, 5, 10}, T -> {2000, 1300, 1100}};

eq /. rule results in this, which is almost what I want:

{2000, 1300, 1100} == {tr - c, tr - c/E^(5k), tr - c/E^(10k)}

I would like to get a list of equations instead like so:

{2000 == tr - c, 1300 == tr - c/E^(5k), 1100 == tr - c/E^(10k)}

which could then be used to solve the equations (using And on the list).

share|improve this question

2 Answers 2

up vote 2 down vote accepted

Pinguin Dirk's solution is very neat for this problem. It is possible because, as you discovered, eq /. rule generates

{2000, 1300, 1100} == {tr - c, tr - c/E^(5*k), tr - c/E^(10*k)}

But this is often not the case! It works only because Power (^) has the attribute Listable. Let's say instead of Power[E,t k] we had f[E,t k] where f is any function that is not Listable. eq /. rule yields:

{2000, 1300, 1100} == tr - c f[E, {0, -5 k, -10 k}]

If you run into this problem, a more general approach would be needed. The key to the general approach is to get your rules into this format:

rules = Thread[Thread /@ {t -> {0, 5, 10}, T -> {2000, 1300, 1100}}]

{{t -> 0, T -> 2000}, {t -> 5, T -> 1300}, {t -> 10, T -> 1100}}

Because in this format we can easily generate the required results, like this:

eq /. rules

{2000 == tr - c f[E, 0], 1300 == tr - c f[E, -5 k], 1100 == tr - c f[E, -10 k]}

share|improve this answer
    
The # & /@ part is redundant as a list mapped to the identity function will return the same list. eq /. rules is enough. –  Tyilo Oct 20 '13 at 20:57
    
@Tyilo Very observant of you, I updated the answer. –  Pickett Oct 20 '13 at 21:01
    
@Tyilo Although I would maintain it's not because of the reason you mention. {expr /. {a->b}, expr /. {b->c}} would not be the same as expr /. {{a->b},{b->c}} unless ReplaceAll had the seemingly undocumented property of threading over it's second argument. –  Pickett Oct 20 '13 at 21:07
    
oh I didn't know that what you wrote before is equal to (eq /. #)& /@ rules). I thought it was eq /. (# & /@ rules) or something else, sorry. –  Tyilo Oct 20 '13 at 21:25

Use for example:

Thread[eq/. rule]

and get:

{2000 == -c + tr, 1300 == -c E^(-5 k) + tr, 1100 == -c E^(-10 k) + tr}

share|improve this answer
    
@Tyilo: Thanks for the accept, but usually it pays to wait a bit... there are most certainly other people out there with other ideas, better ideas. And you don't wanna scare them away, do you? Still, I am glad you like my approach! –  Pinguin Dirk Oct 20 '13 at 13:49
    
Fair enough, I'll wait a little longer –  Tyilo Oct 20 '13 at 14:09

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.