Next: Functions and Variables for Facts, Previous: Introduction to Maxima's Database, Up: Maxima's Database [Contents][Index]
alphabetic is a property type recognized by declare.
The expression declare(s, alphabetic) tells Maxima to recognize
as alphabetic all of the characters in s, which must be a string.
See also Identifiers.
Example:
(%i1) xx\~yy\`\@ : 1729;
(%o1)                         1729
(%i2) declare ("~`@", alphabetic);
(%o2)                         done
(%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
(%o3)               `xx@@yy~ + @yy`xx + 1729
(%i4) listofvars (%);
(%o4)                  [@yy`xx, `xx@@yy~]
The command declare(x, bindtest) tells Maxima to trigger an error
when the symbol x is evaluated unbound.
(%i1) aa + bb; (%o1) bb + aa (%i2) declare (aa, bindtest); (%o2) done (%i3) aa + bb; aa unbound variable -- an error. Quitting. To debug this try debugmode(true); (%i4) aa : 1234; (%o4) 1234 (%i5) aa + bb; (%o5) bb + 1234
declare(a, constant) declares a to be a constant.  The
declaration of a symbol to be constant does not prevent the assignment of a
nonconstant value to the symbol.
Example:
(%i1) declare(c, constant); (%o1) done (%i2) constantp(c); (%o2) true (%i3) c : x; (%o3) x (%i4) constantp(c); (%o4) false
Returns true if expr is a constant expression, otherwise returns
false.
An expression is considered a constant expression if its arguments are
numbers (including rational numbers, as displayed with /R/),
symbolic constants such as %pi, %e, and %i,
variables bound to a constant or declared constant by declare,
or functions whose arguments are constant.
constantp evaluates its arguments.
See the property constant which declares a symbol to be constant.
Examples:
(%i1) constantp (7 * sin(2)); (%o1) true (%i2) constantp (rat (17/29)); (%o2) true (%i3) constantp (%pi * sin(%e)); (%o3) true (%i4) constantp (exp (x)); (%o4) false (%i5) declare (x, constant); (%o5) done (%i6) constantp (exp (x)); (%o6) true (%i7) constantp (foo (x) + bar (%e) + baz (2)); (%o7) false (%i8)
Assigns the atom or list of atoms a_i the property or list of properties p_i. When a_i and/or p_i are lists, each of the atoms gets all of the properties.
declare quotes its arguments.  declare always returns done.
As noted in the description for each declaration flag, for some flags
featurep(object, feature) returns true if object
has been declared to have feature.
For more information about the features system, see features. To
remove a property from an atom, use remove.
declare recognizes the following properties:
additiveTells Maxima to simplify a_i expressions by the substitution
a_i(x + y + z + ...) -->
a_i(x) + a_i(y) + a_i(z) + ....
The substitution is carried out on the first argument only.
alphabeticTells Maxima to recognize all characters in a_i (which must be a string) as alphabetic characters.
antisymmetric, commutative, symmetricTells Maxima to recognize a_i as a symmetric or antisymmetric
function.  commutative is the same as symmetric.
bindtestTells Maxima to trigger an error when a_i is evaluated unbound.
constantTells Maxima to consider a_i a symbolic constant.
even, oddTells Maxima to recognize a_i as an even or odd integer variable.
evenfun, oddfunTells Maxima to recognize a_i as an odd or even function.
evflagMakes a_i known to the ev function so that a_i is bound
to true during the execution of ev when a_i appears as
a flag argument of ev.
evfunMakes a_i known to ev so that the function named by a_i
is applied when a_i appears as a flag argument of ev.
featureTells Maxima to recognize a_i as the name of a feature. Other atoms may then be declared to have the a_i property.
increasing, decreasingTells Maxima to recognize a_i as an increasing or decreasing function.
integer, nonintegerTells Maxima to recognize a_i as an integer or noninteger variable.
integervaluedTells Maxima to recognize a_i as an integer-valued function.
lassociative, rassociativeTells Maxima to recognize a_i as a right-associative or left-associative function.
linearEquivalent to declaring a_i both outative and
additive.
mainvarTells Maxima to consider a_i a "main variable".  A main variable
succeeds all other constants and variables in the canonical ordering of
Maxima expressions, as determined by ordergreatp.
multiplicativeTells Maxima to simplify a_i expressions by the substitution
a_i(x * y * z * ...) --> 
a_i(x) * a_i(y) * a_i(z) * ....
The substitution is carried out on the first argument only.
naryTells Maxima to recognize a_i as an n-ary function.
The nary declaration is not the same as calling the nary
function.  The sole effect of declare(foo, nary) is to instruct the
Maxima simplifier to flatten nested expressions, for example, to simplify
foo(x, foo(y, z)) to foo(x, y, z).
nonarrayTells Maxima to consider a_i not an array. This declaration prevents multiple evaluation of a subscripted variable name.
nonscalarTells Maxima to consider a_i a nonscalar variable. The usual application is to declare a variable as a symbolic vector or matrix.
nounTells Maxima to parse a_i as a noun.  The effect of this is to
replace instances of a_i with 'a_i or
nounify(a_i), depending on the context.
outativeTells Maxima to simplify a_i expressions by pulling constant factors out of the first argument.
When a_i has one argument, a factor is considered constant if it is a literal or declared constant.
When a_i has two or more arguments, a factor is considered constant if the second argument is a symbol and the factor is free of the second argument.
posfunTells Maxima to recognize a_i as a positive function.
rational, irrationalTells Maxima to recognize a_i as a rational or irrational real variable.
real, imaginary, complexTells Maxima to recognize a_i as a real, pure imaginary, or complex variable.
scalarTells Maxima to consider a_i a scalar variable.
Examples of the usage of the properties are available in the documentation for each separate description of a property.
The commands declare(f, decreasing) or
declare(f, increasing) tell Maxima to recognize the function
f as an decreasing or increasing function.
See also declare for more properties.
Example:
(%i1) assume(a > b); (%o1) [a > b] (%i2) is(f(a) > f(b)); (%o2) unknown (%i3) declare(f, increasing); (%o3) done (%i4) is(f(a) > f(b)); (%o4) true
declare(a, even) or declare(a, odd) tells Maxima to
recognize the symbol a as an even or odd integer variable.  The
properties even and odd are not recognized by the functions
evenp, oddp, and integerp.
See also declare and askinteger.
Example:
(%i1) declare(n, even); (%o1) done (%i2) askinteger(n, even); (%o2) yes (%i3) askinteger(n); (%o3) yes (%i4) evenp(n); (%o4) false
Maxima understands two distinct types of features, system features and features
which apply to mathematical expressions.  See also status for information
about system features.  See also features and featurep for
information about mathematical features.
feature itself is not the name of a function or variable.
Attempts to determine whether the object a has the feature f on the
basis of the facts in the current database.  If so, it returns true,
else false.
Note that featurep returns false when neither f
nor the negation of f can be established.
featurep evaluates its argument.
See also declare and features.
(%i1) declare (j, even)$ (%i2) featurep (j, integer); (%o2) true
Maxima recognizes certain mathematical properties of functions and variables. These are called "features".
declare (x, foo) gives the property foo
to the function or variable x.
declare (foo, feature) declares a new feature foo.
For example,
declare ([red, green, blue], feature)
declares three new features, red, green, and blue.
The predicate featurep (x, foo)
returns true if x has the foo property,
and false otherwise.
The infolist features is a list of known features.  These are
integer noninteger even odd rational irrational real imaginary complex analytic increasing decreasing oddfun evenfun posfun constant commutative lassociative rassociative symmetric antisymmetric integervalued
plus any user-defined features.
features is a list of mathematical features.  There is also a list of
non-mathematical, system-dependent features.  See status.
Example:
(%i1) declare (FOO, feature); (%o1) done (%i2) declare (x, FOO); (%o2) done (%i3) featurep (x, FOO); (%o3) true
Retrieves the user property indicated by i associated with
atom a or returns false if a doesn’t have property i.
get evaluates its arguments.
(%i1) put (%e, 'transcendental, 'type);
(%o1)                    transcendental
(%i2) put (%pi, 'transcendental, 'type)$
(%i3) put (%i, 'algebraic, 'type)$
(%i4) typeof (expr) := block ([q],
        if numberp (expr)
        then return ('algebraic),
        if not atom (expr)
        then return (maplist ('typeof, expr)),
        q: get (expr, 'type),
        if q=false
        then errcatch (error(expr,"is not numeric.")) else q)$
(%i5) typeof (2*%e + x*%pi);
x is not numeric.
(%o5)  [[transcendental, []], [algebraic, transcendental]]
(%i6) typeof (2*%e + %pi);
(%o6)     [transcendental, [algebraic, transcendental]]
declare(a, integer) or declare(a, noninteger) tells
Maxima to recognize a as an integer or noninteger variable.
See also declare.
Example:
(%i1) declare(n, integer, x, noninteger); (%o1) done (%i2) askinteger(n); (%o2) yes (%i3) askinteger(x); (%o3) no
declare(f, integervalued) tells Maxima to recognize f as an
integer-valued function.
See also declare.
Example:
(%i1) exp(%i)^f(x);
                              %i f(x)
(%o1)                      (%e  )
(%i2) declare(f, integervalued);
(%o2)                         done
(%i3) exp(%i)^f(x);
                              %i f(x)
(%o3)                       %e
The command declare(a, nonarray) tells Maxima to consider a not
an array.  This declaration prevents multiple evaluation, if a is a
subscripted variable.
See also declare.
Example:
(%i1) a:'b$ b:'c$ c:'d$
(%i4) a[x];
(%o4)                          d
                                x
(%i5) declare(a, nonarray);
(%o5)                         done
(%i6) a[x];
(%o6)                          a
                                x
Makes atoms behave as does a list or matrix with respect to the dot operator.
See also declare.
Returns true if expr is a non-scalar, i.e., it contains
atoms declared as non-scalars, lists, or matrices.
declare (f, posfun) declares f to be a positive function.
is (f(x) > 0) yields true.
See also declare.
Displays the property with the indicator i associated with the atom
a.  a may also be a list of atoms or the atom all in which
case all of the atoms with the given property will be used.  For example,
printprops ([f, g], atvalue).  printprops is for properties that
cannot otherwise be displayed, i.e.  for atvalue,
atomgrad, gradef, and matchdeclare.
Returns a list of the names of all the properties associated with the atom a.
Default value: []
props are atoms which have any property other than those explicitly
mentioned in infolists, such as specified by atvalue,
matchdeclare, etc., as well as properties specified in the
declare function.
Returns a list of those atoms on the props list which
have the property indicated by prop.  Thus propvars (atvalue)
returns a list of atoms which have atvalues.
Assigns value to the property (specified by indicator) of atom. indicator may be the name of any property, not just a system-defined property.
rem reverses the effect of put.
put evaluates its arguments.
put returns value.
Examples:
(%i1) put (foo, (a+b)^5, expr);
                                   5
(%o1)                       (b + a)
(%i2) put (foo, "Hello", str);
(%o2)                         Hello
(%i3) properties (foo);
(%o3)            [[user properties, str, expr]]
(%i4) get (foo, expr);
                                   5
(%o4)                       (b + a)
(%i5) get (foo, str);
(%o5)                         Hello
Assigns value to the property (specified by indicator) of
atom.  This is the same as put, except that the arguments are
quoted.
See also get.
Example:
(%i1) foo: aa$ 
(%i2) bar: bb$
(%i3) baz: cc$
(%i4) put (foo, bar, baz);
(%o4)                          bb
(%i5) properties (aa);
(%o5)                [[user properties, cc]]
(%i6) get (aa, cc);
(%o6)                          bb
(%i7) qput (foo, bar, baz);
(%o7)                          bar
(%i8) properties (foo);
(%o8)            [value, [user properties, baz]]
(%i9) get ('foo, 'baz);
(%o9)                          bar
declare(a, rational) or declare(a, irrational) tells
Maxima to recognize a as a rational or irrational real variable.
See also declare.
declare(a, real), declare(a, imaginary), or
declare(a, complex) tells Maxima to recognize a as a real,
pure imaginary, or complex variable.
See also declare.
Removes the property indicated by indicator from atom.
rem reverses the effect of put.
rem returns done if atom had an indicator property
when rem was called, or false if it had no such property.
Removes properties associated with atoms.
remove (a_1, p_1, ..., a_n, p_n)
removes property p_k from atom a_k.
remove ([a_1, ..., a_m], [p_1, ..., p_n], ...)
removes properties p_1, ..., p_n
from atoms a_1, …, a_m.
There may be more than one pair of lists.
remove (all, p) removes the property p from all atoms which
have it.
The removed properties may be system-defined properties such as
function, macro, or mode_declare.
remove does not remove properties defined by put.
A property may be transfun to remove
the translated Lisp version of a function.
After executing this, the Maxima version of the function is executed
rather than the translated version.
remove ("a", operator) or, equivalently,
remove ("a", op) removes from a the operator properties
declared by prefix, infix,
nary, postfix, matchfix, or
nofix.  Note that the name of the operator must be written as a quoted
string.
remove always returns done whether or not an atom has a specified
property.  This behavior is unlike the more specific remove functions
remvalue, remarray, remfunction, and
remrule.
remove quotes its arguments.
declare(a, scalar) tells Maxima to consider a a scalar
variable.
See also declare.
Returns true if expr is a number, constant, or variable declared
scalar with declare, or composed entirely of numbers,
constants, and such variables, but not containing matrices or lists.
See also the predicate function nonscalarp.
Next: Functions and Variables for Facts, Previous: Introduction to Maxima's Database, Up: Maxima's Database [Contents][Index]