# LinearOrdinaryDifferentialOperator(A, diff)ΒΆ

• A: Ring
• diff: A -> A

LinearOrdinaryDifferentialOperator defines a ring of differential operators with coefficients in a ring A with a given derivation. Multiplication of operators corresponds to functional composition: (L1 * L2).(f) = L1 L2 f

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, A) -> %
from RightModule A
*: (%, Fraction Integer) -> % if A has Algebra Fraction Integer
from RightModule Fraction Integer
*: (A, %) -> %
from LeftModule A
*: (Fraction Integer, %) -> % if A has Algebra Fraction Integer
from LeftModule Fraction Integer
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, A) -> % if A has Field
from AbelianMonoidRing(A, NonNegativeInteger)
=: (%, %) -> Boolean
from BasicType
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
from LinearOrdinaryDifferentialOperatorCategory A
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
apply: (%, A, A) -> A
from UnivariateSkewPolynomialCategory A
associates?: (%, %) -> Boolean if A has EntireRing
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
binomThmExpt: (%, %, NonNegativeInteger) -> % if % has CommutativeRing
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
charthRoot: % -> Union(%, failed) if A has CharacteristicNonZero
from CharacteristicNonZero
coefficient: (%, List SingletonAsOrderedSet, List NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
coefficient: (%, NonNegativeInteger) -> A
from AbelianMonoidRing(A, NonNegativeInteger)
coefficient: (%, SingletonAsOrderedSet, NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
coefficients: % -> List A
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
coerce: % -> % if A has IntegralDomain and % has VariablesCommuteWithCoefficients or % has VariablesCommuteWithCoefficients and A has CommutativeRing
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: A -> %
from Algebra A
coerce: Fraction Integer -> % if A has RetractableTo Fraction Integer or A has Algebra Fraction Integer
from Algebra Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
commutator: (%, %) -> %
from NonAssociativeRng
content: % -> A if A has GcdDomain
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
D: () -> %
from LinearOrdinaryDifferentialOperatorCategory A
degree: % -> NonNegativeInteger
from AbelianMonoidRing(A, NonNegativeInteger)
degree: (%, List SingletonAsOrderedSet) -> List NonNegativeInteger
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
degree: (%, SingletonAsOrderedSet) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
directSum: (%, %) -> % if A has Field
from LinearOrdinaryDifferentialOperatorCategory A
elt: (%, A) -> A
from Eltable(A, A)
exquo: (%, %) -> Union(%, failed) if A has EntireRing
from EntireRing
exquo: (%, A) -> Union(%, failed) if A has EntireRing
from UnivariateSkewPolynomialCategory A
fmecg: (%, NonNegativeInteger, A, %) -> %
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
ground: % -> A
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
ground?: % -> Boolean
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
latex: % -> String
from SetCategory
from AbelianMonoidRing(A, NonNegativeInteger)
from AbelianMonoidRing(A, NonNegativeInteger)
leftDivide: (%, %) -> Record(quotient: %, remainder: %) if A has Field
from UnivariateSkewPolynomialCategory A
leftExactQuotient: (%, %) -> Union(%, failed) if A has Field
from UnivariateSkewPolynomialCategory A
leftExtendedGcd: (%, %) -> Record(coef1: %, coef2: %, generator: %) if A has Field
from UnivariateSkewPolynomialCategory A
leftGcd: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
leftLcm: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %
from Magma
leftQuotient: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
leftRecip: % -> Union(%, failed)
from MagmaWithUnit
leftRemainder: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
mainVariable: % -> Union(SingletonAsOrderedSet, failed)
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
map: (A -> A, %) -> %
from AbelianMonoidRing(A, NonNegativeInteger)
mapExponents: (NonNegativeInteger -> NonNegativeInteger, %) -> %
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
minimumDegree: % -> NonNegativeInteger
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
monicLeftDivide: (%, %) -> Record(quotient: %, remainder: %) if A has IntegralDomain
from UnivariateSkewPolynomialCategory A
monicRightDivide: (%, %) -> Record(quotient: %, remainder: %) if A has IntegralDomain
from UnivariateSkewPolynomialCategory A
monomial: (%, List SingletonAsOrderedSet, List NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
monomial: (%, SingletonAsOrderedSet, NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
monomial: (A, NonNegativeInteger) -> %
from AbelianMonoidRing(A, NonNegativeInteger)
monomial?: % -> Boolean
from AbelianMonoidRing(A, NonNegativeInteger)
monomials: % -> List %
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
numberOfMonomials: % -> NonNegativeInteger
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
pomopo!: (%, A, NonNegativeInteger, %) -> %
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
primitiveMonomials: % -> List %
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
primitivePart: % -> % if A has GcdDomain
from FiniteAbelianMonoidRing(A, NonNegativeInteger)
recip: % -> Union(%, failed)
from MagmaWithUnit
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix A, vec: Vector A)
from LinearlyExplicitOver A
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if A has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix A
from LinearlyExplicitOver A
reducedSystem: Matrix % -> Matrix Integer if A has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reductum: % -> %
from AbelianMonoidRing(A, NonNegativeInteger)
retract: % -> A
from RetractableTo A
retract: % -> Fraction Integer if A has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retract: % -> Integer if A has RetractableTo Integer
from RetractableTo Integer
retractIfCan: % -> Union(A, failed)
from RetractableTo A
retractIfCan: % -> Union(Fraction Integer, failed) if A has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retractIfCan: % -> Union(Integer, failed) if A has RetractableTo Integer
from RetractableTo Integer
right_ext_ext_GCD: (%, %) -> Record(generator: %, coef1: %, coef2: %, coefu: %, coefv: %) if A has Field
from UnivariateSkewPolynomialCategory A
rightDivide: (%, %) -> Record(quotient: %, remainder: %) if A has Field
from UnivariateSkewPolynomialCategory A
rightExactQuotient: (%, %) -> Union(%, failed) if A has Field
from UnivariateSkewPolynomialCategory A
rightExtendedGcd: (%, %) -> Record(coef1: %, coef2: %, generator: %) if A has Field
from UnivariateSkewPolynomialCategory A
rightGcd: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
rightLcm: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightQuotient: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
rightRemainder: (%, %) -> % if A has Field
from UnivariateSkewPolynomialCategory A
sample: %
from AbelianMonoid
smaller?: (%, %) -> Boolean if A has Comparable
from Comparable
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
symmetricPower: (%, NonNegativeInteger) -> % if A has Field
from LinearOrdinaryDifferentialOperatorCategory A
symmetricProduct: (%, %) -> % if A has Field
from LinearOrdinaryDifferentialOperatorCategory A
symmetricSquare: % -> % if A has Field
from LinearOrdinaryDifferentialOperatorCategory A
totalDegree: % -> NonNegativeInteger
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
totalDegree: (%, List SingletonAsOrderedSet) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
totalDegreeSorted: (%, List SingletonAsOrderedSet) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
unit?: % -> Boolean if A has EntireRing
from EntireRing
unitCanonical: % -> % if A has EntireRing
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %) if A has EntireRing
from EntireRing
variables: % -> List SingletonAsOrderedSet
from MaybeSkewPolynomialCategory(A, NonNegativeInteger, SingletonAsOrderedSet)
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra % if A has IntegralDomain and % has VariablesCommuteWithCoefficients or % has VariablesCommuteWithCoefficients and A has CommutativeRing

Algebra A if A has CommutativeRing

BasicType

BiModule(%, %)

BiModule(A, A)

CancellationAbelianMonoid

CommutativeRing if % has VariablesCommuteWithCoefficients and A has CommutativeRing or A has IntegralDomain and % has VariablesCommuteWithCoefficients

CommutativeStar if A has IntegralDomain and % has VariablesCommuteWithCoefficients or % has VariablesCommuteWithCoefficients and A has CommutativeRing

Comparable if A has Comparable

Eltable(A, A)

EntireRing if A has EntireRing

IntegralDomain if A has IntegralDomain and % has VariablesCommuteWithCoefficients

Magma

MagmaWithUnit

Module % if A has IntegralDomain and % has VariablesCommuteWithCoefficients or % has VariablesCommuteWithCoefficients and A has CommutativeRing

Module A if A has CommutativeRing

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if A has EntireRing

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

unitsKnown