tutoriel

An `Xcas` Tutorial

## Contents

`Xcas` is a free (as in Free Software) computer algebra system. Although there are other computer algebra systems, both free and commercial, few if any are as versatile as `Xcas`, which is capable of, among other things:

- Symbolic and numeric calculation.
- Programming.
- Graphing functions.
- Working with spreadsheets.
- Interactive geometry (both two- and three-dimensional).
- Turtle geometry.

This tutorial will briefly introduce you to calculating, programming and graphing with `Xcas`. The first section, “Getting started”, will be just enough information to get you started. The second section will be a brief overview of the graphic interface and the rest will be more in-depth tutorial.

For more information, you can refer to the manual or any of the other sources of information under the `Help` menu.

## 1 Getting started

### 1.1 Starting `Xcas`

`Xcas` is available from `http://www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html`. This page also has information on installation. Once installed, the way to start the program depends on the operating system.

- Under Windows, there should be a shortcut `xcasen.bat` that you can click on.
- Under Linux, you can either find it on a menu provided by the desktop environment, or enter `xcas &` in a terminal window.
- Under MacOS, you can click on `xcas` in the Applications menu.

For this tutorial, you will mostly be working with the command line, which will be a white rectangle next to the number `1`. There you can enter a command, after which there will be a window with the result, followed by another command line with the number `2`.

### 1.2 `XCas` as a calculator

Once you have started `Xcas`, you can immediately use it as a calculator. Simply type in the expression that you wish to use using the standard arithmetic operators; namely `+` for addition, `-` for subtraction, `*` for multiplication, `/` for division and `^` for exponentiation. If you enter

> `34+45*12`

you will get

574

If you enter

> `2/3 + 98/7`

you will get

44
3

The operators have a standard order of operations, and parentheses can be used for grouping. (Brackets have a different meaning, see section 3.5, “Lists, sequences and sets”.)

Notice that if you enter integers or other exact values, `Xcas` will give you the exact result. If you enter an approximate value, such as a number with a decimal point (computers regard numbers with decimal points as approximate values), then `Xcas` will give you an approximate result. For example, if you enter

> `2/3 + 3/2`

you will get

13
6

but if you enter

> `2/3 + 1.5`

you will get

2.16666666667

You can also get a decimal approximation using the `evalf` function. If you enter

> `evalf(2/3 + 3/2)`

you will get

2.16666666667

By default, `Xcas` will give you 12 decimal places of accuracy in its approximations, but this is configurable (see section 2.3, “Configuration”).

`Xcas` also has the standard functions, such as `sin`, `cos`, `asin` (for the arcsin), `log` (for the natural logarithm). It also has common constants such as `pi`, `e` and `i`.

The trigonometric functions assume that angles are measured in radians. (This can be configured, see section 2.3, “Configuration”.) If you enter

> `sin(pi/4)`

you will get

√ |
2
2

### 1.3 Functions and variables

`Xcas` can work with expressions and variables as well as numbers. A variable in `Xcas` needs to begin with a letter and can include numbers and underscores. If you enter

> `x^2 + x + 2*x + 2`

you will get

x2 + 3*x + 2

You can give a variable a value with the assignment operator, `:=`. To assign the variable `myvar` the value 5, for example, you can enter

> `myvar := 5`

If you later use `myvar` in an expression, it will be replaced by `5`; entering

> `myvar*x + myvar^2`

will result in

5*x + 25

The assignment operator can also be used to define functions. To define the squaring function, for example, you can enter

> `sqr(x) := x^2`

Afterwards, whenever you enter `sqr(expression)` you will get the expression squared. For example, entering

> `sqr(7)`

will return

49

and entering

> `sqr(x+1)`

will result in

(x+1)2

### 1.4 Simplifying expressions

When you enter an expression into `Xcas`, some simplifications will be done automatically. For example, if you enter

> `a := 3`

> `b := 4`

and

> `a*b*x + 4*b^2`

you will get

12*x + 64

`Xcas` has several transformations in case you want an expression to be simplified beyond the automatic simplifications, or perhaps transformed in another way. Some examples 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

`factor`
  This will factor polynomials. For example, if you enter

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

  you will get

  (x + 1)*(x + 2)

### 1.5 Graphs

`Xcas` has several functions for plotting graphs; perhaps the simplest is the `plot` function. The `plot` function requires two arguments, an expression to be graphed and a variable. For example, if you enter

> `plot(sin(x),x)`

you will get the graph

To the right of the graph will be a panel you can use to control various aspects. By default, the graph will cover values of the variable from −10 to 10; this is of course configurable (see section 2.3, “Configuration”). To plot over a different interval you can also use a second argument of var=min..max instead of simply var. For example, if you enter

> `plot(sin(x),x=-pi..pi)`

you will get the graph

### 1.6 The Help Index

You can get a list of all `Xcas` commands and variables using the `Help``▸``Index` menu item. This will bring up the following window:

Under `Index` will be a scrollable list of all the commands and variables. If you begin typing to the right of the question mark, you will be taken to the part of the list beginning with the characters you typed; for example, if you type `evalf`, you will get the following:

In the upper right-hand pane under `Related` is a list of commands related to the chosen command, below that is a list of synonyms; you can see that the `approx` command is the same as the `evalf` command. Below the line where you typed the command name is a description of the command; here you can see that `evalf` takes an optional second argument (brackets in the description indicate that an argument is optional) which can specify the number of digits in the approximation; for example,

> `evalf(pi)`

will return

3.14159265359

but

> `evalf(pi,20)`

will return

3.1415926535897932385

Below the description is a line where you can enter the arguments for the command; if you enter values in these boxes then the command with the chosen arguments will be placed on the `Xcas` command line. At the bottom of the help window is a list of examples of the command being used; if you click on one of these examples it will appear on the `Xcas` command line.

As well as using the menu, you can get to the help index by using the tab key while at the `Xcas` command line. If you have typed the beginning of a command before using the tab key, then that beginning will be presented to you in the help index.

## 2 The interface

### 2.1 Overview

When you start `Xcas`, you will be presented with a window which looks like the following:

From top to bottom, there is

- A menu bar.
- A tab indicating the name of the session, or `Unnamed` if the session has not been saved. You can run several sessions simultaneously, in which case each session will get its own tab.
- A session management bar, with
  - A `?` button, which will open the help index.
  - A `save` button to save the session.
  - A configuration button indicating how `Xcas` is currently configured. Clicking on this button will open a configuration window.
  - A `STOP` button you can use to interrupt a calculation which is running on too long.
  - A `Kbd` button to bring up an on-screen keyboard which you can use to help enter your commands. It will come with a control panel which you can use to display a message window (`msg`) or show an extra menu (`cmds`) at the bottom.
  - An `X` button to close the session.
- A numbered command line.

### 2.2 The menu bar

The menu items have submenus, and sometimes sub-submenus. When indicating a submenu item, it will be separated from the menu item with ▸; for example, you can save a session with `File``▸``Save`, which is the `Save` item in the `File` menu.

The menu bar contains the usual menus for graphic programs. It also contains all of the `Xcas` commands grouped by themes. For some commands, if you choose it from a menu then the command will be put on the command line. If the message window is open (which you can open with the `Cfg``▸``Show``▸``msg` menu item), a brief description of the command will appear in that window. For other commands, for example the `Graphic` commands, you will get a dialog box which lets you specify the arguments; afterwards, the command with the arguments will be placed on the command line.

The `Help` menu has links to the Help index, various manuals, as well as the online forum.

### 2.3 Configuration

The `Cfg` menu has various items that allow you to configure various aspects of `Xcas`. This tutorial will refer to the `Cfg``▸``Cas configuration` and `Cfg``▸``Graph configuration` menu items. The `Cfg``▸``Cas configuration` menu item will bring up the same configuration page as clicking on the status bar. These items will bring up windows with various entry fields and check boxes; after you make any changes, you can click the `Apply` button to apply them and the `Save` button to save them for future sessions.

The `Cfg``▸``Cas configuration` menu item will bring up a window with options that determine how `Xcas` computes. This includes some things mentioned in this tutorial, such as:

- Digits. This entry field determines the number of significant digits used in calculations. This resets the value of the variable `Digits`, which you can also reset from the command line.
- epsilon. This entry field determines how close the fraction returned by `exact` will be to the input. This resets the value of the variable `epsilon`, which you can also reset from the command line.
- radian. This checkbox determines whether angles are measured in radians or degrees.
- Complex. This checkbox determines whether computations will find complex solutions to equations.
- All_trig_sol. This checkbox determines whether `solve` will find the primary solutions to trigonometric equations or all solutions.

The `Cfg``▸``Graph configuration` menu item will bring up a window with options that determine how `Xcas` draws graphs. This includes the default ranges for the axes; the x-axis will go from `X-` to `X+`, the y-axis will go from `Y-` to `Y+` and the z-axis will go from `Z-` to `Z+`.

### 2.4 The command line

You can run a command by typing it into the command line and pressing `Enter`. If you want to enter more than one command on a line, you can separate them with semicolons. If you want to suppress the output of a command, you can end it with a colon-semicolon (`:;`).

If you have enough commands, there will be a scroll bar on the right which you can use to scroll through different command line levels. The `Edit` menu will allow you to merge levels, group levels and add comments.

All commands are kept in memory. You can scroll through previous commands with `Ctrl+` arrow keys, and modify them if you want.

## 3 Computational objects

### 3.1 Numbers

Operations
`+` | addition
`-` | subtraction
`*` | multiplication
`/` | division
`^` | power

Conversions
`evalf` | approximate a number
`exact` | find an exact number close to the given number
`epsilon` | determine how close a fraction has to be to a floating point number to be returned by `exact`

Constants
`pi` | π≃ 3.14159265359
`e` | e ≃ 2.71828182846
`i` | i=√−1
`infinity` or `inf` | ∞
`+infinity` or `+inf` | +∞
`-infinity` or `-inf` | −∞

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

sin(1)

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

0.841470984808

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

9

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

17

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

5
2

while entering

> `1.5 + 1`

will return

2.5

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

> `sqrt(2)`

will return

| √ |
2

entering

> `evalf(sqrt(2))`

will return

1.41421356237

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

1.4142135623730950488016887242096980785696718753770

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−12. This value is configurable (see section 2.3, “Configuration”).

### 3.2 Variables

Variables
`:=` | assignment
`subst` | give a variable a value for a single instance
`assume` | put assumptions on variables
`and` | combine assumptions
`or` | combine assumptions
`purge` | remove values and assumptions attached to 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

36

The `purge` command will unassign a variable; if you enter

> `purge(a)`

and then

> `4*a^2`

you will get

4· a2

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

11

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 √a2 simplifies to |a|, since a could be positive or negative. If you enter

> `sqrt(a^2)`

you will get

|a|

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

−a

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

0

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

### 3.3 Expressions

Conversions
`expand` | expand powers and distribute multiplication
`normal` | reduce to lowest terms
`ratnormal` | reduce to lowest terms
`factor` | factor
`simplify` | reduce an expression to simpler form
`tsimplify` | reduce and expression to simpler form
`convert` | convert an expression to a different type

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 ei θ to sines and cosines with

> `convert(exp(i*theta),sincos)`

the result will be

cos(θ) + i*sin(θ)

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

2
(x+1)*3
| + |
1
(x−2)*3

### 3.4 Functions

Common functions
`abs` | absolute value
`sign` | sign (-1,0,+1)
`max` | maximum
`min` | minimum
`round` | round to the nearest integer
`floor` | greatest integer less than or equal to
`frac` | fractional part
`ceil` | least integer greater than or equal to
`re` | real part
`im` | imaginary part
`abs` | absolute value
`arg` | argument
`conj` | conjugate
`coordinates` | the coordinates of a point
`factorial` | factorial
`!` | factorial
`sqrt` | square root
`exp` | exponential
`log` | natural logarithm
`ln` | natural logarithm
`log10` | logarithm base 10
`sin` | sine
`cos` | cosine
`tan` | tangent
`cot` | cotangent
`asin` | arcsine
`acos` | arccosine
`atan` | arctangent
`sinh` | hyperbolic sine
`cosh` | hyperbolic cosine
`tanh` | hyperbolic tangent
`asinh` | inverse hyperbolic sine
`acosh` | inverse hyperbolic cosine
`atanh` | inverse hyperbolic tangent

Create functions
`:=` | assign an expression to a function
`->` | define a function
`unapply` | turn an expression into a function

`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

2*exp(2)

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

x −>x*exp(x)

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

x −>x*exp(x)

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

sin(x) + x * cos(x)

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

x −>(sin(x))2 + 1

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

x −> sin(sin(sin(x)))

### 3.5 Lists, sequences and sets

Sequences and lists
`( )` | sequence delimiters
`[ ]` | list delimiters
`%{ %}` | set delimiters
`NULL` | empty sequence
`E$(k=n..m)` | create a sequence
`seq(E,k=n..m)` | create a sequence
`[E$(k=n..m)]` | create a list
`makelist(f,k,n,m,p)` | create a list
`append` | append an element to a list
`op(li)` | convert a list to a sequence
`nop(se)` | convert a sequence to a list
`nops(li)` | the number of elements
`size(li)` | the number of elements
`mid(li)` | extract a subsequence
`sum` | the sum of the elements
`product` | the product of the elements
`cumSum` | the cumulative sums
`apply(f,li)` | apply a function to the list elements
`map(li,f)` | apply a function to the list elements
`map(li,f,matrix)` | apply a function to the elements of a matrix
`poly2symb` | convert a polynomial expression to a polynomial list
`symb2poly` | convert a polynomial list to a polynomial expression

`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

[1,2,4,2]

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

(1,2,3)

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

3

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

(4,1,0,1,4)

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

> `k^2$k=-2..2`

you will get, as above,

(4,1,0,1,4)

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

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

you will get the list

[1,8,27]

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

[4,1,0,1,4]

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

[1,5,3]

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

B

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

[C,D,E]

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

[C,D,E]

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

[C,D,E,F]

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

[A,7,C,D,E,F]

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

[0,0,5]

If `nols` is an undefined variable and you set

> `nols[2] := 5`

then `nols` will be a table,

`table`(2=5)

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

[a,b,3]

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

poly1[2,0,−4,1]

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

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

you will get

2*x3 − 4*x + 1

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

### 3.6 Characters and strings

String commands
`asc` | convert a string to a list of ASCII codes
`char` | convert a list of ASCII codes to a string
`size` | the number of characters
`concat` or `+` | concatenation
`mid` | substring
`head` | first character
`tail` | the string without the first character
`string` | convert a number or expression to a string
`expr` | convert a string to a number or expression

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

11

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

A

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

> `asc("A")`

you will get

[65]

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

a

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

bcd

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

> `head(str)`

will return

a

The `tail` command will produce the remaining characters;

> `tail(str)`

will return

bcde

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

> `concat("abc","def")`

and

> `"abc" + "def"`

will return

abcdef

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.

## 4 Analysis with `Xcas`

### 4.1 Derivatives

Derivatives
`diff(ex,t)` | the derivative of an expression with respect to t
`function_diff(f)` | the derivative of a function
`diff(ex,x$n,y$m)` | partial derivatives
`grad` | gradient
`divergence` | divergence
`curl` | curl
`laplacian` | laplacian
`hessian` | hessian matrix

The `diff` function will find the derivative of an expression and returns the derivative as an expression. If you have a function f, you can find the derivative by entering

> `diff(f(x),x)`

Note that the result will itself be an expression; do not define the deritivave function by `fprime(x) := diff(f(x),x)`. If you want to define the derivative as a function, you can use `unapply`:

> `fprime := unapply(diff(f(x),x),x)`

Alternatively, you can use `function_diff`, which takes a function (not an expression) as input and returns the derivative function;

> `fprime := function_diff(f)`

The `diff` function can take a sequence of variables as the second argument, and so can calculate successive partial derivatives. Given

> `E := sin(x*y)`

then

> `diff(E,x)`

will return

y*cos(x*y)

> `diff(E,y)`

will return

x*cos(x*y)

> `diff(E,x,y)`

will return

−x*y*sin(x*y) + cos(x*y)

and

> `diff(E,x $ 2)`

will return

−y2*sin(x*y)

If the second argument to `diff` is a list, then a list of derivatives is returned. For example, to find the gradient of `E`, you can enter

> `diff(E,[x,y])`

and get

[y*cos(x*y),x*cos(x*y)]

There is also a special `grad` command for this, as well as commands for other types of special derivatives.

### 4.2 Limits and series

Limits and series
`limit` | the limit of an expression
`taylor` | Taylor series
`series` | Taylor series
`order_size` | used in the remainder term of a series expansion

The `limit` function will take an expression, a variable and a point and return the limit at the point. If you enter

> `limit(sin(x)/x,x,0)`

you will get

1

`Xcas` can also find limits at plus and minus infinity;

> `limit(sin(x)/x,x,+infinity)`

will return

0

as well as limits of infinity;

> `limit(1/x,x,0)`

will return

∞

which recall is unsigned infinity. An optional fourth argument can be used to find one-sided limits; if the fourth argument is `1` it will be a right-handed limit and if the argument is `-1` it will be a left-handed limit. Entering

> `limit(1/x,x,0,-1)`

will result in

−∞

Given an expression and a variable, the `taylor` function will find the Taylor series of the expression. If you enter

> `taylor(sin(x)/x,x)`

you will get

1− |
x2
6
| + |
x4
120
| + x6*`order_size`(x)

The `series` function works the same as the `taylor` function.

By default, `taylor` will find the terms up to the fifth degree. The `order_size(x)` represents a factor for which for all a>0, the term xa`order_size`(x) will approach 0 as x approaches 0.

The series returned by `taylor` will also be centered about 0 by default; if you want to center it around the number `a`, you can replace `x` by `x=a`;

> `taylor(exp(x),x=1)`

will result in

exp(1)+exp(1)*(x−1)+exp(1)*(x−1)2/2+ exp(1)*(x−1)3/6+

exp(1)*(x−1)4/24+exp(1)*(x−1)5/120+(x−1)6*`order_size`(x−1)

You can also give the center of the series with a third argument. To find the terms to a different you can add an extra argument giving the order;

> `taylor(sin(x)/x,x=0,3)`

will return

1− |
x2
6
| + x4*`order_size`(x)

Note that in this case you must explicitly give the center of the series, even if it is 0.

To find the Taylor polynomial, you can add an extra argument of `polynom`;

> `taylor(sin(x)/x,x,polynom)`

will return

1− |
x2
6
| + |
x4
120

### 4.3 Antiderivatives and integrals

Integrals
`int` | antiderivatives and exact integrals
`romberg` | approximation of integrals

The `int` function will find an antiderivative of an expression. By default, it will assume that the variable is x, to use another variable you can give it as an argument.

> `int(x*sin(x))`

will result in

sin(x) − x*cos(x)

and

> `int(t*sin(t),t)`

will result in

sin(t) − t*cos(t)

To compute a definite integral, you can give the limits of integration as arguments after the variable; to integrate x*sin(x) from x=0 to x=π, you can enter

> `int(x*sin(x),x,0,pi)`

and get

π

The limits of integration are allowed to be expressions; this can be useful when computing a multiple integral over a non-rectangular region. For example, you can integrate x y over the triangle 0 ≤ x ≤ 1, 0 ≤ y ≤ x with

> `int(int(x*y,y,0,x),x,0,1)`

resulting in

1
8

The `romberg` function will approximate the value of a definite integral, for cases when the exact value can’t be computed or you don’t want to compute it. For example,

> `romberg(exp(-x^2),x,0,10)`

will return

0.886226925452

### 4.4 Solving equations

Solving equations
`solve(eq,x)` | exact solutions of an equation
`solve([eq1,eq2],[x,y])` | exact solutions of a system of equations
`fsolve(eq,x)` | approximate solution of an equation
`fsolve([eq1,eq2],[x,y])` | approximate solution of a system of equations
`linsolve` | solve a linear system
`proot` | approximate roots of a polynomial

Solving equations is important, but it is often impossible to find exact solutions. `Xcas` has the ability to find exact solutions in some cases and to approximate solutions.

The `solve` function will attempt to find the exact solution of an equation that you give it. If you enter an expression that isn’t an equation, it will try to solve for the expression equal to zero. By default, the variable will be x, but you can give a different variable as a second argument. If you enter

> `solve(x^3 -2*x^2 + 1=0, x)`

you will get

| ⎡ ⎢ ⎢ ⎣ |
−( | √ |
5
| )+1
2
| ,1, |
√ |
5
| +1
2
| ⎤ ⎥ ⎥ ⎦

By default, `solve` will only try to find real solutions; if you enter

> `solve(x^3+1=0,x)`

you will get

[−1]

You can configure `Xcas` to find complex solutions (see section 2.3, “Configuration”). If you do that, then entering

> `solve(x^3+1=0,x)`

will result in

| ⎡ ⎢ ⎢ ⎣ | −1, |
− | √ |
3
| *i+1
2
| , |
√ |
3
| *i+1
2
| ⎤ ⎥ ⎥ ⎦

For linear and quadratic functions, `solve` will always return the exact solution. For higher degree polynomials, `solve` will try some approaches, but may return intermediate results or approximate solutions. (It doesn’t use the Cardan and Ferrari formulas for polynomials of degrees 3 and 4, since the solutions would then not be easily managable.)

For trigonometric equations, the primary solutions are returned. For example,

> `solve(cos(x) + sin(x) = 0, x)`

will result in

| ⎡ ⎢ ⎢ ⎣ | − |
π
4
| , |
3*π
4
| ⎤ ⎥ ⎥ ⎦

You can configure `Xcas` to find all solutions (see section 2.3, “Configuration”). If you do that, then

> `solve(cos(x) + sin(x) = 0, x)`

will result in

| ⎡ ⎢ ⎢ ⎣ |
4*n0*π−π
4
| ⎤ ⎥ ⎥ ⎦

where n0 represents an arbitrary integer.

The `solve` function can also handle systems of equations. For this, use a list of equations for the first argument and a list of variables for the second. If you enter

> `solve([x^2 + y - 2, x + y^2 - 2],[x,y])`

you will get all four solutions as a matrix; each row represents one solution.

| ⎡ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎣ |
1, | 1
−2, | −2
√ |
5
| +1
2
| ,
− | ⎛ ⎜ ⎜ ⎝ |
√ |
5
| +1
2
| ⎞ ⎟ ⎟ ⎠ |
2
| + 2
−( | √ |
5
| )+1
2
| ,
− | ⎛ ⎜ ⎜ ⎝ |
−( | √ |
5
| )+1
2
| ⎞ ⎟ ⎟ ⎠ |
2
| + 2
| ⎤ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎦

To approximate a solution to an equation or system of equations, `Xcas` provides the `fsolve` command. If you enter

> `fsolve(x^3 -3*x + 1,x)`

you will get

[−1.87938524157,0.347296355334,1.53208888624]

Algorithms for approximating solutions of equations typically involve starting with a given point and finding a sequence which converges to a solution. The `fsolve` command can take a starting point, if you enter

> `fsolve(x^3 -3*x + 1,x,1)`

you will get

0.347296355334

### 4.5 Differential equations

Commands for differential equations
`desolve` | exact solution
`odesolve` | approximate solution
`plotode` | graph of solution
`plotfield` | vector field
`interactive_plotode` | clickable interface

The `desolve` command is used to try to find exact solutions of differential equations. The first argument is the differential equation itself, the second argument is the function. The derivative of an unknown function y is denoted `diff(y)`, which can be abbreviated `y’`. The second derivative will be `diff(diff(y))` or `y’’`, etc. If you enter

> `desolve(x^2*y’ = y,y)`

you will get

c0 * exp(− |
1
x
| )

where c0 is an arbitrary constant. By default the variable is x, if you want to use a different variable, put it in the function in the second argument;

> `desolve(t^2*y’ = y,y(t))`

will return

c0 * exp(− |
1
t
| )

If you want to solve a differential equation with initial conditions, the first argument should be a list with the differential equation and the conditions. If you enter

> `desolve([y’’ + 2*y’ + y = 0, y(0) = 1, y’(0) = 2],y)`

you will get

exp(−x)*(3*x+1)

To solve a differential equation numerically, you can use the `odesolve` command. This will allow you to solve the equation y′=f(x,y) where the graph passes through a point (x0,y0). The command

> `odesolve(f(x,y),[x,y],[x_0,y_0],a)`

will find y(a) in this case. For example, to calculate y(2) where y(x) is the solution of y′(x) =sin(xy) with y(0)=1, you can enter

> `odesolve(sin(x*y),[x,y],[0,1],2)`

The result will be

[1.82241255674]

The `plotode` command will plot the graph of the solution; if you enter

> `plotode(sin(x*y),[x,y],[0,1])`

you will get

The `plotfield` command will plot the entire vector field;

> `plotfield(sin(x*y),[x,y])`

will result in

If you use the `interactive_odeplot` command, you will get the vector field and you will be able to click on a point to find the graph of the solution passing through the point.

## 5 Algebra with `Xcas`

### 5.1 Integer arithmetic

Integers
`irem` | remainder
`iquo` | quotient
`iquorem` | quotient and remainder
`ifactor` | prime factorization
`ifactors` | list of prime factors
`idivis` | list of divisors
`gcd` | greatest common divisor
`lcm` | least common multiple
`iegcd` | Bezout’s identity
`isprime` | primality test
`nextprime` | next prime number
`previousprime` | previous prime number
`a%p` | a modulo p
`powmod(a,n,p)` | an modulo p

`Xcas` has the usual number theoretic functions. The `iquo` command will find the integer quotient of two integers and `irem` will find the remainder. The `iquorem` command will return a list of both the quotient and remainder; if you enter

> `iquorem(30,7)`

you will get

[4,2]

since 30 divided by 7 is 4 with a remainder of 2.

The `gcd` and `lcm` commands will find the greatest common divisor and least common multiple of two integers. If you enter

> `gcd(72,120)`

you will get

24

The greatest common divisor d of two integers a and b can always be written in the form a*u + b*v = d for integers u and v. (This is known as Bézout’s Identity.) The `iegcd` will return the coefficients u and v as well as the greatest commond divisor. If you enter

> `iegcd(72,120)`

you will get

[2,−1,24]

since

72· 2 + 120·(−1) = 24

The `ifactor` command will give the prime factorization of an integer; if you enter

> `ifactor(250)`

you will get

2*53

You can use `ifactors` to get a list of the prime factors of an integer, where in the list each factor is followed by its multiplicity. If you enter

> `ifactors(250)`

you will get

[2,1,5,3]

since 250 has a prime factor of 2 (it has 1 factor of 2) and a prime factor of 5 (it has 3 factors of 5). The `idivis` command will return a complete list of factors;

> `idivis(250)`

will return

[1,2,5,10,25,50,125,250]

The subject of primes is a difficult one, and you should see the manual for a discussion of how `Xcas` checks for primes. But the command `isprime` will return `true` or `false` depending on whether or not you enter a prime. If you enter

