Accelerating the pace of engineering and science

# Documentation Center

• Trial Software

# Dom::LinearOrdinaryDifferentialOperator

Domain of linear ordinary differential operators

## Syntax

### Domain Creation

`Dom::LinearOrdinaryDifferentialOperator(<Var, <DVar, <Ring>>>)`

### Element Creation

`Dom::LinearOrdinaryDifferentialOperator(Var, DVar, Ring)(p)`
`Dom::LinearOrdinaryDifferentialOperator(Var, DVar, Ring)(l)`
`Dom::LinearOrdinaryDifferentialOperator(Var, DVar, Ring)(eq, yx)`

## Description

Dom::LinearOrdinaryDifferentialOperator(Var, DVar, Ring) creates the domain of linear ordinary differential operators with coefficients in the differential ring Ring and with derivation Var where DVar is the differential indeterminate. Elements of this domain are also called Ore polynomials and the multiplication of two elements is completely determined by the prescribed rule for every element r in Ring. And so Dom::LinearOrdinaryDifferentialOperator is a noncommutative ring.

 Note:   Nevertheless, for some reasons, for every element r in Ring, Var*r is automatically rewritten as r*Var. See Example 1.

If Dom::LinearOrdinaryDifferentialOperator is called without any argument, a domain with coefficients in Dom::ExpressionField(normal) with derivation Df and differential indeterminate x is created.

 Note:   Only commutative differential rings of type DOM_DOMAIN are allowed which inherit from Dom::BaseDomain. If Ring is of type DOM_DOMAIN but does not inherit from Dom::BaseDomain, the domain Dom::ExpressionField(normal) will be used instead.
 Note:   It is highly recommend to use only coefficient rings with unique zero representation. Otherwise it can happen that, e.g., a polynomial division will not terminate or a wrong degree will be returned.

## Examples

### Example 1

First we create the domain of linear ordinary differential operators:

`lodo := Dom::LinearOrdinaryDifferentialOperator()`

by default the above domain has coefficients in the field Dom::ExpressionField(normal) with derivation Df and differential indeterminate x.

We can create elements of lodo in 3 ways: polynomials in Df, list of elements of Dom::ExpressionField and with a linear ordinary homogeneous differential equation:

```lodo(Df^2 + (x + 1)*Df + 2*x), lodo([2*x, x + 1, 1]),
lodo(diff(y(x),x,x) + (x + 1)*diff(y(x),x) + 2*x*y(x), y(x))```

It's easy to obtain the linear differential equation associated to a linear differential operator:

```L := lodo((x + x^3)*Df^3 + (6*x^2 + 3)*Df^2 - 12):
L(y(x))```

and one can also evaluates a differential operator at an expression:

`L(2*x^2 + 1), L(ln(x)), L(ln(x), Unsimplified)`

Multiplication of elements of lodo is noncommutative but for every element r of the coefficients ring one has Df*r = r*Df:

`lodo(x^2*Df), lodo(Df*x^2), lodo(Df)*lodo(x^2)`

### Example 2

Dom::LinearOrdinaryDifferentialOperator is a domain where the Euclidean division exists but one has to precise if the multiplication of 2 elements of this domain is made on the right or on the left side:

```L1 := lodo(x*Df^3 + (x^2 - 3)*Df^2 + 4*x*Df + 2):
lodo::leftDivide(L1,lodo(x*Df + 1))```

`lodo(x*Df + 1) * %[quotient] = L1`

Hence one has the notions of greatest common divisor, least common multiple on the right and on the left, and a modified version of the extended Euclidean algorithm:

```L2 := lodo(x*Df + 1):
ree := lodo::rightExtendedEuclid(L1,L2)```

The right greatest common divisor and the left least common multiple can be read from the above list:

```iszero(lodo::rightGcd(L1,L2) - ree[1][1]),
iszero(ree[1][1] - (ree[1][2]*L1 + ree[1][3]*L2)),
iszero(lodo::leftLcm(L1,L2) - (-ree[2][1]*L1)),
iszero(-ree[2][1]*L1 - ree[2][2]*L2)```

### Example 3

