Download File _XLS_ - Equalis - Excel

Document Sample
Download File _XLS_ - Equalis - Excel Powered By Docstoc
					                                           Toolboxes Available in 5.3
Package Name   Title       Summary
ampl_toolbox   AMPL        An interface
               Scilab      to load .nl
               interface   files created
                           by AMPL

ANN_Toolbox    ANN         ANN Toolbox

apifun         Apifun      Check input
                           arguments in

assert         Assert      A collection
               module      of predicate

celestlab      CelestLab CNES Space
                         toolbox for
conmin         Conmin    A Scilab
                         interface to
                         the conmin
csv_readwrite   csv_readw fast
                rite      dedicated
                          functions to
                          read and
                          write csv files

CUTEr           CUTEr       Testing
                            and linear
dace_scilab     DACE for    This is a
                Scilab      conversion
                Kriging     of the well
                toolbox     known DACE
                            toolbox for

dde_toolbox     DDE         Dynamic
                Toolbox     Data
                            client for
edflib          edflib      load/write

emd_toolbox     Empirical   Toolbox for
                Mode        Empirical
                Decompos    Mode
                ition       Decompositio
                Toolbox     n of 1-D, 2-D
                            and more

femtruss        FEMTruss A Truss finite
                         code for
Financial           Financial     Module is
                                  about risk
                                  measure and
                                  and pricing

floatingpoint       Floating      Functions to
                    Point         manage
                    Module        floating point

fmincon             Fmincon       Nonlinearily

fsmtbx              Factorizati   Fast
                    on of         factorization
                    Structured    of matrices
                    Matrices      with
                    Toolbox       displacement

Global_Optim_toolbo A Toolbox     Global
x                   for           optimization
                    Unconstra     toolbox for
                    ined          solving
                    Global        unconstraine
                    Optimizati    d polynomial
                    on of         optimization
                    Polynomia     problems
grocer       GROCER      Comprehensi

guibuilder   GUI         A Graphic
             Builder     User

guimaker     guimaker A toolbox for
                      creating GUIs
                      with a
                      minimum of

HYDROGRv50   HYDROGR Models and
                        function for
intprbs      Integratio Provides 23
             n          functions for
             Problems multidimensi
             Module     onal

lolimot      Lolimot     A fast neural
                         network -
                         LOcal LInear
                         MOdel Tree

lowdisc      Low         Provides
             Discrepan   Halton, Sobol
             cy          and other
             Sequences   sequences.
lsitbx             Linear      Scilab 5
                   System      toolbox for
                   Inversion   optimal
                   Toolbox     stable
                               inversion of
                               linear time-

makematrix         Make        A collection
                   Matrix      of test
MatrixMarket       Matrix      Read and
                   Market      Write Matrix

Max_Plus_Algebra   Max-Plus Collection of
                   Algebra  some theory
                   Toolbox and
                            in Max Plus
MDPtoolbox         MDPtoolb Markov
                   ox       Decision
metanet            Metanet Graph and
mingw              MinGw    Dynamic link
                   toolbox  with MinGW
                            for Scilab on

minphase_toolbox   Minphase Design a
                            discrete IIR
                            filter with
                            arbitrary gain
                            or phase.

module_lycee       Module      Scilab pour
                   Lycée       les lycées
NISP         NISP       Non Intrusive

NTG          Network This module
             Topology is dedicated
             Generator to network

number       Number     Number

opc_client   OPC Client OLE for
                        Toolbox for
optkelley    Optkelley Scilab
                        software for
                        Methods for

plotlib      Plotting   "Matlab-like"
             library    Plotting
                        library for

quapro       Quapro     Linear and
RLDesign          Control      Simple GUI
                  Design       for Control
                  Tool         Design Using
                               Root Locus

scicobyla         SciCOBYLA An interface
                             to the
scilab2c          Scilab 2 C Translate
                             Scilab code
                             into C code

scipad            Scipad       Scipad 7.20
simplex           Simplex      This package
                  optimizati   contains the
                  on           simplex
                  toolbox      optimization

SIVP              Scilab       SIVP intends
                  Image        to do image
                  and Video    processing
                  Processing   and video
                   toolbox     processing

sndfile_toolbox   sndfile      Read & write
                  Toolbox      sound files

