convert an OrePoly structure to the corresponding linear functional equation - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Algebra : Skew Polynomials : OreTools : OreTools/Converters/FromOrePolyToPoly

OreTools[Converters][FromOrePolyToLinearEquation] - convert an OrePoly structure to the corresponding linear functional equation

OreTools[Converters][FromLinearEquationToOrePoly] - convert a linear functional equation to the corresponding OrePoly structure

OreTools[Converters][AddConversionRule] - add conversion rules to FromLinearEquationToOrePoly

OreTools[Converters][FromOrePolyToPoly] - convert an OrePoly structure to the corresponding polynomial

OreTools[Converters][FromPolyToOrePoly] - convert a polynomial to the corresponding OrePoly structure

Calling Sequence

FromOrePolyToLinearEquation (Ore, f, A)

FromLinearEquationToOrePoly (expr, f, A)

AddConversionRule (CaseName, ConvertProc)

FromOrePolyToPoly(Ore, x)

FromPolyToOrePoly(P, x)

Parameters

Ore

-

Ore polynomial; to define an Ore polynomial, use the OrePoly structure.

f

-

name; dependent variable

A

-

Ore algebra; to define an Ore algebra, use the SetOreRing function.

expr

-

expression; linear functional equation

CaseName

-

name; labels the new conversion case

ConvertProc

-

procedure; algorithm for converting a linear functional equation to an Ore polynomial

x

-

name; noncommutative indeterminate

P

-

polynomial

Description

• 

The FromOrePolyToLinearEquation(Ore, f, A) calling sequence converts the Ore polynomial Ore to the corresponding linear functional equation.

• 

The FromLinearEquationToOrePoly(expr, f, A) calling sequence converts the linear functional equation expr to the corresponding Ore polynomial. The Ore polynomial is returned as an OrePoly structure.

  

The FromLinearEquationToOrePoly command currently supports only the shift and differential cases.

• 

The AddConversionRule(CaseName, ConvertProc) command adds a new conversion rule from a linear equation to an Ore polynomial to be used by the FromLinearEquationToOrePoly command.

  

The ConvertProc procedure must accept three arguments: linear functional equation, name of dependent variable, and Ore algebra; and return an Ore polynomial as an OrePoly structure.

• 

The FromOrePolyToPoly(Ore, x) calling sequence converts the Ore polynomial Ore to the corresponding polynomial.

• 

The FromPolyToOrePoly(P, x) calling sequence converts the polynomial P to the corresponding Ore polynomial. The Ore polynomial is returned as an OrePoly structure.

Examples

withOreTools:

withOreTools[Converters]:

Define the differential algebra.

A:=SetOreRingx,'differential'

A:=UnivariateOreRingx,differential

(1)

L:=OrePoly1,x,x2+Cx

L:=OrePoly1,x,Cx+x2

(2)

eq:=FromOrePolyToLinearEquationL,f,A

eq:=fxxⅆⅆxfx+Cx+x2ⅆ2ⅆx2fx

(3)

FromLinearEquationToOrePolyeq,f,A

OrePoly1,x,Cx+x2

(4)

To convert a linear difference equation to an OrePoly structure, first define the difference polynomial ring.

A := SetOreRing(n, 'difference', 'sigma' = proc(p, x) eval(p, x=x+1) end,
'sigma_inverse' = proc(p, x) eval(p, x=x-1) end,
'delta' = proc(p, x) eval(p, x=x+1) - p end,
'theta1' = 0);

A:=UnivariateOreRingn,difference

(5)

Consider the following difference operator.

L:=OrePolyn4n1,n4n3,n1n+2

L:=OrePolyn4n1,n4n3,n1n+2

(6)

Convert L to a linear difference equation.

eq:=FromOrePolyToLinearEquationL,s,A

eq:=n4snn1+n4n3sn+1sn+n1sn+22sn+1+snn+2

(7)

The FromLinearEquationToOrePoly function cannot convert eq to the corresponding OrePoly structure.

FromLinearEquationToOrePolyeq,s,A

Error, (in OreTools:-Converters:-FromLinearEquationToOrePoly) unable to handle the difference case

You must define the rule for the difference case.

difference_case := proc(eq, func, A)
     local reqn, info, fcn, E, receq, req, func_set, n, place, i, var;
      var := OreTools[Properties][GetVariable](A);

      # Do some argument checking and processing
      reqn := LREtools['REcreate'](eq, func(var), {});
      info := eval(op(4, reqn));

      if info['linear']=false then
          error "only linear equations are handled"
      end if;
      n := info['vars'];
      if not (nops([n])=1 and type(n, name)) then
          error "only single equations are handled"
      end if;
      fcn := op(2, reqn)[1];
      # locate n in arguments to fcn
      for place to nops(fcn) while op(place, fcn) <> n do end do;

      # Transform the equation from a difference equation to a
      # difference operator
      req := args[1];
      func_set := indets(req, specfunc(anything, info['functions']));
      receq := collect( subs( map( (x, y, z, i) -> x = (z+1)^(op(i, x)-y),
          func_set, n, 'E', place), req), 'E', Normalizer);
      'OrePoly'(seq(coeff(receq, 'E', i), i=0..degree(receq, 'E')))
   end proc:

Add this rule to OreTools, and then use the FromOrePolyToLinearEquation function again.

AddConversionRule&apos;difference&apos;&comma;difference_case

FromLinearEquationToOrePolyeq&comma;s&comma;A

OrePolyn4n1&comma;n4n3&comma;n1n&plus;2

(8)

Ore:=OrePolyn&comma;n1&comma;1n

Ore:=OrePolyn&comma;n1&comma;1n

(9)

q:=FromOrePolyToPolyOre&comma;S

q:=n&plus;n1S&plus;S2n

(10)

FromPolyToOrePolyq&comma;S

OrePolyn&comma;n1&comma;1n

(11)

See Also

args, coeff, collect, error, eval, indets, LREtools[REcreate], map, nops, op, OreTools, OreTools/OreAlgebra, OreTools/OrePoly, OreTools[Converters], OreTools[Properties][GetVariable], OreTools[SetOreRing], proc, seq, subs, type/name


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam