OreTools[Converters] - Maple Programming 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

  

FromLinearEquationToOrePoly

  

convert a linear functional equation to the corresponding OrePoly structure

  

AddConversionRule

  

add conversion rules to FromLinearEquationToOrePoly

  

FromOrePolyToPoly

  

convert an OrePoly structure to the corresponding polynomial

  

FromPolyToOrePoly

  

convert a polynomial to the corresponding OrePoly structure

 

Calling Sequence

Parameters

Description

Examples

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.

ASetOreRingx,'differential'

A:=UnivariateOreRingx,differential

(1)

LOrePoly1,x,x2+Cx

L:=OrePoly1,x,Cx+x2

(2)

eqFromOrePolyToLinearEquationL,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.

LOrePolyn4n1,n4n3,n1n+2

L:=OrePolyn4n1,n4n3,n1n+2

(6)

Convert L to a linear difference equation.

eqFromOrePolyToLinearEquationL,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)

OreOrePolyn&comma;n1&comma;1n

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

(9)

qFromOrePolyToPolyOre&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