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
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
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
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 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
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>, 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
(%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 to see them.
(%o1) true (%i2)