3  Computational objects

3.1  Numbers

There are two types of numbers in Xcas, approximate and exact.

Computer programs like Xcas regard floating point numbers, which are numbers displayed with decimal points, as approximations. Other numbers will be regarded as exact. For example, the number 2 is exactly 2, while 2.0 represents a number that equals 2 to within the current precision, which by default is about 12 significant digits (see section 2.3, “Configuration”). Approximate numbers can be entered by typing in a number with a decimal point or in scientific notation (which is a decimal number followed by e and then an integer, where the integer represents the power of 10). So 2000.0, 2e3 and 2.0e3 all represent the same approximate number.

Exact numbers are integers, symbolic constants (like e and π), and numeric expressions which only involve exact numbers. For example, sin(1) will be exact, and so won’t be given a decimal approximation; if you enter

sin(1)

you will get

However, sin(1.0) involves the approximate number 1.0, and so will be regarded as approximate itself. If you enter

sin(1.0)

you will get

As with many computer languages, if you enter an integer beginning with the digit 0, the Xcas will regard it as an integer base 8; if you enter

011

you will get

since 11 is the base 8 representation of the decimal number 9. Similarly, if you write 0x at the beginning of an integer, Xcas will regard it as a hexadecimal (base 16) integer. If you enter

0x11

you will get

since 11 is the base 16 representation of the decimal number 17.

The symbolic constants that are built in to Xcas are pi, e, i, infinity, +infinity and -infinity. Note that Xcas distinguishes between +infinity, -infinity and infinity, which is unsigned infinity. The distinction can be noted in the following calculations:

1/0

will result in infinity,

while

(1/0)^2

will result in +infinity,

and

-(1/0)^2

will result in -infinity,

These variables cannot be reassigned; in particular, the variable i can’t be used as a loop index.

Xcas can handle integers of arbitrary length; if, for example, you enter

500!

you will be given all 1135 digits of the factorial of 500.

When Xcas combines two numbers, the result will be exact unless one of the numbers is approximate, in which case the result will be approximate. For example, entering

3/2 + 1

will return the exact value

while entering

1.5 + 1

will return

The evalf function will transform a number to an approximate value. While entering

sqrt(2)

will return

entering

evalf(sqrt(2))

will return

which is the square root of two to the default precision, in this case 12 digits. The evalf function can also take a second argument which you can use to specify how many digits of precision that you want; for example if you want to know the square root of two to 50 digits, you can enter

evalf(sqrt(2),50)

and get

The exact function will turn an approximate value into a nearby exact value. Specifically, given an approximate value x, exact(x) will be a rational number r with |x − r| < є, where є is the value of the variable epsilon, which has a default value of 10⁻¹². This value is configurable (see section 2.3, “Configuration”).

3.2  Variables

A variable in Xcas begins with a letter and can contain letters, numbers and underscores.

A variable can be given a value with the assignment operator :=. If you enter

a := 3

then a will be replaced by 3 in all later calculations. If you later enter

4*a^2

you will get

The purge command will unassign a variable; if you enter

purge(a)

and then

4*a^2

you will get

The assignment operator := is one of three types of equalities used in Xcas. They are

• The assignment operator, :=, which is used to assign values.
• The Boolean equality, ==, which tells you whether two quantities are equal to each other or not. If you enter A==B, then you will get either true or false as a result. The predefined constants true and True are equal to 1, the predefined constants false and False are equal to 0.
• The equal sign = is used to define an equation. In this case, the equation will be the expression.

If you want to replace a variable by a value for a single expression, you can use the subst command. This command takes an expression and an equation var = value as a second argument. If a is an unassigned variable, for example, then entering

subst(a^2 + 2, a=3)

will result in

Afterwards, a will still be unassigned.

Even without giving a variable a value, you can still tell Xcas some of its properties with the assume command. For example, for a real number a, the expression √a² simplifies to |a|, since a could be positive or negative. If you enter

sqrt(a^2)

you will get

If you enter

assume(a<0)

beforehand, then Xcas will work under the assumption that a is negative, and so entering

