New Scientific Features in 2009
Contents

New Scientific Features in 2009
 29th September 2009 : NISP  Non Intrusive Spectral Projection
 15th of October 2009 : the Lolimot toolbox
 15th of October 2009: Design and Analysis of Computer Experiments, DACE
 18th November 2009 : CUTEr
 9th of November 2009: AMPL Scilab interface
 19th November 2009  Matrix Market : Read and Write Matrix Market formatted files
 23rd November 2009  CelestLab : CNES Space mechanics toolbox for mission analysis
 24th November 2009  Number : Number theory related algorithms
 17th December 2009 : Scilab 5.2.0 provides the fminsearch function
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 :
 13th February 2009 : Scilab v5.1
 14th April 2009 : Scilab v5.1.1
 17th December 2009 : Scilab v5.2.0
In summary, the following is a list of new or updated modules during the year 2009 :
 29th September 2009 : NISP  Non Intrusive Spectral Projection
 15th of October 2009: Design and Analysis of Computer Experiments, DACE
 15th of October 2009 : the Lolimot toolbox
 9th of November 2009: AMPL Scilab interface
 18th November 2009 : CUTEr
 19th November 2009  Matrix Market : Read and Write Matrix Market formatted files
23rd November 2009  CelestLab : CNES Space mechanics toolbox for mission analysis
 24th November 2009  Number : Number theory related algorithms
 17th December 2009 : Scilab 5.2.0 provides the fminsearch function
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 objectoriented approach of the C++ NISP library.
The module provides the following components :
 “nisp” provides function to configure the global behaviour of the toolbox. This allows to startup and shutdown the library, configure and quiery the verbose level or initialize the seed of the random number generator.
 “randvar” is the class which allows to manage a random variable. Various types of random variables are available, including uniform, normal, exponential, etc...
 “setrandvar”, is the class which allows to manage a set of random variables. Several methods are available to build a sampling from a set
 of random variables. We can use, for example, a MonteCarlo sampling or a Sobol low discrepancy sequence. This feature allows to use the class as Design of Experiment tool (DOE).
 “polychaos” is the class which allows to manage a polynomial chaos expansion. The coefficients of the expansion are computed based on given
 numerical experiments which creates the association between the inputs and the outputs. Once computed, the expansion can be used as a regular function. The mean, standard deviation or quantile can also be directly retrieved.
The following list presents the features provided by the NISP toolbox :
 Manage various types of random variables : uniform, normal, exponential, lognormal,
 Generate random numbers from a given random variable,
 Transform an outcome from a given random variable into another,
 Manage various sampling methods for sets of random variables: MonteCarlo, Sobol, Latin Hypercube Sampling, various samplings based on Smolyak.
 Manage polynomial chaos expansion and get specific outputs, including: mean, variance, quantile, correlation, etc...
 Generate the C source code which computes the output of the polynomial chaos expansion.
This toolbox has been created in the context of the OPUS project :
within the workpackage 2.1.1 "Construction de métamodèles". This project has received funding by Agence Nationale de la recherche :
http://www.agencenationalerecherche.fr/
This module is available in ATOMS :
http://atoms.scilab.org/toolboxes/NISP/2.1
To install it, type :
atomsInstall(['NISP','2.1'])
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 nonlinear 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 :
http://atoms.scilab.org/toolboxes/lolimot
To install it, we just type:
atomsInstall('lolimot')
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:
 estim_der_lolimot — Analytical Lolimot derivative of a learnt model
 estim_lolimot — Computes the Lolimot estimation for a given vector
 estim_vec_lolimot — Computes the Lolimot estimation for a given vector
 export_der_model — Export the partial derivative of a Lolimot model into a .sci file
 export_model — Export a Lolimot model to a .sci file
 learn_lolimot — Learns a Lolimot model for a given inputs/output data set
 learn_valid_lolimot — Learns a Lolimot model for a given inputs/output data set and using a validation data set
 plot_lolimot_part — Plot the Lolimot cuts for a 2D model
 read_lolimot — Read a Lolimot model
 update_lolimot — The function update the linear models of a given Lolimot model for a given learning data set
 write_lolimot — Saves a Lolimot model in a file
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.
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 :
http://atoms.scilab.org/toolboxes/dace_scilab
This module provides the following functions:
 corrcubic — Cubic correlation function
 correxp — Exponential correlation function
 correxpg — General exponential correlation function
 corrgauss — Gaussian correlation function
 corrlin — Linear correlation function
 corrspherical — Spherical correlation function
 corrspline — Cubix spline correlation function
 dacefit — DACE  Kriging
 dsmerge — Merge data for multiple design sites
 gridsamp — ndimensional grid over given range
 lhsamp — Latin hypercube distributed random numbers
 predictor — Predictor for y(x) using the given DACE model
 randperm — random permutation of the integers from 1 to n
 regpoly0 — Zero order polynomial regression function
 regpoly1 — First order polynomial regression function
 regpoly2 — Second order polynomial regression function
