Sponsored links: Algebra eBooks ### Related

##### describe-eigenvalues

describe(eigenvalues);

Calculate

describe(rk);

Calculate

##### describe-float

describe (float);

Calculate

##### describe-plot2d plot2d([[parametric, ...

describe( "plotting o...

Calculate

##### describe-expand

describe(expand);

Calculate

##### describe-eliminate-rat

p(z):= a*z^2+b;

q(z):= c*z^2+d;

nxt(ns) := rat(ns^...

Calculate

##### describe-trigexpand

describe(trigexpand);

Calculate

##### describe-solvetrigwarn

describe(solvetrigwarn);

Calculate

##### describe-float

describe (float);

Calculate

describe(ntrig);

Calculate

### describe

Run Example
```(%i1)describe(laplace);

-- Function: laplace (<expr>, <t>, <s>)
Attempts to compute the Laplace transform of <expr> with respect
to the variable <t> and transform parameter <s>.

`laplace' recognizes in <expr> the functions `delta', `exp',
`log', `sin', `cos', `sinh', `cosh', and `erf', as well as
`derivative', `integrate', `sum', and `ilt'. If laplace fails to
find a transform the function `specint' is called.  `specint' can
find the laplace transform for expressions with special functions
like the bessel functions `bessel_j', `bessel_i', ... and can
handle the `unit_step' function. See also `specint'.

If `specint' cannot find a solution too, a noun `laplace' is
returned.

<expr> may also be a linear, constant coefficient differential
equation in which case `atvalue' of the dependent variable is used.
The required atvalue may be supplied either before or after the
transform is computed.  Since the initial conditions must be
specified at zero, if one has boundary conditions imposed
elsewhere he can impose these on the general solution and
eliminate the constants by solving the general solution for them
and substituting their values back.

`laplace' recognizes convolution integrals of the form `integrate
(f(x) * g(t - x), x, 0, t)'; other kinds of convolutions are not
recognized.

Functional relations must be explicitly represented in <expr>;
implicit relations, established by `depends', are not recognized.
That is, if <f> depends on <x> and <y>, `f (x, y)' must appear in
<expr>.

See also `ilt', the inverse Laplace transform.

Examples:

(%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
a
%e  (2 s - 4)
(%o1)                    ---------------
2           2
(s  - 4 s + 5)
(%i2) laplace ('diff (f (x), x), x, s);
(%o2)             s laplace(f(x), x, s) - f(0)
(%i3) diff (diff (delta (t), t), t);
2
d
(%o3)                    --- (delta(t))
2
dt
(%i4) laplace (%, t, s);
!
d            !         2
(%o4)        - -- (delta(t))!      + s  - delta(0) s
dt           !
!t = 0
(%i5) assume(a>0)\$
(%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true;
- a - 1
gamma(a)   gamma(a) s
(%o6)                    -------- - -----------------
s            1     a
(- + 1)
s
(%i7) factor(laplace(gamma_incomplete(1/2,t),t,s));
s + 1
sqrt(%pi) (sqrt(s) sqrt(-----) - 1)
s
(%o7)                 -----------------------------------
3/2      s + 1
s    sqrt(-----)
s
(%i8) assume(exp(%pi*s)>1)\$
(%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s),simpsum;
%i                         %i
------------------------ - ------------------------
- %pi s                    - %pi s
(s + %i) (1 - %e       )   (s - %i) (1 - %e       )
(%o9)         ---------------------------------------------------
2
(%i9) factor(%);
%pi s
%e
(%o9)                   -------------------------------
%pi s
(s - %i) (s + %i) (%e      - 1)

There are also some inexact matches for `laplace'.
Try `?? laplace' to see them.

(%o1)                                true
(%i2) ```
Run Example
```describe(eigenvalues);

-- Function: eigenvalues (<M>)
-- Function: eivals (<M>)
Returns a list of two lists containing the eigenvalues of the
matrix <M>.  The first sublist of the return value is the list of
eigenvalues of the matrix, and the second sublist is the list of
the multiplicities of the eigenvalues in the corresponding order.

`eivals' is a synonym for `eigenvalues'.

`eigenvalues' calls the function `solve' to find the roots of the
characteristic polynomial of the matrix.  Sometimes `solve' may
not be able to find the roots of the polynomial; in that case some
other functions in this package (except `innerproduct',
`unitvector', `columnvector' and `gramschmidt') will not work.

In some cases the eigenvalues found by `solve' may be complicated
expressions.  (This may happen when `solve' returns a
not-so-obviously real expression for an eigenvalue which is known
to be real.)  It may be possible to simplify the eigenvalues using
some other functions.