sqrt(a^2)

will result in

As well as assuming that a variable satifies an equation or inequality, you can use the keywords and and or to assume that a variable satisifies more than one inequality. Some assumptions on a variable require a second argument; for example, to assume that a is an integer you can enter

assume(a,integer)

Afterwards

sin(a*pi)

will result in

The purge command will remove any assumptions about a variable as well as any assigned values.

3.3  Expressions

An expression is a combination of numbers and variables combined by arithmetic operators. For example, x^2 + 2*x + c is an expression.

When you enter an expression, Xcas will perform some automatic simplifications, such as

• Any variables that have been assigned are replaced by their values.
• Operations on numbers are performed.
• Trivial simplifications, such as x+0=x and x· 0 = 0, are made.
• Some trigonometric forms are rewritten; for example, cos(-x) is replaced by cos(x) and cos(pi/4) is replaced by √2/2.

Other simplifications are not done automatically, since it isn’t always clear what sort of simplifications the user might want, and besides non-trivial simplifications are time-consuming. The most used commands for simplifying and transforming commands are:

expand

This will expand integer powers and more generally distribute multiplication across addition. For example, if you enter

expand((x+1)^3)

you will get

x3 + 3*x2 + 3*x + 1

normal and ratnormal

These commands will reduce a rational function to lowest terms. For example, if you enter

normal((x^3-1)/(x^2-1))

then Xcas will cancel a common factor of x−1 from the top and bottom and return

x2+x+1 x+1

ratnormal will have the same behavior on this expression. The difference between the two commands is that ratnormal does not take into account reductions with algebraic numbers, while normal does. If you enter

ratnormal((x^2-2)/(x-sqrt(2)))

you will get

x2−2 x− √ 2

but if you enter

normal((x^2-2)/(x-sqrt(2)))

you will get

x+

√

2

Neither of these commands will take into account relationships between transcendental functions such as sin and cos.

factor

This will factor polynomials and reduce rational expressions. This is a little slower than normal and ratnormal and different in that it will give the result in factored form. For example, if you enter

factor(x^2 + 3*x + 2)

you will get

(x + 1)*(x + 2)

simplify

This command will try to reduce an expression to algebraically independent variables, then it will apply normal. Simplifications requiring algebraic extensions (such as roots) may require two calls to simplify and possibly adding some assumptions with assume.

tsimplify

Like simplify, this will try to reduce an expression to algebraically independent variables, but will not apply normal afterwards.

The convert command will rewrite expressions to different formats; the first argument will be the expression and the second argument will indicate the format to convert the expression to. For example, you can convert e^{i θ} to sines and cosines with

convert(exp(i*theta),sincos)

the result will be

You can use convert to find the partial fraction decomposition of a rational expression with a second argument of partfrac; for example, if you enter

convert((x-1)/(x^2 - x -2), partfrac)

you will get

3.4  Functions

Xcas has many built in functions; you can get a complete list with the help index. You can also define your own functions with the assignment (:=) operator. To define a function f given by f(x) = x*exp(x), for example, you can enter

f(x) := x*exp(x)

Note that in this case the name of the function is f; f(x) is the value of the function evaluated at x. The function is a rule which takes an input x and returns x*exp(x). This rule can be written without giving it a name as x -> x*exp(x). In fact, another way you can define the function f as above is

f := x ->x*exp(x)

In either case, if you enter

f(2)

you will get

You can similarly define functions of more than one variable. For example, to convert polar coordinates to rectangular coordinates, you could define

p(r,theta) := (r*cos(theta), r*sin(theta))

or equivalently

p := (r, theta) -> (r*cos(theta),r*sin(theta))

The unapply command will transform an expression into a function. It takes as arguments an expression and a variable, it will return the function defined by the expression. If you enter

unapply(x*exp(x),x)

you will get

The unapply command will return the function written in terms of built in functions; for example, for the function f defined above, if you enter

unapply(f(x),x)

you will also get

You can define a function in terms of a function that you previously defined, but it’s probably better to define any new functions in terms of built-in functions. For example, if you define

f(x) := exp(x)*sin(x)

you can define a new function

g(x) := x*f(x)

but it might be better to write

g(x) := x*exp(x)*sin(x)

Perhaps a better alternative is to use unapply; you can define g by g := unapply(x*f(x),x)

In some cases, it will be necessary to use unapply to define a function. For example (see section 4.1, “Derivatives”), the diff command will find the derivative of an expression; if you enter

diff(x*sin(x),x)

you will get

However, you cannot simply define a function g(x) := diff(x*sin(x),x) if you tried to do this, then evaluating g(0) for example would give you diff(0*sin(0),0), which is not what you want. Instead, you could define g by

g := unapply(diff(x*sin(x),x)

Another case where you need to use unapply to define a function is when you have a function of two variables and you want to use it to define a function of one variable, where the other variable is a parameter. For example, consider the polar coordinate function

p(r,theta) := (r*cos(theta), r*sin(theta))

If you want to use this to define C(r) as a function of θ for any value of r, you cannot simply define it as

C(r) := p(r,theta)

Doing this will define C(r) as an expression involving θ, not a function of θ. Entering

C(1)(pi/4)

would be the same as

(cos(theta),sin(theta))(pi/4)

which is not what you want. To define C(r), you would have to use unapply:

C(r) := unapply(p(r,theta),theta)

The necessity of using unapply in these cases is because when you define a function, the right hand side of the assignment is not evaluated. For example, if you try to define the squaring function by

sq := x^2

f(x) := sq

it will not work; if you enter f(5), for example, it will get the value sq, which will then be replaced by its value. You will end up getting x^2 and not 5^2. You should either define the function f by

f(x) := x^2

or perhaps

f := unapply(sq,x)

Functions (not just expressions) can be added and multiplied. To define a function which is the sine function times the exponential, instead of defining f(x) as the expression sin(x)*exp(x), you could simply enter

f := sin*exp

Functions can also be composed with the @ symbol. For example, if you define functions f and g by

f(x) := x^2 + 1

g(x) := sin(x)

then

f @ g

will result in

You can use the @ operator to compose a function with itself; f@f(x) is the same as f(f(x)), but if you want to compose a function with itself several times, you can use the @@ operator. Entering f @@ n for a positive integer n will give you the composition of f with itself n times; for example, if you enter

sin @@ 3

you will get

3.5  Lists, sequences and sets

Xcas can combine objects in several different ways.

sequences

A sequence is simply several items between parentheses, separated by commas. For example, (1,2,x,4) is a sequence. (The parentheses can be omitted, but it’s a good idea to use them.) Sequences are flat, meaning an element in a sequence cannot be another sequence. The empty sequence is denoted NULL.

lists

A list consists of several items between square brackets, separated by commas. For example, [1,2,x,4] is a list. A list can contain other lists as elements. Matrices, which will be discussed later, are lists of lists. The empty list is denoted [].

sets

A set consists of several items between %{ and %}, separated by commas. For example, %{1,2,3%} is a set. In a set, order doesn’t matter and each item only counts once. The sets %{1,2,3%} %{3,2,1%} and %{1,2,2,3%} are all the same set.

tables

Tables are described later.

A sequence can be turned into a list or a set by putting it between the appropriate delimiters. For example, if you define a sequence

se := (1,2,4,2)

then if you enter

[se]

you will get the list

You can turn a set or list into a sequence with the op command; if you define a set

st := %{1,2,3%}

and then enter

op(st)

you will get the sequence

You can find the number of elements in a sequence, list or set with the size command; with st as above,

size(st)

will return

Sequences can be built using one of the iteration commands seq or $. The seq command takes an expression as the first argument, the second argument will be a variable followed by a range in the form variable=beginning value..ending value. The resulting sequence will be the values of the expression with the variable replaced by the sequence of values. For example,

seq(k^2,k=-2..2)

will result in the sequence

The $ operator is an infix version of seq. If you enter

k^2$k=-2..2

you will get, as above,

A list can be built by putting a sequence in brackets; if you enter

[k^3,k=1..3]

you will get the list

You can also create a list with the makelist command. It takes three arguments; a function (not an expression), an initial value for the variable and an ending value for the variable. If you enter

makelist(x -> x^2,-2,2)

you will get the list

There is an optional fourth argument, which will be the step size.

You can add an element to the end of a list with the append command. If you enter

append([1,5],3)

you will get

The elements of sequences and lists are indexed, beginning with the index 0. You can get an element by following the sequence or list with the index number in square brackets; if you enter

ls := [A,B,C,D,E,F]

then

ls[1]

will return

You can get a subsequence (or sublist) by putting an interval (a beginning value and an ending values separated by two dots) in brackets. If you enter

ls[2..4]

you will get

The mid command is another way to get a subsequence or sublist. Given a sequence or list, a beginning index and a length, then mid will return the subsequence of the sequence beginning at the given index of the given length. With ls as above, if you enter

mid(ls,2,3)

you will get

If the length is left off, then the subsequence will go to the end of the given sequence; if you enter

mid(ls,2)

you will get

You can change the element in a particular position with the := operator; for example, to change the second element in ls, you can enter

ls[1] := 7

The value of ls will then be

If a variable var is not a list or sequence and you assign a value to var[n], then var becomes a table. A table is like a list, but the indices don’t have to be integers. If you define

newls := []

and then set

newls[2] := 5

then since newls was previous a list, it will now be equal to the list

If nols is an undefined variable and you set

nols[2] := 5

then nols will be a table,

When changing an element of a list (or sequence or table) using :=, the entire list is copied. This can be inefficient. To save copy time and modify the list element in place, you can use =<. If you have

ls := [a,b,c]

and then enter

ls[2] =< 3

then ls will be equal to

Polynomials are typically given by expressions, but they can also be given by a list of the coefficients in decreasing order, delimited with poly1[ and ]. The symb2poly will transform a polynomial written as an expression to the list form of the polynomial. If you enter

symb2poly(2*x^3 - 4*x + 1)

you will get

The poly2symb will transform in the other direction; if you enter

poly2symb(poly1[2,0,-4,1])

you will get

There is also a way to represent a multivariable polynomial with lists; see the manual for more information.

3.6  Characters and strings

A string is simply text enclosed within quotation marks. You can find out how many characters are in a string with the size command; if you enter

size("this string")

you will get

A character is simply a string with length 1. The char command will take an ASCII code (or a list of ASCII codes) and return the character or string determined by the codes. For example, the letter “a” has ASCII code 65, so

char(65)

will return

The asc command will turn a string into the list of ASCII codes; if you enter

asc("A")

you will get

The characters in a string are indexed starting with 0. To get the first character, for example, you can enter a string, or the name of a string, followed by [0]. If you enter

str := "abcde"

str[0]

you will get

You can choose a substring from a string by putting the beginning and ending indices in the brackets, separated by two periods ... If you enter

str[1..3]

you will get

An alternate way of getting the first character from a string is with the head command. With str as above,

head(str)

will return

The tail command will produce the remaining characters;

tail(str)

will return

Strings can be combined with the concat command or the infix + operator. Both

concat("abc","def")

and

"abc" + "def"

will return

If a string represents a number, then the expr command will convert the string to the number. For example,

expr("123")

will return the number 123. More generally, expr will convert a string representing an expression or command into the corresponding expression or command. The string command works in the opposite direction; it will take an expression and convert it to a string.

3.7  Calculation time and memory space

One major issue with symbolic calculations is the complexity of the intermediate calculations. This complexity takes the form of the amount of time required for the calculations and the amount of computer memory needed. The algorithms used by Xcas are efficient, but not necessarily optimal. The time command will tell you how long a calculation takes. For very quick calculations, Xcas will execute it several times and return the average for a more accurate result. The amount of memory used by Xcas is shown in the status line of the Unix version of Xcas.

If a command that you are timing takes more than a few seconds, you could have made an input error and you may have to interrupt the command (with the red STOP button on the status line, for example). It is a good idea to make a backup of your session beforehand.