One can compute polynomial, rational and exponential zeros of linear differential operators of any degree provided the ring Ring is the field of rational functions of x

```L3 := lodo((x^2 + 1)*x*Df^3 + 3*(2*x^2 + 1)*Df^2 - 12):
lodo::rationalZeros(L3), lodo::exponentialZeros(L3)```

even when the operator contains some parameters rationally:

```lodo::exponentialZeros(
lodo(Df^4 + (b*l - 2*a^2 - a*l*x)*Df^2 + a^4-a^2*b*l + a^3*l*x))```

### Example 4

One can factorize linear differential operators into irreducible factors when the ring Ring is the field of rational functions of x. Nevertheless, the algorithm is complete only for operators of degree at most 3; for higher degree only left and right factors of degree 1 are found:

```factor(lodo((x^2 + 1)*x*Df^3 + 3*(2*x^2 + 1)*Df^2 - 12)),
factor(lodo(Df^3 + a*x*Df + a + b^3 + a*b*x))```

Here the operator factors into two factors of degree 2 which cannot be found by MuPAD®:

`factor(lodo(Df^2 + x^3 + 1/x^3) * lodo(Df^2 + x^2 - 1/x^3))`

### Example 5

Solving linear differential operators using the command solve is also possible:

`solve(lodo(Df^2 + (3 - x)/(16*x^2)))`

For certain cases, where the groups associated to the dfferential operators are finite primitive groups of degree 2, a polynomial is returned corresponding to the minimal polynomial of all zeros of the differential operator (they are algebraic over the base field):

```solve(lodo(Df^2 +
(-27*x + 32*x^2 + 27)/(144*x^2 - 288*x^3 + 144*x^4)))```

For linear differential operators of degree greater than 3 only exponential zeros will be found:

`solve(lodo(x*Df^4 + (-x + 4)*Df^3 - 3*Df^2 - x^2*Df - x + x^2))`

Certain second degree linear differential operator can be solved in terms of some special functions (nonliouvillian functions) such as airyAi, besselI and whittakerM:

`solve(lodo(Df^2 - (x + 1)/(x - 1)^5))`

```solve(lodo(Df^2 - (243 + 4*x^8 + 162*x^2 + 19*x^4)/
36/x^2/(x^2 + 3)^2))```

## Parameters

 Var An indeterminate of type DOM_IDENT. Default is Df. DVar A differential indeterminate of type DOM_IDENT. Default is x. Ring An arbitrary commutative differential ring of characteristic zero. Default is Dom::ExpressionField(normal). p A polynomial expression in Var. l A list corresponding to the coefficients of the differential operator. If n is the length of l then the result returned is l[1] + l[2]*Var + ... + l[n]*Var^(n-1). eq A linear homogeneous differential equation. yx A function of DVar representing the dependent variable of the above linear differential equation.

expand all

## Mathematical Methods

### _mult — Multiplie linear differential operators

_mult(<a, b, …>)

This method overloads the function _mult of the system kernel, i.e. one may use it either in the form a * b * ... or in functional notation _mult(a, b, ...).

### _negate — Negate a linear differential operator

_negate(a)

This method overloads the function _negate of the system kernel, i.e. one may use it either in the form -a or in functional notation _negate(a).

### _plus — Add linear differential operators and coefficient ring elements

_plus(<a, b, …>)

This method overloads the function _plus of the system kernel, i.e. one may use it either in the form a + b + ... or in functional notation _plus(a, b, ...).

### _power — Nth power of a linear differential operator

_power(a, n)

This method overloads the function _power of the system kernel, i.e., one may use it either in the form a^n or in functional notation _power(a,n).

### _subtract — Subtract a linear differential operator

_subtract(a, b)

This method overloads the function _subtract of the system kernel, i.e. one may use it either in the form a - b or in functional notation _subtract(a, b).

### companionSystem — Companion matrix of a linear differential operator

companionSystem(a)

If a is not of positive degree, an error message is issued.

D(<l>, a)

### Dpoly — Derivative of a linear differential operator

Dpoly(<l>, a)

Dpoly(l,a) computes the partial derivative of a with respect to l. If l = [1,...,1] with length(l) = n then the method computes the n-th derivative a. If l = [] then the result returned is a.

