Next: Simplification procedures Up: ALIAS-Maple Previous: Interval evaluation in ALIAS-Maple

• La page de J-P. Merlet
• La page Présentation de HEPHAISTOS
• La page "Présentation" de l'INRIA

Subsections

# Introduction

## Allowed mathematical operators

The following Maple mathematical operators are recognized in an expression:

• arithmetic: +,-,*,/,,**
• trigonometry: sin,cos,tan,cot,sec,csc,arcsin,arccos,arctan,arccot
• hyperbolic trigonometry : sinh,cosh,tanh,coth,sech,csch,arcsinh,arccosh,arctanh,arccoth
• log and exponential: log,ln,log10,exp
• miscellaneous: abs, signum, signum(1,..),abs(1,...),INTERVAL,ceil,floor,round

Note that the value of signum(x)=|x|/x where x is an interval whose absolute value is lower than
ALIAS/value_sign_signum is set to the Maple variable _Envsignum0. This allows one to specify the value of signum(0).

## Basic principles

Many of the algorithm existing in the ALIAS-C++ library can be used directly from Maple. Their efficiency may be improved by using the simplification procedures described in the previous chapter.

All these procedures use the same mechanism:

• they generate the C++code specific for the problem at hand (using the ALIAS-Maple procedures Make[FJH])
• they generate a main program that call specific algorithms of the ALIAS-C++ library
• the C++ code is compiled into an executable program
• the executable program is run and the result is written in a file
• the procedure read the result file and returns the result in Maple format

All these procedures allow for an optional last argument which is the name of a simplification procedure (see chapter 4).

There are numerous parameters that allows to change the behavior of the solving procedures: they are described in the section 3.5.

## Bisection mode

All the solving procedures proceed by considering a box for the variables. Some calculation is performed with the current box (for example trying to reduce the width of the box). Then this box will be bisected. Hence the bisection process is a key element of the algorithms and ALIAS offers various bisection modes that are controlled through the variable ALIAS/single_bisection:
• 0: all the ranges of the variables are bisected at their middle point. Hence new boxes are created after the bisection process. This is a mode that has to be avoided
• : a single variable will be bisected. The choice of the bisected variable will depend on the the value of ALIAS/single_bisection variable: see the C++ manual for the possible values of this variable
• 20: you have defined your own bissection procedure. By default this procedure should be written in the file BISSECTION_USER.C which must include the procedure. Alternatively you may give the file name in the variable ALIAS/bisection_user which should be a string. .

int Select_Best_Direction_Interval_User(int DimVar,int DimEq,
INTERVAL_VECTOR (* TheIntervalFunction)(int,int,INTERVAL_VECTOR &),
INTERVAL_VECTOR &Input)

where DimVar is the size of the unknown vector, DimEq the number of equations, TheIntervalFunction the evaluation function of your problem (by default F)and Input the current box. This procedure shall return the variable number that will be bisected.

• a mix of these 2 modes in which ranges among the available will be bisected. ALIAS/mixed_bisection. gives the number of bisected ranges

## Storage mode

The boxes created after a bisection are stored in a list for further processing. There are different ways to store the new boxes:

• immediately at the end of the list: this is a called the direct mode
• immediately in place of the current box and after it: this is called the reverse storage mode
• as a mix between these two modes: this is the mixed bisection mode
The reverse storage mode is the one that ensure that we will use the minimal amount of memory storage.

The storage mode is controlled through the variable ALIAS/storage_mode: 0 is used for the direct storage mode while reverse storage will be used when ALIAS/storage_mode is set to a number equal or larger than the number of unknowns+1. Mixed storage may also be used using the variable ALIAS/mixed_storage that indicates how many boxes are stored in place of the current box. For more details on the storage mode see the ALIAS-C++ manual.

## Simplification procedures

