Documentation

# `/`, `_divide`

Divide expressions

MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

## Syntax

```x / y
_divide(`x`, `y`)
```

## Description

`x/y` computes the quotient of `x` and `y`.

`x/y` is equivalent to the function call ```_divide(x, y)```.

For numbers of type `Type::Numeric`, the quotient is returned as a number.

If neither `x` nor `y` are elements of library domains with `"_divide"` methods, `x/y` is internally represented as `x * y^(-1)` = ```_mult(x, _power(y, -1))```.

If `x` or `y` is an element of a domain with a slot`"_divide"`, then this method is used to compute `x/y`. Many library domains overload the `/` operator by an appropriate `"_divide"` slot. Quotients are processed as follows:

`x/y` is searched for elements of library domains from left to right. Let `z` (either `x` or `y`) be the first term that is not of one of the basic types provided by the kernel (numbers, expressions, etc.). If the domain `d` = `z::dom` = `domtype(z)` has a slot`"_divide"`, it is called in the form `d::_divide(x, y)`. The result returned by `d::_divide` is the result of `x/y`.

Cf. examples Example 4 and Example 5.

Polynomials of type `DOM_POLY` can be divided by `/`, if they have the same indeterminates and the same coefficient ring, and if exact division is possible. The function `divide` can be used to compute the quotient of polynomials with a remainder term.

For finite sets `X`, `Y`, the quotient `X/Y` is the set .

## Examples

### Example 1

The quotient of numbers is simplified to a number:

`1234/234, 7.5/7, 6*I/2`

Internally, a symbolic quotient `x/y` is represented as the product `x * y^(-1)`:

`type(x/y), op(x/y, 0), op(x/y, 1), op(x/y, 2)`

`op(op(x/y, 2), 0), op(op(x/y, 2), 1), op(op(x/y, 2), 2)`

### Example 2

For finite sets `X`, `Y`, the quotient `X/Y` is the set :

`{a, b, c} / {2, 3}`

### Example 3

Polynomials of type `DOM_POLY` can be divided by `/` if they have the same indeterminates, the same coefficient ring, and if exact division is possible:

`poly(x^2 - 1, [x]) / poly(x - 1, [x])`

`poly(x^2 - 1, [x]) / poly(x - 2, [x])`

The function `divide` provides division with a remainder:

`divide(poly(x^2 - 1, [x]), poly(x - 2, [x]))`

The polynomials must have the same indeterminates and the same coefficient ring:

`poly(x^2 - 1, [x, y]) / poly(x - 1, [x])`
```Error: Invalid argument. [divide] ```

### Example 4

Various library domains such as matrix domains overload `_divide`. The matrix domain defines `x/y` as ```x * (1/y)```, where `1/y` is the inverse of `y`:

```x := Dom::Matrix(Dom::Integer)([[1, 2], [3, 4]]): y := Dom::Matrix(Dom::Rational)([[10, 11], [12, 13]]): x/y```

The inverse of `x` has rational entries. Therefore, `1/x` returns `FAIL`, because the component ring of `x` is `Dom::Integer`. Consequently, also `y/x` returns `FAIL`:

`y/x`

`delete x, y:`

### Example 5

This example demonstrates the behavior of `_divide` on user-defined domains. In the first case below, the user-defined domain does not have a `"_divide"`slot. Thus `x/y` is transformed to `x * (1/y)`:

```Do := newDomain("Do"): x := new(Do, 1): y := new(Do, 2): x/y; op(x/y, 0..2)```

After the slot`"_divide"` is defined in the domain `Do`, this method is used to divide elements:

`Do::_divide := proc() begin "The Result" end: x/y`

`delete Do, x, y:`

## Parameters

 `x, y, …`

## Return Values

Arithmetical expression, a polynomial, or a set.

`x`, ` y`