### evalLODO — Applie an expression to a linear differential operator

evalLODO(a, f)

This method may be used either in the form a(f) or in functional notation evalLODO(a,f).

### exponentialZeros — Exponential zeros of a linear differential operator

exponentialZeros(a)

 Note:   This method only works when Ring is the field of rational functions in DVar.

### factor — Factor a linear differential operator

factor(a)

 Note:   This method is only available when the base field Ring is the field of rational functions in DVar. If a is of degree greater than or equal to 4 then only left and right factors of degree 1 of a will be found. Otherwise, a complete factorization is returned.

This method overloads the function factor of the system kernel.

factors(a)

### func_call — Applie an expression to a linear differential operator

func_call(a, f, <Unsimplified>)

This method may be used either in the form a(f) or in functional notation func_call(a,f).

leftDivide(a, b)

### leftExtendedEuclid — Left extended Euclidean algorithm for linear differential operators

leftExtendedEuclid(a, b)

### leftExtendedGcd — Coefficient in the left extended Euclidean algorithm

leftExtendedGcd(a, b)

leftGcd(a, b)

leftLcm(a, b)

### leftQuotient — Left quotient of linear differential operators

leftQuotient(a, b)

### leftRemainder — Left remainder of linear differential operators

leftRemainder(a, b)

makeIntegral(a)

monic(a)

### polynomialZeros — Polynomial zeros of a linear differential operator

polynomialZeros(a)

 Note:   This method only works when Ring is the field of rational functions in DVar.

### rationalZeros — Rational zeros of a linear differential operator

rationalZeros(a)

 Note:   This method only works when Ring is the field of rational functions in DVar.

### rightDivide — Right division of 2 linear differential operators

rightDivide(a, b)

### rightExtendedEuclid — Right extended Euclidean algorithm for linear differential operators

rightExtendedEuclid(a, b)

### rightExtendedGcd — Coefficient in the right extended Euclidean algorithm

rightExtendedGcd(a, b)

rightGcd(a, b)

rightLcm(a, b)

### rightQuotient — Right quotient of linear differential operators

rightQuotient(a, b)

### rightRemainder — Right remainder of linear differential operators

rightRemainder(a, b)

### solve — Zero of a linear differential operator

solve(a, <Transform>, <Irreducible>)

The algorithm for finding liouvillian solutions is complete for operators of degree at most 2 and enables to solve partially operators of higher degree (i.e. it finds all exponential solutions). The algorithm for finding solutions in terms of special functions (nonliouvillian solutions) is not complete even for the degree 2.

When option Transform is given the unimodular transformation is performed unconditionally and when option Irreducible is given, a is assumed to be irreducible.

 Note:   This method only works when Ring is the field of rational functions in DVar.

This method overloads the function solve of the system kernel.

### symmetricPower — Symmetric power of a linear differential operator

symmetricPower(a, m)

### unimodular — Unimodular transformation of a linear differential operator

unimodular(a, <Transform>)

If the option Transform is given then a is transformed unconditionally even if a has yet a unimodular Galois group.

## Access Methods

### coeff — Coefficient of a linear differential operator

coeff(a)

coeff(a, Var, n)

coeff(a, n)

coeff(a,Var,n) returns the coefficient of the term Var^n as an element of the coefficient ring Ring, where a is a linear differential operator in the variable Var.

coeff(a,n) returns the coefficient of the term Var^n as an element of the coefficient ring Ring, where a is a linear differential operator in the variable Var.

This method overloads the function coeff of the system kernel.

### degree — Degree of a linear differential operator

degree(a)

The degree of the zero polynomial is defined as zero.

This method overloads the function degree for polynomials.

vectorize(a)

## Conversion Methods

### convert — Conversion to a linear differential operator

convert(a)

FAIL is returned if the conversion fails.

### expr — Conversion into an object of a kernel domain

expr(a)

This method overloads the function expr of the system kernel.

### TeX — TeX formatting of a linear differential operator

TeX(a)

This method is used by the function generate::TeX.

## Algorithms

Some references on linear differential equations/operators: