@vv 

It looks like our replies have crossed

@vv 

I found myself the solution :-)
I just  declared  use plots  within the procedure and it  works correctly now.

(I thought that loading the package plots in the worksheet itself would be sufficient)

Sorry for the inconvenience

 

@vv 

This works well but your answer made me realize that  I oversimplified my problem.
If it's not too much to ask, could you answer this one please ?


 f := proc(DrawThis)
     plotsetup(jpeg, plotoutput=SomeJpegFile);
     print(DrawThis)
     plotsetup(default);
end proc;

MyPlot := plot(x, x=0..1)
f(MyPlot);   # That's fine, thank you,

MyPlot := display(plot(x, x=0..1), plot(x^2, x=0..1))
f(MyPlot);   # No file is created

Even this simplified procedure
 f := proc(DrawThis)
     print(DrawThis)
end proc;

returns what I would have obtained by writting
MyPlot := display(plot(x, x=0..1), plot(x^2, x=0..1)) ;


Could you help me please ?

@acer 
Thanks a lot for your fruitful help.
I tested tou .mw file and it works beond my expectations.

 

@tomleslie 

I am going to implement these two solutions and look what happens on my machine.

Thanks again

@tomleslie 

It works perfectly well

@tomleslie 

Thanks for the suggestion.


To make it more concrete ...

The unknown is a function r(x) which represents tjhe radius of a revolution object at abscissa. r(x) verifies a nonlinear first order ODE and I'm interested in the radius of curvarure of "solution shap" in some range of x. Assessing this radius by divided differences is not accurate, hence the idea to work with a piecewise solution.

@tomleslie 

Thank you for the information.

I had already used the work-around you refet to but the result is less nice.

Thanks again

@ecterrab 

I will have a look at this package.
Thanks for this alternative solution.

@acer 

You wrote “We haven't been told the precise nature of the expressions that may be present…”

The  ODE system I am concerned with describes  the motion of N masses inside a closed box submitted to an outer acceleration. Within this box they are connectors that link each mass to another one or to the box. A connector between masses i  and j delivers a force on these two masses which depends of the displacements (x) and velocities (v) of the masses i and j (think to some generalization of a spring or a linear damper).
This force can be “simple” (an ideal spring) or more complex and highly nonlinear. A common situation concerns forces that come from experimental measurements: in this case the connector is pointwise defined and a continuous representation of it is obtained by piecewise reconstruction (often piecewise linear).
Then some expressions can be piecewise functions.

For each mass these  two ODEs are written (the upper arrow represents all the x or v variables)

diff(x[i](t), t) = v[i](t),   
F[i](t, (t),  (t))*diff(v[n](t), t) =         

 where the summation is extended to all masses j connected to mass i.


Maybe this will give you some ideas about the general problem.

Now a last point:  I use a Maple code written a few years ago and this code is “frozen” in the sense that it has been approved for simulating very critical phenomena. Modifying this code for it returns the “indets” of the system before the ODE system is constructed is technically simple. But it is incredibly complicated in terms of red tape.  One output of the code is the ODE system itself, so the idea to identify the “indets” from this output in order to prevent any modification (even light) of the code.

In any case I want to thank you for all the work you have been doing.

@Kitonum 
@Thomas Richard 
@tomleslie 

indets(eq, {name, function(name)})     (Kitonum)
and
indets(eq,function(name))  (Thomas Richard)

work both of them amazing well, all of this in a single instruction !

Who should I plebiscite for the first idea?
 

@Kitonum 
@Thomas Richard 
@tomleslie 

 Our mutual responses must have crossed, I will watch your latest messages carefully.

@Kitonum 
@Thomas Richard 
@tomleslie 

***** Ouups,  I cannot find my reply to tomleslie ... probably an operating error of my own

First, I must thank you all for the time you spent to give me answers or hints.
Some of your answers, if not solving my “more complicated” problem have given me some ideas to deal with it.

Maybe you will be interested by these two examples where my "method" (not at all one hundred percent sure of its robustness !!!) returns the expected answers

Case 1
eq :=  F *diff(x(t), t$n)  - G

Where n is an integer >=1 and F and G are arbitrary functions of x(t) and its successive derivatives up to order n-1 (at most), it seems that this piece of code returns the desired answer “x(t)”

INDEP  := indets(eq, name):     # should contain t  only
DEP      := convert(indets(eq, function), list):
OpDEP :=  op~(1, DEP):
zip((u,v) -> if member(u, INDEP) then v end if, OpDEP, DEP)

# result is x(t)

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

Case 2
 eq := {
               diff(x(t), t) - v(t),   
               F(t, x(t),  v(t))*diff(v(t), t) - G(t, x(t), v(t))
           }

the « generalization » below seems to work well

INDEP  := `union`(op~( indets(eq, name))):
DEP      := convert(`union`(op~(indets(eq, function))), list):
OpDEP :=  op~(1, DEP):
zip((u,v) -> if member(u, INDEP) then v end if, OpDEP, DEP)

# result is { v(t), x(t) }

@Thomas Richard 

Thanks for your help,
I have just sent a reply to tomleslie from which I reproduce here this element

It is not fair to complicate the question once an answer has been provided (my apologies)
… but how how can I deal with this problem ?
eq := diff(x(t), t) = x(t) - 1 +  sin(x(t))

I cannot generalize your solution to all possible functions of x(t) (here a sine).

I'm very sorry to ask you for this extra help

@tomleslie 

Efficient but not completely satisfactory ...

The reason is :
 I'm working in a team where several computation codes are developed in different languages. To insure that new versions of them do not “regress” we test them on a bunch of test cases and compare the results to those given by a reference version.

To do this one has developed a global Eclipse-based application that eases code versioning and regression testing. This app uses environment variables, for instance  to inform the code of the  test case to run.
… and I must comply with this framework.

So I would prefer, if it is possible, a solution which suits our requirements

Nevertheless, thank you for your help