> `isprime(37)`

you will get

true

since 37 is a prime number. The commands `nextprime` and `previousprime` will find the first prime after (or before) the number that you give it; if you enter

> `nextprime(37)`

you will get

41

since the first prime after 37 is 41.

Integers modulo p are defined by putting `% p` after them. Once an integer modulo p is defined, then any calculations done with it are done in ℤ/pℤ. For example, if you define

> `a := 3 % 5`

then

> `a*2`

will return

1 % 5

(since 6 mod 5 is reduced to 1 mod 5);

> `1/a`

will return

2 % 5

etc. The `powermod` or `powmod` functions can be used to efficiently calculate powers modulo a number.

### 5.2 Polynomials and rational functions

Polynomials
`normal` | normal form (expanded and reduced)
`expand` | expanded form
`ptayl` | Taylor form
`peval` or `horner` | evaluation using Horner’s method
`canonical_form` | canonical form for a trinomial
`coeff` | list of coefficients
`poly2symb` | transform an algebraic polynomial to list form
`symb2poly` | transform the list form of a polynomial to algebraic form
`pcoeff` | return the polynomial (list form) given a list of zeroes
`degree` | degree
`lcoeff` | the coefficient of the leading term
`valuation` | the lowest degree of the terms
`tcoeff` | the coefficient of the term with the lowest degree
`factor` | prime factorization
`factors` | list of prime factors
`divis` | list of divisors
`froot` | roots with multiplicities
`proot` | approximate values of the roots
`sturmab` | the number of roots in an interval
`getNum` | the numerator of a rational function
`getDenom` | the denominator of a rational function
`propfrac` | writes a rational expression as a whole part and a proper rational part
`partfrac` | partial fraction decomposition
`quo` | quotient
`rem` | remainder
`gcd` | greatest common divisor
`lcm` | least common multiple
`egcd` | Bezout’s identity
`divpc` | Taylor polynomial for a rational expression
`randpoly` | random polynomial
`cyclotomic` | cyclotomic polynomial
`lagrange` | Lagrange polynomials
`hermite` | Hermite polynomials
`laguerre` | Laguerre polynomials
`tchebyshev1` | Tchebyshev polynomials
`tchebyshev2` | Tchebyshev polynomials

Various polynomial operations are available in the `Polynomials` submenu of the `Cmds` menu.

The `expand` and `normal` operators will distribute multiplication across addition, and so expand a polynomial completely out. If you enter

> `expand((x+1)*(x+2)^2)`

you will get

x3+5*x2+8*x+4

Additionally, `normal` will reduce a rational expression to lowest terms; if you enter

> `normal((x-1)^2/(x^2-1))`

you will get

x−1
x+1

The `factor` operator will factor a polynomial. If you enter

> `factor(x^3+6*x^2+3*x-10`

you will get

(x−1)*(x+2)*(x+5)

The result often depends on the number field being used. For example, over the rational numbers the polynomial x4 − 1 factors as (x−1)(x+1)(x2 + 1), while over the complex numbers it factors as (x−1)(x+1)(x−i)(x+i). If the coefficients of a polynomial are exact fractions, then the factoring will be over the rationals. To factor over the complex numbers, you can configure `Xcas` to do complex factorization (see section 2.3, “Configuration”) or use the `cfactor` command. If the coefficients are in ℤ/pℤ then the polynomial will be factored over ℤ/pℤ.

### 5.3 Trigonometry

Trigonométrie
`tlin` | linearize
`tcollect` | linearize and regroup
`texpand` | expand
`trig2exp` | trigonometric to exponential
`exp2trig` | exponential to trigonometric
`hyp2exp` | hyperbolic to exponential

`Xcas` has the usual trigonometic functions, both circular and hyperbolic, as well as their inverses. It also has commands for manipulating trigonometric expressions; these are in the `Trigo` submenus of the `Expression` menu.

One example is the `tlin` command will write products and powers of sines and cosines as linear combinations of sin(n x)s and cos(n x)s. If you enter

> `tlin(2*sin(x)^2*cos(3*x))`

you will get

− |
cos(x)
2
| + cos(3*x) − |
cos(5*x)
2

The `texpand` command will take expressions involving sin(n x) and cos(n x) and write them in terms of powers if sin(x) and cos(x). If you enter

> `texpand(sin(2*x)^2*cos(3*x))`

you will get

16*cos(x)5*sin(x)2−12*cos(x)3*sin(x)2

### 5.4 Vectors and matrices

Vectors and matrices
`v*w` | scalar product
`cross(v,w)` | cross product
`A*B` | matrix product
`A.*B` | term by term product
`1/A` | inverse
`tran` | transpose
`rank` | rank
`det` | determinant
`ker` | basis for the kernel
`image` | base for the image
`idn` | identity matrix
`ranm` | matrix with random coefficients
`makematrix` | make a matrix from a function
`matrix` | make a matrix from a function
`blockmatrix` | combine matrices

A vector is a list of numbers, such as `[2,3,5]`, and a matrix is a list of vectors all of the same length, such as `[[1,2,3],[4,5,6]]`.

The usual matrix operations (addition, scalar multiplication, matrix multiplication) are done with the usual operators `+` and `*`. If you define

> `A := [[1,2,3],[4,5,6],[7,8,9]]`

> `B := [[1,1,1],[2,2,2]]`

then

> `3*A`

will give you

⎛ ⎜ ⎜ ⎝ |
3 | 6 | 9
12 | 15 | 18
21 | 24 | 27
| ⎞ ⎟ ⎟ ⎠

and

> `B*A`

will give you

⎛ ⎜ ⎝ |
12 | 15 | 18
24 | 30 | 36
| ⎞ ⎟ ⎠

A vector can be regarded as a matrix with one row, except that if a matrix is multiplied on the right by a vector, the vector will be regarded as a column. In particular, if `v` and `w` are vectors of the same length, then `v*w` will return the scalar product.

The `idn` command will create an identity matrix;

> `idn(2)`

will return

⎛ ⎜ ⎝ |
1 | 0
0 | 1
| ⎞ ⎟ ⎠

You can also use `makemat` or `matrix` commands to build a matrix. They both require a real-valued function of two variables, the number of rows and the number of columns. The indices start at 0, and with the `makemat` the function comes first, with `matrix` the function comes last. Both

> `makemat((j,k)->j+k,3,2)`

and

> `matrix(3,2,(j,k)->j+k)`

produce

⎛ ⎜ ⎜ ⎝ |
0 | 1
1 | 2
2 | 3
| ⎞ ⎟ ⎟ ⎠

Several matrices can be combined into a larger matrix with the `blockmatrix` command. To arrange m * n matrices into m rows and n columns, you give `blockmatrix` the values m, n and a list of the matrices. If you enter

> `A := [[1,2,3],[4,5,6]]`

> `B := [[1,2],[2,3]]`

then

> `blockmatrix(2,2,[A,B,B,A])`

will give you

⎛ ⎜ ⎜ ⎜ ⎝ |
1 | 2 | 3 | 1 | 2
4 | 5 | 6 | 2 | 3
1 | 2 | 1 | 2 | 3
2 | 3 | 4 | 5 | 5
| ⎞ ⎟ ⎟ ⎟ ⎠

You can get the elements from a matrix by following the matrix with the indices in brackets, separated by commas. For `A` as above,

> `A[1,2]`

will return

6

You can extract a submatrix by using intervals of indices (the beginning and end index separated by two periods);

> `A[0..1,1..2]`

returns

⎛ ⎜ ⎝ |
2 | 3
5 | 6
| ⎞ ⎟ ⎠

Note that if you change one value of a matrix in `Xcas`, the entire matrix will be copied. If a program modifies parts of a large matrix one element at a time, this time can add up.

### 5.5 Linear systems

Linear systems
`linsolve` | solution of a linear system
`simult` | solutions of many linear systems
`rref` | Gauss-Jordan reduction

The `linsolve` command will solve a system of linear equations; its syntax is the same as that of `solve` (see section 4.4, “Solving equations”). If you enter

> `linsolve([2*x + 3*y = 4, 5*x + 4*y = 3],[x,y])`

you will get

[−1,2]

The `simult` command can also solve a system of linear equations; more generally, it can solve several systems with the same coefficient matrix. To solve the systems

Ax = b1,…,Ax=bk

you can enter

> `simult(A,B)`

where

B = | ⎛ ⎝ | b1 ⋯ bk | ⎞ ⎠

The result will be a matrix whose jth column is the solution of Ax=bj. For example, if you want to solve the systems

⎧ ⎪ ⎨ ⎪ ⎩ |
x | + | y | − | z | = | 1
x | − | y | + | z | = | 1
−x | + | y | + | z | = | −2

⎧ ⎪ ⎨ ⎪ ⎩ |
x | + | y | − | z | = | −2
x | − | y | + | z | = | 1
−x | + | y | + | z | = | 1

which both have the same matrix of coefficients

⎛ ⎜ ⎜ ⎝ |
1 | 1 | −1
1 | −1 | 1
−1 | 1 | 1
| ⎞ ⎟ ⎟ ⎠

you can create the matrix which has one column for each system