For a specific problem the end-user may have some knowledge of the problem that implies that he may determine that for some intervals for the variables the problem has no solution, that the intervals for some variables may be reduced or that a solution may be found. Most of the ALIAS C++ solving programs have an optional argument that allows then end-user to provide this knowledge as a procedure, that will be called a simplification procedure.

Usually this procedure will take as input a set of intervals for the variables and will return an integer which is typically:

• -1 if there is no solution to the problem at hand for the given set of intervals
• 1 if the routine has allowed to reduce the width of the intervals of the set
• 0 if the routine has not changed the set of intervals
• if the procedure has provided a solution to the problem

As these simplification procedures are very important for solving efficiently most problems we will devote the specific chapter 4 for those used in system solving. More specific simplification procedures will be presented together with the solving algorithms.

# General purpose system solving procedures

You may solve a system of equations and inequalities by calling the ALIAS-Maple procedures:



Most of the solving procedures may deal with inequalities constraints but in the list of functions you must first define the equations and then the inequalities. For using these solvers it is needed to create C++ programs that interval evaluate the equations and their derivatives in the appropriate format. By default these procedures will use Make[FJH] to create these programs but they offer the possibility of using user's pre-defined C++ programs.

The name of the executable created by ALIAS-Maple is _GS_ but this may be changed by assigning another string to the variable ALIAS/name_executable or by setting the string ALIAS/ID.

The calculation done by these procedures may be stopped although the calculation has not been completed by setting the variable ALIAS/time_out to a floating point that indicates the maximum computation time in minutes. In that case the procedure will return a time out signal together with the solutions that have been obtained up to now. For example for a problem with 2 variables the message will be:


[[TIME_OUT],[[1.,1.],[2.,2.]],[[2.5,2.5],[3.,3.]]]

which indicates that 2 solutions have been found before the time-out occurs.

## GeneralSolve

This is the most basic procedure for solving systems. It uses only the the interval evaluation of the expressions and can deal with equations involving intervals as coefficients, while the other solving procedure cannot be used in that case.

This procedure will return as solution a set of boxes: a box is defined as a set of intervals, one for each unknowns. Such box will be obtained as soon as either the width of all the intervals is lower than ALIAS/epsilon or the width of the interval evaluation of the expressions for the box is lower than ALIAS/fepsilon. To avoid returning a large number of solutions it is assumed that all the solutions of the system are at a distance at least larger than ALIAS/dist.

Hence the results provided by this procedure exhibit the following features:

• if ALIAS/dist is set to 0: all the solutions of the system will be included in one of the result boxes. But there may be some result boxes that do no include a solution of the system
• if ALIAS/dist is not set to 0: the number of result boxes will be in general lower than in the previous case but some solutions of the system may not be included in the result boxes and be only close to a solution box. There still may be some result boxes that do no include a solution of the system

For example:


with(ALIAS):
u:=GeneralSolve([x^2+y^2-1,x+y],[x,y],[[-2,2],[-2,1]]);

will provide in u an approximation of the 2 solutions of the system. for included in the range [-2,2], [-2,1].

The efficiency of the calculation may be improved by using a simplification procedure, see chapter 4. Hence the following code will be faster:


with(ALIAS):
HullConsistency([x^2+y^2-1,x+y],[x,y],"Simp"):
u:=GeneralSolve([x^2+y^2-1,x+y],[x,y],[[-2,2],[-2,1]],"Simp");


Note that by default when an evaluation of all the equations is needed in the C++ program, the program will proceed by successive calls to the procedure created by MakeF. This behavior may be changed by setting ALIAS/equation_alone to 0: in that case all equations will be evaluated by a single call to the C++ evaluation procedure. This may be important in term of computation time if the evaluation of simplification terms is performed before doing the evaluation (e.g. if the procedure ALIAS_FSIMPLIFY has been defined, see the MakeF section 2.1.1).

