< , > , <= , >= , != , = , Not , And , Or , IsFreeOf , IsZeroVector , IsNonObject , IsEven , IsOdd , IsFunction , IsAtom , IsString , IsNumber , IsInteger , IsList , IsBound , IsBoolean , IsNegativeNumber , IsNegativeInteger , IsPositiveNumber , IsPositiveInteger , IsNotZero , IsNonZeroInteger , IsInfinity , IsConstant , Predicates

Predicates


x < y (prec. 9)

x < y : Return True if "x" is smaller than "y", False otherwise.


x > y (prec. 9)

x > y : Return True if "x" is larger than "y", False otherwise.


x <= y (prec. 9)

x <= y : Return True if "x" is smaller than or equals "y", False otherwise.


x >= y (prec. 9)

x >= y : Return True if "x" is larger than or equals "y", False otherwise.


x!=y (prec. 9)

x!=y : Return True if "x" is not equal to "y", False otherwise.


x=y (prec. 9)

x=y : This operator performs the same action as Equals(x,y). It returns True if x and y would be displayed on screen the same, False otherwise.


Not(x)

Not(x) : Same as MatNot. Just nicer notation. Returns "True" if "x" is "False", "False" of x is "True".


x And y (prec. 100)

x And y : Infix version of boolean and.


x Or y (prec. 101)

x Or y : Infix version of boolean or.


IsFreeOf(expression,variable) or IsFreeOf(expression,{varlist})

Returns wether "expression" depends on "variable". "expression" is evaluated beforehand. Example: "IsFreeOf(x+y,x);" evaluates to "False".

When a list of variables is passed, IsFreeOf returns True iff the expression is independent of all the variables listed. "IsFreeOf(x+y,{a,b});" would return True, and "IsFreeOf(x+y,{a,x});" would return False.


IsZeroVector(vector)

Returns wether "vector" only contains zeroes. "vector" should be a list.


IsNonObject(x)

IsNonObject(x) : returns true if x is not of the form Object(...).


IsEven(n) and IsOdd(n)

Returns whether the integer n is even or odd (an integer n is even if n divided by 2 is also an integer).


IsFunction(expr)

IsFunction(expr) : Predicate that checks the type of a object. cos(a) is a function.


IsAtom(expr)

IsAtom(expr) : Predicate that checks the type of a object. Atoms are any object that can be represented with a text string (that is, excluding lists).


IsString(expr)

IsString(expr) : Predicate that checks the type of a object. Strings have the form "string", that is, with quotes.


IsNumber(expr)

IsNumber(expr) : Predicate that checks the type of a object. 1.2 or 1 are numbers.


IsInteger(expr)

IsInteger(expr) : Predicate that checks the type of a object. 1 is a integer.


IsList(expr)

IsList(expr) : Predicate that checks the type of a object. {cos,a} is a list.


IsBound(var)

IsBound(var) :Predicate that checks the type of a object. IsBound checks to see if variable var is bound.


IsBoolean

Standard math library
Calling Sequence:
IsBoolean(expression)
Parameters:
expression - an expression
Description:
IsBoolean returns True if the argument is of a boolean type. This means it has to be either True, False, or an expression involving functions that return a boolean result, like =, >, <, >=, <=, !=, And, Not, Or.
Examples:
In> IsBoolean(a)
Out> False;
In> IsBoolean(True)
Out> True;
In> IsBoolean(a And b)
Out> True;

See Also:
True , False ,


Predicates on numbers

These predicates return whether the argument is a number, and of a specific type.


IsNegativeNumber(n)


IsNegativeInteger(n)


IsPositiveNumber(n)


IsPositiveInteger(n)


IsNotZero(n)


IsNonZeroInteger(n)


IsInfinity(n)

Returns True if the argument is either Infinity or -Infinity


IsConstant

Standard math library
Calling Sequence:
IsConstant(expression)
Parameters:
expression - some expression
Description:
IsConstant returns True if the expression is some constant or a function with constant arguments. It does this by checking that no variables are referenced in the expression.
Examples:
In> IsConstant(Cos(x))
Out> False;
In> IsConstant(Cos(2))
Out> True;
In> IsConstant(Cos(2+x))
Out> False;
See Also:
IsNumber , IsInteger ,