⎛ ⎜ ⎜ ⎝ |
1 | −2
1 | 1
−2 | 1
| ⎞ ⎟ ⎟ ⎠

If you enter

> `simult([[1,1,-1],[1,-1,1],[-1,1,1]],[[1,-2],[1,1],[-2,1]])`

you will get

⎛ ⎜ ⎜ ⎝ |
1 | −1/2
−1/2 | −1/2
−1/2 | 1
| ⎞ ⎟ ⎟ ⎠

The solution to the first system is the first column, x=1,y=−1/2,z=−1/2, and the solution to the second system is the second column, x=−1/2,y=−1/2,z=1.

When there are no solutions, `linsolve` will return the empty list while `simult` will return an error. When there are infinitely many solutions, `linsolve` will return formulas for all solutions while `simult` will return one solution.

### 5.6 Matrix reduction

Matrix reduction
`jordan` | diagonalization or Jordan reduction
`pcar` | characteristic polynomial (list form)
`pmin` | minimal polynomial (list form)
`eigenvals` | eigenvalues
`eigenvects` | eigenvectors

The `jordan` command will take a matrix A and returns a transition matrix P and a matrix J in Jordan canonical form, so that P−1 A P = J. In particular, if A is diagonalizable, then J will be diagonal with the eigenvalues of A on the diagonal and the columns of P will be the corresponding eigenvectors. If you enter

> `jordan([[4,1],[-8,-5]])`

you will get

| ⎛ ⎜ ⎝ |
⎛ ⎜ ⎝ |
1 | 1
−1 | −8
| ⎞ ⎟ ⎠
| , |
⎛ ⎜ ⎝ |
3 | 0
0 | −4
| ⎞ ⎟ ⎠
| ⎞ ⎟ ⎠

This means that 3 and −4 (the diagonal elements of the second matrix) are the eigenvalues of (

4 | 1
−8 | −5

) and the corresponding eigenvectors are (

1
−1

) and (

1
−8

) (the columns of the first matrix). For diagonalizable matrices you can also get this information with the `eigenvals` and `eigenvects` commands;

> `eigenvals([[4,1],[-8,-5]])`

will return

(3,−4)

and

> `eigenvects([[4,1],[-8,-5]])`

will return

⎛ ⎜ ⎝ |
1 | 1
−1 | −8
| ⎞ ⎟ ⎠

For matrices with exact and symbolic values, the only eigenvalues used are those computable with `solve`; for matrices with floating point numbers, a numerical algorithm is used to find the eigenvalues. This algorithm may fail in some cases where there are very close eigenvalues or eigenvalues with multiplicity greater than one.

If a function is defined by a polynomial, you can evaluate it with an argument of a square matrix. If a function is given by a series, the Jordan form of the matrix can be used to define the value of the function at a matrix. For example, you can find the exponential of a square matrix;

> `exp([[0,-1],[1,2]])`

will result in

⎛ ⎜ ⎝ |
0 | −exp(1)
exp(1) | 2*exp(1)
| ⎞ ⎟ ⎠

## 6 Graphs

Plotting graphs
`plot` | graph an expression of one variable
`plotfunc` | graph an expression of one or two variables
`tangent` | tangent to a curve
`plotparam` | parametric curve
`plotpolar` | polar plotting
`plotimplicit` | implicit curve

The `Graphic` menu has entries for several graphing commands; if you choose one you will be given a template you can fill out to produce a graphic. The appropriate command will be placed on the command line. If you want several graphs in the same window, you can put the commands on the same command line separated by semicolons.

Once you have created a graphic window, there will be a panel to the right with buttons allowing you to control the image. The default parameters for graphs, such as the size of the graphs, are configurable (see section 2.3, “Configuration”).

As well as being displayed in the `Xcas` window, the two dimensional graphics also appear in the DispG (Display Graphics) window. You can bring that window up with the `Cfg``▸``Show``▸``DispG` menu item. This window will contain all two dimensional graphs; they can be cleared with the `ClrGraph` command.

### 6.1 Curves

The simplest way to draw graphs is with the templates from the `Graphic` menu, but there are command line equivalents.

The command line instruction for graphing a function is the `plot` command. It takes an expression (or list of expressions) followed by the variable. To use a domain different than the default, you can indicate the range of the variable by setting it equal to an interval. If you are plotting several curves, you can distinguish them by giving them different colors; you can do this with a third argument `color=` followed by a list of colors. If you plot

> `plot([x^2,x^3],x=-1..1,color=[red,blue])`

you will get

You can draw parameterized curves with the `plotparam` command. The coordinates of the curve must be given as a single complex expression; the x coordinate will be the real part of the expression and the y coordinate will be the imaginary part. For example, if you enter

> `plotparam(sin(t) + i*cos(t),t)`

you will get the circle

(Since the x- and y-axes are scaled differently, the circle looks elliptical.)

You can draw a curve using polar coordinates with the `plotpolar` command. This takes the form `plotpolar(f(theta),theta,theta-min,theta-max)`.

You can draw an implicitly defined curve with the `plotimplicit` command; the command `plotimplicit(``f(x,y)``,``x``,``y``)` will draw the curve f(x,y)=0. For example, the command

> `plotimplicit(x^2 + y^2 = 1,x,y)`

will draw a circle.

The `tangent` command will draw the tangent line to a curve, if you tell it the curve and the point. To draw the tangent line to the graph y=x2 at x=1, for example, you can enter

> `tangent(plotfunc(x^2,x),1)`

You will get

### 6.2 Plane geometry

2D graphical objects
`legend` | place text starting from a given point
`point` | determine a point given a complex number or two coordinates
`segment` | segment determined by 2 points
`circle` | circle determined by a point and radius
`inter` | find the intersection of curves
`equation` | return the cartesian equation of a curve
`parameq` | return the parametric equation of a curve
`polygonplot` | draw a polygonal line
`scatterplot` | draw a cloud of dots
`polygon` | draw a closed polygon
`open_polygon` | draw an open polygon

Among its other capabilities, `Xcas` works with plane geometry. The `Geo``▸``New figure 2D` menu item or the `Alt+g` key will bring up the screen for plane geometry.

A point on the geometry screen can be specified with the `point` command, which can take either an ordered pair or real numbers or a complex number as argument. The `Geo` menu contains many commands for drawing geometric objects, such as `circle` (which takes a point and a radius as arguments) and `polygon` (which takes a sequence of points as arguments).

Some functions, such as `polygonplot` and `scatterplot`, take lists of x-coordinates and y-coordinates as arguments. For example,

> `polygonplot([0,2,0],[0,0,2])`

and

> `open_polygon(point(0,0),point(2,0),point(0,2))`

will both draw the same segments.

The `legend` can be used to place text on the screen; one simple way of using it is to give it a point and text as arguments.

### 6.3 3D graphical objects

3D graphical objects
`plotfunc` | graph of a function
`plotparam` | parametric surface
`point` | point
`plane` | plane
`sphere` | sphere with a center and radius
`cone` | cone with a center, axis and opening angle
`inter` | intersection
`polygon` | polygon
`open_polygon` | open polygon

`Xcas` can also handle three-dimensions graphically, either by drawing curves and graphs in three-dimensions or by drawing three-dimensional geometric objects. A three-dimensional screen can be brought up with the `Geo``▸``New figure 3D` menu item or the `Alt+h` key. There will controls for the view window to the right of the screen. You can rotate the visualization cube by using the mouse outside of the cube or by clicking in the cube and using the `x`, `y` and `z` keys to rotate and the `+` and `-` keys for zooming.

You can draw a graph z = f(x,y) with the `plotfunc` command, which takes an expression and a list of two variables. Like graphs of functions of one variable, you can use a domain different than the default by giving the variables their own intervals. The command

> `plotfunc(y^2 - x^2,[x=-1..1,y=-1..1])`

will give you the graph

The `plotparam` command can be used to draw a parameterized curves and surfaces in three-dimensions. If the first argument is a list of three expressions involving two variables and the next two arguments are the variables (with optional intervals), then `plotparam` will plot the surface. If you enter

> `plotparam([u,u+v,v],u,v)`

you will get

If the first argument is a list of three expressions involving one variable and the next argument is the variable, then `plotparam` will plot the curve. If you enter

> `plotparam([cos(t),sin(t),t],t)`

you will get

A point in three-dimensions is given with the `point` command with three arguments. Commands like `polygon` and `open_polygon` work in three-dimensions as well as two, as well as additional commands such as `sphere`. A plane can be drawn with the `plane` command, which can be given either three points, a line and two points, or an equation of the form `a*x + b*y + c*z = d`.

## 7 Programming

### 7.1 The language

Instructions for `Xcas`
`a:=2;` | assignment
`input("a=",a);` | input expression
`textinput("a=",a);` | string input
`print("a=",a);` | output
`return(a);` | return value
`break;` | break out of loop
`continue;` | go to the next iteration
`if (<condition>)` `<inst>``;` | if…then
`if (<condition>)` `<inst1>``else` `<inst2>``;` | if…then …else
`for (j:= a;j<=b;j++)` `<inst>``;` | for loop
`for (j:= a;j<=b;j:=j+p)` `<inst>``;` | for loop
`repeat <inst> until <condition>;` | repeat loop
`while (<condition>)` `<inst>``;` | while loop
`do <inst1> if (<condition>) break;<inst2> od;` | do loop