Note that there is a specific bisection mode that can be used for this solving algorithm. The table ALIAS/table_ordered_bisection, with as many lines as equations, will contain variable number in a row such as for the first row [1,3,4]. This will indicate that only variables 1, 3, 4 will first be bisected until the first equation is satisfied. Then we will move to the second equation and the second row of the table. This bisection method is validated as soon as the flag ALIAS/ordered_bisection is set to 1.

The syntax of these procedures is the same as GeneralSolve but there are two main differences between these procedures and GeneralSolve:

• the derivatives of the expressions are used to improve their interval evaluation: hence the expressions should be at least for GradientSolve and for HessianSolve
• provided that the jacobian of the system is regular these algorithms are able to compute exactly the solutions of a system in the following sense: each of the solution boxes are guaranteed to contain one and only one solution and furthermore there is a numerical scheme that allows to determine this solution. If this is the case these procedures will return as result boxes for which each interval is reduced to a point (otherwise interval solutions are returned: this is a good way to determine if ALIAS has been able to calculate an exact solution). Furthermore the result provided by HessianSolve may be used as input for the Newton procedure that will allow to compute the solutions with an arbitrary accuracy, see section 9.8.

When ALIAS has returned a point M as solution it is always possible to retrieve the boxes in which it was found that there was a unique solution whose approximation is M: all interval solutions are available via the list ALIAS/Solutions.

In spite of the additional computation time involved by the use of the derivatives, these procedures are in general faster than GeneralSolve. Indeed the algorithms that are used in these procedures may allow to determine relatively large box in which an unique solution will be found, thereby avoiding a large number of bisection. As this knowledge is used to manage the list of boxes it may have a drastic effect on the computation time of the algorithm.

Note that it is possible to avoid using the Hessian (which may be computer intensive) for the evaluation of the expressions by setting the variable ALIAS/no_hessian to 1. The flag ALIAS/rand may be used to switch of bisection mode from time to time (it fixes the value of the ALIAS-C++ ALIAS_RANDG variable). The variables ALIAS/size_tranche_bisection and ALIAS/tranche_bisection may be used for the bisection mode 8 of GradientSolve (see the ALIAS-C++ manual).

For systems with equations and unknowns with the algorithm computes the exact solutions of the first equations. Then if the interval evaluation of all the remaining equations has an absolute value lower than ALIAS/fepsilon the solution is supposed to be valid. For systems with see section 3.4.

# Specific solving procedures

ALIAS-Maple provides solving procedures for systems having specific structures.

## The SolveSimplex and SolveSimplexGradient procedures

This procedure allows to solve systems that have algebraic terms in at least at two equations. Each equation is transformed as the sum of a linear part and a non linear part. The linear part is substituted into a new variable that is submitted to a linear constraints. Then the simplex method is used to improve the range for the unknowns. The difference between the SolveSimplex and SolveSimplexGradient procedure is that in the second case the derivatives of the non linear parts of the equations are used to improve their interval evaluation and hence the linear constraints used by the simplex.

The following variables plays a role in these procedures:

• ALIAS/diam_simplex: the simplex will not be applied if the width of the current box is lower than this value (default value:0.1)
• ALIAS/full_simplex: if the value of this variable is the simplex will be applied only for searching the minimum and maximum of the first variables when they are ordered by decreasing order of width. This is probably the most important parameter to set: a compromise has to be found between the gain of considering all variables and the computation time of the simplex
• ALIAS/init_simplex_linear: if some of the coefficients of the linear part of the expressions have an identical value you may assign this value to this variable so that a faster assignation of the coefficients will be performed (available only for the parallel version of these procedures). For example if a majority of the linear coefficients are 2 setting ALIAS/init_simplex_linear to 2 implies that the C++ procedure that calculate the linear coefficients will just compute the coefficients that are not equal to 2
• ALIAS/min_diam_simplex: the simplex will not be applied if the width of the current box is larger than this value (default value: 1.e7)
• ALIAS/min_improve_simplex: if the width of one range of the box has been improved by a value larger than this variable, then the simplex method will be repeated (default value: 0.1)
• ALIAS/no_simplex: if this parameter is set to 1 the simplex will not be used. This may be interesting for the parallel implementation where the computation involved by the simplex may be to computer intensive for the master
• ALIAS/simplex_expanded: for the simplex method using the gradient setting this flag to 1 indicates that the expression will be expanded with respect to the lower bound of each variable (i.e. the unknown with lower bound will be written as =+ and the simplex method will use the variable )

## Systems of distance equations

### The SolveDistance procedure

The SolveDistance procedure allows to solve systems of distance equations. A distance equation describes that the distance between m points in a n-dimensional space is given. The unknowns are the n coordinates of the points. Hence a distance equation may be written as:

where are numerical values. Furthermore the algorithm allows for the use of virtual points. The coordinates of a virtual point M are linear combination of the coordinates of real points:

Hence a distance equation may also be written as:

The syntax of SolveDistance is:

SolveDistance(Func,Vars,Init)

The initial search domain for SolveDistance may be determined using the Bound_Distance procedure.

### Specificity of the procedure

Note that there is no need to use the HullConsistency simplification procedure when using SolveDistance as it is already embedded in the C++ method. The consistency method in the algorithm updates the value of the variables and starts again the update if the change in at least one interval exceed the threshold ALIAS/seuil2B (which has the default value 0.1).

As the SolveDistance algorithm uses systematically a Newton scheme with as estimate of the solution the center of the box, it may be interesting to switch the current box with the largest one in the list of boxes to process in order to find new solutions to the system very quickly. Indeed if the Newton scheme appears to converge toward an approximate solution we will use a special version of the Kantorovitch test to determine a box centered at that contains only one solution. This box will be further enlarged by using a specific version of the Neumaier test (this is called an inflation of the box). Then we will determine if has an intersection with each box in the list of boxes to process and if this is the case we will modify the list of boxes so that it has only boxes that are the complementary of : this process will speed up the algorithm.

Switching the current box with the largest one is done by setting the flag ALIAS/permute to the number of bisection after which the boxes will be permuted. The default value for this flag is 1000 and if it is set to 0 no permutation will be done.

Note that if you have a system of distance equations with one parameter, you may fix the value of this parameter to a given value and then follow the solutions when the parameter changes in the range [] by using a specific continuation procedure (see section 7.3)

## Linear algebra

### Enclosure of an interval linear system

Let consider the family of linear systems defined by the matrix equality

where is a set of unknowns, a square matrix whose elements are functions of and a dimensional vector whose elements are also functions of . The enclosure of the set of solutions of this family of linear systems is a box that includes the solution of all linear systems in the family.

The enclosure can be computed using the LinearBound procedure whose syntax is


LinearBound(A,B,Derivative,Vars,Init)

where:
• A is a square array whose elements are function of the unknowns in Vars
• B is an array whose elements are function of the unknowns in Vars
• Derivative is an integer. If set to 0 the procedure uses the classical interval Gaussian elimination scheme to calculate the enclosure. If set to 1 it will use an ALIAS specific version of the Gaussian elimination scheme that uses the derivatives of the elements of A, B to improve the enclosure calculation
• Vars: a list of unknowns names
• Init: a list of ranges for the unknowns
A typical example is:

with(ALIAS):
with(linalg):

A:=array([[x,y],[x,x]]):
B:=array([x,y]):
VAR:=[x,y]:
LinearBound(A,B,0,[x,y],[[3,4],[1,2]]);
LinearBound(A,B,1,[x,y],[[3,4],[1,2]]);

which returns the enclosure [[.76923076923077, 10], [-13, -.076923076923077]] if Derivative is set to 0 and [[.91666666666667, 2.6666666666667], [-2, -.66666666666667]] if Derivative is set to 1 (note that these values are computer dependent), the exact answer being [[1.25,1.66666],[-1]].

### Regularity of parametric matrices

We consider a matrix whose coefficients are functions of a set of variables. The procedure RegularMatrix allows one to determine if the set of matrices includes only regular matrices. Its syntax is


