Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
2007
*January
*February
*March
*April
*May
*June
*July
*August
*September
*October
*Archive Index
*Ask about this page
*Print this page
*Give us feedback
*Sign up for the Wolfram Insider

MathGroup Archive 2007

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Arranging input data (nonlinear control systems)

  • To: mathgroup at smc.vnet.net
  • Subject: [mg77641] Re: [mg77563] Arranging input data (nonlinear control systems)
  • From: DrMajorBob <drmajorbob at bigfoot.com>
  • Date: Thu, 14 Jun 2007 05:27:54 -0400 (EDT)
  • References: <9560865.1181739420791.JavaMail.root@m35>
  • Reply-to: drmajorbob at bigfoot.com

This might help:

Clear[Shift,Pseudo]
discrete := {Shift[a_, t_] :> (a /. t -> t + 1),
    PseudoD[a_, t_] :> 0};
continuous := {Shift[a_, t_] :> a, PseudoD[a_, t_] :> Dt[a, t]};
difference := {Shift[a_, t_] :> (a /. t -> t + 1),
    PseudoD[a_, t_] :> Shift[a, t] - a};
qShift := {Shift[a_, t_] :> (a /. t -> q*t), PseudoD[a_, t_] :> 0};
qDifference := {Shift[a_, t_] :> (a /. t -> q*t),
    PseudoD[a_, t_] :> Shift[a, t] - a};

Now, anywhere you need a set of rules, you can mention it by name:

StateSpace[f, Xt, Ut, t, h, Yt, discrete]

but remember you're passing rules, not functions.

Instead, you could define the rule-sets as strings:

discrete = "Clear[Shift,Pseudo];Shift[a_,t_]:=(a/.t\[Rule] \
t+1);PseudoD[a_,t_]=0;"
continuous = "Clear[Shift,Pseudo];Shift[a_,t_]:= \
a;PseudoD[a_,t_]:=Dt[a,t];"
difference = \
"Clear[Shift,Pseudo];Shift[a_,t_]:=(a/.t\[Rule]t+1);PseudoD[a_,t_]\
:=Shift[a,t]-a;"
qShift = "Clear[Shift,Pseudo];Shift[a_,t_]:=(a/.t\[Rule]q*t);PseudoD[\
a_,t_]:=0;"
qDifference = \
"Clear[Shift,Pseudo];Shift[a_,t_]:=(a/.t\[Rule]q*t);PseudoD[a_,t_]\
:=Shift[a,t]-a;"

and then, when you've called

StateSpace[f, Xt, Ut, t, h, Yt, discrete]

StateSpace can temporarily use the rules passed to it by executing

ToExpression[ruleSet];

where ruleSet is the last argument in the pattern definition for  
StateSpace.

For instance:

ToExpression[discrete]
?Shift