The package `eigen.mac' is loaded automatically when `eigenvalues'
or `eigenvectors' is referenced.  If `eigen.mac' is not already
and variables in the package are available.

There are also some inexact matches for `eigenvalues'.
Try `?? eigenvalues' to see them.

(%o1)                                true
(%i2) ```
Run Example
```describe(eigenvectors);

-- Function: eigenvectors (<M>)
-- Function: eivects (<M>)
Computes eigenvectors of the matrix <M>.  The return value is a
list of two elements.  The first is a list of the eigenvalues of
<M> and a list of the multiplicities of the eigenvalues.  The
second is a list of lists of eigenvectors.  There is one list of
eigenvectors for each eigenvalue.  There may be one or more
eigenvectors in each list.

`eivects' is a synonym for `eigenvectors'.

The package `eigen.mac' is loaded automatically when `eigenvalues'
or `eigenvectors' is referenced.  If `eigen.mac' is not already
and variables in the package are available.

The flags that affect this function are:

`nondiagonalizable' is set to `true' or `false' depending on
whether the matrix is nondiagonalizable or diagonalizable after
`eigenvectors' returns.

`hermitianmatrix' when `true', causes the degenerate eigenvectors
of the Hermitian matrix to be orthogonalized using the
Gram-Schmidt algorithm.

`knowneigvals' when `true' causes the `eigen' package to assume the
eigenvalues of the matrix are known to the user and stored under
the global name `listeigvals'.  `listeigvals' should be set to a
list similar to the output `eigenvalues'.

The function `algsys' is used here to solve for the eigenvectors.
Sometimes if the eigenvalues are messy, `algsys' may not be able
to find a solution.  In some cases, it may be possible to simplify
the eigenvalues by first finding them using `eigenvalues' command
and then using other functions to reduce them to something simpler.
Following simplification, `eigenvectors' can be called again with
the `knowneigvals' flag set to `true'.

Examples:

A matrix which has just one eigenvector per eigenvalue.

(%i1) M1 : matrix ([11, -1], [1, 7]);
[ 11  - 1 ]
(%o1)                      [         ]
[ 1    7  ]
(%i2) [vals, vecs] : eigenvectors (M1);
(%o2) [[[9 - sqrt(3), sqrt(3) + 9], [1, 1]],
[[[1, sqrt(3) + 2]], [[1, 2 - sqrt(3)]]]]
(%i3) for i thru length (vals) do disp (val[i] = vals[i],
mult[i] = vals[i], vec[i] = vecs[i]);
val  = 9 - sqrt(3)
1

mult  = 1
1

vec  = [[1, sqrt(3) + 2]]
1

val  = sqrt(3) + 9
2

mult  = 1
2

vec  = [[1, 2 - sqrt(3)]]
2

(%o3)                         done

A matrix which has two eigenvectors for one eigenvalue (namely 2).

(%i1) M1 : matrix ([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]);
[ 0  1  0  0 ]
[            ]
[ 0  0  0  0 ]
(%o1)                    [            ]
[ 0  0  2  0 ]
[            ]
[ 0  0  0  2 ]
(%i2) [vals, vecs] : eigenvectors (M1);
(%o2) [[[0, 2], [2, 2]], [[[1, 0, 0, 0]],
[[0, 0, 1, 0], [0, 0, 0, 1]]]]
(%i3) for i thru length (vals) do disp (val[i] = vals[i],
mult[i] = vals[i], vec[i] = vecs[i]);
val  = 0
1

mult  = 2
1

vec  = [[1, 0, 0, 0]]
1

val  = 2
2

mult  = 2
2

vec  = [[0, 0, 1, 0], [0, 0, 0, 1]]
2

(%o3)                         done

There are also some inexact matches for `eigenvectors'.
Try `?? eigenvectors' to see them.

(%o1)                                true
(%i2) ```

### Related Help

Help for Describe 