[Contents] [TitleIndex] [WordIndex

New Scientific Features in 2009

The goal of this page is to summarize the new or scientific features of Scilab and its environment during the year 2009.

During the year 2009, the following versions of Scilab were released :

In summary, the following is a list of new or updated modules during the year 2009 :

29th September 2009 : NISP - Non Intrusive Spectral Projection

This toolbox allows to approximate a given model, which is associated with input random variables. It allows to compute sensitivity indices, which measure the importance of a variable, or a group of variable, in the total variance of the function. The representation uses polynomials which are specially selected for sensitivity analysis. The current toolbox provides an object-oriented approach of the C++ NISP library.

The module provides the following components :

The following list presents the features provided by the NISP toolbox :

This toolbox has been created in the context of the OPUS project :


within the workpackage 2.1.1 "Construction de méta-modèles". This project has received funding by Agence Nationale de la recherche :


This module is available in ATOMS :


To install it, type :



15th of October 2009 : the Lolimot toolbox

The lolimot toolbox for Scilab is a Neural Netwok module developped by Yann Collette. The lolimot toolbox is available under the CeCILL licence.

The Lolimot model (LOcal LInear MOdel Tree) is a model from the neural network familly. It is able to learn every kind of non-linear relationship. Compared to a classical neural network, the learning phase of a LOLIMOT model is quite fast and deterministic. Once a model is learnt, you have an easy access to analytical derivatives of your model through a call to the function estim_der_lolimot.

The lolimot toolbox is packaged on Atoms :


To install it, we just type:


and restart Scilab.

On the negative side, the demos of the v2.0 packaged in Atoms fails with Scilab 5.3.0 saying that "getf" is undefined.

The module provides the following functions:

The help pages provide good descriptions of the input and output arguments. On the negative side, there is no example provided in the help pages.

The toolbox provides one demo. This demo produces the output (if we execute them with write rights in the demo directory):

Learning a 121 data set
learn_lolimot: partition 1 / 10 - residual = 18876.00 / 10167.38 - improvement = 85.65 % - elapsed time = 0.38 s
learn_lolimot: partition 2 / 10 - residual = 10167.38 / 5393.19 - improvement = 88.52 % - elapsed time = 0.44 s
learn_lolimot: partition 3 / 10 - residual = 5393.19 / 1552.60 - improvement = 247.36 % - elapsed time = 0.55 s
learn_lolimot: partition 4 / 10 - residual = 1552.60 / 1317.85 - improvement = 17.81 % - elapsed time = 0.92 s
learn_lolimot: partition 5 / 10 - residual = 1317.85 / 1090.00 - improvement = 20.90 % - elapsed time = 0.86 s
learn_lolimot: partition 6 / 10 - residual = 1090.00 / 859.55 - improvement = 26.81 % - elapsed time = 0.97 s
learn_lolimot: partition 7 / 10 - residual = 859.55 / 635.57 - improvement = 35.24 % - elapsed time = 1.14 s
learn_lolimot: partition 8 / 10 - residual = 635.57 / 557.57 - improvement = 13.99 % - elapsed time = 1.39 s
learn_lolimot: partition 9 / 10 - residual = 557.57 / 479.28 - improvement = 16.34 % - elapsed time = 1.65 s
8.908000 s required for learning - final residual = 479.277009
learn_lolimot: partition 1 / 10 - residual = 18876.00 / 10073.63 - improvement = 87.38 % - elapsed time = 0.48 s
learn_lolimot: partition 2 / 10 - residual = 10073.63 / 5339.36 - improvement = 88.67 % - elapsed time = 0.69 s
learn_lolimot: partition 3 / 10 - residual = 5339.36 / 1272.63 - improvement = 319.55 % - elapsed time = 1.12 s
learn_lolimot: partition 4 / 10 - residual = 1272.63 / 1111.49 - improvement = 14.50 % - elapsed time = 1.75 s
learn_lolimot: partition 5 / 10 - residual = 1111.49 / 940.38 - improvement = 18.20 % - elapsed time = 2.46 s
learn_lolimot: partition 6 / 10 - residual = 940.38 / 785.26 - improvement = 19.75 % - elapsed time = 3.01 s
learn_lolimot: partition 7 / 10 - residual = 785.26 / 628.38 - improvement = 24.97 % - elapsed time = 4.05 s
learn_lolimot: partition 8 / 10 - residual = 628.38 / 544.33 - improvement = 15.44 % - elapsed time = 4.42 s
learn_lolimot: partition 9 / 10 - residual = 544.33 / 461.81 - improvement = 17.87 % - elapsed time = 5.97 s
24.545000 s required for learning a non exponential model - final residual = 461.805855
Lolimot: 0.95 s needed to compute sequentially the estimations
Lolimot: 0.23 s needed to compute vectorially the estimations

The previous demo also produces the following figures.

Lolimot Figure 1 Lolimot Figure 1 Lolimot Figure 1 Lolimot Figure 1

15th of October 2009: Design and Analysis of Computer Experiments, DACE

DACE, Design and Analysis of Computer Experiments, is a toolbox for working with kriging approximations to computer models.

This module is a Scilab port by Yann Collette of the Matlab module by Hans Bruun Nielsen.

Typical use of this software is to construct a kriging approximation model based on data from a computer experiment, and to use this approximation model as a surrogate for the computer model.

The software also addresses the design of experiment problem, that is choosing the inputs at which to evaluate the computer model for constructing the kriging approximation.

This module is available on ATOMS :


This module provides the following functions:

To install the DACE module:


The demonstration of the module is based on the script:

loadmatfile(DACEPath + 'data1.mat');
theta = [10 10];
lob   = [0.1 0.1];
upb   = [20 20];

[dmodel,perf] = dacefit(S, Y, regpoly0, corrgauss, theta, lob, upb);

X = gridsamp([0 0; 100 100], [40 40]);
[YX] = predictor(X, dmodel);

X1 = matrix(X(:,1), 40, 40);
X2 = matrix(X(:,2), 40, 40);
YX = matrix(YX, size(X1,1), size(X1,2));

h = scf();
param3d1(S(:,1), S(:,2), list(Y,-1));
Color = 127*((YX - min(YX))/(max(YX) - min(YX))) + 1;
xtitle('Kriging interpolation','x1','x2','yx');

[emodel,perf] = dacefit(S, Y, regpoly0, corrgauss, 2);
[tmp,MSE] = predictor(X, dmodel);
printf('max MSE = %f - min MSE = %f\n', max(MSE), min(MSE));

h = scf();
xtitle('Variance of the kriging model','x1','x2','mse');

[y,dy] = predictor(S(1,:),dmodel);
printf('y = %f - should be 34.1\n',y);
printf('dy = '); disp(dy'); printf('should be [0.2526 0.1774]''\n');

[y,dy,mse,dmse] = predictor([50 50],dmodel);
printf('y = %f - should be 38.0610\n',y);
printf('dy = '); disp(dy'); printf('should be [-0.0141 -0.0431]''\n');
printf('mse = %f - should be 0.7526\n',mse);
printf('dmse = '); disp(dmse'); printf('should be [0.0004 0.0187]''\n');

The previous script produces the following output.

max MSE = 2.080212 - min MSE = 0.000004
y = 34.100000 - should be 34.1
dy =  
    0.2526436    0.1774495  
should be [0.2526 0.1774]'
y = 38.061025 - should be 38.0610
dy =  
  - 0.0140699  - 0.0430717  
should be [-0.0141 -0.0431]'
mse = 0.752628 - should be 0.7526
dmse =  
    0.0004124    0.0187276  
should be [0.0004 0.0187]'

It also produces the two following plots.



18th November 2009 : CUTEr

CUTEr is a versatile testing environment for optimization and linear algebra solvers. The package contains a collection of test problems, along with tools intended to help developers design, compare and improve new and existing solvers. Because the large set of test problems and testing facilities produced in this context were useful in their own right, they were extended to provide easy interfaces with other commonly used optimization packages, gathered in a coherent multi-platform framework and made available, on the world wide web and via anonymous ftp, to the research community.

The test problems provided are written in so-called Standard Input Format (SIF). A decoder to convert from this format into well-defined Fortran 77 and data files is provided. Once translated, these files may be manipulated to provide tools suitable for testing optimization packages.

This module is available in ATOMS :


To install it, type :


9th of November 2009: AMPL Scilab interface

This toolbox allows to load into Scilab .nl files created using AMPL (http://www.ampl.com).

AMPL is a comprehensive and powerful algebraic modeling language for linear and nonlinear optimization problems, in discrete or continuous variables.

Developed at Bell Laboratories, AMPL lets you use common notation and familiar concepts to formulate optimization models and examine solutions, while the computer manages communication with an appropriate solver.

AMPL's flexibility and convenience render it ideal for rapid prototyping and model development, while its speed and control options make it an especially efficient choice for repeated production runs.

The AMPL toolbox for Scilab allows to use an AMPL model like any other objective functions, get derivatives, constraints, etc. You can use Scilab optimization tools to find some solutions.

You must compile ampl .mod files into .nl files before using this toolbox to load the file into Scilab.

This module was created by Yann Collette under the CeCILL.

This project is managed on the Google code project:


and it is available in ATOMS:


To install it, type:


This module provides the following functions:

The following script is a sample test case which evaluates the gradient of the objective function.

cd SCI\contrib\ampl_toolbox\1.2-1
[asl, x0, bl, bu, v, cl, cu] = ampl_init('demos/data/asl/ch3.nl');
[g, jac]     = ampl_evalg(asl, x0);
[spg, spjac] = ampl_eval_sp_g(asl, x0);
printf('Difference between Jacobian and sparse Jacobian = %f\n', norm(jac - spjac'));

The previous script prints the following message.

-->printf('Difference between Jacobian and sparse Jacobian = %f\n', norm(jac - spjac'));
Difference between Jacobian and sparse Jacobian = 0.000000

19th November 2009 - Matrix Market : Read and Write Matrix Market formatted files

The Matrix Market file format allows to store matrices in simple ASCII data files. This format can be used for dense or sparse matrices. The toolbox contains the functions mminfo, mmread and mmwrite for reading and writing matrices on Matrix Market formatted files.

This module is available in ATOMS :


and is managed on the Forge:


To install it, type :


This module provides the following functions:

The following is the example of the mmwrite and mmread functions.


23rd November 2009 - CelestLab : CNES Space mechanics toolbox for mission analysis

CelestLab is a library of space flight dynamics functions written in Scilab. This library has been developed and is maintained by the CNES (Centre National d’Etudes Spatiales) for mission analysis purposes. The library is used by CNES for the trajectory analysis and orbit design for various type of missions. CelestLab contains about ten modules that allow to perform various tasks such as: orbit extrapolation, attitude computation, elementary manoeuvre computation, change of reference frame, change of coordinates,…CelestLab has been validated against the CNES flight dynamics software legacy. Every function, is described, in its own help page with selected examples.

This toolbox is developped by Alain Lamy and Thierry Martin, from CNES.

This module is available in ATOMS :


To install it, type


The following is the list of functions in this module.

1. About

2. Coordinates and frames

3. Geometry and events

4. Interplanetary

5. Models

6. Orbit properties

7. Relative motion

8. Trajectory and maneuvers

9. Utilities

This module provides lots of demonstrations. The following demo is extract from the Maneuvers set of demonstrations. The following figure plots the cost of the Hohmann transfer for an minimum altitude of 0 km and a maximum altitude of 35000 km.


The goal of this toolbox is to provide several Number theory related algorithms. The following is a list of the current features:

The toolbox is based on macros. The implementation uses Scilab's double precision integers, therefore is limited to integers in the [-252,252] interval. Many features are missing so that the current state is more a "toy" toolbox.

This module is available in ATOMS : http://atoms.scilab.org/toolboxes/number

To install it, type :


17th December 2009 : Scilab 5.2.0 provides the fminsearch function

This function searches for the unconstrained minimum of a given cost function. The provided algorithm is a direct search algorithm, i.e. an algorithm which does not use the derivative of the cost function. It is based on the update of a simplex, which is a set of n+1 vertices, where each vertex is associated with one point and one function value. This algorithm is the Nelder-Mead algorithm.

The Nelder-Mead algorithm is especially popular in the fields of chemistry, chemical engineering, and medicine. Two measures of the ubiquity of the Nelder-Mead algorithm are that it appears in the best-selling handbook Numerical Recipes and in Matlab. The algorithm attemps to replace the worst vertex with a new point, which depends on the worst point and the centre of the best vertices.

The fminsearch function is based on the neldermead component, which provides an object-oriented tool for simplex-based algorithms. It provides the Spendley, Hext and Himsworth fixed shape simplex method, Nelder and Mead variable shape simplex method and the Box complex method. Box's algorithm is able to manage bounds on the parameters.

See the help for fminsearch at http://help.scilab.org/fminsearch.

2022-09-08 09:27