Global`Shift

Shift[a_,t_]:=a/.t->t+1

Bobby

On Wed, 13 Jun 2007 06:24:37 -0500, Maris To~nso <mtonso at staff.ttu.ee>  
wrote:

> Dear group,
>
> I am writing a Mathematica package dealing with nonlinear control  
> systems.
> I have a problems with organizing input data. I try to describe my  
> problem
> so that people, who are not aquainted with control systems theory, can
> understand, too.
>
>
> There are different types of nonlinear control systems.
>
>
> ____________1. Discrete system
>
> classical state equations are in the form
>
> x(t+1) = f(x(t),u(t)), (here f = (f1,f2,...) is nonlinear function)
> y(t) = h(x(t))
>
> for example,
>
> x1(t+1) = x1(t) + x2(t) u2(t)
> x2(t+1) = u1(t)
> y(t) =  x1(t)
>
> So far I have entered and hold above system like this:
>
> f = {x1[t] + x2[t] u2[t],  u1[t]};
> Xt = {x1[t], x2[t]};
> Ut = {u1[t], u2[t]};
> h = {x1[t]};
> Yt = {y[t]};
> dstateeqs = DStateSpace[f, Xt, Ut, t, h, Yt];
>
> The head DStateSpace indicates it is a discrete system and keeps the
> system data together. Now a user can apply package functions to the
> system, entering the single argument. For example,
>
>
> Observability[ dstateeqs ] (* checks observability *)
>
> ClassicStatesToIO[ dstateeqs ] (* finds input-output equations *)
>
> BookForm[ dstateeqs ] (* acts like TraditionalForm, i.e. prints the  
> system
> in normal way x1[t+1] = ... *)
>
>
>
> __________2. Continuous system:
>
> classical state equations are in the form
>
> \dot x = f(x,u) (Here \dot x is time derivative)
> y = h(x)
>
> for example,
>
> \dot x1 = u1 + u2
> \dot x2 = x1*x2
> \dot x3 = x3
> y =  x1 + x2
>
> So far I have entered and hold above system like this:
>
> f = {u1[t] + u2[t],  x1[t]*x2[t], x3[t]};
> Xt = {x1[t], x2[t], x3[t]};
> Ut = {u1[t], u2[t]};
> h = {x1[t] + x2[t]};
> Yt = {y[t]};
> cstateeqs = CStateSpace[f, Xt, Ut, t, h, Yt];
>
> Though continuous systems are traditionally written without time argument
> t, I have chosen to write it, to keep analogy with discrete case.
> CStateSpace indicates it is a continuous system. Package functions can be
> applied to it exactly like in discrete case.
>
> Observability[ cstateeqs ]
> ClassicStatesToIO[ cstateeqs ]
> BookForm[ cstateeqs ]
>
>
> The sysem worked quite properly and was easy to understand and use, but  
> no
> a big trouble has appeared. My professor says there will be more cases
> than just discrete and continuous!
>
>
> __________3. General case:
>
> classical state equations have form
>
> x^<1> = f(x,u)
> y = h(x)
>
> here x^<1> (x with superscripted "<1>" ) is a changeable operator,
> depending on two functions: generalized shift and pseudoderivative. Of
> course, the general case covers discrete and continuous systems, if shift
> and pseudoderivative are chosen in a right way. Some examples:
>
> Discrete:     Shift[a_, t_]:= a/.t->t+1; PseudoD[a_, t_]:= 0
> Continuous:   Shift[a_, t_]:= a;         PseudoD[a_, t_]:= Dt[a, t]
> Difference:   Shift[a_, t_]:= a/.t->t+1; PseudoD[a_, t_]:= Shift[a,t]-a
> q-shift:      Shift[a_, t_]:= a/.t->q*t; PseudoD[a_, t_]:= 0
> q-difference: Shift[a_, t_]:= a/.t->q*t; PseudoD[a_, t_]:= Shift[a,t]-a
> ... and there are more of them.
>
> Now, the the expression of state equations should carry also an
> information about shift and pseudoderivative operators. Something like
>
> StateSpace[f, Xt, Ut, t, h, Yt, Hold[{Shift[a_, t_]:= a/.t->t+1,
> PseudoD[a_, t_]:= 0]}]
>
> If I don't use Hold, it gives simply Null. Unfortunately, I have never
> seen a Mathematica function, which arguments should be entered with Hold.
>
> An alternative is to define two global variables Shift[a_,t_] and
> PseudoD[a_,t_]. I am bit afraid of global variables, because Mathemativa
> built-in functions and Standard packages use them really rarely.
>
> So, were should I put these shift and pseudoderivative?
>
>
> It is also clear classical discrete and continuous systems are used much
> more often than those other cases, so there should be an oportunity to
> enter these systems easily, without thinking about shifts and
> pseudoderivatives. So, I should probably keep the old heads DStateSpace
> and CStateSpace, too. Or would it be better to use complete words,
> something like
>
> StateSpace[f, Xt, Ut, t, h, Yt, "Discrete"] and
>
> StateSpace[f, Xt, Ut, t, h, Yt, "Continuous"] ?
>
>
> Thank you for reading. I am not expecting a complete solution, any ideas
> and hints would be helpful.
>
>
>
>
>
> Yours sincerely
> Maris Tõnso
>
>
> --------------------------------------------------------
>
>
> Maris Tõnso
> Control Systems Department
> Institute of Cybernetics at TUT
> Akadeemia tee 12, 12618
> Tallinn, Estonia
>
>
>
>
>
>



-- 
DrMajorBob at bigfoot.com


  • Prev by Date: Re: Integrate question
  • Next by Date: Mathematica 6.0 vs SELinux?
  • Previous by thread: Re: Arranging input data (nonlinear control systems)
  • Next by thread: NumericalMath`TrigFit