Sponsored links: Algebra eBooks ### The Maxima on-line user's manual

Algebra Calculator

#### Search: #### Let

Function: let (<prod>, <repl>, <predname>, <arg_1>, ..., <arg_n>)

Function: let ([<prod>, <repl>, <predname>, <arg_1>, ..., <arg_n>], <package_name>) Defines a substitution rule for `letsimp` such that <prod> is replaced by <repl>. <prod> is a product of positive or negative powers of the following terms:

* Atoms which `letsimp` will search for literally unless previous to calling `letsimp` the `matchdeclare` function is used to associate a predicate with the atom. In this case `letsimp` will match the atom to any term of a product satisfying the predicate.

* Kernels such as `sin(x)`, `n!`, `f(x,y)`, etc. As with atoms above `letsimp` will look for a literal match unless `matchdeclare` is used to associate a predicate with the argument of the kernel.

A term to a positive power will only match a term having at least that power. A term to a negative power on the other hand will only match a term with a power at least as negative. In the case of negative powers in <prod> the switch `letrat` must be set to `true`. See also `letrat`.

If a predicate is included in the `let` function followed by a list of arguments, a tentative match (i.e. one that would be accepted if the predicate were omitted) is accepted only if `predname (arg_1`, ..., arg_n) evaluates to `true` where <arg_i> is the value matched to <arg_i>. The <arg_i> may be the name of any atom or the argument of any kernel appearing in <prod>. <repl> may be any rational expression. If any of the atoms or arguments from <prod> appear in <repl> the appropriate substitutions are made. The global flag `letrat` controls the simplification of quotients by `letsimp`. When `letrat` is `false`, `letsimp` simplifies the numerator and denominator of <expr> separately, and does not simplify the quotient. Substitutions such as `n!/n` goes to `(n-1)!` then fail. When `letrat` is `true`, then the numerator, denominator, and the quotient are simplified in that order.

These substitution functions allow you to work with several rule packages at once. Each rule package can contain any number of `let` rules and is referenced by a user-defined name. `let ([<prod>, <repl>, <predname>, <arg_1>, ..., <arg_n>], <package_name>)` adds the rule <predname> to the rule package <package_name>. `letsimp (<expr>, <package_name>)` applies the rules in <package_name>. `letsimp (<expr>, <package_name1>, <package_name2>, ...)` is equivalent to `letsimp (<expr>,`

``     <package_name1>)` followed by `letsimp (%, <package_name2>)`, ....`

`current_let_rule_package` is the name of the rule package that is presently being used. This variable may be assigned the name of any rule package defined via the `let` command. Whenever any of the functions comprising the `let` package are called with no package name, the package named by `current_let_rule_package` is used. If a call such as `letsimp (<expr>, <rule_pkg_name>)` is made, the rule package <rule_pkg_name> is used for that `letsimp` command only, and `current_let_rule_package` is not changed. If not otherwise specified, `current_let_rule_package` defaults to `default_let_rule_package`.

```          (%i1) matchdeclare ([a, a1, a2], true)\$
(%i2) oneless (x, y) := is (x = y-1)\$
(%i3) let (a1*a2!, a1!, oneless, a2, a1);
(%o3)         a1 a2! --> a1! where oneless(a2, a1)
(%i4) letrat: true\$
(%i5) let (a1!/a1, (a1-1)!);
a1!
(%o5)                   --- --> (a1 - 1)!
a1
(%i6) letsimp (n*m!*(n-1)!/m);
(%o6)                      (m - 1)! n!
(%i7) let (sin(a)^2, 1 - cos(a)^2);
2               2
(%o7)                sin (a) --> 1 - cos (a)
(%i8) letsimp (sin(x)^4);
4           2
(%o8)                cos (x) - 2 cos (x) + 1```

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

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

### Related Examples

##### let-letsimp

expr : ((2*%pi*n)/(%p...

let (b*c, E);

letsimp (expr);

Calculate

:lisp (defun ucs-inse...

:lisp (loop for x fro...

Calculate

##### let

:lisp (defun swap (a ...

:lisp (swap 1 2);

:lisp (defun swaps (s...

Calculate

:lisp (defun ucs-inse...

:lisp (loop for x fro...

Calculate

##### let

:lisp (setq a '(1 (2 ...

:lisp (dotimes (i 8) ...

:lisp (setq a '(1 2 3...

Calculate

##### let-letsimp-solve

eq1: (10+x)^2 = 100 +...

eq2: y^2 = z^2 + w^2;

eq3: (10+w)^2 = (10+x...

Calculate

##### let-letsimp-solve

eq1: (10+x)^2 = 100 +...

eq2: y^2 = z^2 + w^2;

eq3: (10+w)^2 = (10+x...

Calculate

##### let

:lisp (let ((result))...

Calculate

##### let

:lisp (defun node (tr...

:lisp (defun left-bra...

:lisp (defun right-br...

Calculate

##### let-letsimp

eq1:x+y+z;

let(x,e);

letsimp(eq1);

Calculate 