RegularMatrix(mat,vars,init,cond,typedet)

where
• mat: the matrix definition (here called A)
• vars: the set of variables
• init: a list of ranges, one for each variable
• cond: an integer that indicates if matrix conditioning is used. It is 0 if no conditioning is used, 1 if the conditioning KA is used, 2 if AK is used and 3 if both conditioning are used. The matrix K used here is Inverse(A(Mid(vars))).
• typedet: a list of 3 integers. This integer indicates which determinant calculation procedure is used. A value lower than 2 indicates the use of Fast_Determinant, a value of 2 the use of Medium_Determinant and a value of 3 Slow_Determinant. A value of -1 indicates that the user has provided its own procedure to compute the determinant: the procedure name is ALIAS/user_determinant_matrix and is written in the file ALIAS/user_determinant_matrix.C. It is also possible to use specific procedures for computing the determinant of the left and right conditioned matrices by using the procedure ALIAS/user_determinant_cond_left and ALIAS/user_determinant_cond_right.
The procedure returns 1 if all matrices are regular, -1 if the set includes a singular matrix and 0 if the algorithm has failed.

Note that the procedure generates the C++ code for calculating the elements of the matrix by using the procedure MakeF. If these elements includes several times the same complex expressions it is advised to use the mechanism described in MakeF (section 2.1.1) to interval evaluate these expressions only once.

Note also that the used bisection method is to bisect the unknown range having the largest width. Scaling the unknown is therefore important

Note a special case that may occur if the matrix may include interval coefficients apart of the parameters or if the matrix is badly numerically conditioned. In that case it may happen that for a specific value of the parameters the sign of the determinant of the matrix cannot be ascertained (such point will be called unsafe). Hence at this point we cannot state the regularity of the matrix. But it may happen that at 2 other points the determinants will have opposite sign indicating the presence of a singularity. So the following cases may occur:

1. at point P1 the determinant has not a constant sign while at points P2, P3 the signs are opposite
2. at a set of points the determinant has not a constant sign while at all other points the determinant have a constant sign
Hence the output of the algorithm may be -1 in the first case but cannot be neither -1 nor 1 in the second one.

The procedure may behave in 2 different ways:

1. stop as soon as an unsafe point has been found
2. continue if an unsafe point is detected until either a case 1 is detected or until only unsafe points remains

The procedure behavior is controlled through the flag ALIAS/unsafe_det. If this flag is set to 1 behavior 1 will be used while behavior 2 is obtained by setting the flag to 0. The default value of this flag is 0. For behavior 1 the return code of the procedure is -3 if an unsafe point is found.

The procedure reorders the boxes every ALIAS/rand iteration (default value=0 i.e. at each iteration). The ordering may be controlled through the ALIAS/order variable. Assume that the interval evaluation for a box is [a,b]. At some point the procedure will have find a box with a constant sign s for the determinant:

• if the order is 0 the box are sorted by decreasing order of b+a is s or -(b+a) if s
• otherwise the box are sorted by decreasing order of b/(b-a) if s or -a/(b-a) if s
The default value for ALIAS/order is 0.

The conditioning may play an important role especially as the conditioned matrix is calculated symbolically. Assume for example that the first row of A is [x  x] and that AK is used. If the first column of K is [a1  a2], then the first element of the conditioned matrix is a1x+a2x, that the procedure will arrange as x(a1+a2), thereby leading to an optimal form in term of interval evaluation, which is better than the numerical conditioning.

The procedure accepts an optional sixth argument which is a string such as SIMP that defines a matrix simplification procedure. The syntax of such procedure is


SIMP(int dimA,INTERVAL_MATRIX & A)

where dimA is the dimension of matrix A. This procedure shall return -1 if all the matrices in the set A are regular, 0 otherwise. The C++ program corresponding to this procedure is written in the file SIMP.C. Such program may be obtained for example by using the RohnConsistency or SpectralRadiusConsistency procedures.