socket_toolbox    Socket       Basic socket
                               functions for
stftb           Time      Toolbox
                Frequency developed
                Toolbox for the
                          analysis of
                          signals using

stixbox         Stixbox    Statistics
                           toolbox for
                           Scilab 5.2
swt             Scilab     mimic
                Wavelet matlab
                Toolbox wavelet
toolbox_1       Toolbox To test the
                Test 1     Atoms
uncprb          Unconstra Provide 35
                ined       unconstraine
                Optimizati d
                on         optimization
                Problem problems

WriteXmlExcel   WriteXmlE   Write Excel
                xcel        xml files
xmltodocbook    xmltodocb   converts
                ook         scilab 4.x
                            help files to
                            scilab 5 help
     Toolboxes Available in 5.3
This toolbox allows you to load into Scilab .nl files created using AMPL ( Once loaded
into Scilab, you can use them 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 represents a toolbox for artificial neural networks, based on my developments described in "Matrix ANN"
book, under development, if interested send me an email at Current features -
Only layered feedforward networks are supported *directly* at the moment (for others use the "hooks"
provided) - Unlimited number of layers - Unlimited number of neurons per each layer separately - User defined
activation function (defaults to logistic) - User defined error function (defaults to SSE) - Algorithms implemented
so far: * standard (vanilla) with or without bias, on-line or batch * momentum with or without bias, on-line or
Purpose The goal of this module is to provide a set to function to check input arguments in macros. In
functions with a variable number of input arguments, we often have the following source code, which checks
that the number of input arguments provided by the user is consistent with the number of expected arguments
: [lhs,rhs]=argn() if ( rhs < 2 | rhs > 5 ) then errmsg = msprintf(gettext("%s: Unexpected number of input
arguments : %d provided while from %d to %d are expected."), "myfunnction", rhs,2,5); error(errmsg) end
Writing this code is error-prone and boring. Moreover, this fragment of source code is duplicated in many
functions, leading to small variations depending on the developer. In particular, this makes the localization of
the error messages difficult, because the message can be slightly different depending on the function. It can also
Purpose ---- The goal of this toolbox is to provide assert function. We emphasize the numerical issues, with the
goal of testing numerical algorithms more easily. In particular, we provide a comparison function for two
floating point numbers, which allows to assert that two numbers are "close" (including, but not limited to,
equal). The function of the assert module are designed to be used in Scilab unit tests files (.tst files). The
following is a list of the current features: * assert for true, equal statements * assert that two floating point
numbers are "close". Use an relative or a absolute tolerance * provide a sorting function for double complex
numbers with a mixed relative/absolute tolerance criteria. The following is a list of the current assert functions :
 * assert_almostequal : Check that computed and expected are numerically close. * assert_equal : Check that
CelestLab is a library of space flight dynamics functions written in Scilab. This library has been developed and is
maintained by CNES (Centre National d’Etudes Spatiales) for mission analysis purposes. The library is used by
CNES for the trajectory analysis and orbit design of various missions. CelestLab gathers in ten modules about
200 functions that allow mission designers to perform various tasks such as: orbit propagation, attitude
computation, elementary manoeuvre computation, change of reference frames, change of coordinates, three
The CONMIN optimization method is currently used in NASTRAN (a professionnal finite element tool) and the
optimization part of NASTRAN (the CONMIN tool) is currently public domain. The CONMIN fortran program has
been written by G. Vanderplaats. This optimization method can solve efficiently constrained optimization
fast dedicated scilab functions to read and write csv files To compare speed: with default scilab functions:
stacksize('max'); M = ones(1000, 1000); timer(); write_csv(M, TMPDIR + "/csv_write_1.csv"); timer() timer(); r =
read_csv(TMPDIR + "/csv_write_1.csv") timer() with optimized functions: stacksize('max'); M = ones(1000,
1000); timer(); csv_write(M, TMPDIR + "/csv_write_1.csv"); timer()

CUTEr is a versatile testing environment for optimization and linear algebra solvers. This toolbox is a scilab port
of the original Matlab toolbox (

DACE, Design and Analysis of Computer Experiments, is a Matlab toolbox for working with kriging
approximations to computer models. 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.

Dynamic Data Exchange client for Scilab to communicate with excel and some others DDE servers. see help &

EDFlib is a programming library for C/C++ to read/write EDF+/BDF+ files. EDF means European Data Format. BDF
is the 24-bits version of EDF. This is a gateway to load/write the EDF+/BDF+ files directly from scilab.
Information about edflib can be found at Version 0.2.4 - new edflib version
V1.07 Version 0.2.3 - new functions: edf_set_record_duration - new edflib version V1.05 Version 0.2.2 - new
functions: edfseek, edftell, edfrewind, edfopen_file_readonly - the parameter edfsignal starts from 1! E.g. read
Toolbox for Empirical Mode Decomposition of 1-D, 2-D and more dimensional signals. Summary from Wikipedia
( Using the EMD method, any complicated
data set can be decomposed into a finite and often small number of components, which is a collection of
intrinsic mode functions (IMF). An IMF represents a generally simple oscillatory mode as a counterpart to the
simple harmonic function. By definition, an IMF is any function with the same number of extrema and zero
crossings, with its envelopes being symmetric with respect to zero. The definition of an IMF guarantees a well-
behaved Hilbert transform of the IMF. This decomposition method operating in the time domain is adaptive
and highly efficient. Since the decomposition is based on the local characteristic time scale of the data, it can be
applied to nonlinear and nonstationary processes.
A Truss finite element code for scilab. In the demos directory, you will find some demos related to structural
optimization, computation of partial derivatives and display of structures.
The module is dedicated to finance. There are three main areas that are covered: (i) risk measure and
management, (ii) asset allocation, and (iii) pricing. For what concerns the risk measure, some functions are
dedicated to the computation of Value at Risk (VaR) and Expected Shortfall (ES). Backtest is also implemented in
order to check the goodness of such risk measures. Both VaR and ES are also computed in an Extreme Value
Theory framework (EVT). Furthermore, it is possible to estimate the parameters of the EVT density function
(through maximum likelihood). The Mean Excess Function for graphical study of an EVT distribution is also
implemented. The interest rate risk is faced by functions aimed at computing duration, convexity, and yield to
maturity. Furthermore, Merton, Vasicek and Cox, Ingersoll and Ross interest rate models are implemented
Floating Point toolbox Purpose The goal of this toolbox is to provide a collection of algorithms for floating point
number management. This is more a learning tool than an operationnal component, although it might
complement some features which are not provided by Scilab. The flps_systemgui function allows to see the
distribution of floating point numbers graphically. By varying the rounding mode, the precision and the logscale,
we can actually the distribution of a toy floating point number. Adding or suppressing the denormals can be
instructive too. The functions allow to compute automatically the properties of the current Scilab system with
respect to the doubles. It is similar in spirit to the number_properties functions, except that our functions are
based on macros and that the returned values are made consistent with the references cited in the
Purpose The goal of this toolbox is to provide a fmincon function in Scilab. The fmincon function is a
nonlinearily constrained optimization solver. Currently, we use ipopt for the actual solver of fmincon. The
current state of the function is experimental. Many features are yet to be implemented. We provide upgraded
versions of the optimset and optimget functions, which manage options which are required by fmincon. The
current implementation is able to manage the following use cases. We use a L-BFGS formula in order to
compute an approximate of the Hessian of the Lagrangian. (0) The initial guess is provided in the x0 input
argument. (1) The nonlinear objective function and the nonlinear constraints are provided. The fun and nonlcon
function can be customized to configure the nonlinear objective function and nonlinear constraints. In this case,
The Factorization of Structured Matrices Toolbox is a Scilab 5 toolbox for the fast factorization of matrices with
displacement structure like, e.g., (block) Toeplitz matrices. Implemented algorithms: * Generalized Schur
algorithm for fast LDL/Cholesky factorization of strongly regular hermitian matrices with displacement structure
of Stein type * Fast LDL/Cholesky factorization of strongly regular (block) Toeplitz matrices * Fast QR
factorization of (block) Toeplitz matrices Features: * Mainly written in C for speed * Implements real and
complex arithmetic Current Limitations: * Source hasn't been optimized in any way

Many problems in science and engineering can be reduced to the problem of finding optimum bounds for the
range of a multivariable polynomial on a specified domain. Local optimization is an important tool for solving
polynomial problems, but there is no guarantee of global optimality. For polynomial optimization problems, an
alternate approach is based on the Bernstein form of the polynomial. If a polynomial is written in the Bernstein
basis over a box, then the range of the polynomial is bounded by the values of the minimum and maximum
Bernstein coefficients. Global optimization based on the Bernstein form does not require the iterative
evaluation of the objective function. Moreover, the coefficients of the Bernstein form are needed to be
computed only once, i.e., only on the initial domain box. The Bernstein coefficients for the subdivided domain
boxes can then be obtained from the initial box itself. Capturing these beautiful properties of the Bernstein
polynomials, global optimum for the polynomial on the given domain can be obtained. The toolbox is developed
based on the above ideas.
GROCER provides many standard econometric methods: ols, instrumental variables, VAR, specification and unit
root tests, limited dependent variables methods, Johansen cointegration tests and VECM, GMM, statistical
filters, basic methods on panel data, ARMA and VARMA estimations, GARCH ... GROCER provides also less
standard ones: a pc-gets like function implementing in an automatic manner the "general-to-specific"
methodology, various Markov-switching estimations, Bayesian Model Averaging estimation, dynamic
GUI Builder is a Graphic User Interface Builder under Scilab. The program allows you to build your GUI quickly,
and the code for the gui would be generated automatically. Version 1.0 limitation 1. The output GUI size is
fixed 2. During the design, the user only have 1 chance to place the uicontrol. There are no way to resize,
modify the properties, or undo the previous operation. All changes only could be done in the generated code.
3. Limited properties are user-defined a. Tag - Used as the pointer to the uicontrol b. String - Used as the display
name at certains uicontol c. Callback - Whether the uicontrol needs a callback, if yes, the callback name would
guimaker is a command line tool for creating graphical user interfaces (GUI) in Scilab. The GUIs are based on the
available uicontrol objects in Scilab. Guimaker can be used either for generating GUIs within programs, or it can
be used for creating Scilab source code which serve as a starting point for more advanced programming of GUIs.
 Changes in version 1.4: * Minor bug fixes.

HYDROGR is a set of models and function to perform data analysis and modelling of hydrological time series. In
particular HYDROGR contains the rainfall-runoff model GR4J developped in CEMAGREF (see The functions are written in Scilab languages and C

Purpose The goal of this toolbox is to provide integration test problems in order to test integration algorithms.
This allows to test integration algorithms on a larger base of functions. Developping these functions is error-
prone, so that using this module allows to save much time. Moreover, testing an algorithm leads to the difficulty
of chosing a set of test functions. But all functions are not equally difficult to integrate; while some are simple,
other might be particularily difficult, leading to poor results. Comparing two algorithms, each on a different set
of functions will not lead to an accurate view of the algorithm. This module allows to compare the algorithms
more precisely. In spirit, this module has the same motivations as the Unconstrained Optimization Scilab
toolbox based on the More, Garbow and Hillstrom collection of functions. Overview The module currently
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 goal of this toolbox is to provide a collection of low discrepancy sequences. These random numbers are
designed to be used in a Monte-Carlo simulation. For example, low discrepancy sequences provide a higher
convergence rate to the Monte-Carlo method when used in numerical integration. The toolbox takes into
account the dimension of the problem, i.e. generate vectors with arbitrary size. The current prototype has the
following features : * manage arbitrary number of dimensions, * skips a given number of elements in the
sequence, * leaps (i.e. ignores) a given number of elements from call to call, * fast sequences based on compiled
source code, * suggest optimal settings to use the best of the sequences, * object oriented programming.
Overview of sequences * The Halton sequence, * The Sobol sequence, * The Faure sequence, * The Reverse
The Linear System Inversion Toolbox is a Scilab 5 toolbox for stable inversion of linear time-invariant systems.
The inverses are optimal in the sense that some norm criterion is minimized. Decision delays are also
implemented for some cases.

The goal of this toolbox is to provide a collection of test matrices. The current toolbox is able to generate the
following matrices: * dingdong * Hadamard * inverse Hilbert * Hilbert * magic * Toeplitz * Candermonde *
Pascal * border * Cauchy * circul * diagonali * Frank * Hankel * identity * Moler * Rosser * urandom * Wilkinson
The toolbox contains the functions mminfo, mmread and mmwrite for reading and writing matrices on Matrix
Market formatted files.

This toolbox is collection of some theory in Max Plus Algebra. Examples: * finding solution Ax=Ay, Cx=Dy in
maxplus algebra * finding eigenvalue and eigenvector in maxplus algebra * possible eigenvalue and eigenvector
of interval matrice over maxplus algebra * maxplus cyle time vector, and many more

The Markov Decision Processes (MDP) toolbox proposes functions related to the resolution of discrete-time
Markov Decision Processes : finite horizon, value iteration, policy iteration, linear programming algorithms with
some variants.

Metanet is a toolbox of Scilab for graphs and networks computations.

MinGW Compiler support for Scilab 5.3 and more on Windows

There are 2 functions. log_fir() calculates phase of a minimum phase function having specified gain. It utilizes
the fact that exp(a0+a1/z+a2/z^2+..) is the minimum phase function. The gain is exp(a0+a1*cos(w)+..) and the
phase is exp(-(a1*sin(w)+..)). So by selecting a0,a1,.. from the specified gain, the phase can be obtained. piir()
calculates the stable IIR filter from the specified phase. The method is shown in. M.Kisaka: Phase design of an
IIR filter and its application to an inverse system, Proceeding of the 2006 IEEE international conference on
control system,Munich, Germany,Oct.2619/2622(2006)

"Scilab pour les lycées" est un module dédié pour les lycées (only in French). Il contient 56 fonctions pour le
travail en classe du secondaire dans les domaines de l'arithmétique, des probabilités, des statistiques et des
This toolbox allows to approximate a given model, which is associated with input random variables. 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
This module is dedicated to network topology analysis for academic and research studies. It has been designed
at the University of Luxembourg withing the Interdisciplinary Centre for Security, Reliability and Trust (Snt). The
Centre carries out interdisciplinary research and graduate education in secure, reliable, and trustworthy ICT
systems and services ( This
work was carried out as a part of the European Project EFIPSANS ( This module is an
enhanced version of the toolbox NTG2.0 that run on Scilab 4.1.2. NTG3.0 is running on Scilab 5.2.1 (or >=). New
functionalities have been added in order to enrich the capabilities of the module. NTG3.0 permits to generate
random topologies in order to study the impact of routing algorithms on the effectiveness of transmission
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
OPC client for Scilab (Windows) OPC is a set of standard OLE/COM interface protocols established by the OPC
Foundation. The aim of OPC is to foster greater interoperability between automation/control applications, field
systems/devices, and business/office applications in the process control industry. This toolbox for Scilab
support OPC interface to exchange data with many software and hardware which also supporting OPC interface.
 see for more informations.
Purpose These Scilab files are implementations of the algorithms from the book 'Iterative Methods for
Optimization', published by SIAM, by C. T. Kelley. The book, which describes the algorithms, is available from
SIAM ( This toolbox provide the following algorithms: * optkelley_bfgswopt: Steepest
descent/bfgs with polynomial line search. * optkelley_cgtrust: Steihaug Newton-CG-Trust region algorithm. *
optkelley_diffhess: Compute a forward difference Hessian. * optkelley_dirdero: Finite difference directional
derivative. * optkelley_gaussn: Damped Gauss-Newton with Armijo rule. * optkelley_gradproj: Gradient
projection with Armijo rule, simple linesearch * optkelley_hooke: Hooke-Jeeves optimization. * optkelley_imfil:
Unconstrained implicit filtering. * optkelley_levmar: Levenberg-Marquardt. * optkelley_mds: Multidirectional
This library is supposed to help you to make plots as if you were using Matlab. Version 0.42 includes new
macros (image, imagesc). By default all plotlib function names are defined with a leading underscore, for
example _gcf, _gca, _plot, _surf, ... in order to differentiate these plotlib functions from the original scilab
functions having the same name. If you want to use the classical names without underscores, which will break
some native Scilab graphic functions, just add the line plotlibmode in your .scilab file, which can be edited by
This toolbox defines linear quadratic programming solvers. The matrices defining the cost and constraints must
be full, but the quadratic term matrix is not required to be full rank.
This simple GUI allows the user to quickly view the response of a given tranfer function (SISO System) on
different close loop gain by adjusting the slider. The user could also implement their on controller on the
forward path by keying in the tranfer function of the controller.

COBYLA is a derivative free non linear constrained optimization method.

Sci2C is a tool capable to translate Scilab code into C code. It is a standalone toolbox of Scilab and it has been
primarily developed to become the interface between the Scilab scientific software package and the hArtes
design flow. The output C code is in a plain style and does not include any part of the Scilab interpreter thus
making it small, efficient and easy to interface to the hArtes tool chain. In other words, the generated C code is
standalone and minimal in the sense that Scilab interpreter is no longer needed and only the minimal number of
C files which are necessary to execute the application are generated. It follows that the generated code can be
embedded in processors or used as entries for other software. Sci2C is implemented in Scilab language, so it
naturally becomes a Scilab toolbox available in the Scilab installation program and consequently it can be
scipad (atoms format)

This the simplex optimization method which performs optimization of non linear function. This optimization
method doesn't use the derivative of the objective function. There is 2 versions of the simplex: -
optim_nelder_mead: a classic script for optimization - step_nelder_mead: the call to the objective function is
done outside of the script.

Scilab needs a powerful image processing toolbox. SIVP intends to do image processing and video processing
tasks. SIVP is meant to be a useful, efficient, and free image and video processing toolbox for Scilab.

Read & write sound files format wrapper on multiplatform C library sndfile http://www.mega- supported format (read & write): Ogg Vorbis (Xiph Foundation) FLAC 16 bit AIFF
(Apple/SGI 16 bit PCM) AIFF (Apple/SGI 32 bit float) AIFF (Apple/SGI 8 bit PCM) AU (Sun/Next 16 bit PCM) AU
(Sun/Next 8-bit u-law) CAF (Apple 16 bit PCM) OKI Dialogic VOX ADPCM WAV (Microsoft 16 bit PCM) WAV
Here is a SOCKET toolbox for Scilab. This toolbox enables communications between an instrument or server
located via TCPIP protocol and Scilab.
This Toolbox was ported from the Time-Frequency Toolbox The Time-Frequency
Toolbox in C was also ported to scilab: The
toolbox contains numerous algorithms which implements various kind of time-frequency analysis with a special
emphasis on quadratic energy distributions of the Cohen and affine classes, along with their version enhanced
by the reassignment method. The toolbox also includes signal generation procedures, processing/post-
processing routines (with display utilities) and a number of demonstrations. Here you will find some notes on
time-frequency analysis: 1.2 - some bugs are removed -
sci_gateway added (Ctftb was ported to scilab) - new demos 1.1.1 - some bugs are removed 1.1 - some bugs are
removed - tftb_window can be plotted - frspec and frpowerspec added

Stixbox-1.2.5 is a statistics toolbox designed for the french examination agregation de mathematiques. This
toolbox is based on the toolbox by Anders Holtsberg with extensions from the Paris Sud University.

This toolbox is aimed to mimic matlab wavelet toolbox. Most of the functions are similiar to their counterparts
in Matlab equivalents. 0.1.11 + Add unit_tests, some macros are removed, some bug fixes 0.1.10 + Add
scal2frq, centfrq, cwtplot, wavedecplot 0.1.9 + Add denoise funtions: wden, wnoisest, wthresh, wnoise,
thselect, ddencmp 0.1.8 + bug fixes for scilab 5, transformation of the help files 0.1.7 + works under scilab 5
Test the Atoms system It contains 4 functions : - t1_version() - t1_function1() - t1_function2() - t1_function3()

Purpose The goal of this toolbox is to provide unconstrained optimization problems in order to test
optimization algorithms. The More, Garbow and Hillstrom collection of test functions is widely used in testing
unconstrained optimization software. The code for these problems is available in Fortran from the netlib
software archives. The port from Fortran to Matlab was done by two undergraduate students at Brooklyn
College, Livia Klein and Madhu Lamba, under the supervision of Chaya Gurwitz. Benoit Hamelin did the port
from Matlab to Scilab v4 with m2sci and did some manual tuning of the result. Michael Baudin did the port
from Scilab v4 to Scilab v5. I renamed the functions to avoid naming conflicts. I formatted the help pages to
generate automatically the xml from the sources. Features Provides 35 unconstrained optimization problems.
Writes datas to an Excel 2003 xml (OOo calc) file on any platforms.

This module provides functions to help you to convert your old Scilab XML help files to the new Docbook based

Shared By: