Next: , Previous: , Up: Maxima’s Database   [Contents][Index]

11.2 Functions and Variables for Properties

Property: alphabetic

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~]
Categories: Declarations and inferences ·
Property: bindtest

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
Property: constant

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.

See constantp and declare.

Example: 

(%i1) declare(c, constant);
(%o1)                         done
(%i2) constantp(c);
(%o2)                         true
(%i3) c : x;
(%o3)                           x
(%i4) constantp(c);
(%o4)                         false
Categories: Declarations and inferences · Constants ·
Function: constantp (expr)

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)
Categories: Predicate functions · Constants ·
Function: declare (a_1, p_1, a_2, p_2, …)

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:

additive

Tells 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.

alphabetic

Tells Maxima to recognize all characters in a_i (which must be a string) as alphabetic characters.

antisymmetric, commutative, symmetric

Tells Maxima to recognize a_i as a symmetric or antisymmetric function. commutative is the same as symmetric.

bindtest

Tells Maxima to trigger an error when a_i is evaluated unbound.

constant

Tells Maxima to consider a_i a symbolic constant.

even, odd

Tells Maxima to recognize a_i as an even or odd integer variable.

evenfun, oddfun

Tells Maxima to recognize a_i as an odd or even function.

evflag

Makes 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. See evflag.

evfun

Makes 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. See evfun.

feature

Tells Maxima to recognize a_i as the name of a feature. Other atoms may then be declared to have the a_i property.

increasing, decreasing

Tells Maxima to recognize a_i as an increasing or decreasing function.

integer, noninteger

Tells Maxima to recognize a_i as an integer or noninteger variable.

integervalued

Tells Maxima to recognize a_i as an integer-valued function.

lassociative, rassociative

Tells Maxima to recognize a_i as a right-associative or left-associative function.

linear

Equivalent to declaring a_i both outative and additive.

mainvar

Tells 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.

multiplicative

Tells 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.

nary

Tells 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).

nonarray

Tells Maxima to consider a_i not an array. This declaration prevents multiple evaluation of a subscripted variable name.

nonscalar

Tells Maxima to consider a_i a nonscalar variable. The usual application is to declare a variable as a symbolic vector or matrix.

noun

Tells 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.

outative

Tells 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.

posfun

Tells Maxima to recognize a_i as a positive function.

rational, irrational

Tells Maxima to recognize a_i as a rational or irrational real variable.

real, imaginary, complex

Tells Maxima to recognize a_i as a real, pure imaginary, or complex variable.

scalar

Tells 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.

Categories: Declarations and inferences ·
Property: decreasing
Property: increasing

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
Categories: Declarations and inferences ·
Property: even
Property: odd

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
Categories: Declarations and inferences ·
Property: feature

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.

Function: featurep (a, f)

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
Categories: Predicate functions · Declarations and inferences ·
Declaration: features

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
Categories: Declarations and inferences ·
Function: get (a, i)

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.

See also put and qput. 

(%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]]
Categories: Declarations and inferences ·
Property: integer
Property: noninteger

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
Categories: Declarations and inferences ·
Property: integervalued

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
Categories: Declarations and inferences ·
Property: nonarray

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
Categories: Expressions ·
Property: nonscalar

Makes atoms behave as does a list or matrix with respect to the dot operator.

See also declare.

Categories: Declarations and inferences · Vectors · Matrices ·
Function: nonscalarp (expr)

Returns true if expr is a non-scalar, i.e., it contains atoms declared as non-scalars, lists, or matrices.

See also the predicate function scalarp and declare.

Categories: Predicate functions · Vectors · Matrices ·
Property: posfun

declare (f, posfun) declares f to be a positive function. is (f(x) > 0) yields true.

See also declare.

Categories: Declarations and inferences · Operators ·
Function: printprops
    printprops (a, i)
    printprops ([a_1, …, a_n], i)
    printprops (all, i)

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.

Categories: Declarations and inferences · Display functions ·
Function: properties (a)

Returns a list of the names of all the properties associated with the atom a.

Categories: Declarations and inferences ·
System variable: props

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.

Categories: Declarations and inferences · Global variables ·
Function: propvars (prop)

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.

Categories: Declarations and inferences ·
Function: put (atom, value, indicator)

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.

See also qput and get.

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
Categories: Declarations and inferences ·
Function: qput (atom, value, indicator)

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
Categories: Declarations and inferences ·
Property: rational
Property: irrational

declare(a, rational) or declare(a, irrational) tells Maxima to recognize a as a rational or irrational real variable.

See also declare.

Categories: Declarations and inferences ·
Property: real
Property: imaginary
Property: complex

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.

Categories: Declarations and inferences ·
Function: rem (atom, indicator)

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.

Categories: Declarations and inferences ·
Function: remove
    remove (a_1, p_1, …, a_n, p_n)
    remove ([a_1, …, a_m], [p_1, …, p_n], …)
    remove ("a", operator)
    remove (a, transfun)
    remove (all, p)

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.

Categories: Declarations and inferences ·
Property: scalar

declare(a, scalar) tells Maxima to consider a a scalar variable.

See also declare.

Categories: Declarations and inferences ·
Function: scalarp (expr)

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.

Categories: Predicate functions · Vectors · Matrices ·

Next: , Previous: , Up: Maxima’s Database   [Contents][Index]