A parallel version of this procedure is ParallelRegularMatrix.

### The RohnConsistency procedure

This procedure creates a matrix simplification program to help testing the regularity of a set of matrices. Its syntax is:

RohnConsistency(name)

where name indicates the name of the procedure, that will be written in the file name.C. This simplification procedure uses Rohn regularity test that is based on the calculation of determinants of scalar matrices (where is the dimension of the matrices). It shall therefore not be used with very large matrices.

Note that if the flag Use_Simp_Cond is set to 0 this test will not be used if the C++ flag Simp_In_Cond is not equal to 0. For example in RegularMatrix this is the case if the matrix received by Rohn is a conditioned matrix.

A remembering mechanism may allow to reduce the computation time by storing information on already processed matrix in the Rohn test. For using this mechanism you must set ALIAS/rohn_remember to the number of matrix that will be stored and ALIAS/rohn_size_matrix to the dimension of the matrix.

This procedure creates a matrix simplification program to help testing the regularity of a set of matrices. Its syntax is:


where name indicates the name of the procedure, that will be written in the file name.C. The floating point eps is used to compute a safe upper bound of the spectral radius: usually a value of is a good value. The integer iter indicates the maximal number of iteration that the algorithm is allowed to perform.

Note that if the flag Use_Simp_Cond is set to 0 this test will not be used if the C++ flag Simp_In_Cond is not equal to 0. For example in RegularMatrix this is the case if the matrix received by the procedure is a conditioned matrix.

### The LinearMatrixConsistency procedure

This procedure should be used in conjunction with RegularMatrix. It should be used only if the matrix includes rows or columns in which a variable appears with degree 1 in at least 2 elements of a row or a column. Its syntax is:


LinearMatrixConsistency(A,VAR,vars,row,context,rohn,
Func,FuncKA,FuncAK,name)

The parameters are:
• A: the considered matrix
• VAR: a list of the variable name that appears in the matrix
• vars: a list of variable names that appears linearly in the row or column of A
• row: 1 if the procedure look at the row of A, 2 for the column
• context: see description
• rohn: 1 if the Rohn consistency procedure is used in the program
• Func, FuncKA, FuncAK: the name of C++ procedures to compute respectively the matrix, the left conditioned matrix and the right conditioned matrix. If this procedure is used in conjunction with RegularMatrix these names are we have Func="F", FuncKA="AKA", FuncAK="AAK".
• name: the name of the C++ procedure that will be created in the file name.C
Linearity has to be understood in a very loose sense. For example if a row of the matrix is

x    xy    x+y

this row may be considered as linear in x in which case we have 3 linear elements in the row. If the row is considered as linear in y we have 2 linear elements in the row. Note that the linearity is checked according to the order provided in Vars.

This procedure may be used for the matrix A, the conditioned matrix KA or the conditioned matrix AK. Context is used to indicate the choice according to the following code:

• 0: for A only
• 1: for KA only
• 2: for AK only
• 3: for A, KA, KA
• 4: for AK, KA
• 5: for A, KA
• 6: for A, AK
The complexity of this procedure is approximately where is is the number of linear terms in the elements of row or column i of A. Hence it should not be be used with a large Vars. The use of Rohn matrix may also be expensive as it requires to calculate scalar determinant, with the dimension of the matrix A.

For example we may use


LinearMatrixConsistency(A,[x,y],[x],1,5,"F","AKA","","Simp"):