Boolean operators
`==` | test for equality
`!=` | test for inequality
`<` | test for strictly less than
`>` | test for strictly greater than
`<=` | tes for less than or equal
`>=` | test for greater than or equal to
`&&`, `and` | infixed “and”
`||`, `or` | infixed “or”
`true` | boolean true (same as 1)
`false` | boolean false (same as 0)
`not`, `!` | “not”

You can extend `Xcas` by adding desired functions with its built-in programming language. The main features of the language are:

- It is a functional language. The argument of a function can be another function; in which case you can either give the name of a function or the definition of the function. If `f(x) := x^2`, then `function_diff(f)` is the same as `function_diff(x->x^2)`.
- There is no distinction between a program and a function. A function returns the value of the last evaluated statement or what follows the reserved word `return`.
- The language is untyped. Any variable can take on any value; the only different types of variables are global variables, which are not declared, and local variables, which are declared at the beginning of a function.

A function declaration looks like

       function_name (var1, var2, ...) := {
       local var_loc1, var_loc2, ... ;
         statement1;
         statement2;
         ...
       }

The syntax is similar to `C++`, although many variants are recognized, particularly in compatibility mode. Recall that `i` is √−1 and cannot be used for a loop variable. The conditional tests are Booleans, which are the results of the usual Boolean operators.

A program can capture runtime errors with a `try`–`catch` construction, which takes the form

       try
         {
          block to catch errors
         }
       catch (variable)
         {
          block to execute when an error is caught
         }

For example, the following will catch an error caused by incorrect matrix multiplication:

       try
         { A := idn(2) * idn(3) }
       catch (error)
         { print("The error is " + error) }

### 7.2 Some examples

To write a program, it is a good idea to use the program editor that comes with `Xcas`, which provides a template and commands helpful for writing programs. You can open this editor with the `New Program` item in the `Prg` menu or the `Alt+p` key.

Consider the following program, which takes two integers and returns the quotient and remainder of the Euclidean division algorithm (like the `iquorem` function).

       idiv2(a,b) := {
         local q,r;
         if (b != 0) {
           q := iquo(a,b);
           r := irem(a,b);
           }
         else {
           q := 0;
           r := a;
           }
         return [q,r];
       }

If you enter this into the editor, you can test it with the `OK` button. You can then use the function in the command line; if you enter

> `idiv2(25,15)`

you will get

[1,10]

You can save it in a file; the name `idiv2.cxx` would be a good name. You can then use it in later session with the command

> `read("idiv2.cxx")`

or by opening it in the program editor and validating it with the `OK` button.

Here are some more programs that you can play with. This first one computes the GCD of two integers iteratively.

       pgcdi(a,b) := {
         local r;
         while (b != 0) {
           r := irem(a,b);
           a := b;
           b := r;
           }
         return a;
       }:;

The second one computes the GCD recursively.

       pgcdr(a,b) := {
         if (b == 0) return a;
         return pgcdr(b, irem(a,b));
       }:;

If a program doesn’t work the way you expect, you can run it in step-by-step mode with the debug command. For more details, consult the `Interface` item of the `Help` menu. For example, you can start the debugging by typing

> `debug(idiv2(25,15))`

The debugger will automatically display the values of the parameters `a` and `b` and local variables `q` and `r` when executing the program line by line with the `sst` button.

### 7.3 Programming style

The `Xcas` programming language is interpreted, not compiled. The run time of an `Xcas` program is affected by the number of instructions rather than the number of lines.

The speed of a program does not always match up with the clarity of the program; compromises are often necessary. For the most part, the calculation time isn’t an issue; interpreted languages are often used to test algorithms and create models. Full scale applications are written in a compiled language like `C++`. A `C++` can use `giac` for the formal calculations.

When you are trying to write a fast program, you may want to take into account the number of instructions and the speed of the instructions. For example, it is in general faster to create lists and sequences than it is to program loops. Recall than in `Xcas` you can find out how long it takes to run a command by entering

> `time(``command``)`

## 8 Exercises

There are usually several ways to get the same result in `Xcas`. We will try to use the simplest approaches.

Exercise 1 Verify the following identities.

1. (21/3+41/3)3−6(21/3+41/3)=6
2. π /4 = 4arctan(1/5)−arctan(1/239)
3. sin(5x) = 5sin(x)−20sin3(x)+16sin5(x)
4. (tan(x)+tan(y))cos(x)cos(y) = sin(x+y)
5. cos6(x)+sin6(x) = 1−3sin2(x)cos2(x)
6. ln(tan(x/2+π/4)) = argsinh(tan(x))

Exercise 2 Transform the rational expression

x4+x3−4x2−4x
x4+x3−x2−x

into the following:

(x+2)(x+1)(x−2)
x3+x2−x−1
| , |
x4+x3−4x2−4x
x(x−1)(x+1)2
| , |
(x+2)(x−2)
(x−1)(x+1)
| ,

x2
(x−1)(x+1)
| − |
4
(x−1)(x+1)
| .

Exercise 3 Transform the rational expression

2 |
x3−yx2−yx+y2
x3−yx2−x+y

into the following

2 |
x2−y
x2−1
| , 2 |
x2−y
(x−1)(x+1)
| ,

2− |
y−1
x−1
| + |
y−1
x+1
| , 2−2 |
y−1
x2−1
| .

Exercise 4 For each of the following definitions of a function f

f(x) = | √ |
ex−1
| , f(x) = |
1
x | √ |
1+x2
| ,

f(x) = |
1
1+sin(x)+cos(x)
| , f(x) = |
ln(x)
x(x2+1)2
| .

1. Find an antiderivative F.
2. Find F′(x) and show that F′(x) can be simplified to f(x).

Exercise 5 For each of the following integrals

∫ |
−1
−2
1
x
| dx , | ∫ |
1
0
| xarctan(x) dx ,

∫ |
π/2
0
|  | √ |
cos(x)
| dx , | ∫ |
π/2
0
| x4sin(x)cos(x) dx .

1. Find the exact value, and find an approximation.
2. For n=100 and n=1000, do the following. For each j=0,…,n, let xj=a+j(b−a)/n and yj=f(xj). Find an approximate value for the integral by using the left endpoint rule:

   n−1
   ∑
   j=0
   | f(xj)(xj+1−xj) .

3. Do the same as the previous part, except use the trapezoid method:

   n−1
   ∑
   j=0
   1
   2
   | (f(xj)+f(xj+1))(xj+1−xj) .

Exercise 6 Define the function f by f(x,y)=cos(xy).

1. Let x0=y0=π/4. Define the function that maps (u,v,t) to

   f(x0+ut,y0+vt) .

2. Define the function g which is the partial derivative of the preceding function with respect to t (so this will be a directional derivative of f).
3. Find the gradient of f at (x0,y0), then find the scalar product of this gradient with the vector (u,v). Write this result in terms of g.

Exercise 7 Consider x3−(a−1)x2+a2x−a3=0 as an equation in x.

1. Graph the solution x as a function of a using `plotimplicit`.
2. Find the three solutions of the equation. You can use `rootof` to find the first solution, then use `quo` to factor out the first solution. You can then find the last two solutions by solving the resulting second degree equation. (You can use `coeff` to find the discriminant of the equation.)
3. For the values of a which give three real roots, graph each of the roots in different colors on the same graph. (You can use `resultant` to find the values of a for which the equation has a multiple root; these values are the possible bounds of intervals for a where each of the roots is real.)
4. Find the solutions for a=0,1,2.

Exercise 8 For each of the limits

lim
x→ 0
sin(x)
x
| , |
lim
x→ 0+
| (sin(x))1/x , |
lim
x→ +∞
| (1+1/x)x , |
lim
x→ +∞
| (2x+3x)1/x

1. Find the exact value.
2. Find a value of x such that the distance from f(x) to the limit is less than 10−3.

Exercise 9 For each function f, find ranges for the x coordinates and the y coordinates that give the most informative graph.

1. f(x)=1/x.
2. f(x)=ex.
3. f(x)=1/sin(x).
4. f(x)=x/sin(x).
5. f(x)=sin(x)/x.

Exercise 10 Let f(x)=3x2+1+1/π4ln((π−x)2).

1. Verify that this function takes negative values on ℝ+. Graph the function over the interval [0,5].
2. Find є >0 such that `Xcas` gives the correct graph of the function over the interval [π−є,π+є].

Exercise 11

1. Graph the function exp(x) over the interval [−1,1]. On the same graph, plot the Taylor polynomials (of orders 1,2,3 and 4) for this function centered at x=0.
2. Same question for the interval [1,2].
3. Graph the function sin(x) on the interval [−π,π]. On the same graph, plot the Taylor polynomials (of orders 1,3 and 5) for this function centered at x=0.

Exercise 12 Plot the following graphs on the same window, with x and y coordinates from 0 to 1.

