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 :

• 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 object-oriented 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 Monte-Carlo 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, log-normal,
• 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: Monte-Carlo, 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 :

http://opus-project.fr/

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

http://www.agence-nationale-recherche.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 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 :

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 — n-dimensional 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 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 :

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/scilab-mip

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.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'));
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

• CelestLab

  • Overview of CelestLab — Overview of CelestLab

  • Conventions used in CelestLab — Conventions used in CelestLab

• 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 — H0-n 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 3-body 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 — Delta-V needed to escape from a planet
• CL_ip_insertionDv — Delta-V 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 — Clohessy-Wiltshire M transformation matrix
• CL_cw_Nmatrix — Clohessy-Wiltshire N transformation Matrix
• CL_cw_ballisticPropa — Ballistic propagation of a chaser relatively to a target
• CL_cw_circularDrift — Clohessy-Wiltshire 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 — Two-impulse 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 bi-elliptic transfer
• CL_man_consumption — Mass consumed as function of delta-V
• 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 semi-major 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 user-friendly 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 Miller-Rabin test
• pseudo-prime 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
  • Pollard-rho
• 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,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 :

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 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.