In this example we will consider the row of matrix A and its elements that are linear in x. The procedure will be used for both the matrix A and the conditioned matrix KA (hence this procedure should be used with the parameter cond of RegularMAtrix set to 1 or 3. Note that we assume here that the conditioning matrix is .

### The GerschgorinConsistency procedure

Any ALIAS maple procedure involved in the calculation on eigenvalues of a matrix A may use the Gerschgorin circles methods that states that all the eigenvalues of a matrix are enclosed in the union of a set of circles (in the complex plane) whose center and radii are calculated as functions of the coefficients of the matrix.

The purpose of the GerschgorinConsistency procedure is to generate the C++ code for a simplification procedure that may be used by the ALIAS-Maple procedures doing calculation on the eigenvalues of a square matrix. The syntax is:



where:
• Func: list of constraints (equation or inequality), the last element must be the matrix.
• Vars: list of parameters name including as first element an auxiliary name that will be the name of the unknown in the characteristic polynomial name
• Gradient: a flag that indicates if the derivatives of the matrix coefficients with respect to the unknowns may be used (1) or not (0)
• n: an integer, the order of the method, see below
• procname: the name of the simplification procedure. The name of the created file will be procname.C
Here we try to improve the bounds given by the Gerschgorin method using the fact that for any diagonal matrix D with positive components the eigenvalues of are the same than the eigenvalues of A. The method is not able to determine D such that the Gerschgorin circles are minimal (i.e. give the best bounds) and only try a set of at most different D where n is the order of the method.

To check only if the eigenvalues lie in the interval provided by the C++ procedure without modifying this interval use a negative n

# Non 0-dimensional system

Although the solving procedures of ALIAS are mostly devoted to be used for 0 dimensional system (i.e. systems having a finite number of solutions) most of them can still be used for non 0-dimensional system. Specific procedures for systems of dimension 1 are described in chapter 7. For larger dimension systems the solving procedures of ALIAS-Maple will provide an approximation of the result as a set of input intervals that are written in a file. To deal with non-0 dimensional system it is necessary to set the flag ALIAS/ND to 1 and to set the name of the file in the variable ALIAS/ND_file (its default value is .resultND.

The total volume of the boxes written in the file may be obtained through the variable ALIAS/VolumeIn. During the process we call neglected boxes the boxes that cannot be eliminated as not containing solutions of the problem but can neither be discarded as part of the boxes may contain a solution. A box will be neglected if its width is lower than ALIAS/epsilon. The total volume of the neglected boxes may be obtained through the variable ALIAS/VolumeNeglected.

The result (or cross-sections of it if the problem has more than 3 variables) may be visualized using the DrawND procedure described in section 9.10.

# Parameters for the solving procedures

The behavior of the solving algorithms may be adjusted using various parameters that are presented in the on-line help (see ALIAS[Parameter]): basically all the parameters that may be adjusted in the C++ library may be also adjusted via Maple.

## General parameters for the solving procedures

We indicate here parameters that appear in most procedures, their meaning, their default value and the corresponding name in the C++ library.

 Parameter name Meaning C++ equivalent ALIAS/debug flag for debug purpose Debug_Level_Solve_General_Interval ALIAS/dist minimal distance between 2 distinct solutions (for GeneralSolve) ALIAS/epsilon maximal width of a solution box ALIAS/fepsilon maximal width of the expressions evaluation for a solution box ALIAS/lib string that indicates the location of the ALIAS C++ library ALIAS/maxbox maximal number of stored boxes ALIAS/maxsol maximal number of solutions ALIAS/rand allow to switch between bisection modes ALIAS_RANDG ALIAS/rand exchange largest box with current every xx iter. ALIAS_RANDG ALIAS/mixed_bisection bisection mode, see section 3.1.3 ALIAS_Mixed_Bisection ALIAS/mixed_storage allows to switch between Switch_Reverse_Storage direct and reverse storage ALIAS/optimized flag to indicate if the C++ files are compiled with -O ALIAS/order ordering for the storage of the boxes, see the ALIAS-C++ manual ALIAS/profil string that indicates the location of the BIAS/Profil library ALIAS/single_bisection bisection mode, see section 3.1.3 Single_Bisection ALIAS/storage_mode bisection mode, see section 3.1.4 Reverse_Storage ALIAS/name_executable name of the executable ALIAS/allows_n_new_boxes maximum number of boxes that can be created when intersecting a box and a unicity box ALIAS_Allows_N_New_Boxes ALIAS/type_n_new_boxes if the maximum number of boxes that is created when intersecting a box and a unicity box is lower than the maximum determine the rule to create the new boxes (see ALIAS-C++) ALIAS/tranche_bisection for bisection mode 8 ALIAS_Tranche_Bisection ALIAS/size_tranche_bisection for bisection mode 8 ALIAS_Size_Tranche_Bisection

The variable ALIAS/stop_first_sol allows to exit from a solving procedure without completing the full calculation. The following behavior will be obtained according to the value of this flag:

• 0: (default value) the procedure complete the whole solving process
• 1: the procedure exit as soon as one solution has been found
• 2: the procedure exit as soon as the maximal number of solution has been found

For the expression involving the determinant of a matrix we have some specific variables:

 Parameter name Meaning C++ equivalent ALIAS/det22 see section 2.1.3 ALIAS/minor22 see section 2.1.3 ALIAS/row22 see section 2.1.3

## Parameters for the procedures using the derivatives

• ALIAS/maxgradient: the maximal width of a box for using the gradient for the evaluation of the expression (default value: 1.e10). (C++:ALIAS_Diam_Max_Gradient)
• ALIAS/maxkraw: the maximal width of a box before using the Krawczyk test (default value: 1.e10) (C++: ALIAS_Diam_Max_Kraw)
• ALIAS/maxnewton: maximal width of a box before using the interval Newton method (default value: 1.e10) (C++: ALIAS_Diam_Max_Newton)
• ALIAS/newton_max_dim: for the numerical C++ Newton scheme the iteration is stopped if the absolute value of the i-th parameter is greater than the i-th of this table
• ALIAS/store_gradient: the signs of the derivatives for each box processed by the algorithm are usually stored. Setting this variable to 0 allows to decrease the size of the storage memory
• ALIAS/transmit_gradient: the master program will usually transmit to the slaves the sign of the elements of the jacobian for the box that is send to the slave. This may be avoided by setting this flag to 0
• ALIAS/use_inflation,ALIAS/eps_inflation: as soon as a solution is found we will try to inflate the box in which the solution has been found by at least ALIAS/eps_inflation. This process may be computer intensive and may be invalidated by setting ALIAS/use_inflation to 0
• ALIAS/type_n_new_boxes, ALIAS/allows_n_new_boxes: if a unicity box has been discovered solutions may be sought in the following boxes only in the complementary part of the box with respect to the unicity box: this is allowed by setting the flag type_n_new_boxes to 1. This may create a large number of boxes and the flag allows_n_new_boxes allows to specify how many new boxes may be created
• ALIAS/Grad_Equation: an integer array used by the HessianSolve procedure. If the i-th element of this array is 0 the derivatives of the i-th equation are not used for the interval evaluation of the equation
• ALIAS/apply_kanto: an integer used by the HessianSolve procedure. If set to 2 the algorithm will always perform ALIAS/newton_iteration (default value: 100) iterations of a Newton scheme with as initial guess of the solution the center of the current box. If the scheme converge it is first verified that a solution has indeed been found and if this solution lie inside the initial search domain. The box in which a solution is found is then inflated and the search domain is reduced by the solution box. Using this method allows to often determine quickly solutions of a system.

# Generating program without running it

You may also directly obtain a full program for one of the three main solving procedures of ALIAS by setting the variable ALIAS/runit to 0.

You may then compile the created program using the makefile _makefile. These procedures may be used with inequality constraints. Alternatively you may run Maple with a solving program embedded in the Maple code and stop the session when the compilation starts. According to the algorithm you are using the name of the main program will start with _G and has the extension .C (alternatively you may define the name of the main program using the variable ALIAS/name_executable) Alternatively you may define a string in ALIAS/ID` and all files that will be created during the solving process will have this string appended to their name.

Next: Simplification procedures Up: ALIAS-Maple Previous: Interval evaluation in ALIAS-Maple