Test Matrix Downhill simplex, Levenberg-Marquardt nmsmax Solvopt LP, LCP, Indefinite QP and Nonlinear Programming Levenberg-Marquardt Line Search, Conjugate Gradient, Stepest Descent Constrained minimization/maximization Minimization functions (deriv.m, gradient.m, Newton-Raphson, Golden Section, Davidon-Fletcher-Powell, Broyden)
XX PHiPAC MTL ATLAS
Octave on MS-WindowsGeographical maps graphical package Ginput PGplot Voronoi/Delaunay triangulation Gnuplot fill/shade epsTk KMatplot PLplot_octave
MATLAB Primer The MATLAB
Primer was written to help students begin to use MATLAB.
PLplot_Octave
An alternative Octave plot package based on PLplot.
Tk_Octave
Package to build Tk based Octave user interfaces.
NNSYSID
Neural network based system identification toolbox
Some
Matlab functions Kolmogorov-Smirnov, Student's t-test, Resampling methods,
KTools non-parametric regression toolbox
Advanced
methods for non-parametric regression Minimisation, Kernel regression,
Neural networks
Netlab neural
network software The Netlab simulation software is designed to
provide the central tools necessary for the simulation of theoretically
well founded neural network algorithms for use in teaching, research and
applications development.
NetMath
For Web Based Computation NetMath is a web browser which knows something
about math.
Time
Series Analysis with Matlab The TSA toolbox is useful for analysing
(univariate, stationary) Time Series.
Matwrap a wrapper generator
for matrix languages
epsTk
Graphical output functions for Matlab and Octave
octavePAK
I've been busy generating bits of Matlab that are missing from Octave.
GTM which stands for
generative topographic mapping, is a model for density modeling and data
visualisation.
Net
Octave demonstration of neural network learning.
Gp
Octave demonstration of Gaussian process interpolation.
Neuron A simple neuron
trained as a classifier.
MATLAB
4 User M-Files
Wavelab
WaveLab is a library of MATLAB routines for wavelet analysis, wavelet-
packet analysis, cosine-packet analysis and matching pursuit.
ICA/EEG
Independent Component Analysis for psychophysiological data analysis.
Rice Wavelet Toolbox
for Matlab Rice-Wlet-Tools (RWT) is a collection of MATLAB M-files
and MEX-files implementing wavelet and filter bank design and analysis.
Image Denoising
Software for Image Denoising using Wavelet-domain Hidden Markov Tree Models.
TFA Software for
Time-Frequency Analysis.
MWM Software for
the Multifractal Wavelet Model.
FastICA The
FastICA package is a public-domain MATLAB program that implements the fast
fixed-point algorithm for independent component analysis and projection
pursuit.
Teaching
MATLAB M-files for Teaching.
Density Estimation
MATLAB Toolbox for Density Estimation.
MT19337
RNG very long period, fast, and memory-efficient Mersenne Twister Random
Number Generator.
Octave
modules to access PostgreSQL.
Matlab
software by Kevin Murphy Bayes Net toolbox, HMM toolbox, MDP toolbox...
Carnegie
Mellon University Matlab Page
Self Organizing
Map toolbox
Jacklam's
list of utility files.
Genetic/Evolutionary
Algorithms for MATLAB.
Octave is just beginning to have optimization routines. The ones
I use
are written for matlab but not part of matlab. If it is unconstrained
problems you are interested in then I recommend the direct search
algorithms in the Test Matrix toolbox which Nick Higham puts on his
home
page at
http://www.ma.man.ac.uk/~higham/testmat.html
The files you are interested in are called adsmax.m nmsmax.m and
mdsmax.m. These methods do not calculate gradients so they may
not be
as fast as a BFGS type method (when you know the gradient) but they
get
confused less often.
Of course is may depend on your problem. Is the function you want
to
optimize concave? If so the fastest way to get a solution is
to use
fsolve and set the gradient to zero. For a concave (convex) function
this gives the maximum (minimum).
If you are intested in constrained problems then I would use solnp from
http://dollar.biz.uiowa.edu/col/ye/matlab.html
which is quite good. It is a minimizer I believe so you'll want
to
minimize -f(x) rather in order to maximize f(x).
Heber Farnsworth
Downhill simplex, Levenberg-Marquardt
Hello,
I have a downhill simplex function (Nelder-Mead)
at http://anonimo.isr.ist.utl.pt:8080/~etienne/octave/.
It should do for
low-dimensional functions.
I also have some code for Levenberg-Marquardt like optimization,
but it isn't online. Just ask if you would like to see it.
Cheers,
Etienne
There is a function called nmsmax which uses the same algorithm as fmins
but
maximizes rather than minimizes. It is not part of Octave.
You can get it
from the Mathworks anonymous ftp site at
ftp://ftp.mathworks.com/pub/contrib/v4/optim/dsmax
More recent versions can be obtained from the authors web site as part
of a
toolbox he calls the test matrix toolbox. The web page is
http://www.ma.man.ac.uk/~higham/testmat.html
The only way in which you would need to change your code is to have
nmsmax
maximize -f(x) where f(x) is the function you want to minimize.
Last time I
checked there was also some problem with the ^ versus ~ operator used
in
that code. Running octave with the --braindead option should
take care of
it. Alternatively you can edit the code and change the one instance
of the
matlab operator to the octave one.
It is also available via
http://bedvgm.kfunigraz.ac.at:8001/alex/solvopt/
if you want to avoid
the matlab registration form.
cheers
Richard
Cyril Fischer wrote:
> > Free: Solver for local nonlinear optimization problems
> > ======================================================
> >
> > The SolvOpt toolbox (Solver for local optimization problems) is
concerned
> > with minimization or maximization of nonlinear, possibly non-smooth
> > objective functions and with the solution of nonlinear programming
problems
> > taking into account constraints by the so-called method of exact
> > penalization. This solver is available for download for free.
> >
> > http://www.mathtools.com/toolbox-solveopt.html
LP, LCP, Indefinite QP and Nonlinear Programming
I seem to recall that someone in the recent postings on the lack of
optimisation code suggested contacting Yinyu Ye, of the University
of
Iowa, College of Business Administration. I would also advocate that
those
people who are interested in (and capable of) integrating GPL optimisation
code into Octave contact Y.Ye
I noticed that the Website for the Computational Optimisation Laboratory
of which he is the Director,
http://dollar.biz.uiowa.edu/col/ye/matlab.html
contains freely distributatble source for LP, LCP, QP and SemiDefinite
Programming, either in Fortran or in C.
There are also Matlab routines at the site, for solving Linear Programs,
(constrained and unconstrained), Quadratic Programs, and NonLinear
Programs, by Sequential QP. These seem to work fine under Octave. Anyone
interested in finding a quick fix for Octave's optimisation incapacities
could start with this (freely-distributable??) archive of M-files.
David Dowey
This is a FAQ. I took from
the mathworks contrib dir a program
implementing the Levenberg-Marquardt nonlinear regression method.
I looked
around for the latest version of this software, which was modified
by three
people. I then adopted
it to Octave. I now
put it on
ftp://fly.cnuce.cnr.it/pub/software/octave/.
I'd like to publish this under the GPL. To this end,
I tried to contact
the authors. Arthur jutan responded, saying that
he has no objection as
long as authorship is acknowledged, but I didn't
manage to contact the
others. I'll try harder when I have time, but if someone
else does it, it
will be quicker.
Line Search, Conjugate Gradient, Stepest Descent
with very small modifications the following also run in Octave:
http://solon.cma.univie.ac.at/~neum/software/ls/ public domain
Matlab Line Search Routines
ELS, Efficient Line Search
ELS is an implementation of a very efficient and robust line search
that
finds along each ray x+alp*p with
g(x)^Tp<0 (where g(x) denotes the gradient of the objective function
f(x)) a step size alp>0 such that
f(x+alp*p) <= f(x) - delta (g(x)^Tp/||p||)^2
with a positive constant delta depending only on f.
Apart from the initial directional derivative g(x)^Tp, ELS only uses
function evaluations at points along the ray.
and ftp://eivind.imm.dtu.dk/pub/cyril/ non-comercial use, I believe.
Search for `conjgrad.m' `steepdes.m'
Constrained minimization/maximization
I've been using some functions developed at the U of Iowa. You
can look
at them at
http://dollar.biz.uiowa.edu/col/ye/matlab.html
They are free in some sense (you have to consult the author before
incorporating them in a commercial package). Solnp is the general
one
which I have used with fair success. Be sure to download to
documentation as well since it's not obvious.
Heber Farnsworth
I've developed a C++ wrapper that allows Octave to interface with the
Fortran subroutine SDIRK4.F. SDIRK4 is a Singly Diagonally Implicit
Runge-Kutta (SDIRK) stiff ODE solver. It works well and differs
from
Octave's existing solver, lsode, by being a single-step method.
lsode
is a multi-step method & therefore not as efficient at integrating
ODEs
that contain discontinuities. (Note that ODE stiffness is different
from an ODE with discontinuities)
You can read more about the
freely available SDIRK4.F at E. Hairer's
web page, http://www.unige.ch/math/folks/hairer/software.html.
You can find a tarred &
gzipped file containing all you need to get
sdirk4 working in Octave at:
http://marc.me.utexas.edu/tmp/octave_ode_solvers
I have also posted the source files to the octave-sources list.
Please send corrections or comments to compere@mail.utexas.edu.
Best regards,
Marc Compere
Octave users,
The latest and greatest versions
of 6 Ordinary Differential Equation
(ODE) solvers have been posted to the octave-sources mailing list.
This
is Copyrighted & licensed software (GPL) designed for use with
Octave.
They are also available and being maintained at
http://marc.me.utexas.edu/tmp/octave_ode_solvers/ode_v1.07/.
The archive octave_ode_solvers_v1.07.tar.gz
contains 6 single-step
Runge-Kutta ODE solvers along with 2 files demonstrating example uses
of
each solver:
- ode23.m : variable step, 2nd-3rd order
- ode45.m : variable step, 4th-5th order
- ode78.m : variable step, 7th-8th order
- rk2fixed.m : fixed step, 2nd order
- rk4fixed.m : fixed step, 4th order
- rk8fixed.m : fixed step, 8th order
- pendulum.m : a sample m-file script that runs all solvers
- penddot.m : derivative function file, returning
dy/dt for a simple
pendulum
None of these solvers are
designed to work with stiff systems,
however,
the fortran code sdirk4.f is a stiff ODE solver written by E. Hairer
and
arranged for use within Octave by Marc Compere. More infomation
is
available at
http://www.che.wisc.edu/octave/mailing-lists/help-octave/2000/264.
Best regards,
Marc Compere
Gnans is a useful tool to simulate complex sistems.
Gnans is a program (and language) for the numerical study of
deterministic and stochastic dynamical systems. The dynamical systems
may evolve in continuous or discrete time.
Well, you can get the last version (1.6.1) from
ftp://ftp.u-aizu.ac.jp/pub/SciEng/math/gnans/
The program is not being maintained now, but I think is bug free (at
least I have been using it for 3 years without any problem).
However this is not a Simulink clone, as you can see from my last post
about this subject. For a system similar to simulink you can use SciCos,
that is a simulation system for SciLab.
Dani.
I had the same problem, so I wrote some of my own. Check out:
http://users.powernet.co.uk/kienzle/octavePAK
These are largely clones of bits of the Matlab signal processing toolbox,
along
with better audio support.
If you do add some more, please send them to me so that I can include
them
on this page. Note, the spctools library available for download
from
the matlab archive site contains a couple of additional AR modellers
(covariance method, modified covariance method) as well as some ARMA
modellers if that's what you are into. The spcline subdirectory
contains all the bits that you need, the rest being matlab GUI which
is not supported by octave.
Paul Kienzle
pkienzle@kienzle.powernet.co.uk
Dear Octave Users,
I thought some of you might be interested to know that I have recently
posted patches to the octave-sources list to allow Octave to read and
write data in HDF5 format "natively" using its load and save commands.
(See my previous post regarding HDF5 and Octave at
http://www.che.wisc.edu/octave/mailing-lists/help-octave/1999/1576)
All of the data types and annotations of Octave's own binary format
are
supported in the HDF5 load/save. In addition, I have added:
1) support for Octave lists (including arbitrarily nested lists of
arbitrary datatypes). To my knowledge, this is now the only way
to load
and save lists in Octave.
2) support for importing multi-dimensional HDF5 datasets using lists
of
matrices (or lists of lists of matrices, etcetera). Thanks to
Joao
Cardoso for the suggestion.
(I have also posted a plug-in called h5read that allows one to import
2d
slices of a multi-dimensional dataset without reading the whole dataset.)
Using the HDF5 format means that a wide variety of other programs can
browse and access the data (especially when you use NCSA's conversion
program to the old HDF format). I can personally recommend it
as a great
way to store the results of scientific computations. I hope that
this
Octave addition will be useful to people, and will be accepted by the
Octave maintainers.
Please let me know if you have any comments.
Cordially,
Steven G. Johnson
I've written auload.m and ausave.m to load and save .wav, .au, and .aiff
files. I've also written auplay to play the files back at the
correct
sample rate (assuming you are using an OSS audio driver). These
are
available from
http://users.powernet.co.uk/kienzle/octavePAK/index.html
Paul Kienzle
pkienzle@kienzle.powernet.co.uk
For those of you using Debian, in the potato distribution there is a
new
package, named GMT, which is targeted
towards geographical maps.
However, it includes an impressive series of
tools for manipulating
files of numerical data and creating sophisticated graphics
from them
(all in batch mode). If you install the complete
package and run the
examples, you will have a demo of the its capabilities.
The upstream source is available from
ftp://pahoehoe.soest.hawaii.edu/pub/gmt/
(main site)
ftp://ftp.geologi.uio.no/pub/gmt/
(the mirror I used)
Can someone please recommend a good fuzzy logic toolbox that works with
Octave? I understand there's one called FSTB at
http://www.csc.umist.ac.uk/fstb/fstb.htm
I don't yet know how to work it; I thought perhaps someone here may
have tried and can share their experience.
Thanks for any help.
I finally got around to learning a little X programming and
wrote a *.oct file that you can dynamically load.
It takes over control of the mouse, and allows you to click
with button 1 and terminates with buttons 2 or 3.
I've put the source at
ftp://d201.njc.org/pub/octave/utils/ginput.cc
and a linux i386 compiled binary at
ftp://d201.njc.org/pub/octave/utils/ginput-linux-i386.oct
There were a couple of problems with installation of the automatic
wrapper generator (matwrap) and the pgplot interface to octave, due
to a
combination of my misunderstanding and a bug in the mkoctfile script
in
octave. I've fixed these problems now; the corrected versions
are
available from
http://www.klab.caltech.edu/~holt/matwrap/
as before, with instructions. All you really need is a patch for
the
mkoctfile script so it properly supports the -llib option; this is
available from
http://www.klab.caltech.edu/~holt/matwrap/mkoctfile.patch.
Voronoi/Delaunay triangulation
Hi,
> The Voronoi/Delaunay triangulation algorithms are good candidates
> for inclusion within Octave - I think suitable C coded raw
> algorithms exist. Has anyone built ".oct" implementations?
I've been using Steve Fortune's C code for making Voronoi diagrams.
This code is quite solid, so might be worth looking at. I think
I
read that the matlab Delaunay algorithms were also based on Steve
Fortune's sweepline algorithm.
Rather than put the code in an .oct file, I currently use system()
commands to call the (standalone) voronoi program via a perl script
to
post-process the output. Not very efficient, but it works.
If anyone
wants further details, just contact me.
Cheers, Stephen
(From www.voronoi.com, there is
a link to Steve
Fortune's code.)
Just to get an impression of how filled gnuplot output can look, check
this page:
http://www.sci.muni.cz/~mikulik/gnuplot.html
Thomas.
Did someone try epsTk
http://programmierer.freepage.de/dalles/epstk.html
for a while?
I'd like to know your comments.
Hi,
PLplot_octave is a replacement for the Octave/gnuplot graphics package.
This package enables you to use PLplot from within Octave and can be found at http://merlin.inescn.pt/~qual/plplot_octave/plplot_octave.html
You have three advantages:
1 - Use a superior plotting
package, having access to dozens
of plotting commands, enabling you to customize your plots
at your will,
2 - Still use the same plot
commands that you are familiarized,
if you really want to.
3 - Have some new and long waited ploting command scripts.
PLplot also has its disadvantages!
Joao
Last year I announced version 0.10 of my sparse matrix package.
I can do most of the MATLAB sparse math except for the more
exotic functions like svd on sparse.
Currently the notation is a little bizarre, but it works and is slightly
faster than MATLAB. (or so my preliminary tests indicate)
Here is my post on octave-sources or 23 nov 98.
________________________________________________
After announcing I was working on it about 6 times:
I present version 0.10 of my sparse matrix package.
Here is some sample code (from the test scripts I
provide with the package)
CCt= spfun(CC,'trans');
CCtSS= spfun(CCt,'mul',SS);
ZZ= spfun(CCtSS,'mul',CC);
ZZs= spfun(ZZ,'extract',2,n,2,n);
QF= full(spfun(QQ,'extract',2,n,1,p));
VV= spfun(ZZs,'solve',QF,2);
which is equivalent to the MATLAB code
ZZ= CC'*SS*CC;
ZZs= ZZ(2:n,2:n);
QF= full(QQ(2:n,:));
VV= ZZs\QF;
The conversion functions: sparse, full, etc are provided.
You can download the package from
http://www.mondenet.com/~adler/octave
have fun,
andy
Meanwhile (Mon, 6 Nov 2000):
My last "release" is at:
http://www.octave.org/mailing-lists/octave-sources/2000/70
I'm working on putting it at octave.sourceforge.net as well.
I tried to make my Matlab Toolbox on Time Series Analysis
(TSA)compatible to octave. I found the following bug:
In case K=1, size(ar)==[4,10]; the following code gives an error
ar(:,1:K-1)=ar(:,1:K-1)-ar(:,K*ones(K-1,1)).*ar(:,K-1:-1:1);
% error: operator -: nonconformant arguments (op1 is 4x0, op2 is 0x0)
However operator - should have the arguments (op1 is 4x0, op2 is 4x0)
It seems that operator .* gives incorrect matrix size.
In case K=1 no calculation should be performed, but also it should
not return with an error (it does not in Matlab). Octave 2.0.12 and
2.0.13 was used for testing.
Kind regards
Alois Schloegl
P.S.: You can download the TSA toolbox from
http://www-dpmi.tu-graz.ac.at/~schloegl/matlab/tsa/
Hi all,
I'd like to announce a bunch of new utility *.oct (and *.m) files
that I'm making available.
chol_inv.cc -> inverse choleski solver for banded
sparse matrices
crc16.cc -> cyclic redundancy check
16 of a vector
diag_inv.cc -> solver for banded sparse symetric
matrices
ginput.cc -> get locations of mouse clicks
jacobi_it.cc -> jacobi iterative solver for banded sparse
matrices
jpgread.cc -> read *jpg files from octave
jpgwrite.cc -> write *jpg files from octave
loadbmp.m -> load *bmp files from octave
sp_gauss.cc -> solve a general banded sparse matrix
They're available at www.mondenet.com/~adler/octave
Use at your own risk.
Send me and bug reports or fixes.o
Some of them are tricky to compile (jpg* and ginput), you
need the appropriate packages installed and the right
swiches for mkoctfile. Read the source.
Linear matrix inequalities have been a popular topic in control systems
theory since Boyd et al's book LINEAR MATRIX INEQUALTIES IN SYSTEM
AND
CONTROL THEORY was released. Boyd and Vandenberghe developed
a semidefinite
programming package that is on their Stanford website. I've ported
the
package to Octave, and it is now available at
ftp://ftp.eng.auburn.edu/pub/hodel/semidef-oct
There are copyright notices, etc., in the code and supporting documentation
that need to be read; in particular, if you use the package in generating
results for a publication, you should give them credit for their package.
MATLAB code for ADAPTIVE RESONANCE THEORY algorithms (ART1,
Fuzzy-ART, ARTMAP, and Fuzzy-ARTMAP) can now be downloaded
from the web at "http://www.imse.cnm.es/~bernabe".
This MATLAB code corresponds to the one described in Appendix A
of the book "ADAPTIVE RESONANCE THEORY MICROCHIPS", available from
Kluwer Academic Publishers at "http://www.wkap.nl/book.htm/0-7923-8231-5".
This MATLAB code is used in the first chapter (a tutorial on
ADAPTIVE RESONANCE THEORY algorithms) to generate the corresponding
illustrative examples.
Recently, I asked about ways to convert Matlab (Octave) files to C++
(Thanks to all who gave me some advise!), and there was also a thread
on C-libraries for matrix manipulation.
Someone kindly pointed me to Matcom from Mathtools. I downloaded
the demo, but the software is full of bugs and crashes. It doesn't
work
with VC 5 'as seen on TV' either. An unstable program for a lot of
money.
However, I finally found some older versions on some FTP servers,
they include the source code and seem to do the job, but are also
great for Matlab (Octave)-like C++ programming.
You can locate the files using http://ftpsearch.ntnu.no/ftpsearch
The filenames are:
matcom15.zip - freeware (~1MB)
matcom20.zip - shareware (~800kB)
The source code is not really readable, but at least matcom15
compiles just fine under VC++ 5/Win98. Matcom20 didn't
compile, but can use external BLAS implementations under
UNIX.
Thought these findings might help some folks...
Frederik Barth
Hi all,
I uploaded a genetic algorithm toolbox to
octave-sources@bevo.che.wisc.edu, http://www.che.wisc.edu/octave/mailing-lists/octave-sources/1999/29
The reason why it took so long was that we had mail problems here. Sorry.
If you have any questions and comments, patches or ideas feel free to contact me.
But please keep the code matlab-compatible. It should run on octave as well as on matlab.
Bye
XX
There is a 'free of charge, but register' Pentium Pro optimized BLAS
available at http://cs.utk.edu/~ghenry/distrib/index.htm
They claim it's beneficial to use it on a Pentium II. I tried it, but
it
was not as good as the other two alternatives I mention below.
PHiPAC
Another 'optimal code generator' is PHiPAC: http://www.cs.berkeley.edu/~siyer/
This package only generates SGEMM and DGEMM. It's most important option
is
the length of the search: short, default or long. The short search
took a
day for my machine (remember that for both ATLAS and PHiPAC it is best
to
give the machine to them alone, so it's off line for other users during
the
code generation!). It generated code that was a bit slower than the
ATLAS
code (speed up of 5, compared to 6). I also tried the 'long' option,
but
after four days, it was still in its first phase and I couldn't keep
the
machine any longer off line. The people of PHiPAC indicate that the
long
search can take a week (or two)... However, they ask people who did
these
long runs to send the library and their machine specifications to them,
so
they can distribute as many 'precompiled' libraries as possible.
MTL
The difference between these code generators and Blitz++ and MTL
(Matrix
Template Library : http://www.lsc.nd.edu/research/mtl/
,
but seems down for
the moment) is that the latter rely on the C++ compiler to optimize
the
code. Their benchmarks show that they can achieve almost optimal
performance, but they need the KAI C++ compiler. With egcs, it's not
that
good. Of course, this approach is much more machine independent than
using
'code generators'.
I hope this information was useful...
Have a nice day,
Gert
Hi,
First, let me say octave is a beautiful package, and it is a real lifesaver
for a linear algebra guy like myself . . . Also, I hope this
is the correct
mailing list to bring up the following idea:
We have a free software project known as ATLAS (www.netlib.org/atlas)
which
provides optimized BLAS for pretty much arbitrary architectures.
These
BLAS may be orders of magnitude faster than the reference BLAS.
The idea is
that it would be nice if a user could use ATLAS, or some other optimized
BLAS,
with octave, thus speeding up all of the lapack-handled routines significantly.
I realize speed is not always important (eg, small problems), but some
engineers
use matlab, for instance, to solve quite large problems, where this
speedup
would be invaluable.
ATLAS takes a while to install, so I doubt you are interested in including
it in octave, but I thought you might be interesting in facilitating
a
user's use of optimized BLAS in order to see these kinds of speedups.
I hacked a previous version of octave to use ATLAS quite a while ago,
but
I doubt your average user would be able to do so unless it were made
a
little easier.
ATLAS presently includes all the BLAS, and LAPACK's LU and Cholesky
factorization routines. To give you an idea of the kinds of speedups
I'm
talking about, I include a few timings below. These timings are
for a
previous release of ATLAS (which did not have Level 2 or 1 BLAS), but
they
can give you an idea of the speedups to be had. I show the MFLOP
rate
for a 500x500 LU factorization, using various configurations an a
266Mhz PII and a 533Mhz DEC ev56:
PII266 533 ev56
======= ========
ATLAS LU & BLAS
: 157
441
LAPACK LU, ATLAS BLAS :
143 330
LAPACK LU, reference BLAS :
68 60
Anyway, if you are interested in pursuing this, please let us know at
atlas@cs.utk.edu.
Thanks,
Clint
I am curious how others feel about having a Symbolic toolbox for
Octave. I would like to see this happen. I have done some
work in this
respect and I would like to here how others feel about putting some
of
my work into Octave when it is a bit more stable.
I have used a recently developed symbolic library known as
GiNaC.(http://www.ginac.de)
GiNaC is written in C++. What I have done
is a fairly simple extension of GiNaC. GiNaC has a number
of classes
that it uses to manipulate equations: ex(e.g. x+y, 2*x^2),symbol(e.g.
x,y),numeric(arbitrary precision) relationals(e.g. x==y,x<=y).
I have
created wrapper classes for ex,symbol and numeric that can be installed
in Octave with a .oct file.
...
Not all the things that need to be implemented have been implemented
and, all of the things that have been implemented are not as stable
as
they will need to be. However, this is a start. You can
get the
package at http://www.neutrino.lanl.gov/~bsapp/octave/symbolic.tar.gz
GiNaC requires Bruno Haible's Class Library for Numbers package.
Both
CLN and GiNaC are under the GNU GPL. I do not think it would
be wise to
require Octave to have GiNaC to compile. It would make Octave
too big
to include both of these packages also. I think configure should
check
for GiNaC and build the toolbox if it finds it otherwise leave it out.
To help configure there should probably be a --with-ginac flag.
The
GiNaC maintainers have made this fairly easy. They have created
a macro
designed to be used by autoconf.
Please let me know what you think of all this. Thanks.
Ben Sapp
Hello Paul,
interesting coincidence. A power outage stopped me yesterday to announce
my recent work on bit operations. I have implemented the matlab
functions bitand, bitor, bitxor, bitget, bitset, bitcmp, bitshift,
bitmax. The bit operators (and,or,xor) are in DLD-functions, so you
have
to compile these yourself (see instructions in bitand.cc).
Be aware these functions are new and just tested for a few cases.
If you find them usefull give me some feedback. I am always interested
in bug reports or other comments.
You can get them at
http://user.berlin.de/~kai.habel
Bye
P.S. these operations work on unsigned long integers (32 or 64 bit)
Kai Habel
I have put some minimization functions I have written on the web at
http://www.neutrino.lanl.gov/~bsapp/octave/minimization.tar.gz
Here is
a list of the functions:
deriv.m -> numerically calculates 1st,2nd,3rd or 4th derivatives
of
O(2) or O(4) of a scalar function.
gradient.m -> numerically calculates the gradient of a multi-variable
function.
nrm.m -> Newton-Raphson minimization of a scalar function.
gs.m -> Golden Section search for a minimum of a scalar function.
__quasi_func__.m -> Used internally by bfgs and dfp. This turns
the
multi-variable functions you supply bfgs and dfp into a scalar function
along some line determined by the bfgs and dfp algorithm. Then this
scalar function is minimized with nrm.m.
dfp.m -> Davidon-Fletcher-Powell minimization of a multi-variable
function.
bfgs.m -> Broyden and company minimization of a multi-variable
function.
dfp and bfgs both need some improvement. They never re-calculate
the
inverse hessian. This makes them somewhat slow when the hessian
changes
drastically. I will eventually have them do this.
They also do not
check the arguements supplied for sanity.
I hope these are useful.
Ben Sapp
Hello,
this is just to say that I added a numerical differentiation
function to the archive of 'Miscellaneous' functions, at
http://anonimo.isr.ist.utl.pt:8080/~etienne/octave/
Cheers,
Etienne
This is just to say that I just changed "mat2html" into "oct2html",
at http://anonimo.isr.ist.utl.pt:8080/~etienne/octave/.
It works well
enough to produce the documentation which is on that page; that does
not mean it is bug-free.
If anyone knows where to find Jeffrey C. Kantor, the author of
"math2html", I would like to thank him for that program.
Cheers,
Etienne
> I was wondering if anyone knows about some data exchange scripts
> between the statistical programming environment R and octave.
There are plugins to let R import/export its data in the standard HDF5
format (according to http://hdf.ncsa.uiuc.edu/tools5.html),
and I wrote a
patch to let Octave use HDF5 files as a native binary file format
(see http://www.che.wisc.edu/octave/mailing-lists/octave-sources/2000/15).
Right now, you have to apply this patch yourself to the CVS sources
(or
maybe it will work on the 2.1.x development sources). Hopefully,
it will
be integrated soon into 2.1.x by JWE, and Octave will reap the benefits
of
supporting a standard file format for scientific data.
Cordially,
Steven G. Johnson
Octave 2.1.31
No more worries.
T. Weichmann's Octave 2.1.31 from his site
installed
painlessly on my Windows ME (Dutch language version). Only thing is
that
the installer assumed the program icon in an invalid location (not
under
\Progam Files\Octave\bin\ but somewhere in the root of C:). That may
be
the error another mailing-list contributor saw flashing by.
BTW Octave 2.1.31 installed just fine besides Octave 2.0.13; Cygwin
was
installed in a directory under C:\Program Files\Octave, while my earlier
Cygwin was somewhere else in C:\Program Files\. Both Octave (and thus
Cygwin) versions run fine, even simultaneously.
Philip Nienhuis
Other Windows related message:
The new GNU Octave for Windows installation has been tested on Windows
2000
by michel@pythie.cepremap.cnrs.fr and he reports that it worked fine.
He
mentions a brief "flash" of an error... this would likely be
at the end of
installation, when the same thing happens on NT. I wrote a line
to try to
launch Octave right away after installation completes (so you can play
without delay!). However, this feature only seems to work on
Windows 98.
I'll remove it for the next release.
In the meantime, "bigger" ideas are brewing for an update- and
slow-modem-friendly version of the installer. If anyone out there
has tips
on freeware or GPL installers for Windows with more capability than
that by
NullSoft (purveyors of WinAmp) -- which is what we found and used so
far -- please pass the word on.
Cheers & Thanks,
Julian / matlinks.net
The latest GNU Octave for Windows 95/98/NT/2K can be found at
http://download.sourceforge.net/matlinks/octave-windows-2000oct25d.exe