Previous Page Next Page Contents

Dom::ExpressionField -- the domains of expressions forming a field

Introduction

Dom::ExpressionField(Normal, IsZero) creates a domain of expressions forming a field, where the functions Normal and IsZero are used to normalize expressions and test for zero.

Domain

Dom::ExpressionField( <Normal <, IsZero>>)

Parameters

Normal - a function used to normalize the expressions of the domain; default is id.
IsZero - a function used to test the expressions of the domain for zero; default is iszero @ Normal.

Details

Categories

Cat::Field

, Cat::DifferentialRing

Introduction

Dom::ExpressionField(Normal, IsZero)(e) creates a field element represented by the expression e.

Creating Elements

Dom::ExpressionField(Normal, IsZero)(e)

Parameters

e - an expression representing a field element.

Details

Entries

characteristic

The characteristic of the fields created by this constructor is assumed to be 0.

one

The element represented by the expression 1 is assumed to be a neutral element w.r.t. "_mult".

zero

The element represented by the expression 0 is assumed to be a neutral element w.r.t. "_plus".

Method abs: absolute value

Method combine: combines terms of the same algebraic structure

Method conjugate: complex conjugate

Method D: differential operator

Method denom: denominator

Method diff: differentiates an element

Method _divide: divides elements

Method equal: test for mathematical equality

Method expand: expands an element

Method factor: factorizes an element

Method float: floating-point approximation

Method gcd: greatest common divisor

Method Im: imaginary part of an element

Method int: definite and indefinite integration

Method intmult: integer mutiple

Method _invert: inverts an element

Method iszero: test for zero

Method lcm: least common multiple

Method _leequal: tests if less or equal

Method _less: tests if element is less

Method limit: limit computation

Method max: maximum of arguments

Method min: minimum of arguments

Method _mult: multiplies elements

Method _negate: negates an element

Method norm: norm of an element

Method normal: normal form

Method numer: numerator

Method _plus: adds elements

Method _power: exponentiates arguments

Method radsimp: simplifies radicals

Method random: creates a random element

Method Re: real part of an element

Method sign: sign of an element

Method simplify: general simplification of an element

Method solve: solves an equation

Method sqrfree: square-free factorization

Method _subtract: subtracts elements

Method convert: convert to this domain

Method convert_to: convert to other domain

Method expr: convert to basic type

Method new: creating an element

Method nops: number of operands

Method op: get operands

Method subs: substitute subexpressions

Method subsex: extended substitution

Method subsop: substitute operand

Method indets: the identifiers of an element

Method length: size of an element

Method map: applies function to operands

Method rationalize: approximate floating point numbers by rationals

Method pivotSize: pivot size

Super-Domain

if  Normal = id and   IsZero = iszero then
Dom::ArithmeticalExpression
else
Dom::BaseDomain

Axioms

if  Normal = id then
Ax::efficientOperation("_divide"), Ax::efficientOperation("_mult"), Ax::efficientOperation("_invert"),
if  IsZero = iszero then
Ax::systemRep
else
Ax::normalRep

Example 1

Dom::ExpressionField(normal) creates a field of rational expressions over the rationals. The expressions representing the field elements are allways normalized by normal:

>> Fn := Dom::ExpressionField(normal):
   a := Fn((x^2 - 1)/(x - 1))
                                   x + 1

The field elements are explicit elements of the domain:

>> domtype(a)
                Dom::ExpressionField(normal, iszero@normal)

Example 2

In the domain Dom::ExpressionField(id, iszero@normal) the expressions representing the elements are normalized by the kernel simplifier only:

>> Fi := Dom::ExpressionField(id, iszero@normal):
   a := Fi((x^2 - 1)/(x - 1))
                                   2
                                  x  - 1
                                  ------
                                  x - 1

The elements of this domain are not normalized (when viewed as rational expressions over the rationals), thus the domain does not have the axiom Ax::normalRep:

>> b := a/Fi(x + 1) - Fi(1)
                                 2
                                x  - 1
                            --------------- - 1
                            (x - 1) (x + 1)

But nevertheless this domain also represents the field of rational expressions over the rationals, because zero is detected correctly by the function iszero @ normal:

>> iszero(b)
                                   TRUE

Changes




Do you have questions or comments?


Copyright © SciFace Software GmbH & Co. KG 2000