Documentation

This is machine translation

Translated by
Mouse over text to see original. Click the button below to return to the English verison of the page.

conjugate

Complex conjugation

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

Syntax

```conjugate(`z`)
conjugate(`L`)
```

Description

`conjugate(z)` computes the conjugate (z) - i (z) of a complex number z = (z) + i (z).

For numbers of type `DOM_INT`, `DOM_RAT`, `DOM_FLOAT`, or `DOM_COMPLEX`, the conjugate is computed directly and very efficiently.

`conjugate` can handle symbolic expressions. Properties of identifiers are taken into account (see `assume`). An identifier `z` without any property is assumed to be complex, and the symbolic call `conjugate(z)` is returned. See Example 2.

`conjugate` knows how to handle special mathematical functions, such as:

```_mult _plus _power abs cos cosh cot coth csc csch erf erfc exp gamma igamma sec sech sin sinh tan tanh ```
See Example 1.

If `conjugate` does not know how to handle a special mathematical function, then a symbolic `conjugate` call is returned. See Example 3.

This function is automatically mapped to all entries of container objects such as arrays, lists, matrices, polynomials, sets, and tables.

Environment Interactions

`conjugate` is sensitive to properties of identifiers set via `assume`.

Examples

Example 1

`conjugate` knows how to handle sums, products, the exponential function and the sine function:

`conjugate((1 + I)*exp(2 - 3*I))`
``` ```
`delete z: conjugate(z + 2*sin(3 - 5*I))`
``` ```

Example 2

`conjugate` reacts to properties of identifiers:

```delete x, y: assume(x, Type::Real): conjugate(x), conjugate(y)```
``` ```

Example 3

If the input contains a function that the system does not know, then a symbolic `conjugate` call is returned:

`delete f, z: conjugate(f(z) + I)`
``` ```

Now suppose that `f` is some user-defined mathematical function, and that $\overline{f\left(z\right)}=f\left(\overline{z}\right)$ holds for all complex numbers z. To extend the functionality of `conjugate` to `f`, we embed it into a function environment and suitably define its `"conjugate"` slot:

```f := funcenv(f): f::conjugate := u -> f(conjugate(u)):```

Now, whenever `conjugate` is called with an argument of the form `f(u)`, it calls `f::conjugate(u)`, which in turn returns `f(conjugate(u))`:

`conjugate(f(z) + I), conjugate(f(I))`
``` ```

Parameters

 `z` `L` A container object: an array, an hfarray, a list, a matrix, a polynomial, a set, or a table.

Return Values

arithmetical expression or a container object containing such expressions

`z`

Algorithms

If a subexpression of the form `f(u,...)` occurs in `z` and `f` is a function environment, then `conjugate` attempts to call the slot `"conjugate"` of `f` to determine the conjugate of `f(u,...)`. In this way, you can extend the functionality of `conjugate` to your own special mathematical functions.

The slot `"conjugate"` is called with the arguments `u`,... of `f`.

If `f` has no slot `"conjugate"`, then the subexpression `f(u,...)` is replaced by the symbolic call `conjugate(f(u,...))` in the returned expression.

See Example 3.

Similarly, if an element `d` of a library domain`T` occurs as a subexpression of `z`, then `conjugate` attempts to call the slot `"conjugate"` of that domain with `d` as argument to compute the conjugate of `d`.

If `T` does not have a slot `"conjugate"`, then `d` is replaced by the symbolic call `conjugate(d)` in the returned expression.