To install the DACE module:
atomsInstall('dace_scilab')
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(); drawlater; param3d1(S(:,1), S(:,2), list(Y,1)); Color = 127*((YX  min(YX))/(max(YX)  min(YX))) + 1; xset('colormap',hotcolormap(128)); mesh(X1,X2,YX,YX); xtitle('Kriging interpolation','x1','x2','yx'); drawnow; [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(); drawlater; mesh(X1,X2,matrix(MSE,size(X1,1),size(X1,2))); xtitle('Variance of the kriging model','x1','x2','mse'); drawnow; [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 multiplatform framework and made available, on the world wide web and via anonymous ftp, to the research community.
The test problems provided are written in socalled Standard Input Format (SIF). A decoder to convert from this format into welldefined 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 :
http://atoms.scilab.org/toolboxes/CUTEr
To install it, type :
atomsInstall('CUTEr')
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:
http://code.google.com/p/scilabmip
and it is available in ATOMS:
http://atoms.scilab.org/toolboxes/ampl_toolbox
To install it, type:
atomsInstall('ampl_toolbox')
This module provides the following functions:
 ampl_eval_sp_g — evaluate the gradient of the objective function and the sparse Jacobian of the constraints of a given AMPL problem
 ampl_eval_sp_w — evaluate the sparse Hessian of the objective function and of the constraints of a given AMPL problem
 ampl_eval_spst_g_rc — evaluate the sparsity structure of the Jacobian of the constraints of a given AMPL problem
 ampl_eval_spst_g_val — evaluate the values of the Jacobian for the position corresponding to the sparsity structure of the Jacobian of a given AMPL problem
 ampl_eval_spst_w_rc — evaluate the sparsity structure of the Hessian of the constraints plus the objective function of a given AMPL problem
 ampl_eval_spst_w_val — evaluate the values of the Hessian for the position corresponding to the sparsity structure of the Hessian of a given AMPL problem
 ampl_evalf — evaluate the objective function and the constraints value of a given AMPL problem
 ampl_evalg — evaluate the gradient of the objective function and the Jacobian of the constraints of a given AMPL problem
 ampl_evalw — evaluate the dense Hessian of the objective function and of the constraints of a given AMPL problem
 ampl_free — free the memory associated to an AMPL problem
 ampl_get_compl — return the list of constraints which are of complementary kinds of a given AMPL problem
 ampl_get_size — return the size of a given AMPL problem
 ampl_get_type — return the type of variables of a given AMPL problem
 ampl_init — read an AMPL .nl file and returns a problem structure plus boundaries of the problem
 ampl_write_sol — write a .sol file which stores the solution of a given AMPL problem
The following script is a sample test case which evaluates the gradient of the objective function.
cd SCI\contrib\ampl_toolbox\1.21 [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')); ampl_free(asl);
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 :
http://atoms.scilab.org/toolboxes/MatrixMarket
and is managed on the Forge:
http://forge.scilab.org/index.php/p/matmark/
To install it, type :
atomsInstall('MatrixMarket')
This module provides the following functions:
 mminfo — Extracts size and storage information out of a Matrix Market file
 mmread — Reads a Matrix Market file
 mmwrite — Writes a sparse or dense matrix to a Matrix Market file
The following is the example of the mmwrite and mmread functions.
A=sparse([1,1;1,3;2,2;3,1;3,3;3,4;4,3;4,4],.. [9;27+%i;16;27%i;145;88;88;121],[4,4]) mmwrite(TMPDIR+'/A.mtx',A); A1=mmread(TMPDIR+'/A.mtx')
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 :
http://atoms.scilab.org/toolboxes/celestlab
To install it, type
atomsInstall('celestlab')
The following is the list of functions in this module.
1. About
 Flight dynamics
 Dates and Time — Dates and Time
 Local Frames — Local Frames
 Orbital elements — Orbital elements
 Reference Frames — Reference Frames
2. Coordinates and frames
 CL_co_car2ell — Cartesian coordinates to elliptical coordinates
 CL_co_car2sph — Cartesian coordinates to spherical coordinates
 CL_co_ell2car — Elliptical coordinates to cartesian coordinates
 CL_co_sph2car — Spherical coordinates to cartesian coordinates
 CL_dat_cal2cjd — Calendar date to modified (1950.0) Julian day
 CL_dat_cal2jd — Calendar date to Julian day
 CL_dat_cjd2cal — Modified (1950.0) Julian day to calendar date
 CL_dat_cjd2jd — Modified (1950.0) Julian day to Julian day
 CL_dat_cjd2mjd — Modified (1950.0) Julian day to modified Julian day
 CL_dat_jd2cal — Julian day to calendar date
 CL_dat_jd2cjd — Julian day to modified (1950.0) Julian day
 CL_dat_mjd2cjd — Modified Julian day to modified (1950.0) Julian day
 CL_dat_tai2utc — TAI to UTC conversion
 CL_dat_utc2tai — UTC to TAI conversion
CL_fr_G502J2000 — Gamma50 (Veis) to EME2000 (J2000) vector transformation
CL_fr_G502J2000Mat — Gamma50 (Veis) to EME2000 (J2000) transformation matrix
 CL_fr_G502ter — Gamma50 (Veis) to terrestrial frame vector transformation
CL_fr_G502terMat — Gamma50 (Veis) to terrestrial frame transformation matrix
CL_fr_H0n2J2000Mat — H0n to EME2000 (J2000) transformation matrix
CL_fr_J20002G50 — EME2000 (J2000) to Gamma50 (Veis) vector transformation
 CL_fr_J20002ter — EME2000 (J2000) to terrestrial frame vector transformation
 CL_fr_inertial2qsw — Inertial to QSW local orbital frame vector transformation
 CL_fr_inertial2tnw — Inertial to TNW local orbital frame vector transformation
 CL_fr_locOrbMat — Inertial frame to custom local orbital frame transformation matrix
 CL_fr_lvlhMat — Inertial frame to LVLH local orbital frame transformation matrix
 CL_fr_qsw2inertial — QSW local orbital frame to inertial frame vector transformation
 CL_fr_qswMat — Inertial frame to QSW local orbital frame transformation matrix
 CL_fr_ter2G50 — Terrestrial frame to Gamma50 (Veis) vector transformation
 CL_fr_ter2J2000 — Terrestrial frame to EME2000 (J2000) vector transformation
 CL_fr_ter2J2000Mat — Terrestrial frame to EME2000 (J2000) transformation matrix
 CL_fr_ter2topoN — Terrestrial frame to topocentric North frame vector transformation
 CL_fr_tnw2inertial — TNW Local orbital frame to inertial frame vector transformation
 CL_fr_tnwMat — Inertial frame to TNW local orbital frame transformation matrix
 CL_fr_topoN2ter — Topocentric North frame to terrestrial frame vector transformation
 CL_fr_topoNMat — Terrestrial frame to topocentric North frame transformation matrix
 CL_oe_car2cir — Cartesien to circular adapted orbital elements
 CL_oe_car2cirEqua — Cartesian to circular equatorial adapted orbital elements
 CL_oe_car2kep — Cartesian to keplerian orbital elements
 CL_oe_cir2car — Circular adapted to cartesian orbital elements
 CL_oe_cirEqua2car — Circular equatorial adapted to cartesian orbital elements
 CL_oe_cirEqua2kep — Circular equatorial adapted to keplerian orbital elements
 CL_oe_kep2car — Keplerian to cartesian orbital elements
 CL_oe_kep2cirEqua — Keplerian to circular equatorial adapted orbital elements
 CL_rot_angles2matrix — Rotation angles to transformation matrix
 CL_rot_angularVelocity — Rotation angles to angular velocity and acceleration vectors
 CL_rot_axAng2quat — Rotation axis and angle to quaternion
 CL_rot_defFrameVec — Frame transformation matrix based on 1 or 2 vectors.
 CL_rot_defQuat — Quaternion definition from real and imaginary components
 CL_rot_defRotVec — Rotation transforming 2 vectors into 2 vectors
 CL_rot_eul2quat — Euler '123' angles to quaternion
 CL_rot_matrix2quat — Transformation matrix to quaternion
 CL_rot_quat2axAng — Quaternion to rotation axis and angle
 CL_rot_quat2eul — Quaternion to Euler '123' angles
 CL_rot_quat2matrix — Quaternion to transformation matrix
 CL_rot_quatSlerp — Quaternion interpolation on the unit sphere using Slerp method
 CL_rot_rotVect — Image of vector by a rotation defined by a quaternion
3. Geometry and events
 CL_ev_visibility — Geometrical visibility start and end times.
 CL_gm_beta2raan — Beta angle to right ascension of ascending node
 CL_gm_betaEclipse — Sun eclipse angle as function of beta for circular orbits.
 CL_gm_eclipseCir — Analytical eclipse calculation for circular orbits
 CL_gm_equatorialOverlap — Ratio between sensor footprint and gap between ground tracks
 CL_gm_equatorialSwath — Sensor view angle for an overlap ratio of 1 at equator
 CL_gm_inertial2orbitSph — Spherical coordinates conversion from inertial frame to orbit frame
 CL_gm_intersectPlanes — Arguments of latitude at the intersection of 2 orbit planes
 CL_gm_lat2locTime — Satellite's local time at given latitude
 CL_gm_locSolTime — Local solar time
 CL_gm_orbit2inertialSph — Spherical coordinates conversion from orbit frame to inertial frame
 CL_gm_orbitalNoon — Argument of latitude at the position of orbital noon
 CL_gm_pixelSize — Footprint dimensions for a conic sensor at an angle to the vertical
 CL_gm_raan2beta — Right ascension of ascending node to beta angle
 CL_gm_sphericDist — Angle (angular distance) between 2 directions
 CL_gm_stationElevation — Elevation of any object as seen from ground stations.
 CL_gm_visiParams — Visibility parameters (angles, distance, ...) for a spherical planet
4. Interplanetary
 CL_3b_environment — Structure creation for the 3body problem functions
 CL_3b_halo — Halo orbit
 CL_3b_lissajous — Lissajous orbit
 CL_3b_manifolds — Manifolds (divergent and convergent) from Halo and Lissajous
 CL_ip_escapeDv — DeltaV needed to escape from a planet
 CL_ip_insertionDv — DeltaV needed for an insertion around a planet
 CL_ip_sphereInfluence — Computation of the sphere of influence
5. Models
 CL_mod_atmUS76 — US 76 Atmospheric model
 CL_mod_equinoxesEquation — Equation of the equinoxes (IERS 1996)
 CL_mod_expDensity — Exponential density model
 CL_mod_expDensityDrag — Atmospheric drag using exponential density model
 CL_mod_meanObliquity — Mean obliquity (IERS 1996)
 CL_mod_moonSunG50 — Moon and Sun positions in Gamma50 (Veis) reference frame
 CL_mod_nutationAngles — Nutation angles (Wahr IAU 1980)
 CL_mod_nutationArg — Fundamental arguments for nutation
 CL_mod_nutationMatrix — Nutation matrix and rotation vectors (IERS 1996)
 CL_mod_planetsG50ecl — Planet positions in Gamma50 ecliptic reference frame
 CL_mod_polarMotionMatrix — Polar motion matrix
 CL_mod_precessionAngles — Precession angles (Lieske 1976)
 CL_mod_precessionMatrix — Precession matrix and rotation vectors (IERS 1996)
 CL_mod_sidTime — Greenwich mean sideral time (IERS 1996)
 CL_mod_sidTimeG50 — Sideral time in Gamma50 (Veis) frame
6. Orbit properties
 CL_kp_E2M — Eccentric anomaly to mean anomaly
 CL_kp_E2v — Eccentric anomaly to true anomaly
 CL_kp_M2E — Mean anomaly to eccentric anomaly (Kepler's equation)
CL_kp_M2Ecir — Mean arg. of latitude to eccentric arg. of latitude (Kepler's equation)
 CL_kp_M2v — Mean anomaly to true anomaly
 CL_kp_characteristics — Various Keplerian characteristics
 CL_kp_params — Orbit properties for a Keplerian motion (mean motion, period, ...)
 CL_kp_v2E — True anomaly to eccentric anomaly
 CL_kp_v2M — True anomaly to mean anomaly
 CL_op_driftJ2 — Drift of orbital elements due to J2
 CL_op_frozenOrbit — Eccentricity and argument of perigee for a frozen orbit
 CL_op_frozenOrbitDer — Eccentricity and perigee drift over time for an orbit close to a frozen orbit
 CL_op_locTimeG50 — Conversion between longitude, right ascension and local time
 CL_op_paramsJ2 — Orbit properties depending on J2 (mean motion, period, nodal period, ...)
 CL_op_rarp2ae — Apoapsis radius and periapsis radius to semi major axis and eccentricity (elliptic orbits)
 CL_op_rava2ae — Apoapsis radius and velocity to semi major axis and eccentricity (elliptic orbits)
 CL_op_repeat2smaInc — Semi major axis and inclination corresponding to (N,P,Q)
 CL_op_repeatGroundTracks — Longitudes of repeating ground tracks
 CL_op_rpvinf2ae — Periapsis radius and velocity at infinity to semi major axis and eccentricity (hyperbolic orbits)
 CL_op_rpvp2ae — Periapsis radius and velocity at periapsis to semi major axis and eccentricity
 CL_op_searchRepeatOrbits — Search for repeat orbits
 CL_op_ssoJ2 — Semi major axis, eccentricity or inclination for a sun synchronous orbit (J2)
7. Relative motion
 CL_cw_Mmatrix — ClohessyWiltshire M transformation matrix
 CL_cw_Nmatrix — ClohessyWiltshire N transformation Matrix
 CL_cw_ballisticPropa — Ballistic propagation of a chaser relatively to a target
 CL_cw_circularDrift — ClohessyWiltshire circular drift
 CL_cw_contPropa — Continuous thrust trajectory
 CL_cw_diffDrag — Differential acceleration drag
 CL_cw_hohmannLine — Hohmann line
 CL_cw_impulPropa — Propagation of a chaser relatively to a target, with impulsives maneuvers
 CL_cw_meanChaser — Mean chaser
 CL_cw_twoImpulse — Twoimpulse transfer
8. Trajectory and maneuvers
 CL_dsp_covCoord — Conversion of type of orbital elements in a covariance matrix
 CL_dsp_kepCovPropa — Keplerian covariance propagation
 CL_ex_eckHech — Eckstein Hechler orbit propagation analytical model
 CL_ex_kepler — Keplerian orbit propagation
 CL_ex_lyddane — Lyddane orbit propagation analytical model
 CL_ex_lyddaneMan — Lyddane orbit propagation analytical model with maneuvers
 CL_ex_meanEckHech — Eckstein Hechler orbit propagation analytical model (mean elements)
 CL_ex_meanLyddane — Lyddane orbit propagation analytical model (mean elements)
 CL_ex_secularJ2 — Secular J2 orbit propagation
 CL_man_applyDv — Effect of maneuver on orbital elements
 CL_man_apsidesLine — Delta V required to change the line of apsides
 CL_man_biElliptic — Delta V for a bielliptic transfer
 CL_man_consumption — Mass consumed as function of deltaV
 CL_man_hohmann — Delta V for a Hohmann transfer
 CL_man_hohmannG — Delta V for a generalized Hohmann transfer
 CL_man_incRaanCirc — Inclination and RAAN maneuver for circular orbits
 CL_man_inclination — Delta V required to change the inclination
 CL_man_lambert — Lambert's problem
 CL_man_sma — Delta V required to change the semimajor axis
 CL_man_thrustDuration — Thrust duration as function of mass consumed
9. Utilities
 CL_autoLevels — Automatic generation of level values
 CL_colMult — Multiplication of column vectors by coefficients  DEPRECATED
 CL_colNorm — Norm of column vectors  DEPRECATED
 CL_cor2cov — Correlation to covariance matrix
 CL_cov2cor — Covariance to correlation matrix
 CL_covDraw — Random values from covariance
 CL_cross — Cross product of column vectors
 CL_dMult — Dot multiplication
 CL_defParam — Definition of parameter structure for * CL_inputParam
 CL_deg2rad — degrees to radians unit conversion
 CL_dot — Dot product of column vectors
 CL_evalPoly — Evaluation of polynom or polynom derivatives
 CL_g_delete — Deletes graphic entities
 CL_g_legend — Defines a legend adequately positioned with optional title
 CL_g_select — Selection of graphic entities
 CL_g_set — Sets graphic properties
 CL_g_stdaxes — Sets 'standard' graphic properties
 CL_g_tag — Tags graphic entities
 CL_gcd — Greatest common divisor (gcd or pgcd)
 CL_graduate — Simple graduation calculation
CL_init — Initialization of CelestLab data
 CL_inputParam — Simple userfriendly input of parameters
 CL_intervInters — Intersection of sets of intervals
 CL_intervInv — Difference of sets of intervals
 CL_intervUnion — Union of sets of intervals
 CL_matSort — Matrix sorting by row or column
 CL_norm — Norm of column vectors
 CL_path — Looks for a file in directories
 CL_plot_earthMap — Plots an Earth map
 CL_plot_ephem — Plots ground tracks
 CL_rMod — Modulo with result in range
 CL_rad2deg — radians to degrees unit conversion
 CL_stat — Statistics on a matrix of samples
 CL_stumpC — Stumpff function C(z)
 CL_stumpS — Stumpff function S(z)
 CL_unitConvert — Unit conversion
 CL_unitVector — Vector normalization
 CL_vectAngle — Angle between vectors
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.
24th November 2009  Number : Number theory related algorithms
The goal of this toolbox is to provide several Number theory related algorithms. The following is a list of the current features:
 primality test with
 fast mass division
 various uses of congruences
 probable primality test with MillerRabin test
 pseudoprime test
 greatest common divisor with
 naive recursive or iterative Euclid's algorithm
 brute force search for divisors
 binary recursive or iterative algorithm
 linear equation solver ax+by=d by extended Euclid's algorithm
 least common multiple
 list of primes lower than by either naive or fast Erathostene's sieve
 factoring into primes by
 either naive or fast trial division
 Fermat's difference of squares
 Pollardrho
 solver for linear equation ax = b mod m
 modular inverse
 power of an integer modulo m
 decompose an integer on a given basis
 table of 1000 first primes
 Fermat, Mersenne, Carmichael numbers
The toolbox is based on macros. The implementation uses Scilab's double precision integers, therefore is limited to integers in the [2^{52,2}52] 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 :
atomsInstall('number')
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 NelderMead algorithm.
The NelderMead algorithm is especially popular in the fields of chemistry, chemical engineering, and medicine. Two measures of the ubiquity of the NelderMead algorithm are that it appears in the bestselling 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 objectoriented tool for simplexbased 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.