1. The line y=x.
2. The graph of the function f : x↦ 1/6+x/3+x2/2.
3. The tangent line to the graph of f at x=1.
4. The vertical line segment from the x-axis to the point where the graph of f intersects the line y=x, and a horizontal line segment from the y-axis to that point of intersection.
5. The labels “fixed point” and “tangent”, at the appropriate positions.

Exercise 13 The goal of this exercise is to graph a family of functions on the same screen. You will need to choose the number of curves, the interval to graph over to obtain the most informative graphic.

1. Functions fa(x) = xae−x for a from −1 to 1.
2. Functions fa(x)=1/(x−a)2 for a from −1 to 1.
3. Functions fa(x)=sin(ax), for a from 0 to 2.

Exercise 14 Graph each of the following curves. You will need to choose a range of values for the parameter to make sure you have the complete graph.

1. ⎧ ⎨ ⎩ |
   x(t) | = | sin(t)
   y(t) | = | cos3(t)

2. ⎧ ⎨ ⎩ |
   x(t) | = | sin(4 t)
   y(t) | = | cos3(6 t)

3. ⎧ ⎨ ⎩ |
   x(t) | = | sin(132 t)
   y(t) | = | cos3(126 t)

Exercise 15 The goal of this exercise is to visualize in different ways the surface of the graph z=f(x,y)=x y2. You will need to have a 3-d geometry window open.

1. Use `plotfunc` to draw an informative graph, choosing an appropriate domain and number of steps.
2. Create an editable parameter a with `assume`. Draw the curve z=f(a,y) and vary the parameter with the mouse.
3. Create an editable parameter b with `assume`. Draw the curve z=f(x,b) and vary the parameter with the mouse.

Exercise 16 The goal of this exercise is to visualize a cone in different ways.

1. Draw the surface given by z=1−√x2+y2.
2. Sketch the parameterized surface defined by

   ⎧ ⎪ ⎨ ⎪ ⎩ |
   x(u,v) | = | u cos(v)
   y(u,v) | = | u sin(v)
   z(u,v) | = | 1−u .

3. For a sufficiently large value of a, draw the curve parameterized by

   ⎧ ⎪ ⎨ ⎪ ⎩ |
   x(t) | = | t cos(a t)
   y(t) | = | t sin(a t)
   z(t) | = | 1−t .

4. Draw the family of curves parameterized by

   ⎧ ⎪ ⎨ ⎪ ⎩ |
   x(t) | = | a cos(t)
   y(t) | = | a sin(t)
   z(t) | = | 1−a .

5. Draw the cone using the `cone` function.

Exercise 17

1. Generate a list ℓ of 100 integers randomly generated between 1 and 9.
2. Verify that all values in ℓ are in {1,…,9}.
3. Extract from the list ℓ all values greater than or equal to 5.
4. For each k=1,…,9, find the number of values in ℓ which are equal to k.

Exercise 18 For a real number x, the continued fraction for x of order n is a list of integers [a0,…,an] created in the following way:

- let x0 = x.
- let a0 be the integer part of x0.
- let x1 = 1/(x0−a0).
- for k=1,…,n, let ak be the integer part of xk and let xk+1 = 1/(xk − ak).

The list [a0,…,an] is associated with the fraction

un = a0+ |
1
a1+ |
1
a2+ |
1
⋱+ |
1
an

For x∈{π,√2, e} and n∈ {5,10} :

1. Find [a0,…,an].
2. Compare your result with the value given by `Xcas`’s `dfc` function.
3. Find un and the numeric value of x−un.

Exercise 19 Write (without using a loop) the following sequences:

1. The numbers from 1 to 3 in steps of 0.1.
2. The numbers from 3 to 1 in steps of −0.1.
3. The squares of the first 10 integers.
4. Numbers of the form (−1)n n2 for n=1,…,10.
5. 10 “0”s followed by 10 “1”s.
6. 3 “0”s followed by 3 “1”s, followed by 3 “2”,…, followed by 3 “9”s.
7. “1” followed by 1 “0”, followed by a “2” followed by 2 “0”s, …, followed by “8” followed by 8 “0”s, followed by “9”.
8. 1 “1” followed by 2 “2”s, followed by 3 “3”s,…, followed by 9 “9”s.

Exercise 20

1. Define the following polynomials of degree 6.
   1. A polynomial whose roots are the integers from 1 to 6.
   2. A polynomial whose roots are 0 (triple root), 1 (double root) and 2 (simple root).
   3. The polynomial (x2−1)3.
   4. The polynomial x6−1.
2. Write (without using the `companion` function) the companion matrix A for each of the polynomials in (1). Recall the the companion matrix for the polynomial

   P=xd+ad−1xd−1+⋯+a1x+a0 ,

   is

   A = | ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ |  |
   0 | 1 | 0 | … |  | 0
   ⋮ | ⋱ | ⋱ | ⋱ |  | ⋮
   ⋮ |  |  | ⋱ | ⋱ | 0
   0 | … |  | … | 0 | 1
   −a0 | −a1 |  | … |  | −ad−1
   |  | ⎞ ⎟ ⎟ ⎟ ⎟ ⎟ ⎟ ⎠ | . (1)

3. Find the eigenvalues of the matrix A.
4. Find the characteristic polynomial of A.

Exercise 21

1. For variables a and b, write the square matrix A of order 4 with aj,k=a if j=k and aj,k=b if j ≠ k.
2. Find and factor the characteristic polynomial of A.
3. Find an orthogonal matrix P such that PT A P is a diagonal matrix.
4. Use your answer to the previous question to define the function that maps an integer n to the matrix An.
5. Find Ak for k=1,…,6 by finding the matrix products. Check that the function given in the previous part gives the same results.

Exercise 22

1. Find the square matrix N of order 6 given by nj,k=1 if k=j+1 and nj,k=0 if k ≠ j+1.
2. Find Np for p=1,…,6.
3. Write the matrix A = xI+N, where x is a variable.
4. Find Ap for p=1,…,6.
5. Find exp(At) as a function of x and t :

   exp(At) = I+ |
   ∞
   ∑
   p=1
   tp
   p!
   | Ap .

Exercise 23 Define the following functions without using a loop.

1. The function f which takes as input an integer n and two real numbers a and b and returns the n× n matrix A whose diagonal terms are all equal to a and whose non-diagonal entries are equal to b.
2. The function g which takes as input an integer n and three real numbers a,b and cm and returns the matrix A=(aj,k)j,k=1,…,n whose diagonal elements are equal to a, whose terms aj,j+1 are equal to b and whose terms aj+1,j are equal to c, and whose remaining terms are 0.
3. The function H which takes as input an integer n and returns Hilbert’s Matrix; the matrix A=(aj,k)j,k=1,…,n where aj,k = 1/(j+k+1). Compare the execution time of your function with that of the `hilbert` function.
4. The function V which takes as input a vector x=[x1,…,xn] and returns Vandermonde’s Matrix; the matrix A=(aj,k)j,k=1,…,n where aj,k = xkj−1. Compare the execution time of your function with that of the `vandermonde` function.
5. The function T which takes as input a vector x=[x1,…,xn] and returns the Toeplitz Matrix; the matrix A=(aj,k)j,k=1,…,n where aj,k = x|j−k|+1 .

Exercise 24 Write the following functions, which take as input a function f:ℝ → ℝ and three real numbers xmin, x0 and xmax with xmin≤ x0 ≤ xmax.

1. `derive` : This function calculates and graphs the derivative of f over the interval [xmin,xmax] and returns f′(x0).
2. `tangent` : This function graphs the function f on the interval [xmin,xmax] and in the same window draws the tangent to the graph at x0. It returns the equation for the tangent line as a first degree polynomial.
3. `araignee` : This function graphs the function f on the [xmin,xmax], as well as the line y=x. It calculates and returns the first 10 iterates of f starting at x0 (so x1 = f(x0), x2 = f(x1),…). It also draws the sequence of segments, alternately vertical and horizontal, allowing you to visualize the iterations: segments joining (x0,0), (x0,x1), (x1,x1), (x1,x2), (x2,x2), …(compare this to the function `plotseq`)
4. `newton_graph` : This function graphs the function f over the interval [xmin,xmax]. It also calculates and returns the first ten iterates of the sequence starting at x0 given by Newton’s Method: x1=x0 −f(x0)/f′(x0), x2=x1 − f(x1)/f′(x1) … (The values of the derivative should be approximated.) This function also graphs in the same window the segments displaying the iterations: segments joining (x0,0), (x0,f(x0)), (x1,0), (x1,f(x1)), (x2,0), (x2,f(x2)),…(compare with the function `newton`)

Exercise 25 Let D be the unit square D=(0,1)2. Let Φ be the function defined on D by

Φ(x,y) = (z(x,y),t(x,y))= | ⎛ ⎜ ⎜ ⎝ |
x
1+y
| , |
y
1+x
| ⎞ ⎟ ⎟ ⎠ | .

1. Find the inverse of Φ.
2. Find and graph the image under Φ of the domain D: Δ=Φ(D).
3. Let A(x,y) be the Jacobian matrix of Φ at a point (x,y) in D, and B(z,t) the Jacobian matrix of Φ−1 at a point (x,y) in Δ. Calculate these two matrices, and verify that B(Φ(x,y)) and A(x,y) are inverses of each other.
4. Let J(z,t) be the determinant of the matrix B. Calculate and simplify J(z,t).
5. Evaluate

   I1= | ∬ |
   D
   |  | ⎛ ⎜ ⎜ ⎝ |
   1+x+y
   (1+x)(1+y)
   |  | ⎞ ⎟ ⎟ ⎠ |
   3
   | dxdy .

6. Evaluate

   I2= | ∬ |
   Δ
   | (1+z)(1+t) dzdt ,

   and verify that I1=I2.

## Index

`()`, 3.5 `->`, 3.4 `:=`, 1.3, 3.2, 3.2 `=`, 3.2, 3.2 `==`, 3.2, 3.2 `[]`, 3.5 `%{ %}`, 3.5 All_trig_sol, 2.3 `abs`, 3.4 absolute value, 3.4 `acos`, 3.4 `acosh`, 3.4 addition, 3.1 and, 7.1 `and`, 3.2 antiderivatives, 4.3 `append`, 3.5 `apply`, 3.5 arc cosine, 3.4 sine, 3.4 tangent, 3.4 `arg`, 3.4 argument, 3.4 `asc`, 3.6 `asin`, 3.4 `asinh`, 3.4 `assume`, 3.2 `atan`, 3.4 `atanh`, 3.4 Bezout, 5.1 Bezout’s identity, 5.2 Booleans, 3.2 `blockmatrix`, 5.4 `canonical_form`, 5.2 `ceil`, 3.4 `char`, 3.6 characters, 3.6 `circle`, 6.2, 6.2 cloud of dots, 6.2 `coeff`, 5.2 command line, 1.1, 2.4 complex roots, 2.3 `concat`, 3.6 `cone`, 6.3 `conj`, 3.4 conjugate, 3.4 `convert`, 3.3 `coordinates`, 3.4 `cos`, 3.4 `cosh`, 3.4 cosine, 3.4 hyperbolic, 3.4 cotangent, 3.4 `cumSum`, 3.5 cumulative sum, 3.5 `curl`, 4.1 curve implicit, 6 parametric, 6 polar, 6 `cyclotomic`, 5.2 `Digits`, 2.3 `degree`, 5.2 `desolve`, 4.5 `det`, 5.4 determinant, 5.4 diagonalization, 5.6 `diff`, 4.1 divergence, 4.1 `divergence`, 4.1 `divis`, 5.2 division, 3.1 divisors, 5.2 `divpc`, 5.2 `e`, 3.1 `egcd`, 5.2 `eigenvals`, 5.6 eigenvalues, 5.6 eigenvectors, 5.6 `eigenvects`, 5.6 `else`, 7.1, 7.1 `epsilon`, 2.3, 3.1 `equation`, 6.2, 6.2 equations, 3.2 `evalf`, 1.2, 1.6, 3.1, 3.1 `exact`, 3.1, 3.1 `exp`, 3.4 `exp2trig`, 5.3 `expand`, 1.4, 3.3, 5.2 `expr`, 3.6 `False`, 3.2 `factor`, 1.4, 3.3, 5.2 `factorial`, 3.4 `factors`, 5.2 `false`, 3.2 `floor`, 3.4 `for`, 7.1 `frac`, 3.4 fractional part, 3.4 `froot`, 5.2 `fsolve`, 4.4 function apply to a list, 3.5 `function_diff`, 4.1 functions, 1.3 Gauss-Jordan, 5.5 `gcd`, 5.1, 5.2 `getDenom`, 5.2 `getNum`, 5.2 `grad`, 4.1 gradient, 4.1 Help index, 1.6, 1.6 `head`, 3.6 `hermite`, 5.2 `hessian`, 4.1 `horner`, 5.2 `hyp2exp`, 5.3 `i`, 3.1 `idivis`, 5.1 `idn`, 5.4 `egcd`, 5.1 `if`, 7.1, 7.1 `ifactor`, 5.1 `ifactors`, 5.1 `im`, 3.4 `image`, 5.4 imaginary part, 3.4 `inf`, 3.1 `infinity`, 3.1 `int`, 4.3 `integer`, 3.2 integrals, 4.3 `inter`, 6.2, 6.3 `interactive_plotode`, 4.5 interface, 2.1 intersection, 6.2 inverse cosine hyperbolic, 3.4 sine hyperbolic, 3.4 tangent hyperbolic, 3.4 `iquo`, 5.1 `iquorem`, 5.1 `irem`, 5.1 `isprime`, 5.1 Jordan form, 5.6 `jordan`, 5.6 `ker`, 5.4 `lagrange`, 5.2 `laguerre`, 5.2 `laplacian`, 4.1 `lcm`, 5.1, 5.2 `lcoeff`, 5.2 `legend`, 6.2 `limit`, 4.2 `linsolve`, 4.4, 5.5 list, 3.5 of coefficients, 3.5 | lists, 3.5 `ln`, 3.4 `log`, 3.4 `log10`, 3.4 logarithm base 10, 3.4 natural, 3.4 loop, 7.1 loops, 7.1 `makematrix`, 5.4 `map`, 3.5 matrix determinant, 5.4 hessian, 4.1 identity, 5.4 image, 5.4 kernel, 5.4 rank, 5.4 `matrix`, 5.4 `max`, 3.4 maximum, 3.4 menu bar, 2.1, 2.2 `mid`, 3.5, 3.6 `min`, 3.4 minimum, 3.4 multiplication, 3.1 `NULL`, 3.5 `nextprime`, 5.1 `normal`, 3.3, 5.2 not, 7.1 number prime, 5.1 numbers approximate, 1.2, 3.1 exact, 1.2, 3.1, 3.1 hexadecimal, 3.1 octal, 3.1 `odesolve`, 4.5 `open_polygon`, 6.2, 6.3 or, 7.1 `or`, 3.2 `parameq`, 6.2 `partfrac`, 3.3, 5.2 `pcar`, 5.6 `pcoeff`, 5.2 `peval`, 5.2 `pi`, 3.1 `plane`, 6.3 `plotpolar`, 6 `plot`, 1.5, 6 `plotfield`, 4.5 `plotfunc`, 6, 6.3 `plotimplicit`, 6 `plotode`, 4.5 `plotparam`, 6, 6.3 `pmin`, 5.6 `point`, 6.2, 6.3 `poly2symb`, 3.5, 5.2 `polygon`, 6.2, 6.3 polygonal line, 6.2, 6.3 `polygonplot`, 6.2, 6.3 polynomial characteristic, 5.6 cyclotomic, 5.2 Hermite, 5.2 Lagrange, 5.2 Laguerre, 5.2 minimal, 5.6 Taylor, 5.2 Tchebyshev, 5.2 power, 3.1 `powmod`, 5.1 `previousprime`, 5.1 prime factors, 5.1 product cross, 5.4 matrix, 5.4 scalar, 5.4 term by term, 5.4 `product`, 3.5 `proot`, 4.4, 5.2 `propfrac`, 5.2 `ptayl`, 5.2 `purge`, 3.2 `quo`, 5.2 quotient, 5.1 radian, 2.3 `randpoly`, 5.2 `rank`, 5.4 `ranm`, 5.4 `ratnormal`, 3.3 `re`, 3.4 real part, 3.4 `rem`, 5.2 remainder, 5.1 `romberg`, 4.3 `round`, 3.4 `rref`, 5.5 `scatterplot`, 6.2 `segment`, 6.2 sequence, 3.5 sequences, 3.5 series, 4.2 Taylor, 4.2 `series`, 4.2 set, 3.5 sets, 3.5 `sign`, 3.4 simplifications, 3.3 `simplify`, 3.3 `simult`, 5.5 `sin`, 3.4 `sincos`, 3.3 sine, 3.4 hyperbolic, 3.4 `sinh`, 3.4 `size`, 3.6 `solve`, 4.4 space, 6.3 `sphere`, 6.3 `sqrt`, 3.4 square root, 3.4 `string`, 3.6 `sturmab`, 5.2 sublist, 3.5 sublists, 3.5 submatrix, 5.4 subsequence, 3.5 subsequences, 3.5 `subst`, 3.2 subtraction, 3.1 `sum`, 3.5 `symb2poly`, 3.5, 5.2 Taylor polynomial, 5.2 `True`, 3.2 tables, 3.5, 3.5 `tail`, 3.6 `cot`, 3.4 `tan`, 3.4 tangent, 3.4 hyperbolic, 3.4 `tangent`, 6 `tanh`, 3.4 `taylor`, 4.2 `tchebyshev1`, 5.2 `tchebyshev2`, 5.2 `tcoeff`, 5.2 `tcollect`, 5.3 test, 7.1, 7.1 `texpand`, 5.3 text, 6.2 `tlin`, 5.3 `trig2exp`, 5.3 `true`, 3.2 `tsimplify`, 3.3 `unapply`, 3.4, 4.1 `valuation`, 5.2 variables, 1.3, 3.2 whole part, 3.4 Xcas getting, 1.1 starting, 1.1

> This document was translated from LATEX by HEVEA.